| /trunk/testfixture/src/tclsqlite_c.cs |
|---|
| @@ -0,0 +1,4427 @@ |
|---|
| 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 |
| } |
| |
