wasCSharpSQLite – Rev 4
?pathlinks?
using System;
using System.Diagnostics;
using sqlite_int64 = System.Int64;
using sqlite_u3264 = System.UInt64;
using u32 = System.UInt32;
namespace Community.CsharpSqlite
{
#if TCLSH
using tcl.lang;
using ClientData = System.Object;
#if !SQLITE_OMIT_INCRBLOB
using sqlite3_blob = sqlite.Incrblob;
#endif
using sqlite3_stmt = Sqlite3.Vdbe;
using Tcl_DString = tcl.lang.TclString;
using Tcl_Interp = tcl.lang.Interp;
using Tcl_Obj = tcl.lang.TclObject;
using Tcl_WideInt = System.Int64;
using sqlite3_value = Sqlite3.Mem;
using System.IO;
using System.Text;
public partial class Sqlite3
{
/*
** 2001 September 15
**
** 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.
**
*************************************************************************
** A TCL Interface to SQLite. Append this file to sqlite3.c and
** compile the whole thing to build a TCL-enabled version of SQLite.
**
** Compile-time options:
**
** -DTCLSH=1 Add a "main()" routine that works as a tclsh.
**
** -DSQLITE_TCLMD5 When used in conjuction with -DTCLSH=1, add
** four new commands to the TCL interpreter for
** generating MD5 checksums: md5, md5file,
** md5-10x8, and md5file-10x8.
**
** -DSQLITE_TEST When used in conjuction with -DTCLSH=1, add
** hundreds of new commands used for testing
** SQLite. This option implies -DSQLITE_TCLMD5.
*************************************************************************
** 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
**
*************************************************************************
*/
//#include "tcl.h"
//#include <errno.h>
/*
** Some additional include files are needed if this file is not
** appended to the amalgamation.
*/
#if !SQLITE_AMALGAMATION
//# include "sqlite3.h"
//# include <stdlib.h>
//# include <string.h>
//# include <Debug.Assert.h>
// typedef unsigned char u8;
#endif
/*
* Windows needs to know which symbols to export. Unix does not.
* BUILD_sqlite should be undefined for Unix.
*/
#if BUILD_sqlite
//#undef TCL.Tcl_STORAGE_CLASS
//#define TCL.Tcl_STORAGE_CLASS DLLEXPORT
#endif // * BUILD_sqlite */
const int NUM_PREPARED_STMTS = 10;//#define NUM_PREPARED_STMTS 10
const int MAX_PREPARED_STMTS = 100;//#define MAX_PREPARED_STMTS 100
/*
** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we
** have to do a translation when going between the two. Set the
** UTF_TRANSLATION_NEEDED macro to indicate that we need to do
** this translation.
*/
#if Tcl_UTF_MAX && !SQLITE_UTF8
//# define UTF_TRANSLATION_NEEDED 1
#endif
/*
** New SQL functions can be created as TCL scripts. Each such function
** is described by an instance of the following structure.
*/
//typedef struct SqlFunc SqlFunc;
public class SqlFunc
{
public Tcl_Interp interp; /* The TCL interpret to execute the function */
public Tcl_Obj pScript; /* The Tcl_Obj representation of the script */
public int useEvalObjv; /* True if it is safe to use TCL.Tcl_EvalObjv */
public string zName; /* Name of this function */
public SqlFunc pNext; /* Next function on the list of them all */
}
/*
** New collation sequences function can be created as TCL scripts. Each such
** function is described by an instance of the following structure.
*/
//typedef struct SqlCollate SqlCollate;
public class SqlCollate
{
public Tcl_Interp interp; /* The TCL interpret to execute the function */
public string zScript; /* The script to be run */
public SqlCollate pNext; /* Next function on the list of them all */
}
/*
** Prepared statements are cached for faster execution. Each prepared
** statement is described by an instance of the following structure.
*/
//typedef struct SqlPreparedStmt SqlPreparedStmt;
public class SqlPreparedStmt
{
public SqlPreparedStmt pNext; /* Next in linked list */
public SqlPreparedStmt pPrev; /* Previous on the list */
public sqlite3_stmt pStmt; /* The prepared statement */
public Mem[] aMem; /* Original Memory Values to be reused */
public int nSql; /* chars in zSql[] */
public string zSql; /* Text of the SQL statement */
public int nParm; /* Size of apParm array */
public Tcl_Obj[] apParm; /* Array of referenced object pointers */
}
//typedef struct IncrblobChannel IncrblobChannel;
/*
** There is one instance of this structure for each SQLite database
** that has been opened by the SQLite TCL interface.
*/
//typedef struct SqliteDb SqliteDb;
public class SqliteDb : object
{
public sqlite3 db; /* The "real" database structure. MUST BE FIRST */
public Tcl_Interp interp; /* The interpreter used for this database */
public string zBusy; /* The busy callback routine */
public string zCommit; /* The commit hook callback routine */
public string zTrace; /* The trace callback routine */
public string zProfile; /* The profile callback routine */
public string zProgress; /* The progress callback routine */
public string zAuth; /* The authorization callback routine */
public int disableAuth; /* Disable the authorizer if it exists */
public string zNull = ""; /* Text to substitute for an SQL NULL value */
public SqlFunc pFunc; /* List of SQL functions */
public Tcl_Obj pUpdateHook; /* Update hook script (if any) */
public Tcl_Obj pRollbackHook; /* Rollback hook script (if any) */
public Tcl_Obj pWalHook; /* WAL hook script (if any) */
public Tcl_Obj pUnlockNotify; /* Unlock notify script (if any) */
public SqlCollate pCollate; /* List of SQL collation functions */
public int rc; /* Return code of most recent sqlite3_exec() */
public Tcl_Obj pCollateNeeded; /* Collation needed script */
public SqlPreparedStmt stmtList; /* List of prepared statements*/
public SqlPreparedStmt stmtLast; /* Last statement in the list */
public int maxStmt; /* The next maximum number of stmtList */
public int nStmt; /* Number of statements in stmtList */
#if !SQLITE_OMIT_INCRBLOB
public IncrblobChannel pIncrblob; /* Linked list of open incrblob channels */
#endif
public int nStep, nSort, nIndex; /* Statistics for most recent operation */
public int nTransaction; /* Number of nested [transaction] methods */
}
#if !SQLITE_OMIT_INCRBLOB
class IncrblobChannel
{
public sqlite3_blob pBlob; /* sqlite3 blob handle */
public SqliteDb pDb; /* Associated database connection */
public int iSeek; /* Current seek offset */
public Tcl_Channel channel; /* Channel identifier */
public IncrblobChannel pNext; /* Linked list of all open incrblob channels */
public IncrblobChannel pPrev; /* Linked list of all open incrblob channels */
}
#endif
/*
** Compute a string length that is limited to what can be stored in
** lower 30 bits of a 32-bit signed integer.
*/
static int strlen30( StringBuilder z )
{
//string z2 = z;
//while( *z2 ){ z2++; }
return 0x3fffffff & z.Length;
}
static int strlen30( string z )
{
//string z2 = z;
//while( *z2 ){ z2++; }
return 0x3fffffff & z.Length;
}
#if !SQLITE_OMIT_INCRBLOB
/*
** Close all incrblob channels opened using database connection pDb.
** This is called when shutting down the database connection.
*/
static void closeIncrblobChannels( SqliteDb pDb )
{
IncrblobChannel p;
IncrblobChannel pNext;
for ( p = pDb.pIncrblob ; p != null ; p = pNext )
{
pNext = p.pNext;
/* Note: Calling unregister here call TCL.Tcl_Close on the incrblob channel,
** which deletes the IncrblobChannel structure at p. So do not
** call TCL.Tcl_Free() here.
*/
TCL.Tcl_UnregisterChannel( pDb.interp, p.channel );
}
}
/*
** Close an incremental blob channel.
*/
//static int incrblobClose(object instanceData, Tcl_Interp interp){
// IncrblobChannel p = (IncrblobChannel )instanceData;
// int rc = sqlite3_blob_close(p.pBlob);
// sqlite3 db = p.pDb.db;
// /* Remove the channel from the SqliteDb.pIncrblob list. */
// if( p.pNext ){
// p.pNext.pPrev = p.pPrev;
// }
// if( p.pPrev ){
// p.pPrev.pNext = p.pNext;
// }
// if( p.pDb.pIncrblob==p ){
// p.pDb.pIncrblob = p.pNext;
// }
// /* Free the IncrblobChannel structure */
// TCL.Tcl_Free((char )p);
// if( rc!=SQLITE_OK ){
// TCL.Tcl_SetResult(interp, (char )sqlite3_errmsg(db), TCL.Tcl_VOLATILE);
// return TCL.TCL_ERROR;
// }
// return TCL.TCL_OK;
//}
/*
** Read data from an incremental blob channel.
*/
//static int incrblobInput(
// object instanceData,
// char *buf,
// int bufSize,
// int *errorCodePtr
//){
// IncrblobChannel p = (IncrblobChannel )instanceData;
// int nRead = bufSize; /* Number of bytes to read */
// int nBlob; /* Total size of the blob */
// int rc; /* sqlite error code */
// nBlob = sqlite3_blob_bytes(p.pBlob);
// if( (p.iSeek+nRead)>nBlob ){
// nRead = nBlob-p.iSeek;
// }
// if( nRead<=0 ){
// return 0;
// }
// rc = sqlite3_blob_read(p.pBlob, (void )buf, nRead, p.iSeek);
// if( rc!=SQLITE_OK ){
// *errorCodePtr = rc;
// return -1;
// }
// p.iSeek += nRead;
// return nRead;
//}
/*
** Write data to an incremental blob channel.
*/
//static int incrblobOutput(
// object instanceData,
// string buf,
// int toWrite,
// int *errorCodePtr
//){
// IncrblobChannel p = (IncrblobChannel )instanceData;
// int nWrite = toWrite; /* Number of bytes to write */
// int nBlob; /* Total size of the blob */
// int rc; /* sqlite error code */
// nBlob = sqlite3_blob_bytes(p.pBlob);
// if( (p.iSeek+nWrite)>nBlob ){
// *errorCodePtr = EINVAL;
// return -1;
// }
// if( nWrite<=0 ){
// return 0;
// }
// rc = sqlite3_blob_write(p.pBlob, (void )buf, nWrite, p.iSeek);
// if( rc!=SQLITE_OK ){
// *errorCodePtr = EIO;
// return -1;
// }
// p.iSeek += nWrite;
// return nWrite;
//}
/*
** Seek an incremental blob channel.
*/
//static int incrblobSeek(
// object instanceData,
// long offset,
// int seekMode,
// int *errorCodePtr
//){
// IncrblobChannel p = (IncrblobChannel )instanceData;
// switch( seekMode ){
// case SEEK_SET:
// p.iSeek = offset;
// break;
// case SEEK_CUR:
// p.iSeek += offset;
// break;
// case SEEK_END:
// p.iSeek = sqlite3_blob_bytes(p.pBlob) + offset;
// break;
// default: Debug.Assert(!"Bad seekMode");
// }
// return p.iSeek;
//}
//static void incrblobWatch(object instanceData, int mode){
// /* NO-OP */
//}
//static int incrblobHandle(object instanceData, int dir, object *hPtr){
// return TCL.TCL_ERROR;
//}
static TCL.Tcl_ChannelType IncrblobChannelType = {
"incrblob", /* typeName */
TCL.Tcl_CHANNEL_VERSION_2, /* version */
incrblobClose, /* closeProc */
incrblobInput, /* inputProc */
incrblobOutput, /* outputProc */
incrblobSeek, /* seekProc */
0, /* setOptionProc */
0, /* getOptionProc */
incrblobWatch, /* watchProc (this is a no-op) */
incrblobHandle, /* getHandleProc (always returns error) */
0, /* close2Proc */
0, /* blockModeProc */
0, /* flushProc */
0, /* handlerProc */
0, /* wideSeekProc */
};
/*
** Create a new incrblob channel.
*/
static int count = 0;
static int createIncrblobChannel(
Tcl_Interp interp,
SqliteDb pDb,
string zDb,
string zTable,
string zColumn,
sqlite_int64 iRow,
int isReadonly
){
IncrblobChannel p;
sqlite3 db = pDb.db;
sqlite3_blob pBlob;
int rc;
int flags = TCL.Tcl_READABLE|(isReadonly ? 0 : TCL.Tcl_WRITABLE);
/* This variable is used to name the channels: "incrblob_[incr count]" */
//static int count = 0;
string zChannel = "";//string[64];
rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, pBlob);
if( rc!=SQLITE_OK ){
TCL.Tcl_SetResult(interp, sqlite3_errmsg(pDb.db), TCL.Tcl_VOLATILE);
return TCL.TCL_ERROR;
}
p = new IncrblobChannel();//(IncrblobChannel )Tcl_Alloc(sizeof(IncrblobChannel));
p.iSeek = 0;
p.pBlob = pBlob;
sqlite3_snprintf(64, zChannel, "incrblob_%d", ++count);
p.channel = TCL.Tcl_CreateChannel(IncrblobChannelType, zChannel, p, flags);
TCL.Tcl_RegisterChannel(interp, p.channel);
/* Link the new channel into the SqliteDb.pIncrblob list. */
p.pNext = pDb.pIncrblob;
p.pPrev = null;
if( p.pNext!=null ){
p.pNext.pPrev = p;
}
pDb.pIncrblob = p;
p.pDb = pDb;
TCL.Tcl_SetResult(interp, Tcl_GetChannelName(p.channel), TCL.Tcl_VOLATILE);
return TCL.TCL_OK;
}
#else // * else clause for "#if !SQLITE_OMIT_INCRBLOB" */
//#define closeIncrblobChannels(pDb)
static void closeIncrblobChannels( SqliteDb pDb )
{
}
#endif
/*
** Look at the script prefix in pCmd. We will be executing this script
** after first appending one or more arguments. This routine analyzes
** the script to see if it is safe to use TCL.Tcl_EvalObjv() on the script
** rather than the more general TCL.Tcl_EvalEx(). TCL.Tcl_EvalObjv() is much
** faster.
**
** Scripts that are safe to use with TCL.Tcl_EvalObjv() consists of a
** command name followed by zero or more arguments with no [...] or $
** or {...} or ; to be seen anywhere. Most callback scripts consist
** of just a single procedure name and they meet this requirement.
*/
static int safeToUseEvalObjv( Tcl_Interp interp, Tcl_Obj pCmd )
{
/* We could try to do something with TCL.Tcl_Parse(). But we will instead
** just do a search for forbidden characters. If any of the forbidden
** characters appear in pCmd, we will report the string as unsafe.
*/
string z;
int n = 0;
z = TCL.Tcl_GetStringFromObj( pCmd, out n );
while ( n-- > 0 )
{
int c = z[n];// *( z++ );
if ( c == '$' || c == '[' || c == ';' )
return 0;
}
return 1;
}
/*
** Find an SqlFunc structure with the given name. Or create a new
** one if an existing one cannot be found. Return a pointer to the
** structure.
*/
static SqlFunc findSqlFunc( SqliteDb pDb, string zName )
{
SqlFunc p, pNew;
int i;
pNew = new SqlFunc();//(SqlFunc)Tcl_Alloc( sizeof(*pNew) + strlen30(zName) + 1 );
//pNew.zName = (char)&pNew[1];
//for(i=0; zName[i]; i++){ pNew.zName[i] = tolower(zName[i]); }
//pNew.zName[i] = 0;
pNew.zName = zName.ToLower();
for ( p = pDb.pFunc; p != null; p = p.pNext )
{
if ( p.zName == pNew.zName )
{
//Tcl_Free((char)pNew);
return p;
}
}
pNew.interp = pDb.interp;
pNew.pScript = null;
pNew.pNext = pDb.pFunc;
pDb.pFunc = pNew;
return pNew;
}
/*
** Finalize and free a list of prepared statements
*/
static void flushStmtCache( SqliteDb pDb )
{
SqlPreparedStmt pPreStmt;
while ( pDb.stmtList != null )
{
sqlite3_finalize( pDb.stmtList.pStmt );
pPreStmt = pDb.stmtList;
pDb.stmtList = pDb.stmtList.pNext;
TCL.Tcl_Free( ref pPreStmt );
}
pDb.nStmt = 0;
pDb.stmtLast = null;
}
/*
** TCL calls this procedure when an sqlite3 database command is
** deleted.
*/
static void DbDeleteCmd( ref object db )
{
SqliteDb pDb = (SqliteDb)db;
flushStmtCache( pDb );
closeIncrblobChannels( pDb );
sqlite3_close( pDb.db );
while ( pDb.pFunc != null )
{
SqlFunc pFunc = pDb.pFunc;
pDb.pFunc = pFunc.pNext;
TCL.Tcl_DecrRefCount( ref pFunc.pScript );
TCL.Tcl_Free( ref pFunc );
}
while ( pDb.pCollate != null )
{
SqlCollate pCollate = pDb.pCollate;
pDb.pCollate = pCollate.pNext;
TCL.Tcl_Free( ref pCollate );
}
if ( pDb.zBusy != null )
{
TCL.Tcl_Free( ref pDb.zBusy );
}
if ( pDb.zTrace != null )
{
TCL.Tcl_Free( ref pDb.zTrace );
}
if ( pDb.zProfile != null )
{
TCL.Tcl_Free( ref pDb.zProfile );
}
if ( pDb.zAuth != null )
{
TCL.Tcl_Free( ref pDb.zAuth );
}
if ( pDb.zNull != null )
{
TCL.Tcl_Free( ref pDb.zNull );
}
if ( pDb.pUpdateHook != null )
{
TCL.Tcl_DecrRefCount( ref pDb.pUpdateHook );
}
if ( pDb.pRollbackHook != null )
{
TCL.Tcl_DecrRefCount( ref pDb.pRollbackHook );
}
if ( pDb.pWalHook != null )
{
TCL.Tcl_DecrRefCount( ref pDb.pWalHook );
}
if ( pDb.pCollateNeeded != null )
{
TCL.Tcl_DecrRefCount( ref pDb.pCollateNeeded );
}
TCL.Tcl_Free( ref pDb );
}
/*
** This routine is called when a database file is locked while trying
** to execute SQL.
*/
static int DbBusyHandler( object cd, int nTries )
{
SqliteDb pDb = (SqliteDb)cd;
int rc;
StringBuilder zVal = new StringBuilder( 30 );//char zVal[30];
sqlite3_snprintf( 30, zVal, "%d", nTries );
rc = TCL.Tcl_VarEval( pDb.interp, pDb.zBusy, " ", zVal.ToString(), null );
if ( rc != TCL.TCL_OK || atoi( TCL.Tcl_GetStringResult( pDb.interp ) ) != 0 )
{
return 0;
}
return 1;
}
#if !SQLITE_OMIT_PROGRESS_CALLBACK
/*
** This routine is invoked as the 'progress callback' for the database.
*/
static int DbProgressHandler( object cd )
{
SqliteDb pDb = (SqliteDb)cd;
int rc;
Debug.Assert( pDb.zProgress != null );
rc = TCL.Tcl_Eval( pDb.interp, pDb.zProgress );
if ( rc != TCL.TCL_OK || atoi( TCL.Tcl_GetStringResult( pDb.interp ) ) != 0 )
{
return 1;
}
return 0;
}
#endif
#if !SQLITE_OMIT_TRACE
/*
** This routine is called by the SQLite trace handler whenever a new
** block of SQL is executed. The TCL script in pDb.zTrace is executed.
*/
static void DbTraceHandler( object cd, string zSql )
{
SqliteDb pDb = (SqliteDb)cd;
TclObject str = null;
TCL.Tcl_DStringInit( out str );
TCL.Tcl_DStringAppendElement( str, pDb.zTrace );
TCL.Tcl_DStringAppendElement( str, " {" + zSql + "}" );
TCL.Tcl_EvalObjEx( pDb.interp, str, 0 );// TCL.Tcl_Eval( pDb.interp, TCL.Tcl_DStringValue( ref str ) );
TCL.Tcl_DStringFree( ref str );
TCL.Tcl_ResetResult( pDb.interp );
}
#endif
#if !SQLITE_OMIT_TRACE
/*
** This routine is called by the SQLite profile handler after a statement
** SQL has executed. The TCL script in pDb.zProfile is evaluated.
*/
static void DbProfileHandler( object cd, string zSql, sqlite_int64 tm )
{
SqliteDb pDb = (SqliteDb)cd;
TclObject str = null;
StringBuilder zTm = new StringBuilder( 100 );//char zTm[100];
sqlite3_snprintf( 100, zTm, "%lld", tm );
TCL.Tcl_DStringInit( out str );
TCL.Tcl_DStringAppendElement( str, pDb.zProfile );
TCL.Tcl_DStringAppendElement( str, " {" + zSql + "}" );
TCL.Tcl_DStringAppendElement( str, " {" + zTm.ToString() + "}" );
TCL.Tcl_Eval( pDb.interp, str.ToString() );
TCL.Tcl_DStringFree( ref str );
TCL.Tcl_ResetResult( pDb.interp );
}
#endif
/*
** This routine is called when a transaction is committed. The
** TCL script in pDb.zCommit is executed. If it returns non-zero or
** if it throws an exception, the transaction is rolled back instead
** of being committed.
*/
static int DbCommitHandler( object cd )
{
SqliteDb pDb = (SqliteDb)cd;
int rc;
rc = TCL.Tcl_Eval( pDb.interp, pDb.zCommit );
if ( rc != TCL.TCL_OK || atoi( TCL.Tcl_GetStringResult( pDb.interp ) ) != 0 )
{
return 1;
}
return 0;
}
static void DbRollbackHandler( object _object )
{
SqliteDb pDb = (SqliteDb)_object;
Debug.Assert( pDb.pRollbackHook != null );
if ( TCL.TCL_OK != TCL.Tcl_EvalObjEx( pDb.interp, pDb.pRollbackHook, 0 ) )
{
TCL.Tcl_BackgroundError( pDb.interp );
}
}
/*
** This procedure handles wal_hook callbacks.
*/
static int DbWalHandler(
object clientData,
sqlite3 db,
string zDb,
int nEntry
)
{
int ret = SQLITE_OK;
Tcl_Obj p;
SqliteDb pDb = (SqliteDb)clientData;
Tcl_Interp interp = pDb.interp;
Debug.Assert( pDb.pWalHook != null );
p = TCL.Tcl_DuplicateObj( pDb.pWalHook );
TCL.Tcl_IncrRefCount( p );
TCL.Tcl_ListObjAppendElement( interp, p, TCL.Tcl_NewStringObj( zDb, -1 ) );
TCL.Tcl_ListObjAppendElement( interp, p, TCL.Tcl_NewIntObj( nEntry ) );
if ( TCL.TCL_OK != TCL.Tcl_EvalObjEx( interp, p, 0 )
|| TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, TCL.Tcl_GetObjResult( interp ), out ret )
)
{
TCL.Tcl_BackgroundError( interp );
}
TCL.Tcl_DecrRefCount( ref p );
return ret;
}
#if (SQLITE_TEST) && (SQLITE_ENABLE_UNLOCK_NOTIFY)
static void setTestUnlockNotifyVars(Tcl_Interp interp, int iArg, int nArg){
char zBuf[64];
sprintf(zBuf, "%d", iArg);
Tcl_SetVar(interp, "sqlite_unlock_notify_arg", zBuf, TCL_GLOBAL_ONLY);
sprintf(zBuf, "%d", nArg);
Tcl_SetVar(interp, "sqlite_unlock_notify_argcount", zBuf, TCL_GLOBAL_ONLY);
}
#else
//# define setTestUnlockNotifyVars(x,y,z)
#endif
#if SQLITE_ENABLE_UNLOCK_NOTIFY
static void DbUnlockNotify(void **apArg, int nArg){
int i;
for(i=0; i<nArg; i++){
const int flags = (TCL_EVAL_GLOBAL|TCL_EVAL_DIRECT);
SqliteDb *pDb = (SqliteDb )apArg[i];
setTestUnlockNotifyVars(pDb.interp, i, nArg);
Debug.Assert( pDb.pUnlockNotify);
Tcl_EvalObjEx(pDb.interp, pDb.pUnlockNotify, flags);
Tcl_DecrRefCount(pDb.pUnlockNotify);
pDb.pUnlockNotify = 0;
}
}
#endif
static void DbUpdateHandler(
object p,
int op,
string zDb,
string zTbl,
sqlite_int64 rowid
)
{
SqliteDb pDb = (SqliteDb)p;
Tcl_Obj pCmd;
Debug.Assert( pDb.pUpdateHook != null );
Debug.Assert( op == SQLITE_INSERT || op == SQLITE_UPDATE || op == SQLITE_DELETE );
pCmd = TCL.Tcl_DuplicateObj( pDb.pUpdateHook );
TCL.Tcl_IncrRefCount( pCmd );
TCL.Tcl_ListObjAppendElement( null, pCmd, TCL.Tcl_NewStringObj(
( ( op == SQLITE_INSERT ) ? "INSERT" : ( op == SQLITE_UPDATE ) ? "UPDATE" : "DELETE" ), -1 ) );
TCL.Tcl_ListObjAppendElement( null, pCmd, TCL.Tcl_NewStringObj( zDb, -1 ) );
TCL.Tcl_ListObjAppendElement( null, pCmd, TCL.Tcl_NewStringObj( zTbl, -1 ) );
TCL.Tcl_ListObjAppendElement( null, pCmd, TCL.Tcl_NewWideIntObj( rowid ) );
TCL.Tcl_EvalObjEx( pDb.interp, pCmd, TCL.TCL_EVAL_DIRECT );
TCL.Tcl_DecrRefCount( ref pCmd );
}
static void tclCollateNeeded(
object pCtx,
sqlite3 db,
int enc,
string zName
)
{
SqliteDb pDb = (SqliteDb)pCtx;
Tcl_Obj pScript = TCL.Tcl_DuplicateObj( pDb.pCollateNeeded );
TCL.Tcl_IncrRefCount( pScript );
TCL.Tcl_ListObjAppendElement( null, pScript, TCL.Tcl_NewStringObj( zName, -1 ) );
TCL.Tcl_EvalObjEx( pDb.interp, pScript, 0 );
TCL.Tcl_DecrRefCount( ref pScript );
}
/*
** This routine is called to evaluate an SQL collation function implemented
** using TCL script.
*/
static int tclSqlCollate(
object pCtx,
int nA,
string zA,
int nB,
string zB
)
{
SqlCollate p = (SqlCollate)pCtx;
Tcl_Obj pCmd;
pCmd = TCL.Tcl_NewStringObj( p.zScript, -1 );
TCL.Tcl_IncrRefCount( pCmd );
TCL.Tcl_ListObjAppendElement( p.interp, pCmd, TCL.Tcl_NewStringObj( zA, nA ) );
TCL.Tcl_ListObjAppendElement( p.interp, pCmd, TCL.Tcl_NewStringObj( zB, nB ) );
TCL.Tcl_EvalObjEx( p.interp, pCmd, TCL.TCL_EVAL_DIRECT );
TCL.Tcl_DecrRefCount( ref pCmd );
return ( atoi( TCL.Tcl_GetStringResult( p.interp ) ) );
}
/*
** This routine is called to evaluate an SQL function implemented
** using TCL script.
*/
static void tclSqlFunc( sqlite3_context context, int argc, sqlite3_value[] argv )
{
SqlFunc p = (SqlFunc)sqlite3_user_data( context );
Tcl_Obj pCmd = null;
int i;
int rc;
if ( argc == 0 )
{
/* If there are no arguments to the function, call TCL.Tcl_EvalObjEx on the
** script object directly. This allows the TCL compiler to generate
** bytecode for the command on the first invocation and thus make
** subsequent invocations much faster. */
pCmd = p.pScript;
TCL.Tcl_IncrRefCount( pCmd );
rc = TCL.Tcl_EvalObjEx( p.interp, pCmd, 0 );
TCL.Tcl_DecrRefCount( ref pCmd );
}
else
{
/* If there are arguments to the function, make a shallow copy of the
** script object, lappend the arguments, then evaluate the copy.
**
** By "shallow" copy, we mean a only the outer list Tcl_Obj is duplicated.
** The new Tcl_Obj contains pointers to the original list elements.
** That way, when TCL.Tcl_EvalObjv() is run and shimmers the first element
** of the list to tclCmdNameType, that alternate representation will
** be preserved and reused on the next invocation.
*/
Tcl_Obj[] aArg = null;
int nArg = 0;
if ( TCL.Tcl_ListObjGetElements( p.interp, p.pScript, out nArg, out aArg ) )
{
sqlite3_result_error( context, TCL.Tcl_GetStringResult( p.interp ), -1 );
return;
}
pCmd = TCL.Tcl_NewListObj( nArg, aArg );
TCL.Tcl_IncrRefCount( pCmd );
for ( i = 0; i < argc; i++ )
{
sqlite3_value pIn = argv[i];
Tcl_Obj pVal;
/* Set pVal to contain the i'th column of this row. */
switch ( sqlite3_value_type( pIn ) )
{
case SQLITE_BLOB:
{
int bytes = sqlite3_value_bytes( pIn );
pVal = TCL.Tcl_NewByteArrayObj( sqlite3_value_blob( pIn ), bytes );
break;
}
case SQLITE_INTEGER:
{
sqlite_int64 v = sqlite3_value_int64( pIn );
if ( v >= -2147483647 && v <= 2147483647 )
{
pVal = TCL.Tcl_NewIntObj( (int)v );
}
else
{
pVal = TCL.Tcl_NewWideIntObj( v );
}
break;
}
case SQLITE_FLOAT:
{
double r = sqlite3_value_double( pIn );
pVal = TCL.Tcl_NewDoubleObj( r );
break;
}
case SQLITE_NULL:
{
pVal = TCL.Tcl_NewStringObj( "", 0 );
break;
}
default:
{
int bytes = sqlite3_value_bytes( pIn );
pVal = TCL.Tcl_NewStringObj( sqlite3_value_text( pIn ), bytes );
break;
}
}
rc = TCL.Tcl_ListObjAppendElement( p.interp, pCmd, pVal ) ? 1 : 0;
if ( rc != 0 )
{
TCL.Tcl_DecrRefCount( ref pCmd );
sqlite3_result_error( context, TCL.Tcl_GetStringResult( p.interp ), -1 );
return;
}
}
if ( p.useEvalObjv == 0 )
{
/* TCL.Tcl_EvalObjEx() will automatically call TCL.Tcl_EvalObjv() if pCmd
** is a list without a string representation. To prevent this from
** happening, make sure pCmd has a valid string representation */
TCL.Tcl_GetString( pCmd );
}
rc = TCL.Tcl_EvalObjEx( p.interp, pCmd, TCL.TCL_EVAL_DIRECT );
TCL.Tcl_DecrRefCount( ref pCmd );
}
if ( rc != 0 && rc != TCL.TCL_RETURN )
{
sqlite3_result_error( context, TCL.Tcl_GetStringResult( p.interp ), -1 );
}
else
{
Tcl_Obj pVar = TCL.Tcl_GetObjResult( p.interp );
int n = 0;
string data = "";
Tcl_WideInt v = 0;
double r = 0;
string zType = pVar.typePtr;//string zType = (pVar.typePtr ? pVar.typePtr.name : "");
if ( zType == "bytearray" )
{ //&& pVar.bytes==0 ){
/* Only return a BLOB type if the Tcl variable is a bytearray and
** has no string representation. */
data = Encoding.UTF8.GetString( TCL.Tcl_GetByteArrayFromObj( pVar, out n ) );
sqlite3_result_blob( context, data, n, null );
}
else if ( zType == "boolean" )
{
TCL.Tcl_GetIntFromObj( null, pVar, out n );
sqlite3_result_int( context, n );
}
else if ( zType == "wideint" ||
zType == "int" || Int64.TryParse( pVar.ToString(), out v ) )
{
TCL.Tcl_GetWideIntFromObj( null, pVar, out v );
sqlite3_result_int64( context, v );
}
else if ( zType == "double" || Double.TryParse( pVar.ToString(), out r ) )
{
TCL.Tcl_GetDoubleFromObj( null, pVar, out r );
sqlite3_result_double( context, r );
}
else
{
data = TCL.Tcl_GetStringFromObj( pVar, n );
n = data.Length;
sqlite3_result_text( context, data, n, SQLITE_TRANSIENT );
}
}
}
#if !SQLITE_OMIT_AUTHORIZATION
/*
** This is the authentication function. It appends the authentication
** type code and the two arguments to zCmd[] then invokes the result
** on the interpreter. The reply is examined to determine if the
** authentication fails or succeeds.
*/
static int auth_callback(
object pArg,
int code,
const string zArg1,
const string zArg2,
const string zArg3,
const string zArg4
){
string zCode;
TCL.Tcl_DString str;
int rc;
const string zReply;
SqliteDb pDb = (SqliteDb)pArg;
if( pdb.disableAuth ) return SQLITE_OK;
switch( code ){
case SQLITE_COPY : zCode="SQLITE_COPY"; break;
case SQLITE_CREATE_INDEX : zCode="SQLITE_CREATE_INDEX"; break;
case SQLITE_CREATE_TABLE : zCode="SQLITE_CREATE_TABLE"; break;
case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;
case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;
case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;
case SQLITE_CREATE_TEMP_VIEW : zCode="SQLITE_CREATE_TEMP_VIEW"; break;
case SQLITE_CREATE_TRIGGER : zCode="SQLITE_CREATE_TRIGGER"; break;
case SQLITE_CREATE_VIEW : zCode="SQLITE_CREATE_VIEW"; break;
case SQLITE_DELETE : zCode="SQLITE_DELETE"; break;
case SQLITE_DROP_INDEX : zCode="SQLITE_DROP_INDEX"; break;
case SQLITE_DROP_TABLE : zCode="SQLITE_DROP_TABLE"; break;
case SQLITE_DROP_TEMP_INDEX : zCode="SQLITE_DROP_TEMP_INDEX"; break;
case SQLITE_DROP_TEMP_TABLE : zCode="SQLITE_DROP_TEMP_TABLE"; break;
case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;
case SQLITE_DROP_TEMP_VIEW : zCode="SQLITE_DROP_TEMP_VIEW"; break;
case SQLITE_DROP_TRIGGER : zCode="SQLITE_DROP_TRIGGER"; break;
case SQLITE_DROP_VIEW : zCode="SQLITE_DROP_VIEW"; break;
case SQLITE_INSERT : zCode="SQLITE_INSERT"; break;
case SQLITE_PRAGMA : zCode="SQLITE_PRAGMA"; break;
case SQLITE_READ : zCode="SQLITE_READ"; break;
case SQLITE_SELECT : zCode="SQLITE_SELECT"; break;
case SQLITE_TRANSACTION : zCode="SQLITE_TRANSACTION"; break;
case SQLITE_UPDATE : zCode="SQLITE_UPDATE"; break;
case SQLITE_ATTACH : zCode="SQLITE_ATTACH"; break;
case SQLITE_DETACH : zCode="SQLITE_DETACH"; break;
case SQLITE_ALTER_TABLE : zCode="SQLITE_ALTER_TABLE"; break;
case SQLITE_REINDEX : zCode="SQLITE_REINDEX"; break;
case SQLITE_ANALYZE : zCode="SQLITE_ANALYZE"; break;
case SQLITE_CREATE_VTABLE : zCode="SQLITE_CREATE_VTABLE"; break;
case SQLITE_DROP_VTABLE : zCode="SQLITE_DROP_VTABLE"; break;
case SQLITE_FUNCTION : zCode="SQLITE_FUNCTION"; break;
case SQLITE_SAVEPOINT : zCode="SQLITE_SAVEPOINT"; break;
default : zCode="????"; break;
}
TCL.Tcl_DStringInit(&str);
TCL.Tcl_DStringAppend(&str, pDb.zAuth, -1);
TCL.Tcl_DStringAppendElement(&str, zCode);
TCL.Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");
TCL.Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");
TCL.Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");
TCL.Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");
rc = TCL.Tcl_GlobalEval(pDb.interp, TCL.Tcl_DStringValue(&str));
TCL.Tcl_DStringFree(&str);
zReply = TCL.Tcl_GetStringResult(pDb.interp);
if( strcmp(zReply,"SQLITE_OK")==0 ){
rc = SQLITE_OK;
}else if( strcmp(zReply,"SQLITE_DENY")==0 ){
rc = SQLITE_DENY;
}else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){
rc = SQLITE_IGNORE;
}else{
rc = 999;
}
return rc;
}
#endif // * SQLITE_OMIT_AUTHORIZATION */
/*
** zText is a pointer to text obtained via an sqlite3_result_text()
** or similar interface. This routine returns a Tcl string object,
** reference count set to 0, containing the text. If a translation
** between iso8859 and UTF-8 is required, it is preformed.
*/
static Tcl_Obj dbTextToObj( string zText )
{
Tcl_Obj pVal;
#if UTF_TRANSLATION_NEEDED
//TCL.Tcl_DString dCol;
//TCL.Tcl_DStringInit(&dCol);
//TCL.Tcl_ExternalToUtfDString(NULL, zText, -1, dCol);
//pVal = TCL.Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1);
//TCL.Tcl_DStringFree(ref dCol);
if (zText.Length == Encoding.UTF8.GetByteCount(zText)) pVal = TCL.Tcl_NewStringObj( zText, -1 );
else pVal = TCL.Tcl_NewStringObj( zText, -1 );
#else
pVal = TCL.Tcl_NewStringObj( zText, -1 );
#endif
return pVal;
}
/*
** This routine reads a line of text from FILE in, stores
** the text in memory obtained from malloc() and returns a pointer
** to the text. NULL is returned at end of file, or if malloc()
** fails.
**
** The interface is like "readline" but no command-line editing
** is done.
**
** copied from shell.c from '.import' command
*/
//static char *local_getline(string zPrompt, FILE *in){
// string zLine;
// int nLine;
// int n;
// int eol;
// nLine = 100;
// zLine = malloc( nLine );
// if( zLine==0 ) return 0;
// n = 0;
// eol = 0;
// while( !eol ){
// if( n+100>nLine ){
// nLine = nLine*2 + 100;
// zLine = realloc(zLine, nLine);
// if( zLine==0 ) return 0;
// }
// if( fgets(&zLine[n], nLine - n, in)==0 ){
// if( n==0 ){
// free(zLine);
// return 0;
// }
// zLine[n] = 0;
// eol = 1;
// break;
// }
// while( zLine[n] ){ n++; }
// if( n>0 && zLine[n-1]=='\n' ){
// n--;
// zLine[n] = 0;
// eol = 1;
// }
// }
// zLine = realloc( zLine, n+1 );
// return zLine;
//}
/*
** This function is part of the implementation of the command:
**
** $db transaction [-deferred|-immediate|-exclusive] SCRIPT
**
** It is invoked after evaluating the script SCRIPT to commit or rollback
** the transaction or savepoint opened by the [transaction] command.
*/
static int DbTransPostCmd(
object data, /* data[0] is the Sqlite3Db* for $db */
Tcl_Interp interp, /* Tcl interpreter */
int result /* Result of evaluating SCRIPT */
)
{
string[] azEnd = {
"RELEASE _tcl_transaction", /* rc==TCL_ERROR, nTransaction!=0 */
"COMMIT", /* rc!=TCL_ERROR, nTransaction==0 */
"ROLLBACK TO _tcl_transaction ; RELEASE _tcl_transaction",
"ROLLBACK" /* rc==TCL_ERROR, nTransaction==0 */
};
SqliteDb pDb = (SqliteDb)data;
int rc = result;
string zEnd;
pDb.nTransaction--;
zEnd = azEnd[( ( rc == TCL.TCL_ERROR ) ? 1 : 0 ) * 2 + ( ( pDb.nTransaction == 0 ) ? 1 : 0 )];
pDb.disableAuth++;
if ( sqlite3_exec( pDb.db, zEnd, 0, 0, 0 ) != 0 )
{
/* This is a tricky scenario to handle. The most likely cause of an
** error is that the exec() above was an attempt to commit the
** top-level transaction that returned SQLITE_BUSY. Or, less likely,
** that an IO-error has occured. In either case, throw a Tcl exception
** and try to rollback the transaction.
**
** But it could also be that the user executed one or more BEGIN,
** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing
** this method's logic. Not clear how this would be best handled.
*/
if ( rc != TCL.TCL_ERROR )
{
TCL.Tcl_AppendResult( interp, sqlite3_errmsg( pDb.db ), 0 );
rc = TCL.TCL_ERROR;
}
sqlite3_exec( pDb.db, "ROLLBACK", 0, 0, 0 );
}
pDb.disableAuth--;
return rc;
}
/*
** Search the cache for a prepared-statement object that implements the
** first SQL statement in the buffer pointed to by parameter zIn. If
** no such prepared-statement can be found, allocate and prepare a new
** one. In either case, bind the current values of the relevant Tcl
** variables to any $var, :var or @var variables in the statement. Before
** returning, set *ppPreStmt to point to the prepared-statement object.
**
** Output parameter *pzOut is set to point to the next SQL statement in
** buffer zIn, or to the '\0' byte at the end of zIn if there is no
** next statement.
**
** If successful, TCL_OK is returned. Otherwise, TCL_ERROR is returned
** and an error message loaded into interpreter pDb.interp.
*/
static int dbPrepareAndBind(
SqliteDb pDb, /* Database object */
string zIn, /* SQL to compile */
ref string pzOut, /* OUT: Pointer to next SQL statement */
ref SqlPreparedStmt ppPreStmt /* OUT: Object used to cache statement */
)
{
string zSql = zIn; /* Pointer to first SQL statement in zIn */
sqlite3_stmt pStmt = null; /* Prepared statement object */
SqlPreparedStmt pPreStmt; /* Pointer to cached statement */
int nSql; /* Length of zSql in bytes */
int nVar = 0; /* Number of variables in statement */
int iParm = 0; /* Next free entry in apParm */
int i;
Tcl_Interp interp = pDb.interp;
pzOut = null;
ppPreStmt = null;
/* Trim spaces from the start of zSql and calculate the remaining length. */
zSql = zSql.TrimStart(); //while ( isspace( zSql[0] ) ) { zSql++; }
nSql = strlen30( zSql );
for ( pPreStmt = pDb.stmtList; pPreStmt != null; pPreStmt = pPreStmt.pNext )
{
int n = pPreStmt.nSql;
if ( nSql >= n
&& zSql.StartsWith(pPreStmt.zSql)
&& ( nSql == n /* zSql[n]==0 */|| zSql[n - 1] == ';' )
)
{
pStmt = pPreStmt.pStmt;
/* Restore aMem values */
if ( pStmt.aMem.Length < pPreStmt.aMem.Length )
Array.Resize( ref pStmt.aMem, pPreStmt.aMem.Length );
for ( int ix = 0; ix < pPreStmt.aMem.Length; ix++ )
{
pPreStmt.aMem[ix].CopyTo( ref pStmt.aMem[ix] );
}
pzOut = zSql.Substring( pPreStmt.nSql );
/* When a prepared statement is found, unlink it from the
** cache list. It will later be added back to the beginning
** of the cache list in order to implement LRU replacement.
*/
if ( pPreStmt.pPrev != null )
{
pPreStmt.pPrev.pNext = pPreStmt.pNext;
}
else
{
pDb.stmtList = pPreStmt.pNext;
}
if ( pPreStmt.pNext != null )
{
pPreStmt.pNext.pPrev = pPreStmt.pPrev;
}
else
{
pDb.stmtLast = pPreStmt.pPrev;
}
pDb.nStmt--;
nVar = sqlite3_bind_parameter_count( pStmt );
break;
}
}
/* If no prepared statement was found. Compile the SQL text. Also allocate
** a new SqlPreparedStmt structure. */
if ( pPreStmt == null )
{
int nByte;
if ( SQLITE_OK != sqlite3_prepare_v2( pDb.db, zSql, -1, ref pStmt, ref pzOut ) )
{
TCL.Tcl_SetObjResult( interp, dbTextToObj( sqlite3_errmsg( pDb.db ) ) );
pPreStmt = new SqlPreparedStmt();// (SqlPreparedStmt)Tcl_Alloc( nByte );
return TCL.TCL_ERROR;
}
if ( pStmt == null )
{
if ( SQLITE_OK != sqlite3_errcode( pDb.db ) )
{
/* A compile-time error in the statement. */
TCL.Tcl_SetObjResult( interp, dbTextToObj( sqlite3_errmsg( pDb.db ) ) );
return TCL.TCL_ERROR;
}
else
{
/* The statement was a no-op. Continue to the next statement
** in the SQL string.
*/
return TCL.TCL_OK;
}
}
Debug.Assert( pPreStmt == null );
nVar = sqlite3_bind_parameter_count( pStmt );
//nByte = sizeof(SqlPreparedStmt) + nVar*sizeof(Tcl_Obj );
pPreStmt = new SqlPreparedStmt();// (SqlPreparedStmt)Tcl_Alloc( nByte );
//memset(pPreStmt, 0, nByte);
pPreStmt.pStmt = pStmt;
pPreStmt.nSql = ( zSql.Length - pzOut.Length );
pPreStmt.zSql = sqlite3_sql( pStmt );
pPreStmt.apParm = new TclObject[nVar];//pPreStmt[1];
}
Debug.Assert( pPreStmt != null );
Debug.Assert( strlen30( pPreStmt.zSql ) == pPreStmt.nSql );
Debug.Assert( zSql.StartsWith( pPreStmt.zSql ) );
/* Bind values to parameters that begin with $ or : */
for ( i = 1; i <= nVar; i++ )
{
string zVar = sqlite3_bind_parameter_name( pStmt, i );
if ( !String.IsNullOrEmpty( zVar ) && ( zVar[0] == '$' || zVar[0] == ':' || zVar[0] == '@' ) )
{
Tcl_Obj pVar = TCL.Tcl_GetVar2Ex( interp, zVar.Substring( 1 ), null, 0 );
if ( pVar != null && pVar.typePtr != "null" )
{
int n = 0;
string data;
string zType = pVar.typePtr;
//char c = zType[0];
if ( zVar[0] == '@' ||
( zType == "bytearray" ) )// TODO -- && pVar.bytes == 0 ) )
{
/* Load a BLOB type if the Tcl variable is a bytearray and
** it has no string representation or the host
** parameter name begins with "@". */
if ( zVar[0] == '@' || pVar.stringRep == null )
sqlite3_bind_blob( pStmt, i, TCL.Tcl_GetByteArrayFromObj( pVar, out n ), n, SQLITE_STATIC );
else
sqlite3_bind_text( pStmt, i, TCL.Tcl_GetStringFromObj( pVar, out n ), n, SQLITE_STATIC );
TCL.Tcl_IncrRefCount( pVar );
pPreStmt.apParm[iParm++] = pVar;
}
else if ( zType == "boolean" )
{
TCL.Tcl_GetIntFromObj( interp, pVar, out n );
sqlite3_bind_int( pStmt, i, n );
}
else if ( zType == "double" )
{
double r = 0;
TCL.Tcl_GetDoubleFromObj( interp, pVar, out r );
sqlite3_bind_double( pStmt, i, r );
}
else if ( zType == "wideint" ||
zType == "int" )
{
Tcl_WideInt v = 0;
TCL.Tcl_GetWideIntFromObj( interp, pVar, out v );
sqlite3_bind_int64( pStmt, i, v );
}
else
{
data = TCL.Tcl_GetStringFromObj( pVar, out n );
sqlite3_bind_text( pStmt, i, data, n, SQLITE_STATIC );
TCL.Tcl_IncrRefCount( pVar );
pPreStmt.apParm[iParm++] = pVar;
}
}
else
{
sqlite3_bind_null( pStmt, i );
}
}
}
pPreStmt.nParm = iParm;
/* save aMem values for later reuse */
pPreStmt.aMem = new Mem[pPreStmt.pStmt.aMem.Length];
for ( int ix = 0; ix < pPreStmt.pStmt.aMem.Length; ix++ )
{
pPreStmt.pStmt.aMem[ix].CopyTo( ref pPreStmt.aMem[ix] );
}
ppPreStmt = pPreStmt;
return TCL.TCL_OK;
}
/*
** Release a statement reference obtained by calling dbPrepareAndBind().
** There should be exactly one call to this function for each call to
** dbPrepareAndBind().
**
** If the discard parameter is non-zero, then the statement is deleted
** immediately. Otherwise it is added to the LRU list and may be returned
** by a subsequent call to dbPrepareAndBind().
*/
static void dbReleaseStmt(
SqliteDb pDb, /* Database handle */
SqlPreparedStmt pPreStmt, /* Prepared statement handle to release */
int discard /* True to delete (not cache) the pPreStmt */
)
{
int i;
/* Free the bound string and blob parameters */
for ( i = 0; i < pPreStmt.nParm; i++ )
{
TCL.Tcl_DecrRefCount( ref pPreStmt.apParm[i] );
}
pPreStmt.nParm = 0;
if ( pDb.maxStmt <= 0 || discard != 0 )
{
/* If the cache is turned off, deallocated the statement */
sqlite3_finalize( pPreStmt.pStmt );
TCL.Tcl_Free( ref pPreStmt );
}
else
{
/* Add the prepared statement to the beginning of the cache list. */
pPreStmt.pNext = pDb.stmtList;
pPreStmt.pPrev = null;
if ( pDb.stmtList != null )
{
pDb.stmtList.pPrev = pPreStmt;
}
pDb.stmtList = pPreStmt;
if ( pDb.stmtLast == null )
{
Debug.Assert( pDb.nStmt == 0 );
pDb.stmtLast = pPreStmt;
}
else
{
Debug.Assert( pDb.nStmt > 0 );
}
pDb.nStmt++;
/* If we have too many statement in cache, remove the surplus from
** the end of the cache list. */
while ( pDb.nStmt > pDb.maxStmt )
{
sqlite3_finalize( pDb.stmtLast.pStmt );
pDb.stmtLast = pDb.stmtLast.pPrev;
TCL.Tcl_Free( ref pDb.stmtLast.pNext );
pDb.stmtLast.pNext = null;
pDb.nStmt--;
}
}
}
/*
** Structure used with dbEvalXXX() functions:
**
** dbEvalInit()
** dbEvalStep()
** dbEvalFinalize()
** dbEvalRowInfo()
** dbEvalColumnValue()
*/
//typedef struct DbEvalContext DbEvalContext;
public class DbEvalContext
{
public SqliteDb pDb; /* Database handle */
public Tcl_Obj pSql; /* Object holding string zSql */
public string zSql; /* Remaining SQL to execute */
public SqlPreparedStmt pPreStmt; /* Current statement */
public int nCol; /* Number of columns returned by pStmt */
public Tcl_Obj pArray; /* Name of array variable */
public Tcl_Obj[] apColName; /* Array of column names */
public void Clear()
{
pDb = null;
pSql = null;
zSql = null;
pPreStmt = null;
pArray = null;
apColName = null;
}
};
/*
** Release any cache of column names currently held as part of
** the DbEvalContext structure passed as the first argument.
*/
static void dbReleaseColumnNames( DbEvalContext p )
{
if ( p.apColName != null )
{
int i;
for ( i = 0; i < p.nCol; i++ )
{
TCL.Tcl_DecrRefCount( ref p.apColName[i] );
}
TCL.Tcl_Free( ref p.apColName );
p.apColName = null;
}
p.nCol = 0;
}
/*
** Initialize a DbEvalContext structure.
**
** If pArray is not NULL, then it contains the name of a Tcl array
** variable. The "*" member of this array is set to a list containing
** the names of the columns returned by the statement as part of each
** call to dbEvalStep(), in order from left to right. e.g. if the names
** of the returned columns are a, b and c, it does the equivalent of the
** tcl command:
**
** set ${pArray}() {a b c}
*/
static void dbEvalInit(
DbEvalContext p, /* Pointer to structure to initialize */
SqliteDb pDb, /* Database handle */
Tcl_Obj pSql, /* Object containing SQL script */
Tcl_Obj pArray /* Name of Tcl array to set () element of */
)
{
if ( p != null )
p.Clear();// memset( p, 0, sizeof( DbEvalContext ) );
p.pDb = pDb;
p.zSql = TCL.Tcl_GetString( pSql );
p.pSql = pSql;
TCL.Tcl_IncrRefCount( pSql );
if ( pArray != null )
{
p.pArray = pArray;
TCL.Tcl_IncrRefCount( pArray );
}
}
/*
** Obtain information about the row that the DbEvalContext passed as the
** first argument currently points to.
*/
static void dbEvalRowInfo(
DbEvalContext p, /* Evaluation context */
out int pnCol, /* OUT: Number of column names */
out Tcl_Obj[] papColName /* OUT: Array of column names */
)
{
/* Compute column names */
if ( null == p.apColName )
{
sqlite3_stmt pStmt = p.pPreStmt.pStmt;
int i; /* Iterator variable */
int nCol; /* Number of columns returned by pStmt */
Tcl_Obj[] apColName = null; /* Array of column names */
p.nCol = nCol = sqlite3_column_count( pStmt );
if ( nCol > 0 )// && ( papColName != null || p.pArray != null ) )
{
apColName = new TclObject[nCol];// (Tcl_Obj*)Tcl_Alloc( sizeof( Tcl_Obj* ) * nCol );
for ( i = 0; i < nCol; i++ )
{
apColName[i] = dbTextToObj( sqlite3_column_name( pStmt, i ) );
TCL.Tcl_IncrRefCount( apColName[i] );
}
p.apColName = apColName;
}
/* If results are being stored in an array variable, then create
** the array() entry for that array
*/
if ( p.pArray != null )
{
Tcl_Interp interp = p.pDb.interp;
Tcl_Obj pColList = TCL.Tcl_NewObj();
Tcl_Obj pStar = TCL.Tcl_NewStringObj( "*", -1 );
for ( i = 0; i < nCol; i++ )
{
TCL.Tcl_ListObjAppendElement( interp, pColList, apColName[i] );
}
TCL.Tcl_IncrRefCount( pStar );
TCL.Tcl_ObjSetVar2( interp, p.pArray, pStar, pColList, 0 );
TCL.Tcl_DecrRefCount( ref pStar );
}
}
//if ( papColName != null )
{
papColName = p.apColName;
}
//if ( pnCol !=0)
{
pnCol = p.nCol;
}
}
/*
** Return one of TCL_OK, TCL_BREAK or TCL_ERROR. If TCL_ERROR is
** returned, then an error message is stored in the interpreter before
** returning.
**
** A return value of TCL_OK means there is a row of data available. The
** data may be accessed using dbEvalRowInfo() and dbEvalColumnValue(). This
** is analogous to a return of SQLITE_ROW from sqlite3_step(). If TCL_BREAK
** is returned, then the SQL script has finished executing and there are
** no further rows available. This is similar to SQLITE_DONE.
*/
static int dbEvalStep( DbEvalContext p )
{
while ( !String.IsNullOrEmpty( p.zSql ) || p.pPreStmt != null )
{
int rc;
if ( p.pPreStmt == null )
{
rc = dbPrepareAndBind( p.pDb, p.zSql, ref p.zSql, ref p.pPreStmt );
if ( rc != TCL.TCL_OK )
return rc;
}
else
{
int rcs;
SqliteDb pDb = p.pDb;
SqlPreparedStmt pPreStmt = p.pPreStmt;
sqlite3_stmt pStmt = pPreStmt.pStmt;
rcs = sqlite3_step( pStmt );
if ( rcs == SQLITE_ROW )
{
return TCL.TCL_OK;
}
if ( p.pArray != null )
{
TclObject[] pDummy;
int iDummy;
dbEvalRowInfo( p, out iDummy, out pDummy );
}
rcs = sqlite3_reset( pStmt );
pDb.nStep = sqlite3_stmt_status( pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP, 1 );
pDb.nSort = sqlite3_stmt_status( pStmt, SQLITE_STMTSTATUS_SORT, 1 );
pDb.nIndex = sqlite3_stmt_status( pStmt, SQLITE_STMTSTATUS_AUTOINDEX, 1 );
dbReleaseColumnNames( p );
p.pPreStmt = null;
if ( rcs != SQLITE_OK )
{
/* If a run-time error occurs, report the error and stop reading
** the SQL. */
TCL.Tcl_SetObjResult( pDb.interp, dbTextToObj( sqlite3_errmsg( pDb.db ) ) );
dbReleaseStmt( pDb, pPreStmt, 1 );
return TCL.TCL_ERROR;
}
else
{
dbReleaseStmt( pDb, pPreStmt, 0 );
}
}
}
/* Finished */
return TCL.TCL_BREAK;
}
/*
** Free all resources currently held by the DbEvalContext structure passed
** as the first argument. There should be exactly one call to this function
** for each call to dbEvalInit().
*/
static void dbEvalFinalize( DbEvalContext p )
{
if ( p.pPreStmt != null )
{
sqlite3_reset( p.pPreStmt.pStmt );
dbReleaseStmt( p.pDb, p.pPreStmt, 1 );
p.pPreStmt = null;
}
if ( p.pArray != null )
{
TCL.Tcl_DecrRefCount( ref p.pArray );
p.pArray = null;
}
TCL.Tcl_DecrRefCount( ref p.pSql );
dbReleaseColumnNames( p );
}
/*
** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains
** the value for the iCol'th column of the row currently pointed to by
** the DbEvalContext structure passed as the first argument.
*/
static Tcl_Obj dbEvalColumnValue( DbEvalContext p, int iCol )
{
sqlite3_stmt pStmt = p.pPreStmt.pStmt;
switch ( sqlite3_column_type( pStmt, iCol ) )
{
case SQLITE_BLOB:
{
int bytes = sqlite3_column_bytes( pStmt, iCol );
byte[] zBlob = sqlite3_column_blob( pStmt, iCol );
if ( null == zBlob )
bytes = 0;
return TCL.Tcl_NewByteArrayObj( zBlob, bytes );
}
case SQLITE_INTEGER:
{
sqlite_int64 v = sqlite3_column_int64( pStmt, iCol );
if ( v >= -2147483647 && v <= 2147483647 )
{
return TCL.Tcl_NewIntObj( (int)v );
}
else
{
return TCL.Tcl_NewWideIntObj( v );
}
}
case SQLITE_FLOAT:
{
return TCL.Tcl_NewDoubleObj( sqlite3_column_double( pStmt, iCol ) );
}
case SQLITE_NULL:
{
return dbTextToObj( p.pDb.zNull );
}
}
return dbTextToObj( sqlite3_column_text( pStmt, iCol ) );
}
/*
** If using Tcl version 8.6 or greater, use the NR functions to avoid
** recursive evalution of scripts by the [db eval] and [db trans]
** commands. Even if the headers used while compiling the extension
** are 8.6 or newer, the code still tests the Tcl version at runtime.
** This allows stubs-enabled builds to be used with older Tcl libraries.
*/
#if TCL_MAJOR_VERSION//>8 || (TCL_MAJOR_VERSION==8 && TCL_MINOR_VERSION>=6)
//# define SQLITE_TCL_NRE 1
static int DbUseNre(void){
int major, minor;
Tcl_GetVersion(&major, &minor, 0, 0);
return( (major==8 && minor>=6) || major>8 );
}
#else
/*
** Compiling using headers earlier than 8.6. In this case NR cannot be
** used, so DbUseNre() to always return zero. Add #defines for the other
** Tcl_NRxxx() functions to prevent them from causing compilation errors,
** even though the only invocations of them are within conditional blocks
** of the form:
**
** if( DbUseNre() ) { ... }
*/
const int SQLITE_TCL_NRE = 0; //# define SQLITE_TCL_NRE 0
static bool DbUseNre()
{
return false;
} //# define DbUseNre() 0
//# define Tcl_NRAddCallback(a,b,c,d,e,f) 0
//# define Tcl_NREvalObj(a,b,c) 0
//# define Tcl_NRCreateCommand(a,b,c,d,e,f) 0
#endif
/*
** This function is part of the implementation of the command:
**
** $db eval SQL ?ARRAYNAME? SCRIPT
*/
static int DbEvalNextCmd(
object[] data, /* data[0] is the (DbEvalContext) */
Tcl_Interp interp, /* Tcl interpreter */
int result /* Result so far */
)
{
int rc = result; /* Return code */
/* The first element of the data[] array is a pointer to a DbEvalContext
** structure allocated using TCL.Tcl_Alloc(). The second element of data[]
** is a pointer to a TCL.Tcl_Obj containing the script to run for each row
** returned by the queries encapsulated in data[0]. */
DbEvalContext p = (DbEvalContext)data[0];
Tcl_Obj pScript = (Tcl_Obj)data[1];
Tcl_Obj pArray = p.pArray;
while ( ( rc == TCL.TCL_OK || rc == TCL.TCL_CONTINUE ) && TCL.TCL_OK == ( rc = dbEvalStep( p ) ) )
{
int i;
int nCol;
Tcl_Obj[] apColName;
dbEvalRowInfo( p, out nCol, out apColName );
for ( i = 0; i < nCol; i++ )
{
Tcl_Obj pVal = dbEvalColumnValue( p, i );
if ( pArray == null )
{
TCL.Tcl_ObjSetVar2( interp, apColName[i], null, pVal, 0 );
}
else
{
TCL.Tcl_ObjSetVar2( interp, pArray, apColName[i], pVal, 0 );
}
}
/* The required interpreter variables are now populated with the data
** from the current row. If using NRE, schedule callbacks to evaluate
** script pScript, then to invoke this function again to fetch the next
** row (or clean up if there is no next row or the script throws an
** exception). After scheduling the callbacks, return control to the
** caller.
**
** If not using NRE, evaluate pScript directly and continue with the
** next iteration of this while(...) loop. */
if ( DbUseNre() )
{
Debugger.Break();
//TCL.Tcl_NRAddCallback(interp, DbEvalNextCmd, (void)p, (void)pScript, 0, 0);
//return TCL.Tcl_NREvalObj(interp, pScript, 0);
}
else
{
rc = TCL.Tcl_EvalObjEx( interp, pScript, 0 );
}
}
TCL.Tcl_DecrRefCount( ref pScript );
dbEvalFinalize( p );
TCL.Tcl_Free( ref p );
if ( rc == TCL.TCL_OK || rc == TCL.TCL_BREAK )
{
TCL.Tcl_ResetResult( interp );
rc = TCL.TCL_OK;
}
return rc;
}
/*
** The "sqlite" command below creates a new Tcl command for each
** connection it opens to an SQLite database. This routine is invoked
** whenever one of those connection-specific commands is executed
** in Tcl. For example, if you run Tcl code like this:
**
** sqlite3 db1 "my_database"
** db1 close
**
** The first command opens a connection to the "my_database" database
** and calls that connection "db1". The second command causes this
** subroutine to be invoked.
*/
enum DB_enum
{
DB_AUTHORIZER,
DB_BACKUP,
DB_BUSY,
DB_CACHE,
DB_CHANGES,
DB_CLOSE,
DB_COLLATE,
DB_COLLATION_NEEDED,
DB_COMMIT_HOOK,
DB_COMPLETE,
DB_COPY,
DB_ENABLE_LOAD_EXTENSION,
DB_ERRORCODE,
DB_EVAL,
DB_EXISTS,
DB_FUNCTION,
DB_INCRBLOB,
DB_INTERRUPT,
DB_LAST_INSERT_ROWID,
DB_NULLVALUE,
DB_ONECOLUMN,
DB_PROFILE,
DB_PROGRESS,
DB_REKEY,
DB_RESTORE,
DB_ROLLBACK_HOOK,
DB_STATUS,
DB_TIMEOUT,
DB_TOTAL_CHANGES,
DB_TRACE,
DB_TRANSACTION,
DB_UNLOCK_NOTIFY,
DB_UPDATE_HOOK,
DB_VERSION,
DB_WAL_HOOK
};
enum TTYPE_enum
{
TTYPE_DEFERRED,
TTYPE_EXCLUSIVE,
TTYPE_IMMEDIATE
};
static int DbObjCmd( object cd, Tcl_Interp interp, int objc, Tcl_Obj[] objv )
{
SqliteDb pDb = (SqliteDb)cd;
int choice = 0;
int rc = TCL.TCL_OK;
string[] DB_strs = {
"authorizer", "backup", "busy",
"cache", "changes", "close",
"collate", "collation_needed", "commit_hook",
"complete", "copy", "enable_load_extension",
"errorcode", "eval", "exists",
"function", "incrblob", "interrupt",
"last_insert_rowid", "nullvalue", "onecolumn",
"profile", "progress", "rekey",
"restore", "rollback_hook", "status",
"timeout", "total_changes", "trace",
"transaction", "unlock_notify", "update_hook",
"version", "wal_hook"
};
/* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */
if ( objc < 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "SUBCOMMAND ..." );
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetIndexFromObj( interp, objv[1], DB_strs, "option", 0, out choice ) )
{
return TCL.TCL_ERROR;
}
switch ( choice )
{
/* $db authorizer ?CALLBACK?
**
** Invoke the given callback to authorize each SQL operation as it is
** compiled. 5 arguments are appended to the callback before it is
** invoked:
**
** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)
** (2) First descriptive name (depends on authorization type)
** (3) Second descriptive name
** (4) Name of the database (ex: "main", "temp")
** (5) Name of trigger that is doing the access
**
** The callback should return on of the following strings: SQLITE_OK,
** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.
**
** If this method is invoked with no arguments, the current authorization
** callback string is returned.
*/
case (int)DB_enum.DB_AUTHORIZER:
{
#if SQLITE_OMIT_AUTHORIZATION
TCL.Tcl_AppendResult( interp, "authorization not available in this build" );
return TCL.TCL_RETURN;
#else
if( objc>3 ){
TCL.Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");
return TCL.TCL_ERROR;
}else if( objc==2 ){
if( pDb.zAuth ){
TCL.Tcl_AppendResult(interp, pDb.zAuth);
}
}else{
string zAuth;
int len;
if( pDb.zAuth ){
TCL.Tcl_Free(pDb.zAuth);
}
zAuth = TCL.Tcl_GetStringFromObj(objv[2], len);
if( zAuth && len>0 ){
pDb.zAuth = TCL.Tcl_Alloc( len + 1 );
memcpy(pDb.zAuth, zAuth, len+1);
}else{
pDb.zAuth = 0;
}
if( pDb.zAuth ){
pDb.interp = interp;
sqlite3_set_authorizer(pDb.db, auth_callback, pDb);
}else{
sqlite3_set_authorizer(pDb.db, 0, 0);
}
}
break;
#endif
}
/* $db backup ?DATABASE? FILENAME
**
** Open or create a database file named FILENAME. Transfer the
** content of local database DATABASE (default: "main") into the
** FILENAME database.
*/
case (int)DB_enum.DB_BACKUP:
{
string zDestFile;
string zSrcDb;
sqlite3 pDest = null;
sqlite3_backup pBackup;
if ( objc == 3 )
{
zSrcDb = "main";
zDestFile = TCL.Tcl_GetString( objv[2] );
}
else if ( objc == 4 )
{
zSrcDb = TCL.Tcl_GetString( objv[2] );
zDestFile = TCL.Tcl_GetString( objv[3] );
}
else
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?DATABASE? FILENAME" );
return TCL.TCL_ERROR;
}
rc = sqlite3_open( zDestFile, out pDest );
if ( rc != SQLITE_OK )
{
TCL.Tcl_AppendResult( interp, "cannot open target database: ",
sqlite3_errmsg( pDest ) );
sqlite3_close( pDest );
return TCL.TCL_ERROR;
}
pBackup = sqlite3_backup_init( pDest, "main", pDb.db, zSrcDb );
if ( pBackup == null )
{
TCL.Tcl_AppendResult( interp, "backup failed: ",
sqlite3_errmsg( pDest ) );
sqlite3_close( pDest );
return TCL.TCL_ERROR;
}
#if SQLITE_HAS_CODEC
if ( pBackup.pSrc.pBt.pPager.pCodec != null )
{
pBackup.pDest.pBt.pPager.xCodec = pBackup.pSrc.pBt.pPager.xCodec;
pBackup.pDest.pBt.pPager.xCodecFree = pBackup.pSrc.pBt.pPager.xCodecFree;
pBackup.pDest.pBt.pPager.xCodecSizeChng = pBackup.pSrc.pBt.pPager.xCodecSizeChng;
pBackup.pDest.pBt.pPager.pCodec = pBackup.pSrc.pBt.pPager.pCodec.Copy();
}
#endif
while ( ( rc = sqlite3_backup_step( pBackup, 100 ) ) == SQLITE_OK )
{
}
sqlite3_backup_finish( pBackup );
if ( rc == SQLITE_DONE )
{
rc = TCL.TCL_OK;
}
else
{
TCL.Tcl_AppendResult( interp, "backup failed: ",
sqlite3_errmsg( pDest ) );
rc = TCL.TCL_ERROR;
}
sqlite3_close( pDest );
break;
}
// /* $db busy ?CALLBACK?
// **
// ** Invoke the given callback if an SQL statement attempts to open
// ** a locked database file.
// */
case (int)DB_enum.DB_BUSY:
{
if ( objc > 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "CALLBACK" );
return TCL.TCL_ERROR;
}
else if ( objc == 2 )
{
if ( pDb.zBusy != null )
{
TCL.Tcl_AppendResult( interp, pDb.zBusy );
}
}
else
{
string zBusy;
int len = 0;
if ( pDb.zBusy != null )
{
TCL.Tcl_Free( ref pDb.zBusy );
}
zBusy = TCL.Tcl_GetStringFromObj( objv[2], out len );
if ( zBusy != null && len > 0 )
{
//pDb.zBusy = TCL.Tcl_Alloc( len + 1 );
pDb.zBusy = zBusy;// memcpy( pDb.zBusy, zBusy, len + 1 );
}
else
{
pDb.zBusy = null;
}
if ( pDb.zBusy != null )
{
pDb.interp = interp;
sqlite3_busy_handler( pDb.db, (dxBusy)DbBusyHandler, pDb );
}
else
{
sqlite3_busy_handler( pDb.db, null, null );
}
}
break;
}
// /* $db cache flush
// ** $db cache size n
// **
// ** Flush the prepared statement cache, or set the maximum number of
// ** cached statements.
// */
case (int)DB_enum.DB_CACHE:
{
string subCmd;
int n = 0;
if ( objc <= 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "cache option ?arg?" );
return TCL.TCL_ERROR;
}
subCmd = TCL.Tcl_GetStringFromObj( objv[2], 0 );
if ( subCmd == "flush" )
{
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "flush" );
return TCL.TCL_ERROR;
}
else
{
flushStmtCache( pDb );
}
}
else if ( subCmd == "size" )
{
if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "size n" );
return TCL.TCL_ERROR;
}
else
{
if ( TCL.TCL_ERROR == ( TCL.Tcl_GetIntFromObj( interp, objv[3], out n ) != TCL.TCL_OK ? TCL.TCL_ERROR : TCL.TCL_OK ) )
{
TCL.Tcl_AppendResult( interp, "cannot convert \"",
TCL.Tcl_GetStringFromObj( objv[3], 0 ), "\" to integer", 0 );
return TCL.TCL_ERROR;
}
else
{
if ( n < 0 )
{
flushStmtCache( pDb );
n = 0;
}
else if ( n > MAX_PREPARED_STMTS )
{
n = MAX_PREPARED_STMTS;
}
pDb.maxStmt = n;
}
}
}
else
{
TCL.Tcl_AppendResult( interp, "bad option \"",
TCL.Tcl_GetStringFromObj( objv[2], 0 ), "\": must be flush or size", null );
return TCL.TCL_ERROR;
}
break;
}
/* $db changes
**
** Return the number of rows that were modified, inserted, or deleted by
** the most recent INSERT, UPDATE or DELETE statement, not including
** any changes made by trigger programs.
*/
case (int)DB_enum.DB_CHANGES:
{
Tcl_Obj pResult;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "" );
return TCL.TCL_ERROR;
}
pResult = TCL.Tcl_GetObjResult( interp );
TCL.Tcl_SetResult( interp, sqlite3_changes( pDb.db ).ToString(), 0 );
break;
}
/* $db close
**
** Shutdown the database
*/
case (int)DB_enum.DB_CLOSE:
{
TCL.Tcl_DeleteCommand( interp, TCL.Tcl_GetStringFromObj( objv[0], 0 ) );
break;
}
/*
** $db collate NAME SCRIPT
**
** Create a new SQL collation function called NAME. Whenever
** that function is called, invoke SCRIPT to evaluate the function.
*/
case (int)DB_enum.DB_COLLATE:
{
SqlCollate pCollate;
string zName;
string zScript;
int nScript = 0;
if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "NAME SCRIPT" );
return TCL.TCL_ERROR;
}
zName = TCL.Tcl_GetStringFromObj( objv[2], 0 );
zScript = TCL.Tcl_GetStringFromObj( objv[3], nScript );
pCollate = new SqlCollate();//(SqlCollate)Tcl_Alloc( sizeof(*pCollate) + nScript + 1 );
//if ( pCollate == null ) return TCL.TCL_ERROR;
pCollate.interp = interp;
pCollate.pNext = pDb.pCollate;
pCollate.zScript = zScript; // pCollate[1];
pDb.pCollate = pCollate;
//memcpy( pCollate.zScript, zScript, nScript + 1 );
if ( sqlite3_create_collation( pDb.db, zName, SQLITE_UTF8,
pCollate, (dxCompare)tclSqlCollate ) != 0 )
{
TCL.Tcl_SetResult( interp, sqlite3_errmsg( pDb.db ), TCL.TCL_VOLATILE );
return TCL.TCL_ERROR;
}
break;
}
/*
** $db collation_needed SCRIPT
**
** Create a new SQL collation function called NAME. Whenever
** that function is called, invoke SCRIPT to evaluate the function.
*/
case (int)DB_enum.DB_COLLATION_NEEDED:
{
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "SCRIPT" );
return TCL.TCL_ERROR;
}
if ( pDb.pCollateNeeded != null )
{
TCL.Tcl_DecrRefCount( ref pDb.pCollateNeeded );
}
pDb.pCollateNeeded = TCL.Tcl_DuplicateObj( objv[2] );
TCL.Tcl_IncrRefCount( pDb.pCollateNeeded );
sqlite3_collation_needed( pDb.db, (object)pDb, (dxCollNeeded)tclCollateNeeded );
break;
}
/* $db commit_hook ?CALLBACK?
**
** Invoke the given callback just before committing every SQL transaction.
** If the callback throws an exception or returns non-zero, then the
** transaction is aborted. If CALLBACK is an empty string, the callback
** is disabled.
*/
case (int)DB_enum.DB_COMMIT_HOOK:
{
if ( objc > 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?CALLBACK?" );
return TCL.TCL_ERROR;
}
else if ( objc == 2 )
{
if ( pDb.zCommit != null )
{
TCL.Tcl_AppendResult( interp, pDb.zCommit );
}
}
else
{
string zCommit;
int len = 0;
if ( pDb.zCommit != null )
{
TCL.Tcl_Free( ref pDb.zCommit );
}
zCommit = TCL.Tcl_GetStringFromObj( objv[2], out len );
if ( zCommit != null && len > 0 )
{
pDb.zCommit = zCommit;// TCL.Tcl_Alloc( len + 1 );
//memcpy( pDb.zCommit, zCommit, len + 1 );
}
else
{
pDb.zCommit = null;
}
if ( pDb.zCommit != null )
{
pDb.interp = interp;
sqlite3_commit_hook( pDb.db, DbCommitHandler, pDb );
}
else
{
sqlite3_commit_hook( pDb.db, null, null );
}
}
break;
}
/* $db complete SQL
**
** Return TRUE if SQL is a complete SQL statement. Return FALSE if
** additional lines of input are needed. This is similar to the
** built-in "info complete" command of Tcl.
*/
case (int)DB_enum.DB_COMPLETE:
{
#if !SQLITE_OMIT_COMPLETE
Tcl_Obj pResult;
int isComplete;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "SQL" );
return TCL.TCL_ERROR;
}
isComplete = sqlite3_complete( TCL.Tcl_GetStringFromObj( objv[2], 0 ) );
pResult = TCL.Tcl_GetObjResult( interp );
TCL.Tcl_SetBooleanObj( pResult, isComplete );
#endif
break;
}
/* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?
**
** Copy data into table from filename, optionally using SEPARATOR
** as column separators. If a column contains a null string, or the
** value of NULLINDICATOR, a NULL is inserted for the column.
** conflict-algorithm is one of the sqlite conflict algorithms:
** rollback, abort, fail, ignore, replace
** On success, return the number of lines processed, not necessarily same
** as 'db changes' due to conflict-algorithm selected.
**
** This code is basically an implementation/enhancement of
** the sqlite3 shell.c ".import" command.
**
** This command usage is equivalent to the sqlite2.x COPY statement,
** which imports file data into a table using the PostgreSQL COPY file format:
** $db copy $conflit_algo $table_name $filename \t \\N
*/
case (int)DB_enum.DB_COPY:
{
string zTable; /* Insert data into this table */
string zFile; /* The file from which to extract data */
string zConflict; /* The conflict algorithm to use */
sqlite3_stmt pStmt = null; /* A statement */
int nCol; /* Number of columns in the table */
int nByte; /* Number of bytes in an SQL string */
int i, j; /* Loop counters */
int nSep; /* Number of bytes in zSep[] */
int nNull; /* Number of bytes in zNull[] */
StringBuilder zSql = new StringBuilder( 200 ); /* An SQL statement */
string zLine; /* A single line of input from the file */
string[] azCol; /* zLine[] broken up into columns */
string zCommit; /* How to commit changes */
TextReader _in; /* The input file */
int lineno = 0; /* Line number of input file */
StringBuilder zLineNum = new StringBuilder( 80 ); /* Line number print buffer */
Tcl_Obj pResult; /* interp result */
string zSep;
string zNull;
if ( objc < 5 || objc > 7 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv,
"CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?" );
return TCL.TCL_ERROR;
}
if ( objc >= 6 )
{
zSep = TCL.Tcl_GetStringFromObj( objv[5], 0 );
}
else
{
zSep = "\t";
}
if ( objc >= 7 )
{
zNull = TCL.Tcl_GetStringFromObj( objv[6], 0 );
}
else
{
zNull = "";
}
zConflict = TCL.Tcl_GetStringFromObj( objv[2], 0 );
zTable = TCL.Tcl_GetStringFromObj( objv[3], 0 );
zFile = TCL.Tcl_GetStringFromObj( objv[4], 0 );
nSep = strlen30( zSep );
nNull = strlen30( zNull );
if ( nSep == 0 )
{
TCL.Tcl_AppendResult( interp, "Error: non-null separator required for copy" );
return TCL.TCL_ERROR;
}
if ( zConflict != "rollback" &&
zConflict != "abort" &&
zConflict != "fail" &&
zConflict != "ignore" &&
zConflict != "replace" )
{
TCL.Tcl_AppendResult( interp, "Error: \"", zConflict,
"\", conflict-algorithm must be one of: rollback, " +
"abort, fail, ignore, or replace", 0 );
return TCL.TCL_ERROR;
}
zSql.Append( sqlite3_mprintf( "SELECT * FROM '%q'", zTable ) );
if ( zSql == null )
{
TCL.Tcl_AppendResult( interp, "Error: no such table: ", zTable );
return TCL.TCL_ERROR;
}
nByte = strlen30( zSql );
rc = sqlite3_prepare( pDb.db, zSql.ToString(), -1, ref pStmt, 0 );
sqlite3DbFree( null, ref zSql );
if ( rc != 0 )
{
TCL.Tcl_AppendResult( interp, "Error: ", sqlite3_errmsg( pDb.db ) );
nCol = 0;
}
else
{
nCol = sqlite3_column_count( pStmt );
}
sqlite3_finalize( pStmt );
if ( nCol == 0 )
{
return TCL.TCL_ERROR;
}
//zSql.Append(malloc( nByte + 50 + nCol*2 );
//if( zSql==0 ) {
// TCL.Tcl_AppendResult(interp, "Error: can't malloc()");
// return TCL.TCL_ERROR;
//}
sqlite3_snprintf( nByte + 50, zSql, "INSERT OR %q INTO '%q' VALUES(?",
zConflict, zTable );
j = strlen30( zSql );
for ( i = 1; i < nCol; i++ )
{
//zSql+=[j++] = ',';
//zSql[j++] = '?';
zSql.Append( ",?" );
}
//zSql[j++] = ')';
//zSql[j] = "";
zSql.Append( ")" );
rc = sqlite3_prepare( pDb.db, zSql.ToString(), -1, ref pStmt, 0 );
//free(zSql);
if ( rc != 0 )
{
TCL.Tcl_AppendResult( interp, "Error: ", sqlite3_errmsg( pDb.db ) );
sqlite3_finalize( pStmt );
return TCL.TCL_ERROR;
}
_in = new StreamReader( zFile );//fopen(zFile, "rb");
if ( _in == null )
{
TCL.Tcl_AppendResult( interp, "Error: cannot open file: ", zFile );
sqlite3_finalize( pStmt );
return TCL.TCL_ERROR;
}
azCol = new string[nCol + 1];//malloc( sizeof(azCol[0])*(nCol+1) );
if ( azCol == null )
{
TCL.Tcl_AppendResult( interp, "Error: can't malloc()" );
_in.Close();//fclose(_in);
return TCL.TCL_ERROR;
}
sqlite3_exec( pDb.db, "BEGIN", 0, 0, 0 );
zCommit = "COMMIT";
while ( ( zLine = _in.ReadLine() ) != null )//local_getline(0, _in))!=0 )
{
string z;
i = 0;
lineno++;
azCol = zLine.Split( zSep[0] );
//for(i=0, z=zLine; *z; z++){
// if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){
// *z = 0;
// i++;
// if( i<nCol ){
// azCol[i] = z[nSep];
// z += nSep-1;
// }
// }
//}
if ( azCol.Length != nCol )
{
StringBuilder zErr = new StringBuilder( 200 );
int nErr = strlen30( zFile ) + 200;
//zErr = malloc(nErr);
//if( zErr ){
sqlite3_snprintf( nErr, zErr,
"Error: %s line %d: expected %d columns of data but found %d",
zFile, lineno, nCol, i + 1 );
TCL.Tcl_AppendResult( interp, zErr );
// free(zErr);
//}
zCommit = "ROLLBACK";
break;
}
for ( i = 0; i < nCol; i++ )
{
/* check for null data, if so, bind as null */
if ( ( nNull > 0 && azCol[i] == zNull )
|| strlen30( azCol[i] ) == 0
)
{
sqlite3_bind_null( pStmt, i + 1 );
}
else
{
sqlite3_bind_text( pStmt, i + 1, azCol[i], -1, SQLITE_STATIC );
}
}
sqlite3_step( pStmt );
rc = sqlite3_reset( pStmt );
//free(zLine);
if ( rc != SQLITE_OK )
{
TCL.Tcl_AppendResult( interp, "Error: ", sqlite3_errmsg( pDb.db ) );
zCommit = "ROLLBACK";
break;
}
}
//free(azCol);
_in.Close();// fclose( _in );
sqlite3_finalize( pStmt );
sqlite3_exec( pDb.db, zCommit, 0, 0, 0 );
if ( zCommit[0] == 'C' )
{
/* success, set result as number of lines processed */
pResult = TCL.Tcl_GetObjResult( interp );
TCL.Tcl_SetIntObj( pResult, lineno );
rc = TCL.TCL_OK;
}
else
{
/* failure, append lineno where failed */
sqlite3_snprintf( 80, zLineNum, "%d", lineno );
TCL.Tcl_AppendResult( interp, ", failed while processing line: ", zLineNum );
rc = TCL.TCL_ERROR;
}
break;
}
/*
** $db enable_load_extension BOOLEAN
**
** Turn the extension loading feature on or off. It if off by
** default.
*/
case (int)DB_enum.DB_ENABLE_LOAD_EXTENSION:
{
#if !SQLITE_OMIT_LOAD_EXTENSION
bool onoff = false;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "BOOLEAN" );
return TCL.TCL_ERROR;
}
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[2], out onoff ) )
{
return TCL.TCL_ERROR;
}
sqlite3_enable_load_extension( pDb.db, onoff ? 1 : 0 );
break;
#else
TCL.Tcl_AppendResult(interp, "extension loading is turned off at compile-time",
0);
return TCL.TCL_ERROR;
#endif
}
/*
** $db errorcode
**
** Return the numeric error code that was returned by the most recent
** call to sqlite3_exec().
*/
case (int)DB_enum.DB_ERRORCODE:
{
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( sqlite3_errcode( pDb.db ) ) );
break;
}
/*
** $db exists $sql
** $db onecolumn $sql
**
** The onecolumn method is the equivalent of:
** lindex [$db eval $sql] 0
*/
case (int)DB_enum.DB_EXISTS:
case (int)DB_enum.DB_ONECOLUMN:
{
DbEvalContext sEval = new DbEvalContext();
;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "SQL" );
return TCL.TCL_ERROR;
}
dbEvalInit( sEval, pDb, objv[2], null );
rc = dbEvalStep( sEval );
if ( choice == (int)DB_enum.DB_ONECOLUMN )
{
if ( rc == TCL.TCL_OK )
{
TCL.Tcl_SetObjResult( interp, dbEvalColumnValue( sEval, 0 ) );
}
}
else if ( rc == TCL.TCL_BREAK || rc == TCL.TCL_OK )
{
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewBooleanObj( ( rc == TCL.TCL_OK ? 1 : 0 ) ) );
}
dbEvalFinalize( sEval );
if ( rc == TCL.TCL_BREAK )
{
rc = TCL.TCL_OK;
}
break;
}
/*
** $db eval $sql ?array? ?{ ...code... }?
**
** The SQL statement in $sql is evaluated. For each row, the values are
** placed in elements of the array named "array" and ...code... is executed.
** If "array" and "code" are omitted, then no callback is every invoked.
** If "array" is an empty string, then the values are placed in variables
** that have the same name as the fields extracted by the query.
*/
case (int)DB_enum.DB_EVAL:
{
if ( objc < 3 || objc > 5 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "SQL ?ARRAY-NAME? ?SCRIPT?" );
return TCL.TCL_ERROR;
}
if ( objc == 3 )
{
DbEvalContext sEval = new DbEvalContext();
Tcl_Obj pRet = TCL.Tcl_NewObj();
TCL.Tcl_IncrRefCount( pRet );
dbEvalInit( sEval, pDb, objv[2], null );
//Console.WriteLine( objv[2].ToString() );
while ( TCL.TCL_OK == ( rc = dbEvalStep( sEval ) ) )
{
int i;
int nCol;
TclObject[] pDummy;
dbEvalRowInfo( sEval, out nCol, out pDummy );
for ( i = 0; i < nCol; i++ )
{
TCL.Tcl_ListObjAppendElement( interp, pRet, dbEvalColumnValue( sEval, i ) );
}
}
dbEvalFinalize( sEval );
if ( rc == TCL.TCL_BREAK )
{
TCL.Tcl_SetObjResult( interp, pRet );
rc = TCL.TCL_OK;
}
TCL.Tcl_DecrRefCount( ref pRet );
}
else
{
cd = new object[2];
DbEvalContext p;
Tcl_Obj pArray = null;
Tcl_Obj pScript;
if ( objc == 5 && !String.IsNullOrEmpty( TCL.Tcl_GetString( objv[3] ) ) )
{
pArray = objv[3];
}
pScript = objv[objc - 1];
TCL.Tcl_IncrRefCount( pScript );
p = new DbEvalContext();// (DbEvalContext)Tcl_Alloc( sizeof( DbEvalContext ) );
dbEvalInit( p, pDb, objv[2], pArray );
( (object[])cd )[0] = p;
( (object[])cd )[1] = pScript;
rc = DbEvalNextCmd( (object[])cd, interp, TCL.TCL_OK );
}
break;
}
/*
** $db function NAME [-argcount N] SCRIPT
**
** Create a new SQL function called NAME. Whenever that function is
** called, invoke SCRIPT to evaluate the function.
*/
case (int)DB_enum.DB_FUNCTION:
{
SqlFunc pFunc;
Tcl_Obj pScript;
string zName;
int nArg = -1;
if ( objc == 6 )
{
string z = TCL.Tcl_GetString( objv[3] );
int n = strlen30( z );
if ( n > 2 && z.StartsWith( "-argcount" ) )//strncmp( z, "-argcount", n ) == 0 )
{
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[4], out nArg ) )
return TCL.TCL_ERROR;
if ( nArg < 0 )
{
TCL.Tcl_AppendResult( interp, "number of arguments must be non-negative" );
return TCL.TCL_ERROR;
}
}
pScript = objv[5];
}
else if ( objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "NAME [-argcount N] SCRIPT" );
return TCL.TCL_ERROR;
}
else
{
pScript = objv[3];
}
zName = TCL.Tcl_GetStringFromObj( objv[2], 0 );
pFunc = findSqlFunc( pDb, zName );
if ( pFunc == null )
return TCL.TCL_ERROR;
if ( pFunc.pScript != null )
{
TCL.Tcl_DecrRefCount( ref pFunc.pScript );
}
pFunc.pScript = pScript;
TCL.Tcl_IncrRefCount( pScript );
pFunc.useEvalObjv = safeToUseEvalObjv( interp, pScript );
rc = sqlite3_create_function( pDb.db, zName, nArg, SQLITE_UTF8,
pFunc, tclSqlFunc, null, null );
if ( rc != SQLITE_OK )
{
rc = TCL.TCL_ERROR;
TCL.Tcl_SetResult( interp, sqlite3_errmsg( pDb.db ), TCL.TCL_VOLATILE );
}
break;
}
/*
** $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID
*/
case (int)DB_enum.DB_INCRBLOB:
{
#if SQLITE_OMIT_INCRBLOB
TCL.Tcl_AppendResult( interp, "incrblob not available in this build" );
return TCL.TCL_ERROR;
#else
int isReadonly = 0;
string zDb = "main" ;
string zTable;
string zColumn;
long iRow = 0;
/* Check for the -readonly option */
if ( objc > 3 && TCL.Tcl_GetString( objv[2] ) == "-readonly" )
{
isReadonly = 1;
}
if ( objc != ( 5 + isReadonly ) && objc != ( 6 + isReadonly ) )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?-readonly? ?DB? TABLE COLUMN ROWID" );
return TCL.TCL_ERROR;
}
if ( objc == ( 6 + isReadonly ) )
{
zDb = TCL.Tcl_GetString( objv[2] ) ;
}
zTable = TCL.Tcl_GetString( objv[objc - 3] );
zColumn = TCL.Tcl_GetString( objv[objc - 2] ) ;
rc = TCL.Tcl_GetWideIntFromObj( interp, objv[objc - 1], out iRow ) ? 1 : 0;
if ( rc == TCL.TCL_OK )
{
rc = createIncrblobChannel(
interp, pDb, zDb, zTable, zColumn, iRow, isReadonly
);
}
break;
#endif
}
/*
** $db interrupt
**
** Interrupt the execution of the inner-most SQL interpreter. This
** causes the SQL statement to return an error of SQLITE_INTERRUPT.
*/
case (int)DB_enum.DB_INTERRUPT:
{
sqlite3_interrupt( pDb.db );
break;
}
/*
** $db nullvalue ?STRING?
**
** Change text used when a NULL comes back from the database. If ?STRING?
** is not present, then the current string used for NULL is returned.
** If STRING is present, then STRING is returned.
**
*/
case (int)DB_enum.DB_NULLVALUE:
{
if ( objc != 2 && objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "NULLVALUE" );
return TCL.TCL_ERROR;
}
if ( objc == 3 )
{
int len = 0;
string zNull = TCL.Tcl_GetStringFromObj( objv[2], out len );
if ( pDb.zNull != null )
{
TCL.Tcl_Free( ref pDb.zNull );
}
if ( zNull != null && len > 0 )
{
pDb.zNull = zNull;
//pDb.zNull = TCL.Tcl_Alloc( len + 1 );
//memcpy(pDb->zNull, zNull, len);
//pDb.zNull[len] = '\0';
}
else
{
pDb.zNull = null;
}
}
TCL.Tcl_SetObjResult( interp, dbTextToObj( pDb.zNull ) );
break;
}
/*
** $db last_insert_rowid
**
** Return an integer which is the ROWID for the most recent insert.
*/
case (int)DB_enum.DB_LAST_INSERT_ROWID:
{
Tcl_Obj pResult;
Tcl_WideInt rowid;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "" );
return TCL.TCL_ERROR;
}
rowid = sqlite3_last_insert_rowid( pDb.db );
pResult = TCL.Tcl_GetObjResult( interp );
TCL.Tcl_SetLongObj( pResult, rowid );
break;
}
/*
** The DB_ONECOLUMN method is implemented together with DB_EXISTS.
*/
/* $db progress ?N CALLBACK?
**
** Invoke the given callback every N virtual machine opcodes while executing
** queries.
*/
case (int)DB_enum.DB_PROGRESS:
{
if ( objc == 2 )
{
if ( !String.IsNullOrEmpty( pDb.zProgress ) )
{
TCL.Tcl_AppendResult( interp, pDb.zProgress );
}
}
else if ( objc == 4 )
{
string zProgress;
int len = 0;
int N = 0;
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out N ) )
{
return TCL.TCL_ERROR;
};
if ( !String.IsNullOrEmpty( pDb.zProgress ) )
{
TCL.Tcl_Free( ref pDb.zProgress );
}
zProgress = TCL.Tcl_GetStringFromObj( objv[3], len );
if ( !String.IsNullOrEmpty( zProgress ) )
{
//pDb.zProgress = TCL.Tcl_Alloc( len + 1 );
//memcpy( pDb.zProgress, zProgress, len + 1 );
pDb.zProgress = zProgress;
}
else
{
pDb.zProgress = null;
}
#if !SQLITE_OMIT_PROGRESS_CALLBACK
if ( !String.IsNullOrEmpty( pDb.zProgress ) )
{
pDb.interp = interp;
sqlite3_progress_handler( pDb.db, N, DbProgressHandler, pDb );
}
else
{
sqlite3_progress_handler( pDb.db, 0, null, 0 );
}
#endif
}
else
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "N CALLBACK" );
return TCL.TCL_ERROR;
}
break;
}
/* $db profile ?CALLBACK?
**
** Make arrangements to invoke the CALLBACK routine after each SQL statement
** that has run. The text of the SQL and the amount of elapse time are
** appended to CALLBACK before the script is run.
*/
case (int)DB_enum.DB_PROFILE:
{
if ( objc > 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?CALLBACK?" );
return TCL.TCL_ERROR;
}
else if ( objc == 2 )
{
if ( !String.IsNullOrEmpty( pDb.zProfile ) )
{
TCL.Tcl_AppendResult( interp, pDb.zProfile );
}
}
else
{
string zProfile;
int len = 0;
if ( !String.IsNullOrEmpty( pDb.zProfile ) )
{
TCL.Tcl_Free( ref pDb.zProfile );
}
zProfile = TCL.Tcl_GetStringFromObj( objv[2], out len );
if ( !String.IsNullOrEmpty( zProfile ) && len > 0 )
{
//pDb.zProfile = TCL.Tcl_Alloc( len + 1 );
//memcpy( pDb.zProfile, zProfile, len + 1 );
pDb.zProfile = zProfile;
}
else
{
pDb.zProfile = null;
}
#if !SQLITE_OMIT_TRACE && !(SQLITE_OMIT_FLOATING_POINT)
if ( !String.IsNullOrEmpty( pDb.zProfile ) )
{
pDb.interp = interp;
sqlite3_profile( pDb.db, DbProfileHandler, pDb );
}
else
{
sqlite3_profile( pDb.db, null, null );
}
#endif
}
break;
}
/*
** $db rekey KEY
**
** Change the encryption key on the currently open database.
*/
case (int)DB_enum.DB_REKEY:
{
int nKey = 0;
string pKey;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "KEY" );
return TCL.TCL_ERROR;
}
pKey = TCL.Tcl_GetStringFromObj( objv[2], out nKey );
#if SQLITE_HAS_CODEC
rc = sqlite3_rekey( pDb.db, pKey, nKey );
if ( rc != 0 )
{
TCL.Tcl_AppendResult( interp, sqlite3ErrStr( rc ) );
rc = TCL.TCL_ERROR;
}
#endif
break;
}
/* $db restore ?DATABASE? FILENAME
**
** Open a database file named FILENAME. Transfer the content
** of FILENAME into the local database DATABASE (default: "main").
*/
case (int)DB_enum.DB_RESTORE:
{
string zSrcFile;
string zDestDb;
sqlite3 pSrc = null;
sqlite3_backup pBackup;
int nTimeout = 0;
if ( objc == 3 )
{
zDestDb = "main";
zSrcFile = TCL.Tcl_GetString( objv[2] );
}
else if ( objc == 4 )
{
zDestDb = TCL.Tcl_GetString( objv[2] );
zSrcFile = TCL.Tcl_GetString( objv[3] );
}
else
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?DATABASE? FILENAME" );
return TCL.TCL_ERROR;
}
rc = sqlite3_open_v2( zSrcFile, out pSrc, SQLITE_OPEN_READONLY, null );
if ( rc != SQLITE_OK )
{
TCL.Tcl_AppendResult( interp, "cannot open source database: ",
sqlite3_errmsg( pSrc ) );
sqlite3_close( pSrc );
return TCL.TCL_ERROR;
}
pBackup = sqlite3_backup_init( pDb.db, zDestDb, pSrc, "main" );
if ( pBackup == null )
{
TCL.Tcl_AppendResult( interp, "restore failed: ",
sqlite3_errmsg( pDb.db ) );
sqlite3_close( pSrc );
return TCL.TCL_ERROR;
}
#if SQLITE_HAS_CODEC
if ( pBackup.pDestDb.aDb[0].pBt.pBt.pPager.pCodec != null )
{
pBackup.pSrc.pBt.pPager.xCodec = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodec;
pBackup.pSrc.pBt.pPager.xCodecFree = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodecFree;
pBackup.pSrc.pBt.pPager.xCodecSizeChng = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodecSizeChng;
pBackup.pSrc.pBt.pPager.pCodec = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.pCodec.Copy();
if ( pBackup.pDest.GetHashCode() != pBackup.pDestDb.aDb[0].GetHashCode() ) // Not Main Database
{
pBackup.pDest.pBt.pPager.xCodec = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodec;
pBackup.pDest.pBt.pPager.xCodecFree = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodecFree;
pBackup.pDest.pBt.pPager.xCodecSizeChng = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.xCodecSizeChng;
pBackup.pDest.pBt.pPager.pCodec = pBackup.pDestDb.aDb[0].pBt.pBt.pPager.pCodec.Copy();
}
}
#endif
while ( ( rc = sqlite3_backup_step( pBackup, 100 ) ) == SQLITE_OK
|| rc == SQLITE_BUSY )
{
if ( rc == SQLITE_BUSY )
{
if ( nTimeout++ >= 3 )
break;
sqlite3_sleep( 100 );
}
}
sqlite3_backup_finish( pBackup );
if ( rc == SQLITE_DONE )
{
rc = TCL.TCL_OK;
}
else if ( rc == SQLITE_BUSY || rc == SQLITE_LOCKED )
{
TCL.Tcl_AppendResult( interp, "restore failed: source database busy"
);
rc = TCL.TCL_ERROR;
}
else
{
TCL.Tcl_AppendResult( interp, "restore failed: ",
sqlite3_errmsg( pDb.db ) );
rc = TCL.TCL_ERROR;
}
sqlite3_close( pSrc );
break;
}
/*
** $db status (step|sort|autoindex)
**
** Display SQLITE_STMTSTATUS_FULLSCAN_STEP or
** SQLITE_STMTSTATUS_SORT for the most recent eval.
*/
case (int)DB_enum.DB_STATUS:
{
int v;
string zOp;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "(step|sort|autoindex)" );
return TCL.TCL_ERROR;
}
zOp = TCL.Tcl_GetString( objv[2] );
if ( zOp == "step" )
{
v = pDb.nStep;
}
else if ( zOp == "sort" )
{
v = pDb.nSort;
}
else if ( zOp == "autoindex" )
{
v = pDb.nIndex;
}
else
{
TCL.Tcl_AppendResult( interp, "bad argument: should be autoindex, step or sort" );
return TCL.TCL_ERROR;
}
TCL.Tcl_SetObjResult( interp, TCL.Tcl_NewIntObj( v ) );
break;
}
/*
** $db timeout MILLESECONDS
**
** Delay for the number of milliseconds specified when a file is locked.
*/
case (int)DB_enum.DB_TIMEOUT:
{
int ms = 0;
if ( objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "MILLISECONDS" );
return TCL.TCL_ERROR;
}
if ( TCL.TCL_OK != TCL.Tcl_GetIntFromObj( interp, objv[2], out ms ) )
return TCL.TCL_ERROR;
sqlite3_busy_timeout( pDb.db, ms );
break;
}
/*
** $db total_changes
**
** Return the number of rows that were modified, inserted, or deleted
** since the database handle was created.
*/
case (int)DB_enum.DB_TOTAL_CHANGES:
{
Tcl_Obj pResult;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "" );
return TCL.TCL_ERROR;
}
pResult = TCL.Tcl_GetObjResult( interp );
TCL.Tcl_SetIntObj( pResult, sqlite3_total_changes( pDb.db ) );
break;
}
/* $db trace ?CALLBACK?
**
** Make arrangements to invoke the CALLBACK routine for each SQL statement
** that is executed. The text of the SQL is appended to CALLBACK before
** it is executed.
*/
case (int)DB_enum.DB_TRACE:
{
if ( objc > 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?CALLBACK?" );
return TCL.TCL_ERROR;
}
else if ( objc == 2 )
{
if ( pDb.zTrace != null )
{
TCL.Tcl_AppendResult( interp, pDb.zTrace );
}
}
else
{
string zTrace;
int len = 0;
if ( pDb.zTrace != null )
{
TCL.Tcl_Free( ref pDb.zTrace );
}
zTrace = TCL.Tcl_GetStringFromObj( objv[2], out len );
if ( zTrace != null && len > 0 )
{
//pDb.zTrace = TCL.Tcl_Alloc( len + 1 );
pDb.zTrace = zTrace;//memcpy( pDb.zTrace, zTrace, len + 1 );
}
else
{
pDb.zTrace = null;
}
#if !SQLITE_OMIT_TRACE && !(SQLITE_OMIT_FLOATING_POINT)
if ( pDb.zTrace != null )
{
pDb.interp = interp;
sqlite3_trace( pDb.db, (dxTrace)DbTraceHandler, pDb );
}
else
{
sqlite3_trace( pDb.db, null, null );
}
#endif
}
break;
}
// /* $db transaction [-deferred|-immediate|-exclusive] SCRIPT
// **
// ** Start a new transaction (if we are not already in the midst of a
// ** transaction) and execute the TCL script SCRIPT. After SCRIPT
// ** completes, either commit the transaction or roll it back if SCRIPT
// ** throws an exception. Or if no new transation was started, do nothing.
// ** pass the exception on up the stack.
// **
// ** This command was inspired by Dave Thomas's talk on Ruby at the
// ** 2005 O'Reilly Open Source Convention (OSCON).
// */
case (int)DB_enum.DB_TRANSACTION:
{
Tcl_Obj pScript;
string zBegin = "SAVEPOINT _tcl_transaction";
if ( objc != 3 && objc != 4 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "[TYPE] SCRIPT" );
return TCL.TCL_ERROR;
}
if ( pDb.nTransaction == 0 && objc == 4 )
{
string[] TTYPE_strs = { "deferred", "exclusive", "immediate", null };
int ttype = 0;
if ( TCL.Tcl_GetIndexFromObj( interp, objv[2], TTYPE_strs, "transaction type",
0, out ttype ) )
{
return TCL.TCL_ERROR;
}
switch ( ttype )
{
case (int)TTYPE_enum.TTYPE_DEFERRED: /* no-op */
;
break;
case (int)TTYPE_enum.TTYPE_EXCLUSIVE:
zBegin = "BEGIN EXCLUSIVE";
break;
case (int)TTYPE_enum.TTYPE_IMMEDIATE:
zBegin = "BEGIN IMMEDIATE";
break;
}
}
pScript = objv[objc - 1];
/* Run the SQLite BEGIN command to open a transaction or savepoint. */
pDb.disableAuth++;
rc = sqlite3_exec( pDb.db, zBegin, 0, 0, 0 );
pDb.disableAuth--;
if ( rc != SQLITE_OK )
{
TCL.Tcl_AppendResult( interp, sqlite3_errmsg( pDb.db ) );
return TCL.TCL_ERROR;
}
pDb.nTransaction++;
/* If using NRE, schedule a callback to invoke the script pScript, then
** a second callback to commit (or rollback) the transaction or savepoint
** opened above. If not using NRE, evaluate the script directly, then
** call function DbTransPostCmd() to commit (or rollback) the transaction
** or savepoint. */
if ( DbUseNre() )
{
Debugger.Break();
//Tcl_NRAddCallback( interp, DbTransPostCmd, cd, 0, 0, 0 );
//Tcl_NREvalObj(interp, pScript, 0);
}
else
{
rc = DbTransPostCmd( cd, interp, TCL.Tcl_EvalObjEx( interp, pScript, 0 ) );
}
break;
}
/*
** $db unlock_notify ?script?
*/
case (int)DB_enum.DB_UNLOCK_NOTIFY:
{
#if !SQLITE_ENABLE_UNLOCK_NOTIFY
TCL.Tcl_AppendResult( interp, "unlock_notify not available in this build", 0 );
rc = TCL.TCL_ERROR;
#else
if( objc!=2 && objc!=3 ){
Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");
rc = TCL.Tcl_ERROR;
}else{
void (*xNotify)(void **, int) = 0;
void *pNotifyArg = 0;
if( pDb.pUnlockNotify ){
Tcl_DecrRefCount(pDb.pUnlockNotify);
pDb.pUnlockNotify = 0;
}
if( objc==3 ){
xNotify = DbUnlockNotify;
pNotifyArg = (void )pDb;
pDb.pUnlockNotify = objv[2];
Tcl_IncrRefCount(pDb.pUnlockNotify);
}
if( sqlite3_unlock_notify(pDb.db, xNotify, pNotifyArg) ){
Tcl_AppendResult(interp, sqlite3_errmsg(pDb.db), 0);
rc = TCL.Tcl_ERROR;
}
}
#endif
break;
}
/*
** $db wal_hook ?script?
** $db update_hook ?script?
** $db rollback_hook ?script?
*/
case (int)DB_enum.DB_WAL_HOOK:
case (int)DB_enum.DB_UPDATE_HOOK:
case (int)DB_enum.DB_ROLLBACK_HOOK:
{
/* set ppHook to point at pUpdateHook or pRollbackHook, depending on
** whether [$db update_hook] or [$db rollback_hook] was invoked.
*/
Tcl_Obj ppHook;
if ( choice == (int)DB_enum.DB_UPDATE_HOOK )
{
ppHook = pDb.pUpdateHook;
}
else if ( choice == (int)DB_enum.DB_WAL_HOOK )
{
ppHook = pDb.pWalHook;
}
else
{
ppHook = pDb.pRollbackHook;
}
if ( objc != 2 && objc != 3 )
{
TCL.Tcl_WrongNumArgs( interp, 2, objv, "?SCRIPT?" );
return TCL.TCL_ERROR;
}
if ( ppHook != null )
{
TCL.Tcl_SetObjResult( interp, ppHook );
if ( objc == 3 )
{
TCL.Tcl_DecrRefCount( ref ppHook );
ppHook = null;
}
}
if ( objc == 3 )
{
Debug.Assert( null == ppHook );
if ( objv[2] != null )//TCL.Tcl_GetCharLength( objv[2] ) > 0 )
{
ppHook = objv[2];
TCL.Tcl_IncrRefCount( ppHook );
}
}
if ( choice == (int)DB_enum.DB_UPDATE_HOOK )
{
pDb.pUpdateHook = ppHook;
}
else
{
pDb.pRollbackHook = ppHook;
}
sqlite3_update_hook( pDb.db, ( pDb.pUpdateHook != null ? (dxUpdateCallback)DbUpdateHandler : null ), pDb );
sqlite3_rollback_hook( pDb.db, ( pDb.pRollbackHook != null ? (dxRollbackCallback)DbRollbackHandler : null ), pDb );
sqlite3_wal_hook( pDb.db, ( pDb.pWalHook != null ? (dxWalCallback)DbWalHandler : null ), pDb );
break;
}
/* $db version
**
** Return the version string for this database.
*/
case (int)DB_enum.DB_VERSION:
{
TCL.Tcl_SetResult( interp, sqlite3_libversion(), TCL.TCL_STATIC );
break;
}
default:
Debug.Assert( false, "Missing switch:" + objv[1].ToString() );
break;
} /* End of the SWITCH statement */
return rc;
}
#if SQLITE_TCL_NRE
/*
** Adaptor that provides an objCmd interface to the NRE-enabled
** interface implementation.
*/
static int DbObjCmdAdaptor(
void *cd,
Tcl_Interp interp,
int objc,
Tcl_Obj *const*objv
){
return TCL.TCL_NRCallObjProc(interp, DbObjCmd, cd, objc, objv);
}
#endif //* SQLITE_TCL_NRE */
/*
** sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?
** ?-create BOOLEAN? ?-nomutex BOOLEAN?
**
** This is the main Tcl command. When the "sqlite" Tcl command is
** invoked, this routine runs to process that command.
**
** The first argument, DBNAME, is an arbitrary name for a new
** database connection. This command creates a new command named
** DBNAME that is used to control that connection. The database
** connection is deleted when the DBNAME command is deleted.
**
** The second argument is the name of the database file.
**
*/
static int DbMain( object cd, Tcl_Interp interp, int objc, Tcl_Obj[] objv )
{
SqliteDb p;
string pKey = null;
int nKey = 0;
string zArg;
string zErrMsg;
int i;
string zFile;
string zVfs = null;
int flags;
Tcl_DString translatedFilename;
/* In normal use, each TCL interpreter runs in a single thread. So
** by default, we can turn of mutexing on SQLite database connections.
** However, for testing purposes it is useful to have mutexes turned
** on. So, by default, mutexes default off. But if compiled with
** SQLITE_TCL_DEFAULT_FULLMUTEX then mutexes default on.
*/
#if SQLITE_TCL_DEFAULT_FULLMUTEX
flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
#else
flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX;
#endif
if ( objc == 2 )
{
zArg = TCL.Tcl_GetStringFromObj( objv[1], 0 );
if ( zArg == "-version" )
{
TCL.Tcl_AppendResult( interp, sqlite3_version, null );
return TCL.TCL_OK;
}
if ( zArg == "-has-codec" )
{
#if SQLITE_HAS_CODEC
TCL.Tcl_AppendResult( interp, "1" );
#else
TCL.Tcl_AppendResult( interp, "0", null );
#endif
return TCL.TCL_OK;
}
if ( zArg == "-tcl-uses-utf" )
{
TCL.Tcl_AppendResult( interp, "1", null );
return TCL.TCL_OK;
}
}
for ( i = 3; i + 1 < objc; i += 2 )
{
zArg = TCL.Tcl_GetString( objv[i] );
if ( zArg == "-key" )
{
pKey = TCL.Tcl_GetStringFromObj( objv[i + 1], out nKey );
}
else if ( zArg == "-vfs" )
{
zVfs = TCL.Tcl_GetString( objv[i + 1] );
}
else if ( zArg == "-readonly" )
{
bool b = false;
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], out b ) )
return TCL.TCL_ERROR;
if ( b )
{
flags &= ~( SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE );
flags |= SQLITE_OPEN_READONLY;
}
else
{
flags &= ~SQLITE_OPEN_READONLY;
flags |= SQLITE_OPEN_READWRITE;
}
}
else if ( zArg == "-create" )
{
bool b = false;
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], out b ) )
return TCL.TCL_ERROR;
if ( b && ( flags & SQLITE_OPEN_READONLY ) == 0 )
{
flags |= SQLITE_OPEN_CREATE;
}
else
{
flags &= ~SQLITE_OPEN_CREATE;
}
}
else if ( zArg == "-nomutex" )
{
bool b = false;
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], out b ) )
return TCL.TCL_ERROR;
if ( b )
{
flags |= SQLITE_OPEN_NOMUTEX;
flags &= ~SQLITE_OPEN_FULLMUTEX;
}
else
{
flags &= ~SQLITE_OPEN_NOMUTEX;
}
}
else if ( zArg == "-fullmutex" )//strcmp( zArg, "-fullmutex" ) == 0 )
{
bool b = false;
if ( TCL.Tcl_GetBooleanFromObj( interp, objv[i + 1], out b ) )
return TCL.TCL_ERROR;
if ( b )
{
flags |= SQLITE_OPEN_FULLMUTEX;
flags &= ~SQLITE_OPEN_NOMUTEX;
}
else
{
flags &= ~SQLITE_OPEN_FULLMUTEX;
}
}
else
{
TCL.Tcl_AppendResult( interp, "unknown option: ", zArg, null );
return TCL.TCL_ERROR;
}
}
if ( objc < 3 || ( objc & 1 ) != 1 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv,
"HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN? ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN?"
#if SQLITE_HAS_CODEC
+ " ?-key CODECKEY?"
#endif
);
return TCL.TCL_ERROR;
}
zErrMsg = "";
p = new SqliteDb();//(SqliteDb)Tcl_Alloc( sizeof(*p) );
if ( p == null )
{
TCL.Tcl_SetResult( interp, "malloc failed", TCL.TCL_STATIC );
return TCL.TCL_ERROR;
}
//memset(p, 0, sizeof(*p));
zFile = TCL.Tcl_GetStringFromObj( objv[2], 0 );
//zFile = TCL.Tcl_TranslateFileName( interp, zFile, ref translatedFilename );
sqlite3_open_v2( zFile, out p.db, flags, zVfs );
//Tcl_DStringFree( ref translatedFilename );
if ( SQLITE_OK != sqlite3_errcode( p.db ) )
{
zErrMsg = sqlite3_errmsg( p.db );// sqlite3_mprintf( "%s", sqlite3_errmsg( p.db ) );
sqlite3_close( p.db );
p.db = null;
}
#if SQLITE_HAS_CODEC
if ( p.db != null )
{
sqlite3_key( p.db, pKey, nKey );
}
#endif
if ( p.db == null )
{
TCL.Tcl_SetResult( interp, zErrMsg, TCL.TCL_VOLATILE );
TCL.Tcl_Free( ref p );
zErrMsg = "";// sqlite3DbFree( db, ref zErrMsg );
return TCL.TCL_ERROR;
}
p.maxStmt = NUM_PREPARED_STMTS;
p.interp = interp;
zArg = TCL.Tcl_GetStringFromObj( objv[1], 0 );
if ( DbUseNre() )
{
Debugger.Break();
//Tcl_NRCreateCommand(interp, zArg, DbObjCmdAdaptor, DbObjCmd,
// p, DbDeleteCmd);
}
else
{
TCL.Tcl_CreateObjCommand( interp, zArg, (Interp.dxObjCmdProc)DbObjCmd, p, (Interp.dxCmdDeleteProc)DbDeleteCmd );
}
return TCL.TCL_OK;
}
/*
** Provide a dummy TCL.Tcl_InitStubs if we are using this as a static
** library.
*/
#if !USE_TCL_STUBS
//# undef TCL.Tcl_InitStubs
static void Tcl_InitStubs( Tcl_Interp interp, string s, int i )
{
}
#endif
/*
** Make sure we have a PACKAGE_VERSION macro defined. This will be
** defined automatically by the TEA makefile. But other makefiles
** do not define it.
*/
#if !PACKAGE_VERSION
public static string PACKAGE_VERSION;//# define PACKAGE_VERSION SQLITE_VERSION
#endif
/*
** Initialize this module.
**
** This Tcl module contains only a single new Tcl command named "sqlite".
** (Hence there is no namespace. There is no point in using a namespace
** if the extension only supplies one new name!) The "sqlite" command is
** used to open a new SQLite database. See the DbMain() routine above
** for additional information.
**
** The EXTERN macros are required by TCL in order to work on windows.
*/
//int Sqlite3_Init(Tcl_Interp interp){
static public int Sqlite3_Init( Tcl_Interp interp )
{
PACKAGE_VERSION = SQLITE_VERSION;
Tcl_InitStubs( interp, "tclsharp 8.4", 0 );
TCL.Tcl_CreateObjCommand( interp, "sqlite3", (Interp.dxObjCmdProc)DbMain, null, null );
TCL.Tcl_PkgProvide( interp, "sqlite3", PACKAGE_VERSION );
#if !SQLITE_3_SUFFIX_ONLY
/* The "sqlite" alias is undocumented. It is here only to support
** legacy scripts. All new scripts should use only the "sqlite3"
** command.
*/
TCL.Tcl_CreateObjCommand( interp, "sqlite", (Interp.dxObjCmdProc)DbMain, null, null );
#endif
return TCL.TCL_OK;
}
//int Tclsqlite3_Init(Tcl_Interp interp){ return Sqlite3_Init(interp); }
//int Sqlite3_SafeInit(Tcl_Interp interp){ return TCL.TCL_OK; }
//int Tclsqlite3_SafeInit(Tcl_Interp interp){ return TCL.TCL_OK; }
//int Sqlite3_Unload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Tclsqlite3_Unload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Sqlite3_SafeUnload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Tclsqlite3_SafeUnload(Tcl_Interp interp, int flags){ return TCL.TCL_OK;}
#if !SQLITE_3_SUFFIX_ONLY
//int Sqlite_Init(Tcl_Interp interp){ return Sqlite3_Init(interp); }
//int Tclsqlite_Init(Tcl_Interp interp){ return Sqlite3_Init(interp); }
//int Sqlite_SafeInit(Tcl_Interp interp){ return TCL.TCL_OK; }
//int Tclsqlite_SafeInit(Tcl_Interp interp){ return TCL.TCL_OK; }
//int Sqlite_Unload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Tclsqlite_Unload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Sqlite_SafeUnload(Tcl_Interp interp, int flags){ return TCL.TCL_OK; }
//int Tclsqlite_SafeUnload(Tcl_Interp interp, int flags){ return TCL.TCL_OK;}
#endif
#if TCLSH
/*****************************************************************************
** All of the code that follows is used to build standalone TCL interpreters
** that are statically linked with SQLite. Enable these by compiling
** with -DTCLSH=n where n can be 1 or 2. An n of 1 generates a standard
** tclsh but with SQLite built in. An n of 2 generates the SQLite space
** analysis program.
*/
#if (SQLITE_TEST) || (SQLITE_TCLMD5)
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*
* To compute the message digest of a chunk of bytes, declare an
* MD5Context structure, pass it to MD5Init, call MD5Update as
* needed on buffers full of bytes, and then call MD5Final, which
* will fill a supplied 16-byte array with the digest.
*/
/*
* If compiled on a machine that doesn't have a 32-bit integer,
* you just set "uint32" to the appropriate datatype for an
* unsigned 32-bit integer. For example:
*
* cc -Duint32='unsigned long' md5.c
*
*/
//#if !uint32
//# define uint32 unsigned int
//#endif
//struct MD5Context {
// int isInit;
// uint32 buf[4];
// uint32 bits[2];
// unsigned char in[64];
//};
//typedef struct MD5Context MD5Context;
class MD5Context
{
public bool isInit;
public u32[] buf = new u32[4];
public u32[] bits = new u32[2];
public u32[] _in = new u32[64];
public Mem _Mem;
};
/*
* Note: this code is harmless on little-endian machines.
*/
//static void byteReverse (unsigned char *buf, unsigned longs){
// uint32 t;
// do {
// t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
// ((unsigned)buf[1]<<8 | buf[0]);
// *(uint32 )buf = t;
// buf += 4;
// } while (--longs);
//}
/* The four core functions - F1 is optimized somewhat */
delegate u32 dxF1234( u32 x, u32 y, u32 z );
//* #define F1(x, y, z) (x & y | ~x & z) */
//#define F1(x, y, z) (z ^ (x & (y ^ z)))
static u32 F1( u32 x, u32 y, u32 z )
{
return ( z ^ ( x & ( y ^ z ) ) );
}
//#define F2(x, y, z) F1(z, x, y)
static u32 F2( u32 x, u32 y, u32 z )
{
return F1( z, x, y );
}
//#define F3(x, y, z) (x ^ y ^ z)
static u32 F3( u32 x, u32 y, u32 z )
{
return ( x ^ y ^ z );
}
//#define F4(x, y, z) (y ^ (x | ~z))
static u32 F4( u32 x, u32 y, u32 z )
{
return ( y ^ ( x | ~z ) );
}
///* This is the central step in the MD5 algorithm. */
//#define MD5STEP(f, w, x, y, z, data, s) \
// ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
static void MD5STEP( dxF1234 f, ref u32 w, u32 x, u32 y, u32 z, u32 data, byte s )
{
w += f( x, y, z ) + data;
w = w << s | w >> ( 32 - s );
w += x;
}
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
static void MD5Transform( u32[] buf, u32[] _in )
{
u32 a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP( F1, ref a, b, c, d, _in[0] + 0xd76aa478, 7 );
MD5STEP( F1, ref d, a, b, c, _in[1] + 0xe8c7b756, 12 );
MD5STEP( F1, ref c, d, a, b, _in[2] + 0x242070db, 17 );
MD5STEP( F1, ref b, c, d, a, _in[3] + 0xc1bdceee, 22 );
MD5STEP( F1, ref a, b, c, d, _in[4] + 0xf57c0faf, 7 );
MD5STEP( F1, ref d, a, b, c, _in[5] + 0x4787c62a, 12 );
MD5STEP( F1, ref c, d, a, b, _in[6] + 0xa8304613, 17 );
MD5STEP( F1, ref b, c, d, a, _in[7] + 0xfd469501, 22 );
MD5STEP( F1, ref a, b, c, d, _in[8] + 0x698098d8, 7 );
MD5STEP( F1, ref d, a, b, c, _in[9] + 0x8b44f7af, 12 );
MD5STEP( F1, ref c, d, a, b, _in[10] + 0xffff5bb1, 17 );
MD5STEP( F1, ref b, c, d, a, _in[11] + 0x895cd7be, 22 );
MD5STEP( F1, ref a, b, c, d, _in[12] + 0x6b901122, 7 );
MD5STEP( F1, ref d, a, b, c, _in[13] + 0xfd987193, 12 );
MD5STEP( F1, ref c, d, a, b, _in[14] + 0xa679438e, 17 );
MD5STEP( F1, ref b, c, d, a, _in[15] + 0x49b40821, 22 );
MD5STEP( F2, ref a, b, c, d, _in[1] + 0xf61e2562, 5 );
MD5STEP( F2, ref d, a, b, c, _in[6] + 0xc040b340, 9 );
MD5STEP( F2, ref c, d, a, b, _in[11] + 0x265e5a51, 14 );
MD5STEP( F2, ref b, c, d, a, _in[0] + 0xe9b6c7aa, 20 );
MD5STEP( F2, ref a, b, c, d, _in[5] + 0xd62f105d, 5 );
MD5STEP( F2, ref d, a, b, c, _in[10] + 0x02441453, 9 );
MD5STEP( F2, ref c, d, a, b, _in[15] + 0xd8a1e681, 14 );
MD5STEP( F2, ref b, c, d, a, _in[4] + 0xe7d3fbc8, 20 );
MD5STEP( F2, ref a, b, c, d, _in[9] + 0x21e1cde6, 5 );
MD5STEP( F2, ref d, a, b, c, _in[14] + 0xc33707d6, 9 );
MD5STEP( F2, ref c, d, a, b, _in[3] + 0xf4d50d87, 14 );
MD5STEP( F2, ref b, c, d, a, _in[8] + 0x455a14ed, 20 );
MD5STEP( F2, ref a, b, c, d, _in[13] + 0xa9e3e905, 5 );
MD5STEP( F2, ref d, a, b, c, _in[2] + 0xfcefa3f8, 9 );
MD5STEP( F2, ref c, d, a, b, _in[7] + 0x676f02d9, 14 );
MD5STEP( F2, ref b, c, d, a, _in[12] + 0x8d2a4c8a, 20 );
MD5STEP( F3, ref a, b, c, d, _in[5] + 0xfffa3942, 4 );
MD5STEP( F3, ref d, a, b, c, _in[8] + 0x8771f681, 11 );
MD5STEP( F3, ref c, d, a, b, _in[11] + 0x6d9d6122, 16 );
MD5STEP( F3, ref b, c, d, a, _in[14] + 0xfde5380c, 23 );
MD5STEP( F3, ref a, b, c, d, _in[1] + 0xa4beea44, 4 );
MD5STEP( F3, ref d, a, b, c, _in[4] + 0x4bdecfa9, 11 );
MD5STEP( F3, ref c, d, a, b, _in[7] + 0xf6bb4b60, 16 );
MD5STEP( F3, ref b, c, d, a, _in[10] + 0xbebfbc70, 23 );
MD5STEP( F3, ref a, b, c, d, _in[13] + 0x289b7ec6, 4 );
MD5STEP( F3, ref d, a, b, c, _in[0] + 0xeaa127fa, 11 );
MD5STEP( F3, ref c, d, a, b, _in[3] + 0xd4ef3085, 16 );
MD5STEP( F3, ref b, c, d, a, _in[6] + 0x04881d05, 23 );
MD5STEP( F3, ref a, b, c, d, _in[9] + 0xd9d4d039, 4 );
MD5STEP( F3, ref d, a, b, c, _in[12] + 0xe6db99e5, 11 );
MD5STEP( F3, ref c, d, a, b, _in[15] + 0x1fa27cf8, 16 );
MD5STEP( F3, ref b, c, d, a, _in[2] + 0xc4ac5665, 23 );
MD5STEP( F4, ref a, b, c, d, _in[0] + 0xf4292244, 6 );
MD5STEP( F4, ref d, a, b, c, _in[7] + 0x432aff97, 10 );
MD5STEP( F4, ref c, d, a, b, _in[14] + 0xab9423a7, 15 );
MD5STEP( F4, ref b, c, d, a, _in[5] + 0xfc93a039, 21 );
MD5STEP( F4, ref a, b, c, d, _in[12] + 0x655b59c3, 6 );
MD5STEP( F4, ref d, a, b, c, _in[3] + 0x8f0ccc92, 10 );
MD5STEP( F4, ref c, d, a, b, _in[10] + 0xffeff47d, 15 );
MD5STEP( F4, ref b, c, d, a, _in[1] + 0x85845dd1, 21 );
MD5STEP( F4, ref a, b, c, d, _in[8] + 0x6fa87e4f, 6 );
MD5STEP( F4, ref d, a, b, c, _in[15] + 0xfe2ce6e0, 10 );
MD5STEP( F4, ref c, d, a, b, _in[6] + 0xa3014314, 15 );
MD5STEP( F4, ref b, c, d, a, _in[13] + 0x4e0811a1, 21 );
MD5STEP( F4, ref a, b, c, d, _in[4] + 0xf7537e82, 6 );
MD5STEP( F4, ref d, a, b, c, _in[11] + 0xbd3af235, 10 );
MD5STEP( F4, ref c, d, a, b, _in[2] + 0x2ad7d2bb, 15 );
MD5STEP( F4, ref b, c, d, a, _in[9] + 0xeb86d391, 21 );
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
/*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/
static void MD5Init( MD5Context ctx )
{
ctx.isInit = true;
ctx.buf[0] = 0x67452301;
ctx.buf[1] = 0xefcdab89;
ctx.buf[2] = 0x98badcfe;
ctx.buf[3] = 0x10325476;
ctx.bits[0] = 0;
ctx.bits[1] = 0;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
static void MD5Update( MD5Context pCtx, byte[] buf, int len )
{
MD5Context ctx = (MD5Context)pCtx;
int t;
/* Update bitcount */
t = (int)ctx.bits[0];
if ( ( ctx.bits[0] = (u32)( t + ( (u32)len << 3 ) ) ) < t )
ctx.bits[1]++; /* Carry from low to high */
ctx.bits[1] += (u32)( len >> 29 );
t = ( t >> 3 ) & 0x3f; /* Bytes already in shsInfo.data */
/* Handle any leading odd-sized chunks */
int _buf = 0; // Offset into buffer
int p = t; //Offset into ctx._in
if ( t != 0 )
{
//byte p = (byte)ctx._in + t;
t = 64 - t;
if ( len < t )
{
Buffer.BlockCopy( buf, _buf, ctx._in, p, len );// memcpy( p, buf, len );
return;
}
Buffer.BlockCopy( buf, _buf, ctx._in, p, t ); //memcpy( p, buf, t );
//byteReverse(ctx._in, 16);
MD5Transform( ctx.buf, ctx._in );
_buf += t;// buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while ( len >= 64 )
{
Buffer.BlockCopy( buf, _buf, ctx._in, 0, 64 );//memcpy( ctx._in, buf, 64 );
//byteReverse(ctx._in, 16);
MD5Transform( ctx.buf, ctx._in );
_buf += 64;// buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
Buffer.BlockCopy( buf, _buf, ctx._in, 0, len ); //memcpy( ctx._in, buf, len );
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
static void MD5Final( byte[] digest, MD5Context pCtx )
{
MD5Context ctx = pCtx;
int count;
int p;
/* Compute number of bytes mod 64 */
count = (int)( ctx.bits[0] >> 3 ) & 0x3F;
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = count;
ctx._in[p++] = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if ( count < 8 )
{
/* Two lots of padding: Pad the first block to 64 bytes */
Array.Clear( ctx._in, p, count );//memset(p, 0, count);
//byteReverse( ctx._in, 16 );
MD5Transform( ctx.buf, ctx._in );
/* Now fill the next block with 56 bytes */
Array.Clear( ctx._in, 0, 56 );//memset(ctx._in, 0, 56);
}
else
{
/* Pad block to 56 bytes */
Array.Clear( ctx._in, p, count - 8 );//memset(p, 0, count-8);
}
//byteReverse( ctx._in, 14 );
/* Append length in bits and transform */
ctx._in[14] = (byte)ctx.bits[0];
ctx._in[15] = (byte)ctx.bits[1];
MD5Transform( ctx.buf, ctx._in );
//byteReverse( ctx.buf, 4 );
Buffer.BlockCopy( ctx.buf, 0, digest, 0, 16 );//memcpy(digest, ctx.buf, 16);
//memset(ctx, 0, sizeof(ctx)); /* In case it is sensitive */
Array.Clear( ctx._in, 0, ctx._in.Length );
Array.Clear( ctx.bits, 0, ctx.bits.Length );
Array.Clear( ctx.buf, 0, ctx.buf.Length );
ctx._Mem = null;
}
/*
** Convert a 128-bit MD5 digest into a 32-digit base-16 number.
*/
static void DigestToBase16( byte[] digest, byte[] zBuf )
{
string zEncode = "0123456789abcdef";
int i, j;
for ( j = i = 0; i < 16; i++ )
{
int a = digest[i];
zBuf[j++] = (byte)zEncode[( a >> 4 ) & 0xf];
zBuf[j++] = (byte)zEncode[a & 0xf];
}
if ( j < zBuf.Length )
zBuf[j] = 0;
}
/*
** Convert a 128-bit MD5 digest into sequency of eight 5-digit integers
** each representing 16 bits of the digest and separated from each
** other by a "-" character.
*/
//static void MD5DigestToBase10x8(unsigned char digest[16], char zDigest[50]){
// int i, j;
// unsigned int x;
// for(i=j=0; i<16; i+=2){
// x = digest[i]*256 + digest[i+1];
// if( i>0 ) zDigest[j++] = '-';
// sprintf(&zDigest[j], "%05u", x);
// j += 5;
// }
// zDigest[j] = 0;
//}
/*
** A TCL command for md5. The argument is the text to be hashed. The
** Result is the hash in base64.
*/
static int md5_cmd( object cd, Tcl_Interp interp, int argc, Tcl_Obj[] argv )
{
MD5Context ctx = new MD5Context();
byte[] digest = new byte[16];
byte[] zBuf = new byte[32];
if ( argc != 2 )
{
TCL.Tcl_AppendResult( interp, "wrong # args: should be \"", argv[0],
" TEXT\"" );
return TCL.TCL_ERROR;
}
MD5Init( ctx );
MD5Update( ctx, Encoding.UTF8.GetBytes( argv[1].ToString() ), Encoding.UTF8.GetByteCount( argv[1].ToString() ) );
MD5Final( digest, ctx );
DigestToBase16( digest, zBuf );
TCL.Tcl_AppendResult( interp, Encoding.UTF8.GetString( zBuf, 0, zBuf.Length ) );
return TCL.TCL_OK;
}
/*
** A TCL command to take the md5 hash of a file. The argument is the
** name of the file.
*/
static int md5file_cmd( object cd, Tcl_Interp interp, int argc, Tcl_Obj[] argv )
{
StreamReader _in = null;
byte[] digest = new byte[16];
StringBuilder zBuf = new StringBuilder( 10240 );
if ( argc != 2 )
{
TCL.Tcl_AppendResult( interp, "wrong # args: should be \"", argv[0],
" FILENAME\"", 0 );
return TCL.TCL_ERROR;
}
Debugger.Break(); // TODO -- _in = fopen( argv[1], "rb" );
if ( _in == null )
{
TCL.Tcl_AppendResult( interp, "unable to open file \"", argv[1],
"\" for reading", 0 );
return TCL.TCL_ERROR;
}
Debugger.Break(); // TODO
//MD5Init( ctx );
//for(;;){
// int n;
// n = fread(zBuf, 1, zBuf.Capacity, _in);
// if( n<=0 ) break;
// MD5Update(ctx, zBuf.ToString(), (unsigned)n);
//}
//fclose(_in);
//MD5Final(digest, ctx);
// DigestToBase16(digest, zBuf);
//Tcl_AppendResult( interp, zBuf );
return TCL.TCL_OK;
}
/*
** Register the four new TCL commands for generating MD5 checksums
** with the TCL interpreter.
*/
static public int Md5_Init( Tcl_Interp interp )
{
TCL.Tcl_CreateCommand( interp, "md5", md5_cmd, null, null );
//Tcl_CreateCommand(interp, "md5-10x8", (Tcl_CmdProc)md5_cmd,
// MD5DigestToBase10x8, 0);
TCL.Tcl_CreateCommand( interp, "md5file", md5file_cmd, null, null );
//Tcl_CreateCommand(interp, "md5file-10x8", (Tcl_CmdProc)md5file_cmd,
// MD5DigestToBase10x8, 0);
return TCL.TCL_OK;
}
#endif //* defined(SQLITE_TEST) || defined(SQLITE_TCLMD5) */
#if (SQLITE_TEST)
/*
** During testing, the special md5sum() aggregate function is available.
** inside SQLite. The following routines implement that function.
*/
static void md5step( sqlite3_context context, int argc, sqlite3_value[] argv )
{
MD5Context p = null;
int i;
if ( argc < 1 )
return;
Mem pMem = sqlite3_aggregate_context( context, 1 );//sizeof(*p));
if ( pMem._MD5Context == null )
{
pMem._MD5Context = new MD5Context();
( (MD5Context)pMem._MD5Context )._Mem = pMem;
}
p = (MD5Context)pMem._MD5Context;
if ( p == null )
return;
if ( !p.isInit )
{
MD5Init( p );
}
for ( i = 0; i < argc; i++ )
{
byte[] zData = sqlite3_value_text( argv[i] ) == null ? null : Encoding.UTF8.GetBytes( sqlite3_value_text( argv[i] ) );
if ( zData != null )
{
MD5Update( p, zData, zData.Length );
}
}
}
static void md5finalize( sqlite3_context context )
{
MD5Context p;
byte[] digest = new byte[16];
byte[] zBuf = new byte[33];
Mem pMem = sqlite3_aggregate_context( context, 0 );
if ( pMem != null )
{
p = (MD5Context)pMem._MD5Context;
MD5Final( digest, p );
}
DigestToBase16( digest, zBuf );
sqlite3_result_text( context, Encoding.UTF8.GetString( zBuf, 0, zBuf.Length ), -1, SQLITE_TRANSIENT );
}
static int Md5_Register( sqlite3 db, ref string dummy1, sqlite3_api_routines dummy2 )
{
int rc = sqlite3_create_function( db, "md5sum", -1, SQLITE_UTF8, 0, null,
md5step, md5finalize );
sqlite3_overload_function( db, "md5sum", -1 ); /* To exercise this API */
return rc;
}
#endif //* defined(SQLITE_TEST) */
/*
** If the macro TCLSH is one, then put in code this for the
** "main" routine that will initialize Tcl and take input from
** standard input, or if a file is named on the command line
** the TCL interpreter reads and evaluates that file.
*/
#if TCLSH//==1
//static char zMainloop[] =
// "set line {}\n"
// "while {![eof stdin]} {\n"
// "if {$line!=\"\"} {\n"
// "puts -nonewline \"> \"\n"
// "} else {\n"
// "puts -nonewline \"% \"\n"
// "}\n"
// "flush stdout\n"
// "append line [gets stdin]\n"
// "if {[info complete $line]} {\n"
// "if {[catch {uplevel #0 $line} result]} {\n"
// "puts stderr \"Error: $result\"\n"
// "} elseif {$result!=\"\"} {\n"
// "puts $result\n"
// "}\n"
// "set line {}\n"
// "} else {\n"
// "append line \\n\n"
// "}\n"
// "}\n"
//;
#endif
//#if TCLSH==2
//static char zMainloop[] =
//#include "spaceanal_tcl.h"
//;
//#endif
//#define TCLSH_MAIN main /* Needed to fake out mktclapp */
#if SQLITE_TEST
//static void init_all(Tcl_Interp );
static int init_all_cmd(
ClientData cd,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
Tcl_Interp slave;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "SLAVE" );
return TCL.TCL_ERROR;
}
slave = null;// TCL.Tcl_GetSlave( interp, TCL.Tcl_GetString( objv[1] ) );
if ( slave == null )
{
return TCL.TCL_ERROR;
}
init_all( slave );
return TCL.TCL_OK;
}
#endif
/*
** Configure the interpreter passed as the first argument to have access
** to the commands and linked variables that make up:
**
** * the [sqlite3] extension itself,
**
** * If SQLITE_TCLMD5 or SQLITE_TEST is defined, the Md5 commands, and
**
** * If SQLITE_TEST is set, the various test interfaces used by the Tcl
** test suite.
*/
static void init_all( Tcl_Interp interp )
{
Sqlite3_Init( interp );
#if (SQLITE_TEST) || (SQLITE_TCLMD5)
Md5_Init( interp );
#endif
#if SQLITE_TEST
//{
//extern int Sqliteconfig_Init(Tcl_Interp);
//extern int Sqlitetest1_Init(Tcl_Interp);
//extern int Sqlitetest2_Init(Tcl_Interp);
//extern int Sqlitetest3_Init(Tcl_Interp);
//extern int Sqlitetest4_Init(Tcl_Interp);
//extern int Sqlitetest5_Init(Tcl_Interp);
//extern int Sqlitetest6_Init(Tcl_Interp);
//extern int Sqlitetest7_Init(Tcl_Interp);
//extern int Sqlitetest8_Init(Tcl_Interp);
//extern int Sqlitetest9_Init(Tcl_Interp);
//extern int Sqlitetestasync_Init(Tcl_Interp);
//extern int Sqlitetest_autoext_Init(Tcl_Interp);
//extern int Sqlitetest_demovfs_Init(Tcl_Interp );
//extern int Sqlitetest_func_Init(Tcl_Interp);
//extern int Sqlitetest_hexio_Init(Tcl_Interp);
//extern int Sqlitetest_malloc_Init(Tcl_Interp);
//extern int Sqlitetest_mutex_Init(Tcl_Interp);
//extern int Sqlitetestschema_Init(Tcl_Interp);
//extern int Sqlitetestsse_Init(Tcl_Interp);
//extern int Sqlitetesttclvar_Init(Tcl_Interp);
//extern int SqlitetestThread_Init(Tcl_Interp);
//extern int SqlitetestOnefile_Init();
//extern int SqlitetestOsinst_Init(Tcl_Interp);
//extern int Sqlitetestbackup_Init(Tcl_Interp);
//extern int Sqlitetestintarray_Init(Tcl_Interp);
//extern int Sqlitetestvfs_Init(Tcl_Interp );
//extern int SqlitetestStat_Init(Tcl_Interp);
//extern int Sqlitetestrtree_Init(Tcl_Interp);
//extern int Sqlitequota_Init(Tcl_Interp);
//extern int Sqlitemultiplex_Init(Tcl_Interp);
//extern int SqliteSuperlock_Init(Tcl_Interp);
//extern int SqlitetestSyscall_Init(Tcl_Interp);
//extern int Sqlitetestfuzzer_Init(Tcl_Interp);
//extern int Sqlitetestwholenumber_Init(Tcl_Interp);
#if (SQLITE_ENABLE_FTS3) || (SQLITE_ENABLE_FTS4)
//extern int Sqlitetestfts3_Init(Tcl_Interp interp);
#endif
#if SQLITE_ENABLE_ZIPVFS
// extern int Zipvfs_Init(Tcl_Interp);
// Zipvfs_Init(interp);
#endif
Sqliteconfig_Init( interp );
Sqlitetest1_Init( interp );
Sqlitetest2_Init( interp );
Sqlitetest3_Init( interp );
//Threads not implemented under C#
//Sqlitetest4_Init(interp);
//TODO implemented under C#
//Sqlitetest5_Init(interp);
//Simulated Crashtests not implemented under C#
//Sqlitetest6_Init(interp);
//client/server version (Unix Only) not implemented under C#
//Sqlitetest7_Init(interp);
//virtual table interface not implemented under C#
//Sqlitetest8_Init(interp);
Sqlitetest9_Init( interp );
//asynchronous IO extension interface not implemented under C#
//Sqlitetestasync_Init(interp);
//sqlite3_auto_extension() function not implemented under C#
//Sqlitetest_autoext_Init(interp);
//VFS not implemented under C#
//Sqlitetest_demovfs_Init(interp);
Sqlitetest_func_Init( interp );
Sqlitetest_hexio_Init( interp );
Sqlitetest_malloc_Init( interp );
Sqlitetest_mutex_Init( interp );
//virtual table interfaces not implemented under C#
//Sqlitetestschema_Init(interp);
//virtual table interfaces not implemented under C#
//Sqlitetesttclvar_Init(interp);
//Threads not implemented under C#
//SqlitetestThread_Init(interp);
//VFS not implemented under C#
//SqlitetestOnefile_Init(interp);
//VFS not implemented under C#
//SqlitetestOsinst_Init(interp);
Sqlitetestbackup_Init( interp );
//virtual table interfaces not implemented under C#
//Sqlitetestintarray_Init(interp);
//VFS not implemented under C#
//Sqlitetestvfs_Init(interp);
//virtual table interfaces not implemented under C#
//SqlitetestStat_Init(interp);
//Sqlitetestrtree_Init( interp );
//Sqlitequota_Init( interp );
//Sqlitemultiplex_Init( interp );
//SqliteSuperlock_Init( interp );
//SqlitetestSyscall_Init( interp );
Sqlitetestfuzzer_Init( interp );
//Sqlitetestwholenumber_Init( interp );
#if (SQLITE_ENABLE_FTS3) || (SQLITE_ENABLE_FTS4)
//Sqlitetestfts3_Init(interp);
#endif
TCL.Tcl_CreateObjCommand( interp, "load_testfixture_extensions", init_all_cmd, 0, null );
#if SQLITE_SSE
Sqlitetestsse_Init(interp);
#endif
}
#endif
}
#if FALSE
//#define TCLSH_MAIN main /* Needed to fake out mktclapp */
int TCLSH_MAIN(int argc, char **argv){
Tcl_Interp interp;
/* Call sqlite3_shutdown() once before doing anything else. This is to
** test that sqlite3_shutdown() can be safely called by a process before
** sqlite3_initialize() is. */
sqlite3_shutdown();
#if TCLSH//TCLSH==2
sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);
#endif
Tcl_FindExecutable(argv[0]);
interp = TCL.Tcl_CreateInterp();
init_all(interp);
if( argc>=2 ){
int i;
char zArgc[32];
sqlite3_snprintf(sizeof(zArgc), zArgc, "%d", argc-(3-TCLSH));
Tcl_SetVar(interp,"argc", zArgc, TCL_GLOBAL_ONLY);
Tcl_SetVar(interp,"argv0",argv[1],TCL_GLOBAL_ONLY);
Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY);
for(i=3-TCLSH; i<argc; i++){
Tcl_SetVar(interp, "argv", argv[i],
TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE);
}
if( TCLSH==1 && Tcl_EvalFile(interp, argv[1])!=TCL_OK ){
string zInfo = TCL.Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
if( zInfo==0 ) zInfo = TCL.Tcl_GetStringResult(interp);
fprintf(stderr,"%s: %s\n", *argv, zInfo);
return 1;
}
}
if( TCLSH==2 || argc<=1 ){
Tcl_GlobalEval(interp, zMainloop);
}
return 0;
}
#endif
#endif // * TCLSH */
#endif // NO_TCL
}