public BookDB(string filePath = @"\BookDB.sqlite3")
{
FilePath = filePath;
Logger.Debug($"Connect to database: {filePath}");
DB = new Sqlite3(FilePath);
CreateTables();
}
internal SqliteDataReader (SqliteCommand cmd, Sqlite3.Vdbe pVm, int version)
{
command = cmd;
rows = new List<object[]>();
column_names_sens = new Dictionary<String, Object>();
column_names_insens = new Dictionary<String, Object>( StringComparer.InvariantCultureIgnoreCase );
closed = false;
current_row = -1;
reading = true;
ReadpVm (pVm, version, cmd);
ReadingDone ();
}
public static void DbTests()
{
var db = new Sqlite3("BookDB.sqlite3");
using (var r = db.ExecuteReaderOne("select count(*) from book"))
{
var v = r.GetValues();
foreach (var i in Enumerable.Range(0, r.FieldCount))
{
Console.WriteLine("{0}: {1}", v.GetKey(i), r.GetValue(i));
}
}
}
private async void _refresh_Click(object sender, RoutedEventArgs e)
{
if (_dbFileList.SelectedItem == null)
{
return;
}
var path = WorkPath.DbPath + @"\" + (string)_dbFileList.SelectedItem;
var tableName = (string)_dbTableList.SelectedItem;
_dataViewer.ItemsSource = await Task.Run(() =>
{
var db = new Sqlite3(path);
return db.GetDatas(tableName).DefaultView;
});
}
private async void _dbFileList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (_dbFileList.SelectedItem == null)
{
return;
}
var path = WorkPath.DbPath + @"\" + (string)_dbFileList.SelectedItem;
DbTableList = await Task.Run(() =>
{
var db = new Sqlite3(path);
return new ObservableCollection<string>(db.GetTables());
});
OnPropertyChanged(nameof(DbTableList));
}
internal SqliteDataReader(SqliteCommand cmd, Sqlite3.Vdbe pVm, int version)
{
command = cmd;
rows = new ArrayList();
column_names_sens = new Hashtable();
column_names_insens = new Hashtable(CaseInsensitiveHashCodeProvider.DefaultInvariant,
CaseInsensitiveComparer.DefaultInvariant);
closed = false;
current_row = -1;
reading = true;
ReadpVm(pVm, version, cmd);
ReadingDone();
}
public static Result Reset(Sqlite3.Vdbe stmt)
{
return((Result)Sqlite3.sqlite3_reset(stmt));
}
public static int Changes(Sqlite3.sqlite3 db)
{
return(Sqlite3.sqlite3_changes(db));
}
public static Result Close(Sqlite3.sqlite3 db)
{
return((Result)Sqlite3.sqlite3_close(db));
}
public static Result Open(string filename, out Sqlite3.sqlite3 db)
{
return((Result)Sqlite3.sqlite3_open(filename, out db));
}
public bool Step()
{
switch (Sqlite3.sqlite3_step(vm))
{
case Sqlite3.SQLITE_DONE: return(false);
case Sqlite3.SQLITE_ROW:
{
int columnCount = Sqlite3.sqlite3_column_count(vm);
columnNames = new string[columnCount];
columnTypes = new int[columnCount];
try
{
// reads columns one by one
for (int i = 0; i < columnCount; i++)
{
columnNames[i] = Sqlite3.sqlite3_column_name(vm, i);
columnTypes[i] = Sqlite3.sqlite3_column_type(vm, i);
}
}
catch
{
throw new Exception("SQLite fail to read column's names and types! error: " + Sqlite3.sqlite3_errmsg(db));
}
return(true);
}
}
throw new Exception("SQLite step fail! error: " + Sqlite3.sqlite3_errmsg(db));
}
// Executes a statement and returns whether there is more data available.
internal bool ExecuteStatement( Sqlite3.Vdbe pStmt, out int cols, out IntPtr pazValue, out IntPtr pazColName )
{
SqliteError err;
//if (parent_conn.Version == 3)
//{
err = (SqliteError)Sqlite3.sqlite3_step( pStmt );
if ( err == SqliteError.ERROR )
throw new SqliteExecutionException(parent_conn.Handle2.errCode, GetError3() + "\n" + pStmt.zErrMsg );
pazValue = IntPtr.Zero;
pazColName = IntPtr.Zero; // not used for v=3
cols = Sqlite3.sqlite3_column_count( pStmt );
/*
}
else
{
err = (SqliteError)Sqlite3.sqlite3_step(pStmt, out cols, out pazValue, out pazColName);
if (err == SqliteError.ERROR)
throw new SqliteExecutionException ();
}
*/
if ( err == SqliteError.BUSY )
throw new SqliteBusyException();
if ( err == SqliteError.MISUSE )
throw new SqliteExecutionException();
// err is either ROW or DONE.
return err == SqliteError.ROW;
}
public XMusicDB()
{
db = new Sqlite3(FilePath);
CreateTables();
}
public double ColumnDouble(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return(Sqlite3.sqlite3_column_double(dbStatement.InternalStmt, index));
}
public long ColumnInt64(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return(Sqlite3.sqlite3_column_int64(dbStatement.InternalStmt, index));
}
public ColType ColumnType(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return((ColType)Sqlite3.sqlite3_column_type(dbStatement.InternalStmt, index));
}
private void GetNextStatement( string pzStart, ref string pzTail, ref Sqlite3.Vdbe pStmt )
{
UTF8Encoding encoding = new UTF8Encoding();
SqliteError err = (SqliteError)Sqlite3.sqlite3_prepare_v2( parent_conn.Handle2, pzStart, pzStart.Length, ref pStmt, ref pzTail );
if ( err != SqliteError.OK )
throw new SqliteSyntaxException( parent_conn.Handle2.errCode, GetError3() );
}
public static long LastInsertRowid(Sqlite3.sqlite3 db)
{
return(Sqlite3.sqlite3_last_insert_rowid(db));
}
public int ColumnBytes(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return(Sqlite3.sqlite3_column_bytes(dbStatement.InternalStmt, index));
}
public static int BindParameterIndex(Sqlite3.Vdbe stmt, string name)
{
return(Sqlite3.sqlite3_bind_parameter_index(stmt, name));
}
public byte[] ColumnBlob(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return(Sqlite3.sqlite3_column_blob(dbStatement.InternalStmt, index));
}
internal void ReadpVm (Sqlite3.Vdbe pVm, int version, SqliteCommand cmd)
{
int pN;
IntPtr pazValue;
IntPtr pazColName;
bool first = true;
int[] declmode = null;
while (true) {
bool hasdata = cmd.ExecuteStatement(pVm, out pN, out pazValue, out pazColName);
// For the first row, get the column information
if (first) {
first = false;
if (version == 3) {
// A decltype might be null if the type is unknown to sqlite.
decltypes = new string[pN];
declmode = new int[pN]; // 1 == integer, 2 == datetime, 3 == guid
for (int i = 0; i < pN; i++) {
string decl = Sqlite3.sqlite3_column_decltype (pVm, i);
if (decl != null) {
decltypes[i] = decl.ToLower(System.Globalization.CultureInfo.InvariantCulture);
if (decltypes[i] == "int" || decltypes[i] == "integer")
declmode[i] = 1;
else if (decltypes[i] == "date" || decltypes[i] == "datetime")
declmode[i] = 2;
else if (decltypes[i] == "guid")
declmode[i] = 3;
}
}
}
columns = new string[pN];
for (int i = 0; i < pN; i++) {
string colName;
//if (version == 2) {
// IntPtr fieldPtr = Marshal.ReadIntPtr (pazColName, i*IntPtr.Size);
// colName = Sqlite.HeapToString (fieldPtr, ((SqliteConnection)cmd.Connection).Encoding);
//} else {
colName = Sqlite3.sqlite3_column_name (pVm, i);
//}
columns[i] = colName;
column_names_sens [colName] = i;
column_names_insens [colName] = i;
}
}
if (!hasdata) break;
object[] data_row = new object [pN];
for (int i = 0; i < pN; i++) {
/*
if (version == 2) {
IntPtr fieldPtr = Marshal.ReadIntPtr (pazValue, i*IntPtr.Size);
data_row[i] = Sqlite.HeapToString (fieldPtr, ((SqliteConnection)cmd.Connection).Encoding);
} else {
*/
switch (Sqlite3.sqlite3_column_type (pVm, i)) {
case 1:
long val = Sqlite3.sqlite3_column_int64 (pVm, i);
// If the column was declared as an 'int' or 'integer', let's play
// nice and return an int (version 3 only).
if (declmode[i] == 1 && val >= int.MinValue && val <= int.MaxValue)
data_row[i] = (int)val;
// Or if it was declared a date or datetime, do the reverse of what we
// do for DateTime parameters.
else if (declmode[i] == 2)
data_row[i] = DateTime.FromFileTime(val);
else
data_row[i] = val;
break;
case 2:
data_row[i] = Sqlite3.sqlite3_column_double (pVm, i);
break;
case 3:
data_row[i] = Sqlite3.sqlite3_column_text (pVm, i);
// If the column was declared as a 'date' or 'datetime', let's play
// nice and return a DateTime (version 3 only).
if (declmode[i] == 2)
if (data_row[i] == null) data_row[i] = null;
else data_row[i] = DateTime.Parse((string)data_row[i], System.Globalization.CultureInfo.InvariantCulture);
else if (declmode[i] == 3)
data_row[i] = Guid.Parse((string) data_row[i]);
break;
case 4:
int blobbytes = Sqlite3.sqlite3_column_bytes16 (pVm, i);
byte[] blob = Sqlite3.sqlite3_column_blob(pVm, i);
//byte[] blob = new byte[blobbytes];
//Marshal.Copy (blobptr, blob, 0, blobbytes);
data_row[i] = blob ?? new byte[0];
break;
case 5:
data_row[i] = null;
break;
default:
throw new Exception ("FATAL: Unknown sqlite3_column_type");
//}
}
}
rows.Add (data_row);
}
}
public string GetErrmsg(IDbHandle db)
{
var dbHandle = (DbHandle)db;
return(Sqlite3.sqlite3_errmsg(dbHandle.InternalDbHandle));
}
private string GetError3()
{
return(Sqlite3.sqlite3_errmsg(parent_conn.Handle2));
//return Marshal.PtrToStringUni (Sqlite.sqlite3_errmsg16 (parent_conn.Handle));
}
public string ColumnText(IDbStatement stmt, int index)
{
var dbStatement = (DbStatement)stmt;
return(Sqlite3.sqlite3_column_text(dbStatement.InternalStmt, index));
}
private void BindParameter(CodeContext context, int index, object arg)
{
int rc;
if (arg == null)
{
rc = Sqlite3.sqlite3_bind_null(st, index);
}
else if (arg is int)
{
rc = Sqlite3.sqlite3_bind_int(st, index, (int)arg);
}
else if (arg is bool)
{
rc = Sqlite3.sqlite3_bind_int(st, index, (bool)arg ? 1 : 0);
}
else if (arg is long)
{
rc = Sqlite3.sqlite3_bind_int64(st, index, (long)arg);
}
else if (arg is Microsoft.Scripting.Math.BigInteger)
{
rc = Sqlite3.sqlite3_bind_int64(st, index, ((Microsoft.Scripting.Math.BigInteger)arg).ToInt64());
}
else if (arg is System.Numerics.BigInteger)
{
rc = Sqlite3.sqlite3_bind_int64(st, index, (long)((System.Numerics.BigInteger)arg));
}
else if (arg is float)
{
rc = Sqlite3.sqlite3_bind_double(st, index, (float)arg);
}
else if (arg is double)
{
rc = Sqlite3.sqlite3_bind_double(st, index, (double)arg);
}
else if (arg is string)
{
rc = Sqlite3.sqlite3_bind_text(st, index, (string)arg, -1, Sqlite3.SQLITE_TRANSIENT);
}
else if (arg is byte[])
{
rc = Sqlite3.sqlite3_bind_blob(this.st, index, (byte[])arg, -1, Sqlite3.SQLITE_TRANSIENT);
}
else if (arg is PythonBuffer)
{
//TODO: see if there is a better way to do this
PythonBuffer buffer = (PythonBuffer)arg;
string s = buffer[new Slice(0, null)].ToString();
byte[] bytes = PythonSQLite.Latin1.GetBytes(s);
rc = Sqlite3.sqlite3_bind_blob(this.st, index, bytes, -1, Sqlite3.SQLITE_TRANSIENT);
}
else
{
throw PythonSQLite.MakeInterfaceError("Unable to bind parameter {0} - unsupported type {1}".Format(index, arg.GetType()));
}
if (rc != Sqlite3.SQLITE_OK)
{
throw PythonSQLite.MakeInterfaceError("Unable to bind parameter {0}: {1}".Format(index, Sqlite3.sqlite3_errmsg(db)));
}
}
public Result EnableLoadExtension(IDbHandle db, int onoff)
{
var dbHandle = (DbHandle)db;
return((Result)Sqlite3.sqlite3_enable_load_extension(dbHandle.InternalDbHandle, onoff));
}
public static Result Open(string filename, out Sqlite3.sqlite3 db, int flags, IntPtr zVfs)
{
return((Result)Sqlite3.sqlite3_open_v2(filename, out db, flags, null));
}
public Result Close(IDbHandle db)
{
var dbHandle = (DbHandle)db;
return((Result)Sqlite3.sqlite3_close(dbHandle.InternalDbHandle));
}
public static Result BusyTimeout(Sqlite3.sqlite3 db, int milliseconds)
{
return((Result)Sqlite3.sqlite3_busy_timeout(db, milliseconds));
}
public Result BusyTimeout(IDbHandle db, int milliseconds)
{
var dbHandle = (DbHandle)db;
return((Result)Sqlite3.sqlite3_busy_timeout(dbHandle.InternalDbHandle, milliseconds));
}
public static Result Step(Sqlite3.Vdbe stmt)
{
return((Result)Sqlite3.sqlite3_step(stmt));
}
public int Changes(IDbHandle db)
{
var dbHandle = (DbHandle)db;
return(Sqlite3.sqlite3_changes(dbHandle.InternalDbHandle));
}
public static Result Finalize(Sqlite3.Vdbe stmt)
{
return((Result)Sqlite3.sqlite3_finalize(stmt));
}
public Result Reset(IDbStatement stmt)
{
var dbStatement = (DbStatement)stmt;
return((Result)Sqlite3.sqlite3_reset(dbStatement.InternalStmt));
}
public static string GetErrmsg(Sqlite3.sqlite3 db)
{
return(Sqlite3.sqlite3_errmsg(db));
}
private void BindParameters3( Sqlite3.Vdbe pStmt )
{
if ( sql_params == null )
return;
if ( sql_params.Count == 0 )
return;
int pcount = Sqlite3.sqlite3_bind_parameter_count( pStmt );
for ( int i = 1; i <= pcount; i++ )
{
String name = Sqlite3.sqlite3_bind_parameter_name( pStmt, i );
SqliteParameter param = null;
if ( !String.IsNullOrEmpty( name ) )
param = sql_params[name] as SqliteParameter;
else
param = sql_params[i - 1] as SqliteParameter;
if ( param.Value == null )
{
Sqlite3.sqlite3_bind_null( pStmt, i );
continue;
}
Type ptype = param.Value.GetType();
if ( ptype.IsEnum )
ptype = Enum.GetUnderlyingType( ptype );
SqliteError err;
if ( ptype.Equals( typeof( String ) ) )
{
String s = (String)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_text( pStmt, i, s, -1, null );
} else if ( ptype.Equals( typeof( DBNull ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_null( pStmt, i );
} else if ( ptype.Equals( typeof( Boolean ) ) )
{
bool b = (bool)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, b ? 1 : 0 );
} else if ( ptype.Equals( typeof( Byte ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (Byte)param.Value );
} else if ( ptype.Equals( typeof( Char ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (Char)param.Value );
} else if ( ptype.IsEnum )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (Int32)param.Value );
} else if ( ptype.Equals( typeof( Int16 ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (Int16)param.Value );
} else if ( ptype.Equals( typeof( Int32 ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (Int32)param.Value );
} else if ( ptype.Equals( typeof( SByte ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (SByte)param.Value );
} else if ( ptype.Equals( typeof( UInt16 ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int( pStmt, i, (UInt16)param.Value );
} else if ( ptype.Equals( typeof( DateTime ) ) )
{
DateTime dt = (DateTime)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_text( pStmt, i, dt.ToString( "yyyy-MM-dd HH:mm:ss.fff"), -1, null );
} else if ( ptype.Equals( typeof( Decimal ) ) )
{
string val = ( (Decimal)param.Value ).ToString( CultureInfo.InvariantCulture );
err = (SqliteError)Sqlite3.sqlite3_bind_text( pStmt, i, val, val.Length, null );
} else if ( ptype.Equals( typeof( Double ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_double( pStmt, i, (Double)param.Value );
} else if ( ptype.Equals( typeof( Single ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_double( pStmt, i, (Single)param.Value );
} else if ( ptype.Equals( typeof( UInt32 ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int64( pStmt, i, (UInt32)param.Value );
} else if ( ptype.Equals( typeof( Int64 ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_int64( pStmt, i, (Int64)param.Value );
} else if ( ptype.Equals( typeof( Byte[] ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_blob( pStmt, i, (byte[])param.Value, ( (byte[])param.Value ).Length, null );
} else if ( ptype.Equals( typeof( Guid ) ) )
{
err = (SqliteError)Sqlite3.sqlite3_bind_text( pStmt, i, param.Value.ToString(), param.Value.ToString().Length, null );
} else
{
throw new ApplicationException( "Unkown Parameter Type" );
}
if ( err != SqliteError.OK )
{
throw new ApplicationException( "Sqlite error in bind " + err );
}
}
}
public static int BindNull(Sqlite3.Vdbe stmt, int index)
{
return(Sqlite3.sqlite3_bind_null(stmt, index));
}
public SqliteDataReader ExecuteReader(CommandBehavior behavior, bool want_results, out int rows_affected)
{
Prepare();
// The SQL string may contain multiple sql commands, so the main
// thing to do is have Sqlite iterate through the commands.
// If want_results, only the last command is returned as a
// DataReader. Otherwise, no command is returned as a
// DataReader.
//IntPtr psql; // pointer to SQL command
// Sqlite 2 docs say this: By default, SQLite assumes that all data uses a fixed-size 8-bit
// character (iso8859). But if you give the --enable-utf8 option to the configure script, then the
// library assumes UTF-8 variable sized characters. This makes a difference for the LIKE and GLOB
// operators and the LENGTH() and SUBSTR() functions. The static string sqlite_encoding will be set
// to either "UTF-8" or "iso8859" to indicate how the library was compiled. In addition, the sqlite.h
// header file will define one of the macros SQLITE_UTF8 or SQLITE_ISO8859, as appropriate.
//
// We have no way of knowing whether Sqlite 2 expects ISO8859 or UTF-8, but ISO8859 seems to be the
// default. Therefore, we need to use an ISO8859(-1) compatible encoding, like ANSI.
// OTOH, the user may want to specify the encoding of the bytes stored in the database, regardless
// of what Sqlite is treating them as,
// For Sqlite 3, we use the UTF-16 prepare function, so we need a UTF-16 string.
/*
* if (parent_conn.Version == 2)
* psql = Sqlite.StringToHeap (sql.Trim(), parent_conn.Encoding);
* else
* psql = Marshal.StringToHGlobalUni (sql.Trim());
*/
string queryval = sql.Trim();
string pzTail = sql.Trim();
IntPtr errMsgPtr;
parent_conn.StartExec();
rows_affected = 0;
try
{
while (true)
{
Sqlite3.Vdbe pStmt = null;
queryval = pzTail;
GetNextStatement(queryval, ref pzTail, ref pStmt);
if (pStmt == null)
{
throw new Exception();
}
// pzTail is positioned after the last byte in the
// statement, which will be the NULL character if
// this was the last statement.
bool last = pzTail.Length == 0;
try
{
if (parent_conn.Version == 3)
{
BindParameters3(pStmt);
}
if (last && want_results)
{
return(new SqliteDataReader(this, pStmt, parent_conn.Version));
}
ExecuteStatement(pStmt);
if (last) // rows_affected is only used if !want_results
{
rows_affected = NumChanges();
}
}
finally
{
//if (parent_conn.Version == 3)
Sqlite3.sqlite3_finalize(pStmt);
//else
// Sqlite.sqlite_finalize (pStmt, out errMsgPtr);
}
if (last)
{
break;
}
}
return(null);
}
//alxwest: Console.WriteLine in shared functionality.
//catch ( Exception ex )
//{
// Console.WriteLine( ex.Message );
// return null;
//}
finally
{
parent_conn.EndExec();
//Marshal.FreeHGlobal (psql);
}
}
public XMusicDB(string path)
{
FilePath = path;
db = new Sqlite3(path);
CreateTables();
}
public string GetLastError()
{
return(Sqlite3.sqlite3_errmsg(parent_conn.Handle2));
}
private void BindParameters3(Sqlite3.Vdbe pStmt)
{
if (sql_params == null)
{
return;
}
if (sql_params.Count == 0)
{
return;
}
int pcount = Sqlite3.sqlite3_bind_parameter_count(pStmt);
for (int i = 1; i <= pcount; i++)
{
String name = Sqlite3.sqlite3_bind_parameter_name(pStmt, i);
SqliteParameter param = null;
if (!String.IsNullOrEmpty(name))
{
param = sql_params[name] as SqliteParameter;
}
else
{
param = sql_params[i - 1] as SqliteParameter;
}
if (param.Value == null)
{
Sqlite3.sqlite3_bind_null(pStmt, i);
continue;
}
Type ptype = param.Value.GetType();
if (ptype.IsEnum)
{
ptype = Enum.GetUnderlyingType(ptype);
}
SqliteError err;
if (ptype.Equals(typeof(String)))
{
String s = (String)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_text(pStmt, i, s, -1, null);
}
else if (ptype.Equals(typeof(DBNull)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_null(pStmt, i);
}
else if (ptype.Equals(typeof(Boolean)))
{
bool b = (bool)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, b ? 1 : 0);
}
else if (ptype.Equals(typeof(Byte)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (Byte)param.Value);
}
else if (ptype.Equals(typeof(Char)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (Char)param.Value);
}
else if (ptype.IsEnum)
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (Int32)param.Value);
}
else if (ptype.Equals(typeof(Int16)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (Int16)param.Value);
}
else if (ptype.Equals(typeof(Int32)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (Int32)param.Value);
}
else if (ptype.Equals(typeof(SByte)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (SByte)param.Value);
}
else if (ptype.Equals(typeof(UInt16)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int(pStmt, i, (UInt16)param.Value);
}
else if (ptype.Equals(typeof(DateTime)))
{
DateTime dt = (DateTime)param.Value;
err = (SqliteError)Sqlite3.sqlite3_bind_text(pStmt, i, dt.ToString("yyyy-MM-dd HH:mm:ss.fff"), -1, null);
}
else if (ptype.Equals(typeof(Decimal)))
{
string val = ((Decimal)param.Value).ToString(CultureInfo.InvariantCulture);
err = (SqliteError)Sqlite3.sqlite3_bind_text(pStmt, i, val, val.Length, null);
}
else if (ptype.Equals(typeof(Double)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_double(pStmt, i, (Double)param.Value);
}
else if (ptype.Equals(typeof(Single)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_double(pStmt, i, (Single)param.Value);
}
else if (ptype.Equals(typeof(UInt32)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int64(pStmt, i, (UInt32)param.Value);
}
else if (ptype.Equals(typeof(Int64)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_int64(pStmt, i, (Int64)param.Value);
}
else if (ptype.Equals(typeof(Byte[])))
{
err = (SqliteError)Sqlite3.sqlite3_bind_blob(pStmt, i, (byte[])param.Value, ((byte[])param.Value).Length, null);
}
else if (ptype.Equals(typeof(Guid)))
{
err = (SqliteError)Sqlite3.sqlite3_bind_text(pStmt, i, param.Value.ToString(), param.Value.ToString().Length, null);
}
else
{
throw new ApplicationException("Unkown Parameter Type");
}
if (err != SqliteError.OK)
{
throw new ApplicationException("Sqlite error in bind " + err);
}
}
}
// Executes a statement and ignores its result.
private void ExecuteStatement( Sqlite3.Vdbe pStmt )
{
int cols;
IntPtr pazValue, pazColName;
ExecuteStatement( pStmt, out cols, out pazValue, out pazColName );
}
