/// <summary>
/// When the database connection is closed, all commands linked to this connection are automatically reset.
/// </summary>
public override void Close()
{
if (_sql != null)
{
if (_enlistment != null)
{
// If the connection is enlisted in a transaction scope and the scope is still active,
// we cannot truly shut down this connection until the scope has completed. Therefore make a
// hidden connection temporarily to hold open the connection until the scope has completed.
var cnn = new SqliteConnection
{
_sql = this._sql,
_transactionLevel = this._transactionLevel,
_enlistment = this._enlistment,
_connectionState = this._connectionState,
_version = this._version
};
cnn._enlistment._transaction._cnn = cnn;
cnn._enlistment._disposeConnection = true;
_sql = null;
_enlistment = null;
}
if (_sql != null)
{
_sql.Close();
}
_sql = null;
_transactionLevel = 0;
}
OnStateChange(ConnectionState.Closed);
}
/// <summary>
/// Initializes the statement and attempts to get all information about parameters in the statement
/// </summary>
/// <param name="sqlbase">The base SQLite object</param>
/// <param name="stmt">The statement</param>
/// <param name="strCommand">The command text for this statement</param>
/// <param name="previous">The previous command in a multi-statement command</param>
internal SqliteStatement(SQLiteBase sqlbase, SqliteStatementHandle stmt, string strCommand, SqliteStatement previous)
{
_sql = sqlbase;
_sqlite_stmt = stmt;
_sqlStatement = strCommand;
// Determine parameters for this statement (if any) and prepare space for them.
int nCmdStart = 0;
int n = _sql.Bind_ParamCount(this);
int x;
string s;
if (n > 0)
{
if (previous != null)
nCmdStart = previous._unnamedParameters;
_paramNames = new string[n];
_paramValues = new SqliteParameter[n];
for (x = 0; x < n; x++)
{
s = _sql.Bind_ParamName(this, x + 1);
if (String.IsNullOrEmpty(s))
{
s = String.Format(CultureInfo.InvariantCulture, ";{0}", nCmdStart);
nCmdStart++;
_unnamedParameters++;
}
_paramNames[x] = s;
_paramValues[x] = null;
}
}
}
/// <summary>
/// Called by SQLiteBase derived classes, this function binds all user-defined functions to a connection.
/// It is done this way so that all user-defined functions will access the database using the same encoding scheme
/// as the connection (UTF-8 or UTF-16).
/// </summary>
/// <remarks>
/// The wrapper functions that interop with SQLite will create a unique cookie value, which internally is a pointer to
/// all the wrapped callback functions. The interop function uses it to map CDecl callbacks to StdCall callbacks.
/// </remarks>
/// <param name="sqlbase">The base object on which the functions are to bind</param>
/// <returns>Returns an array of functions which the connection object should retain until the connection is closed.</returns>
internal static SqliteFunction[] BindFunctions(SQLiteBase sqlbase)
{
SqliteFunction f;
List <SqliteFunction> lFunctions = new List <SqliteFunction>();
foreach (SqliteFunctionAttribute pr in _registeredFunctions)
{
f = (SqliteFunction)Activator.CreateInstance(pr._instanceType);
f._base = sqlbase;
f._InvokeFunc = (pr.FuncType == FunctionType.Scalar) ? new SQLiteCallback(f.ScalarCallback) : null;
f._StepFunc = (pr.FuncType == FunctionType.Aggregate) ? new SQLiteCallback(f.StepCallback) : null;
f._FinalFunc = (pr.FuncType == FunctionType.Aggregate) ? new SQLiteFinalCallback(f.FinalCallback) : null;
f._CompareFunc = (pr.FuncType == FunctionType.Collation) ? new SQLiteCollation(f.CompareCallback) : null;
f._CompareFunc16 = (pr.FuncType == FunctionType.Collation) ? new SQLiteCollation(f.CompareCallback16) : null;
if (pr.FuncType != FunctionType.Collation)
{
sqlbase.CreateFunction(pr.Name, pr.Arguments, (f is SqliteFunctionEx), f._InvokeFunc, f._StepFunc, f._FinalFunc);
}
else
{
sqlbase.CreateCollation(pr.Name, f._CompareFunc, f._CompareFunc16);
}
lFunctions.Add(f);
}
SqliteFunction[] arFunctions = new SqliteFunction[lFunctions.Count];
lFunctions.CopyTo(arFunctions, 0);
return(arFunctions);
}
internal static void Dispose(this SqliteConnectionHandle connection)
{
try
{
SQLiteBase.CloseConnection(connection);
}
catch (SqliteException)
{
}
}
internal static void Dispose(this SqliteStatementHandle statement)
{
try
{
SQLiteBase.FinalizeStatement(statement);
}
catch (SqliteException)
{
}
}
protected override bool ReleaseHandle()
{
try
{
SQLiteBase.FinalizeStatement(this);
}
catch (SqliteException)
{
}
return(true);
}
protected override bool ReleaseHandle()
{
try
{
SQLiteBase.CloseConnection(this);
}
catch (SqliteException)
{
}
return(true);
}
/// <summary>
/// Disposes and finalizes the statement
/// </summary>
public void Dispose()
{
if (_sqlite_stmt != null)
{
_sqlite_stmt.Dispose();
}
_sqlite_stmt = null;
_paramNames = null;
_paramValues = null;
_sql = null;
_sqlStatement = null;
}
/// <summary>
/// Initializes the connection with the specified connection string
/// </summary>
/// <param name="connectionString">The connection string to use on the connection</param>
public SqliteConnection(string connectionString)
{
_sql = null;
_connectionState = ConnectionState.Closed;
_connectionString = "";
_transactionLevel = 0;
_version = 0;
//_commandList = new List<WeakReference>();
if (connectionString != null)
{
ConnectionString = connectionString;
}
}
// It isn't necessary to cleanup any functions we've registered. If the connection
// goes to the pool and is resurrected later, re-registered functions will overwrite the
// previous functions. The SqliteFunctionCookieHandle will take care of freeing unmanaged
// resources belonging to the previously-registered functions.
internal override void Close()
{
if (_sql != null)
{
if (_usePool)
{
SQLiteBase.ResetConnection(_sql);
SqliteConnectionPool.Add(_fileName, _sql, _poolVersion);
}
else
{
_sql.Dispose();
}
}
_sql = null;
}
protected override bool ReleaseHandle()
{
try
{
lock (this._cnn)
{
SQLiteBase.FinalizeStatement(this);
Interlocked.Exchange(ref this.handle, IntPtr.Zero);
}
}
catch (SqliteException)
{
}
finally
{
this.SetHandleAsInvalid();
}
return(true);
}
protected override bool ReleaseHandle()
{
try
{
IntPtr localHandle = Interlocked.Exchange(ref this.handle, IntPtr.Zero);
if (localHandle != IntPtr.Zero)
{
SQLiteBase.CloseConnection(this, localHandle);
}
}
catch (SqliteException)
{
}
finally
{
this.handle = IntPtr.Zero;
this.SetHandleAsInvalid();
}
return(true);
}
// It isn't necessary to cleanup any functions we've registered. If the connection
// goes to the pool and is resurrected later, re-registered functions will overwrite the
// previous functions. The SqliteFunctionCookieHandle will take care of freeing unmanaged
// resources belonging to the previously-registered functions.
internal override void Close()
{
if (_sql != null)
{
if (_usePool)
{
SQLiteBase.ResetConnection(_sql);
SqliteConnectionPool.Add(_fileName, _sql, _poolVersion);
}
else
{
_sql.Dispose();
}
}
_sql = null;
#if MONOTOUCH
if (gch.IsAllocated)
{
gch.Free();
}
#endif
}
/// <summary>
/// Placeholder for a user-defined disposal routine
/// </summary>
/// <param name="disposing">True if the object is being disposed explicitly</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
IDisposable disp;
foreach (KeyValuePair <long, AggregateData> kv in _contextDataList)
{
disp = kv.Value._data as IDisposable;
if (disp != null)
{
disp.Dispose();
}
}
_contextDataList.Clear();
_InvokeFunc = null;
_StepFunc = null;
_FinalFunc = null;
_CompareFunc = null;
_base = null;
_contextDataList = null;
}
}
/// <summary>
/// Initializes the statement and attempts to get all information about parameters in the statement
/// </summary>
/// <param name="sqlbase">The base SQLite object</param>
/// <param name="stmt">The statement</param>
/// <param name="strCommand">The command text for this statement</param>
/// <param name="previous">The previous command in a multi-statement command</param>
internal SqliteStatement(SQLiteBase sqlbase, SqliteStatementHandle stmt, string strCommand, SqliteStatement previous)
{
_sql = sqlbase;
_sqlite_stmt = stmt;
_sqlStatement = strCommand;
// Determine parameters for this statement (if any) and prepare space for them.
int nCmdStart = 0;
int n = _sql.Bind_ParamCount(this);
int x;
string s;
if (n > 0)
{
if (previous != null)
{
nCmdStart = previous._unnamedParameters;
}
_paramNames = new string[n];
_paramValues = new SqliteParameter[n];
for (x = 0; x < n; x++)
{
s = _sql.Bind_ParamName(this, x + 1);
if (String.IsNullOrEmpty(s))
{
s = String.Format(CultureInfo.InvariantCulture, ";{0}", nCmdStart);
nCmdStart++;
_unnamedParameters++;
}
_paramNames[x] = s;
_paramValues[x] = null;
}
}
}
/// <summary>
/// Called by SQLiteBase derived classes, this function binds all user-defined functions to a connection.
/// It is done this way so that all user-defined functions will access the database using the same encoding scheme
/// as the connection (UTF-8 or UTF-16).
/// </summary>
/// <remarks>
/// The wrapper functions that interop with SQLite will create a unique cookie value, which internally is a pointer to
/// all the wrapped callback functions. The interop function uses it to map CDecl callbacks to StdCall callbacks.
/// </remarks>
/// <param name="sqlbase">The base object on which the functions are to bind</param>
/// <returns>Returns an array of functions which the connection object should retain until the connection is closed.</returns>
internal static SqliteFunction[] BindFunctions(SQLiteBase sqlbase)
{
SqliteFunction f;
List<SqliteFunction> lFunctions = new List<SqliteFunction>();
foreach (SqliteFunctionAttribute pr in _registeredFunctions)
{
f = (SqliteFunction)Activator.CreateInstance(pr._instanceType);
f._base = sqlbase;
f._InvokeFunc = (pr.FuncType == FunctionType.Scalar) ? new SQLiteCallback(f.ScalarCallback) : null;
f._StepFunc = (pr.FuncType == FunctionType.Aggregate) ? new SQLiteCallback(f.StepCallback) : null;
f._FinalFunc = (pr.FuncType == FunctionType.Aggregate) ? new SQLiteFinalCallback(f.FinalCallback) : null;
f._CompareFunc = (pr.FuncType == FunctionType.Collation) ? new SQLiteCollation(f.CompareCallback) : null;
f._CompareFunc16 = (pr.FuncType == FunctionType.Collation) ? new SQLiteCollation(f.CompareCallback16) : null;
if (pr.FuncType != FunctionType.Collation)
sqlbase.CreateFunction(pr.Name, pr.Arguments, (f is SqliteFunctionEx), f._InvokeFunc, f._StepFunc, f._FinalFunc);
else
sqlbase.CreateCollation(pr.Name, f._CompareFunc, f._CompareFunc16);
lFunctions.Add(f);
}
SqliteFunction[] arFunctions = new SqliteFunction[lFunctions.Count];
lFunctions.CopyTo(arFunctions, 0);
return arFunctions;
}
/// <summary>
/// Opens the connection using the parameters found in the <see cref="ConnectionString">ConnectionString</see>
/// </summary>
public override void Open()
{
if (_connectionState != ConnectionState.Closed)
throw new InvalidOperationException();
Close();
SortedList<string, string> opts = ParseConnectionString(_connectionString);
string fileName;
if (Convert.ToInt32(FindKey(opts, "Version", "3"), CultureInfo.InvariantCulture) != 3)
throw new NotSupportedException("Only SQLite Version 3 is supported at this time");
fileName = FindKey(opts, "Data Source", "");
if (String.IsNullOrEmpty(fileName))
{
fileName = FindKey(opts, "Uri", "");
if (String.IsNullOrEmpty(fileName))
throw new ArgumentException("Data Source cannot be empty. Use :memory: to open an in-memory database");
else
fileName = MapUriPath(fileName);
}
if (String.Compare(fileName, ":MEMORY:", true, CultureInfo.InvariantCulture) == 0)
fileName = ":memory:";
else
{
#if PLATFORM_COMPACTFRAMEWORK
if (fileName.StartsWith(".\\"))
fileName = Path.GetDirectoryName(System.Reflection.Assembly.GetCallingAssembly().GetName().CodeBase) + fileName.Substring(1);
#endif
fileName = ExpandFileName(fileName);
}
try
{
bool usePooling = (SqliteConvert.ToBoolean(FindKey(opts, "Pooling", Boolean.FalseString)) == true);
bool bUTF16 = (SqliteConvert.ToBoolean(FindKey(opts, "UseUTF16Encoding", Boolean.FalseString)) == true);
int maxPoolSize = Convert.ToInt32(FindKey(opts, "Max Pool Size", "100"));
_defaultTimeout = Convert.ToInt32(FindKey(opts, "Default Timeout", "30"), CultureInfo.CurrentCulture);
_defaultIsolation = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), FindKey(opts, "Default IsolationLevel", "Serializable"), true);
if (_defaultIsolation != IsolationLevel.Serializable && _defaultIsolation != IsolationLevel.ReadCommitted)
throw new NotSupportedException("Invalid Default IsolationLevel specified");
SQLiteDateFormats dateFormat = (SQLiteDateFormats)Enum.Parse(typeof(SQLiteDateFormats), FindKey(opts, "DateTimeFormat", "ISO8601"), true);
//string temp = FindKey(opts, "DateTimeFormat", "ISO8601");
//if (String.Compare(temp, "ticks", true, CultureInfo.InvariantCulture) == 0) dateFormat = SQLiteDateFormats.Ticks;
//else if (String.Compare(temp, "julianday", true, CultureInfo.InvariantCulture) == 0) dateFormat = SQLiteDateFormats.JulianDay;
if (bUTF16) // SQLite automatically sets the encoding of the database to UTF16 if called from sqlite3_open16()
_sql = new SQLite3_UTF16(dateFormat);
else
_sql = new SQLite3(dateFormat);
SQLiteOpenFlagsEnum flags = SQLiteOpenFlagsEnum.None;
if (SqliteConvert.ToBoolean(FindKey(opts, "Read Only", Boolean.FalseString)) == true)
flags |= SQLiteOpenFlagsEnum.ReadOnly;
else {
flags |= SQLiteOpenFlagsEnum.ReadWrite;
if (SqliteConvert.ToBoolean(FindKey(opts, "FailIfMissing", Boolean.FalseString)) == false)
flags |= SQLiteOpenFlagsEnum.Create;
}
if (SqliteConvert.ToBoolean (FindKey (opts, "FileProtectionComplete", Boolean.FalseString)))
flags |= SQLiteOpenFlagsEnum.FileProtectionComplete;
if (SqliteConvert.ToBoolean (FindKey (opts, "FileProtectionCompleteUnlessOpen", Boolean.FalseString)))
flags |= SQLiteOpenFlagsEnum.FileProtectionCompleteUnlessOpen;
if (SqliteConvert.ToBoolean (FindKey (opts, "FileProtectionCompleteUntilFirstUserAuthentication", Boolean.FalseString)))
flags |= SQLiteOpenFlagsEnum.FileProtectionCompleteUntilFirstUserAuthentication;
if (SqliteConvert.ToBoolean (FindKey (opts, "FileProtectionNone", Boolean.FalseString)))
flags |= SQLiteOpenFlagsEnum.FileProtectionNone;
_sql.Open(fileName, flags, maxPoolSize, usePooling);
_binaryGuid = (SqliteConvert.ToBoolean(FindKey(opts, "BinaryGUID", Boolean.TrueString)) == true);
string password = FindKey(opts, "Password", null);
if (String.IsNullOrEmpty(password) == false)
_sql.SetPassword(System.Text.UTF8Encoding.UTF8.GetBytes(password));
else if (_password != null)
_sql.SetPassword(_password);
_password = null;
_dataSource = Path.GetFileNameWithoutExtension(fileName);
OnStateChange(ConnectionState.Open);
_version++;
using (SqliteCommand cmd = CreateCommand())
{
string defValue;
if (fileName != ":memory:")
{
defValue = FindKey(opts, "Page Size", "1024");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 1024)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA page_size={0}", defValue);
cmd.ExecuteNonQuery();
}
}
defValue = FindKey(opts, "Max Page Count", "0");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA max_page_count={0}", defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Legacy Format", Boolean.FalseString);
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA legacy_file_format={0}", SqliteConvert.ToBoolean(defValue) == true ? "ON" : "OFF");
cmd.ExecuteNonQuery();
defValue = FindKey(opts, "Synchronous", "Normal");
if (String.Compare(defValue, "Full", StringComparison.OrdinalIgnoreCase) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA synchronous={0}", defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Cache Size", "2000");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 2000)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA cache_size={0}", defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Journal Mode", "Delete");
if (String.Compare(defValue, "Default", StringComparison.OrdinalIgnoreCase) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA journal_mode={0}", defValue);
cmd.ExecuteNonQuery();
}
}
if (_commitHandler != null)
_sql.SetCommitHook(_commitCallback);
if (_updateHandler != null)
_sql.SetUpdateHook(_updateCallback);
if (_rollbackHandler != null)
_sql.SetRollbackHook(_rollbackCallback);
#if !PLATFORM_COMPACTFRAMEWORK
if (global::System.Transactions.Transaction.Current != null && SqliteConvert.ToBoolean(FindKey(opts, "Enlist", Boolean.TrueString)) == true)
EnlistTransaction(global::System.Transactions.Transaction.Current);
#endif
}
catch (SqliteException)
{
Close();
throw;
}
}
/// <summary>
/// When the database connection is closed, all commands linked to this connection are automatically reset.
/// </summary>
public override void Close()
{
if (_sql != null)
{
#if !PLATFORM_COMPACTFRAMEWORK
if (_enlistment != null)
{
// If the connection is enlisted in a transaction scope and the scope is still active,
// we cannot truly shut down this connection until the scope has completed. Therefore make a
// hidden connection temporarily to hold open the connection until the scope has completed.
SqliteConnection cnn = new SqliteConnection();
cnn._sql = _sql;
cnn._transactionLevel = _transactionLevel;
cnn._enlistment = _enlistment;
cnn._connectionState = _connectionState;
cnn._version = _version;
cnn._enlistment._transaction._cnn = cnn;
cnn._enlistment._disposeConnection = true;
_sql = null;
_enlistment = null;
}
#endif
if (_sql != null)
{
_sql.Close();
}
_sql = null;
_transactionLevel = 0;
}
OnStateChange(ConnectionState.Closed);
}
/// <summary>
/// Initializes the connection with the specified connection string
/// </summary>
/// <param name="connectionString">The connection string to use on the connection</param>
public SqliteConnection(string connectionString)
{
_sql = null;
_connectionState = ConnectionState.Closed;
_connectionString = "";
_transactionLevel = 0;
_version = 0;
//_commandList = new List<WeakReference>();
if (connectionString != null)
ConnectionString = connectionString;
}
internal override string SQLiteLastError()
{
return(SQLiteBase.SQLiteLastError(_sql));
}
/// <summary>
/// Opens the connection using the parameters found in the <see cref="ConnectionString">ConnectionString</see>
/// </summary>
public override void Open()
{
if (_connectionState != ConnectionState.Closed)
{
throw new InvalidOperationException();
}
Close();
Dictionary <string, string> opts = ParseConnectionString(_connectionString);
if (Convert.ToInt32(FindKey(opts, "Version", "3"), CultureInfo.InvariantCulture) != 3)
{
throw new NotSupportedException("Only SQLite Version 3 is supported at this time");
}
string fileName = FindKey(opts, "Data Source", "");
if (String.IsNullOrEmpty(fileName))
{
fileName = FindKey(opts, "Uri", "");
if (String.IsNullOrEmpty(fileName))
{
throw new ArgumentException("Data Source cannot be empty. Use :memory: to open an in-memory database");
}
fileName = MapUriPath(fileName);
}
if (String.Compare(fileName, ":MEMORY:", StringComparison.OrdinalIgnoreCase) == 0)
{
fileName = ":memory:";
}
else
{
fileName = this.ExpandFileName(fileName);
}
try
{
bool usePooling = SqliteConvert.ToBoolean(FindKey(opts, "Pooling", Boolean.FalseString));
bool bUTF16 = SqliteConvert.ToBoolean(FindKey(opts, "UseUTF16Encoding", Boolean.FalseString));
int maxPoolSize = Convert.ToInt32(FindKey(opts, "Max Pool Size", "100"));
_defaultTimeout = Convert.ToInt32(FindKey(opts, "Default Timeout", "30"), CultureInfo.CurrentCulture);
_defaultIsolation =
(IsolationLevel)
Enum.Parse(typeof(IsolationLevel), FindKey(opts, "Default IsolationLevel", "Serializable"), true);
if (_defaultIsolation != IsolationLevel.Serializable &&
_defaultIsolation != IsolationLevel.ReadCommitted)
{
throw new NotSupportedException("Invalid Default IsolationLevel specified");
}
var dateFormat =
(SQLiteDateFormats)
Enum.Parse(typeof(SQLiteDateFormats), FindKey(opts, "DateTimeFormat", "ISO8601"), true);
//string temp = FindKey(opts, "DateTimeFormat", "ISO8601");
//if (String.Compare(temp, "ticks", true, CultureInfo.InvariantCulture) == 0) dateFormat = SQLiteDateFormats.Ticks;
//else if (String.Compare(temp, "julianday", true, CultureInfo.InvariantCulture) == 0) dateFormat = SQLiteDateFormats.JulianDay;
// SQLite automatically sets the encoding of the database to UTF16 if called from sqlite3_open16()
this._sql = bUTF16 ? new SQLite3_UTF16(dateFormat) : new SQLite3(dateFormat);
SQLiteOpenFlagsEnum flags = SQLiteOpenFlagsEnum.None;
if (SqliteConvert.ToBoolean(FindKey(opts, "Read Only", Boolean.FalseString)))
{
flags |= SQLiteOpenFlagsEnum.ReadOnly;
}
else
{
flags |= SQLiteOpenFlagsEnum.ReadWrite;
if (SqliteConvert.ToBoolean(FindKey(opts, "FailIfMissing", Boolean.FalseString)) == false)
{
flags |= SQLiteOpenFlagsEnum.Create;
}
}
if (SqliteConvert.ToBoolean(FindKey(opts, "FileProtectionComplete", Boolean.FalseString)))
{
flags |= SQLiteOpenFlagsEnum.FileProtectionComplete;
}
if (SqliteConvert.ToBoolean(FindKey(opts, "FileProtectionCompleteUnlessOpen", Boolean.FalseString)))
{
flags |= SQLiteOpenFlagsEnum.FileProtectionCompleteUnlessOpen;
}
if (SqliteConvert.ToBoolean(FindKey(opts, "FileProtectionCompleteUntilFirstUserAuthentication", Boolean.FalseString)))
{
flags |= SQLiteOpenFlagsEnum.FileProtectionCompleteUntilFirstUserAuthentication;
}
if (SqliteConvert.ToBoolean(FindKey(opts, "FileProtectionNone", Boolean.FalseString)))
{
flags |= SQLiteOpenFlagsEnum.FileProtectionNone;
}
_sql.Open(fileName, flags, maxPoolSize, usePooling);
_binaryGuid = SqliteConvert.ToBoolean(FindKey(opts, "BinaryGUID", Boolean.TrueString));
string password = FindKey(opts, "Password", null);
if (String.IsNullOrEmpty(password) == false)
{
_sql.SetPassword(password);
}
else if (_password != null)
{
_sql.SetPassword(_password);
}
_password = null;
// TODO : _dataSource = Path.GetFileNameWithoutExtension(fileName);
_dataSource = fileName;
OnStateChange(ConnectionState.Open);
_version++;
using (SqliteCommand cmd = CreateCommand())
{
string defValue;
if (fileName != ":memory:")
{
defValue = FindKey(opts, "Page Size", "1024");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 1024)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA page_size={0}",
defValue);
cmd.ExecuteNonQuery();
}
}
defValue = FindKey(opts, "Max Page Count", "0");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA max_page_count={0}",
defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Legacy Format", Boolean.FalseString);
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA legacy_file_format={0}",
SqliteConvert.ToBoolean(defValue) ? "ON" : "OFF");
cmd.ExecuteNonQuery();
defValue = FindKey(opts, "Synchronous", "Normal");
if (String.Compare(defValue, "Full", StringComparison.OrdinalIgnoreCase) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA synchronous={0}", defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Cache Size", "2000");
if (Convert.ToInt32(defValue, CultureInfo.InvariantCulture) != 2000)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA cache_size={0}", defValue);
cmd.ExecuteNonQuery();
}
defValue = FindKey(opts, "Journal Mode", "Delete");
if (String.Compare(defValue, "Default", StringComparison.OrdinalIgnoreCase) != 0)
{
cmd.CommandText = String.Format(CultureInfo.InvariantCulture, "PRAGMA journal_mode={0}",
defValue);
cmd.ExecuteNonQuery();
}
}
if (_commitHandler != null)
{
_sql.SetCommitHook(_commitCallback);
}
if (_updateHandler != null)
{
_sql.SetUpdateHook(_updateCallback);
}
if (_rollbackHandler != null)
{
_sql.SetRollbackHook(_rollbackCallback);
}
if (global::System.Transactions.Transaction.Current != null &&
SqliteConvert.ToBoolean(FindKey(opts, "Enlist", Boolean.TrueString)))
{
EnlistTransaction(global::System.Transactions.Transaction.Current);
}
}
catch (SqliteException)
{
Close();
throw;
}
}
/// <summary>
/// Disposes and finalizes the statement
/// </summary>
public void Dispose()
{
if (_sqlite_stmt != null)
{
_sqlite_stmt.Dispose();
}
_sqlite_stmt = null;
_paramNames = null;
_paramValues = null;
_sql = null;
_sqlStatement = null;
}
/// <summary>
/// When the database connection is closed, all commands linked to this connection are automatically reset.
/// </summary>
public override void Close()
{
if (_sql != null)
{
if (_enlistment != null)
{
// If the connection is enlisted in a transaction scope and the scope is still active,
// we cannot truly shut down this connection until the scope has completed. Therefore make a
// hidden connection temporarily to hold open the connection until the scope has completed.
var cnn = new SqliteConnection
{
_sql = this._sql,
_transactionLevel = this._transactionLevel,
_enlistment = this._enlistment,
_connectionState = this._connectionState,
_version = this._version
};
cnn._enlistment._transaction._cnn = cnn;
cnn._enlistment._disposeConnection = true;
_sql = null;
_enlistment = null;
}
if (_sql != null)
{
_sql.Close();
}
_sql = null;
_transactionLevel = 0;
}
OnStateChange(ConnectionState.Closed);
}
/// <summary>
/// Placeholder for a user-defined disposal routine
/// </summary>
/// <param name="disposing">True if the object is being disposed explicitly</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
IDisposable disp;
foreach (KeyValuePair<long, AggregateData> kv in _contextDataList)
{
disp = kv.Value._data as IDisposable;
if (disp != null)
disp.Dispose();
}
_contextDataList.Clear();
_InvokeFunc = null;
_StepFunc = null;
_FinalFunc = null;
_CompareFunc = null;
_base = null;
_contextDataList = null;
}
}
