// 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;
}
internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero))
{
return("null connection or database handle");
}
string result = null;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
if (!hdl.IsInvalid && !hdl.IsClosed)
{
#if !SQLITE_STANDARD
int len;
result = UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
#else
result = UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
}
else
{
result = "closed or invalid connection handle";
}
}
}
GC.KeepAlive(hdl);
return(result);
}
internal static void ResetConnection(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero))
{
return;
}
if (hdl.IsClosed || hdl.IsInvalid)
{
return;
}
lock (hdl)
{
IntPtr stmt = IntPtr.Zero;
int n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
if (IsAutocommit(hdl, db) == false) // a transaction is pending on the connection
{
n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
if (n > 0)
{
throw new SQLiteException(n, GetLastError(hdl, db));
}
}
}
GC.KeepAlive(hdl);
}
internal override void Open(string strFilename, SQLiteOpenFlagsEnum flags, int maxPoolSize, bool usePool)
{
if (this._sql == null)
{
this._usePool = usePool;
if (usePool)
{
this._fileName = strFilename;
this._sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out this._poolVersion);
}
if (this._sql == null)
{
IntPtr ptr;
int errorCode = UnsafeNativeMethods.sqlite3_open_interop(SQLiteConvert.ToUTF8(strFilename), (int)flags, out ptr);
if (errorCode > 0)
{
throw new SQLiteException(errorCode, null);
}
this._sql = ptr;
}
this._functionsArray = SQLiteFunction.BindFunctions(this);
this.SetTimeout(0);
}
}
internal static void CloseConnection(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero)) return;
lock (hdl)
{
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_close_interop(db);
#else
ResetConnection(hdl, db);
int n = UnsafeNativeMethods.sqlite3_close(db);
#endif
if (n > 0) throw new SQLiteException(n, GetLastError(hdl, db));
}
}
internal static void FinishBackup(SQLiteConnectionHandle hdl, IntPtr backup)
{
if ((hdl == null) || (backup == IntPtr.Zero)) return;
lock (hdl)
{
int n = UnsafeNativeMethods.sqlite3_backup_finish(backup);
if (n > 0) throw new SQLiteException(n, null);
}
}
internal static bool IsAutocommit(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero)) return false;
bool result = false;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
if (!hdl.IsInvalid && !hdl.IsClosed)
result = (UnsafeNativeMethods.sqlite3_get_autocommit(db) == 1);
}
}
GC.KeepAlive(hdl); /* NOTE: Unreachable code. */
return result;
}
internal static void CloseConnectionV2(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero)) return;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
#if !SQLITE_STANDARD
SQLiteErrorCode n = UnsafeNativeMethods.sqlite3_close_interop(db);
#else
ResetConnection(hdl, db, false);
SQLiteErrorCode n = UnsafeNativeMethods.sqlite3_close_v2(db);
#endif
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, GetLastError(hdl, db));
}
}
}
internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero))
return "null connection or database handle";
string result = null;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
if (!hdl.IsInvalid && !hdl.IsClosed)
{
#if !SQLITE_STANDARD
int len = 0;
result = UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, ref len), len);
#else
result = UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
}
else
{
result = "closed or invalid connection handle";
}
}
}
GC.KeepAlive(hdl);
return result;
}
///////////////////////////////////////////////////////////////////////////////////////////////
// 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(bool canThrow)
{
if (_sql != null)
{
if (!_sql.OwnHandle)
{
_sql = null;
return;
}
bool unbindFunctions = ((_flags & SQLiteConnectionFlags.UnbindFunctionsOnClose)
== SQLiteConnectionFlags.UnbindFunctionsOnClose);
if (_usePool)
{
if (SQLiteBase.ResetConnection(_sql, _sql, canThrow))
{
if (unbindFunctions)
{
if (SQLiteFunction.UnbindAllFunctions(this, _flags, false))
{
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"UnbindFunctions (Pool) Success: {0}",
HandleToString()));
#endif
}
else
{
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"UnbindFunctions (Pool) Failure: {0}",
HandleToString()));
#endif
}
}
#if INTEROP_VIRTUAL_TABLE
DisposeModules();
#endif
SQLiteConnectionPool.Add(_fileName, _sql, _poolVersion);
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.ClosedToPool, null, null,
null, null, _sql, _fileName, new object[] {
typeof(SQLite3), canThrow, _fileName, _poolVersion }));
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"Close (Pool) Success: {0}",
HandleToString()));
#endif
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
else
{
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"Close (Pool) Failure: {0}",
HandleToString()));
}
#endif
}
else
{
if (unbindFunctions)
{
if (SQLiteFunction.UnbindAllFunctions(this, _flags, false))
{
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"UnbindFunctions Success: {0}",
HandleToString()));
#endif
}
else
{
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"UnbindFunctions Failure: {0}",
HandleToString()));
#endif
}
}
_sql.Dispose();
}
_sql = null;
}
}
internal SQLiteStatementHandle(SQLiteConnectionHandle cnn, IntPtr stmt)
: this()
{
this.cnn = cnn;
SetHandle(stmt);
}
///////////////////////////////////////////////////////////////////////
internal SQLiteStatementHandle(SQLiteConnectionHandle cnn, IntPtr stmt)
: this()
{
#if PLATFORM_COMPACTFRAMEWORK
lock (syncRoot)
#endif
{
this.cnn = cnn;
SetHandle(stmt);
}
}
internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
if (_sql != null)
{
return;
}
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16 (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db;
SQLiteErrorCode n;
#if !SQLITE_STANDARD
if ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions)
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), openFlags, out db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
}
n = UnsafeNativeMethods.sqlite3_open16(strFilename, out db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok)
{
throw new SQLiteException(n, null);
}
_sql = new SQLiteConnectionHandle(db);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
}
_functionsArray = SQLiteFunction.BindFunctions(this, connectionFlags);
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal static string SQLiteLastError(SQLiteConnectionHandle db)
{
int num;
return(SQLiteConvert.UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop((IntPtr)db, out num), num));
}
internal static bool ResetConnection(SQLiteConnectionHandle hdl, IntPtr db, bool canThrow)
{
if ((hdl == null) || (db == IntPtr.Zero))
{
return(false);
}
bool result = false;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
if (canThrow && hdl.IsInvalid)
{
throw new InvalidOperationException("The connection handle is invalid.");
}
if (canThrow && hdl.IsClosed)
{
throw new InvalidOperationException("The connection handle is closed.");
}
if (!hdl.IsInvalid && !hdl.IsClosed)
{
IntPtr stmt = IntPtr.Zero;
SQLiteErrorCode n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
//
// NOTE: Is a transaction NOT pending on the connection?
//
if (IsAutocommit(hdl, db))
{
result = true;
}
else
{
n = UnsafeNativeMethods.sqlite3_exec(
db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero,
out stmt);
if (n == SQLiteErrorCode.Ok)
{
result = true;
}
else if (canThrow)
{
throw new SQLiteException(n, GetLastError(hdl, db));
}
}
}
}
}
GC.KeepAlive(hdl);
return(result);
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Constructs the object used to interact with the SQLite core library
/// using the UTF-8 text encoding.
/// </summary>
/// <param name="fmt">
/// The DateTime format to be used when converting string values to a
/// DateTime and binding DateTime parameters.
/// </param>
/// <param name="kind">
/// The <see cref="DateTimeKind" /> to be used when creating DateTime
/// values.
/// </param>
/// <param name="fmtString">
/// The format string to be used when parsing and formatting DateTime
/// values.
/// </param>
/// <param name="db">
/// The native handle to be associated with the database connection.
/// </param>
/// <param name="fileName">
/// The fully qualified file name associated with <paramref name="db "/>.
/// </param>
/// <param name="ownHandle">
/// Non-zero if the newly created object instance will need to dispose
/// of <paramref name="db" /> when it is no longer needed.
/// </param>
internal SQLite3(
SQLiteDateFormats fmt,
DateTimeKind kind,
string fmtString,
IntPtr db,
string fileName,
bool ownHandle
)
: base(fmt, kind, fmtString)
{
if (db != IntPtr.Zero)
{
_sql = new SQLiteConnectionHandle(db, ownHandle);
_fileName = fileName;
}
}
internal static bool IsAutocommit(SQLiteConnectionHandle hdl, IntPtr db)
{
if (db == IntPtr.Zero) return false;
if (hdl.IsClosed || hdl.IsInvalid) return false;
lock (hdl)
{
return (UnsafeNativeMethods.sqlite3_get_autocommit(db) == 1);
}
#pragma warning disable 162
GC.KeepAlive(hdl); /* NOTE: Unreachable code. */
#pragma warning restore 162
}
internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
if (_sql != null) return;
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if DEBUG && !NET_COMPACT_20
Trace.WriteLine(String.Format("Open (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
IntPtr db;
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_open_interop(ToUTF8(strFilename), (int)openFlags, out db);
#else
int n = UnsafeNativeMethods.sqlite3_open_v2(ToUTF8(strFilename), out db, (int)openFlags, IntPtr.Zero);
#endif
#if DEBUG && !NET_COMPACT_20
Trace.WriteLine(String.Format("Open: {0}", db));
#endif
if (n > 0) throw new SQLiteException(n, null);
_sql = new SQLiteConnectionHandle(db);
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
_functionsArray = SQLiteFunction.BindFunctions(this, connectionFlags);
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal static bool IsAutocommit(SQLiteConnectionHandle hdl)
{
return(UnsafeNativeMethods.sqlite3_get_autocommit(hdl) == 1);
}
///////////////////////////////////////////////////////////////////////
/// <summary>
/// Removes a connection from the pool of those associated with the
/// specified database file name with the intent of using it to
/// interact with the database.
/// </summary>
/// <param name="fileName">
/// The database file name.
/// </param>
/// <param name="maxPoolSize">
/// The new maximum size of the connection pool for the specified
/// database file name.
/// </param>
/// <param name="version">
/// The connection pool version associated with the returned database
/// connection handle, if any.
/// </param>
/// <returns>
/// The database connection handle associated with the specified
/// database file name or null if it cannot be obtained.
/// </returns>
internal static SQLiteConnectionHandle Remove(
string fileName,
int maxPoolSize,
out int version
)
{
ISQLiteConnectionPool connectionPool = GetConnectionPool();
if (connectionPool != null)
{
return(connectionPool.Remove(fileName, maxPoolSize,
out version) as SQLiteConnectionHandle);
}
else
{
int localVersion;
Queue <WeakReference> poolQueue;
//
// NOTE: This lock cannot be held while checking the queue for
// available connections because other methods of this
// class are called from the GC finalizer thread and we
// use the WaitForPendingFinalizers method (below).
// Holding this lock while calling that method would
// therefore result in a deadlock. Instead, this lock
// is held only while a temporary copy of the queue is
// created, and if necessary, when committing changes
// back to that original queue prior to returning from
// this method.
//
lock (_syncRoot)
{
PoolQueue queue;
//
// NOTE: Default to the highest pool version.
//
version = _poolVersion;
//
// NOTE: If we didn't find a pool for this file, create one
// even though it will be empty. We have to do this
// here because otherwise calling ClearPool() on the
// file will not work for active connections that have
// never seen the pool yet.
//
if (!_queueList.TryGetValue(fileName, out queue))
{
queue = new PoolQueue(_poolVersion, maxPoolSize);
_queueList.Add(fileName, queue);
return(null);
}
//
// NOTE: We found a pool for this file, so use its version
// number.
//
version = localVersion = queue.PoolVersion;
queue.MaxPoolSize = maxPoolSize;
//
// NOTE: Now, resize the pool to the new maximum size, if
// necessary.
//
ResizePool(queue, false);
//
// NOTE: Try and get a pooled connection from the queue.
//
poolQueue = queue.Queue;
if (poolQueue == null)
{
return(null);
}
//
// NOTE: Temporarily tranfer the queue for this file into
// a local variable. The queue for this file will
// be modified and then committed back to the real
// pool list (below) prior to returning from this
// method.
//
_queueList.Remove(fileName);
poolQueue = new Queue <WeakReference>(poolQueue);
}
try
{
while (poolQueue.Count > 0)
{
WeakReference connection = poolQueue.Dequeue();
if (connection == null)
{
continue;
}
SQLiteConnectionHandle handle =
connection.Target as SQLiteConnectionHandle;
if (handle == null)
{
continue;
}
//
// BUGFIX: For ticket [996d13cd87], step #1. After
// this point, make sure that the finalizer for
// the connection handle just obtained from the
// queue cannot START running (i.e. it may
// still be pending but it will no longer start
// after this point).
//
GC.SuppressFinalize(handle);
try
{
//
// BUGFIX: For ticket [996d13cd87], step #2. Now,
// we must wait for all pending finalizers
// which have STARTED running and have not
// yet COMPLETED. This must be done just
// in case the finalizer for the connection
// handle just obtained from the queue has
// STARTED running at some point before
// SuppressFinalize was called on it.
//
// After this point, checking properties of
// the connection handle (e.g. IsClosed)
// should work reliably without having to
// worry that they will (due to the
// finalizer) change out from under us.
//
GC.WaitForPendingFinalizers();
//
// BUGFIX: For ticket [996d13cd87], step #3. Next,
// verify that the connection handle is
// actually valid and [still?] not closed
// prior to actually returning it to our
// caller.
//
if (!handle.IsInvalid && !handle.IsClosed)
{
Interlocked.Increment(ref _poolOpened);
return(handle);
}
}
finally
{
//
// BUGFIX: For ticket [996d13cd87], step #4. Next,
// we must re-register the connection
// handle for finalization now that we have
// a strong reference to it (i.e. the
// finalizer will not run at least until
// the connection is subsequently closed).
//
GC.ReRegisterForFinalize(handle);
}
GC.KeepAlive(handle);
}
}
finally
{
//
// BUGFIX: For ticket [996d13cd87], step #5. Finally,
// commit any changes to the pool/queue for this
// database file.
//
lock (_syncRoot)
{
//
// NOTE: We must check [again] if a pool exists for
// this file because one may have been added
// while the search for an available connection
// was in progress (above).
//
PoolQueue queue;
Queue <WeakReference> newPoolQueue;
bool addPool;
if (_queueList.TryGetValue(fileName, out queue))
{
addPool = false;
}
else
{
addPool = true;
queue = new PoolQueue(localVersion, maxPoolSize);
}
newPoolQueue = queue.Queue;
while (poolQueue.Count > 0)
{
newPoolQueue.Enqueue(poolQueue.Dequeue());
}
ResizePool(queue, false);
if (addPool)
{
_queueList.Add(fileName, queue);
}
}
}
return(null);
}
}
///////////////////////////////////////////////////////////////////////
internal SQLiteBackupHandle(SQLiteConnectionHandle cnn, IntPtr backup)
: this()
{
#if PLATFORM_COMPACTFRAMEWORK
lock (syncRoot)
#endif
{
this.cnn = cnn;
SetHandle(backup);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Static "Factory" Methods
/// <summary>
/// Creates a <see cref="SQLiteBlob" /> object. This will not work
/// for tables that were created WITHOUT ROWID -OR- if the query
/// does not include the "rowid" column or one of its aliases -OR-
/// if the <see cref="SQLiteDataReader" /> was not created with the
/// <see cref="CommandBehavior.KeyInfo" /> flag.
/// </summary>
/// <param name="dataReader">
/// The <see cref="SQLiteDataReader" /> instance with a result set
/// containing the desired blob column.
/// </param>
/// <param name="i">
/// The index of the blob column.
/// </param>
/// <param name="readOnly">
/// Non-zero to open the blob object for read-only access.
/// </param>
/// <returns>
/// The newly created <see cref="SQLiteBlob" /> instance -OR- null
/// if an error occurs.
/// </returns>
public static SQLiteBlob Create(
SQLiteDataReader dataReader,
int i,
bool readOnly
)
{
SQLiteConnection connection = SQLiteDataReader.GetConnection(
dataReader);
if (connection == null)
{
throw new InvalidOperationException("Connection not available");
}
SQLite3 sqlite3 = connection._sql as SQLite3;
if (sqlite3 == null)
{
throw new InvalidOperationException("Connection has no wrapper");
}
SQLiteConnectionHandle handle = sqlite3._sql;
if (handle == null)
{
throw new InvalidOperationException("Connection has an invalid handle.");
}
long?rowId = dataReader.GetRowId(i);
if (rowId == null)
{
throw new InvalidOperationException("No RowId is available");
}
SQLiteBlobHandle blob = null;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr ptrBlob = IntPtr.Zero;
SQLiteErrorCode rc = UnsafeNativeMethods.sqlite3_blob_open(
sqlite3._sql, SQLiteConvert.ToUTF8(
dataReader.GetDatabaseName(i)), SQLiteConvert.ToUTF8(
dataReader.GetTableName(i)), SQLiteConvert.ToUTF8(
dataReader.GetName(i)), (long)rowId, readOnly ? 0 : 1,
ref ptrBlob);
if (rc != SQLiteErrorCode.Ok)
{
throw new SQLiteException(rc, null);
}
blob = new SQLiteBlobHandle(handle, ptrBlob);
}
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null,
null, null, dataReader, blob, null, new object[] {
typeof(SQLiteBlob), dataReader, i, readOnly
}));
return(new SQLiteBlob(sqlite3, blob));
}
///////////////////////////////////////////////////////////////////////
/// <summary>
/// Disposes of all pooled connections.
/// </summary>
internal static void ClearAllPools()
{
ISQLiteConnectionPool connectionPool = GetConnectionPool();
if (connectionPool != null)
{
connectionPool.ClearAllPools();
}
else
{
lock (_syncRoot)
{
foreach (KeyValuePair <string, PoolQueue> pair in _queueList)
{
if (pair.Value == null)
{
continue;
}
Queue <WeakReference> poolQueue = pair.Value.Queue;
while (poolQueue.Count > 0)
{
WeakReference connection = poolQueue.Dequeue();
if (connection == null)
{
continue;
}
SQLiteConnectionHandle handle =
connection.Target as SQLiteConnectionHandle;
if (handle != null)
{
handle.Dispose();
}
GC.KeepAlive(handle);
}
//
// NOTE: Keep track of the highest revision so we can
// go one higher when we are finished.
//
if (_poolVersion <= pair.Value.PoolVersion)
{
_poolVersion = pair.Value.PoolVersion + 1;
}
}
//
// NOTE: All pools are cleared and we have a new highest
// version number to force all old version active
// items to get discarded instead of going back to
// the queue when they are closed. We can get away
// with this because we have pumped up the pool
// version out of range of all active connections,
// so they will all get discarded when they try to
// put themselves back into their pools.
//
_queueList.Clear();
}
}
}
// These statics are here for lack of a better place to put them.
// They exist here because they are called during the finalization of
// a SQLiteStatementHandle, SQLiteConnectionHandle, and SQLiteFunctionCookieHandle.
// Therefore these functions have to be static, and have to be low-level.
internal static string SQLiteLastError(SQLiteConnectionHandle db)
{
#if !SQLITE_STANDARD
int len;
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
#else
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
}
internal override void Open(string strFilename, string vfsName, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
//
// NOTE: If the database connection is currently open, attempt to
// close it now. This must be done because the file name or
// other parameters that may impact the underlying database
// connection may have changed.
//
if (_sql != null) Close(true);
//
// NOTE: If the connection was not closed successfully, throw an
// exception now.
//
if (_sql != null)
throw new SQLiteException("connection handle is still active");
_usePool = usePool;
_fileName = strFilename;
_flags = connectionFlags;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.OpenedFromPool, null, null,
null, null, _sql, strFilename, new object[] {
typeof(SQLite3_UTF16), strFilename, vfsName,
connectionFlags, openFlags, maxPoolSize, usePool,
_poolVersion }));
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"Open16 (Pool): {0}",
HandleToString()));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db = IntPtr.Zero;
SQLiteErrorCode n;
int extFuncs = ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions) ? 1 : 0;
#if !SQLITE_STANDARD
if ((vfsName != null) || (extFuncs != 0))
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), ToUTF8(vfsName), openFlags, extFuncs, ref db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
if (vfsName != null)
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"cannot open using UTF-16 and VFS \"{0}\": need interop assembly", vfsName));
}
n = UnsafeNativeMethods.sqlite3_open16(strFilename, ref db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(UnsafeNativeMethods.StringFormat(
CultureInfo.CurrentCulture,
"Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
_sql = new SQLiteConnectionHandle(db, true);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null,
null, null, null, _sql, strFilename, new object[] {
typeof(SQLite3_UTF16), strFilename, vfsName,
connectionFlags, openFlags, maxPoolSize, usePool }));
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions)
{
if (_functions == null)
_functions = new Dictionary<SQLiteFunctionAttribute, SQLiteFunction>();
foreach (KeyValuePair<SQLiteFunctionAttribute, SQLiteFunction> pair
in SQLiteFunction.BindFunctions(this, connectionFlags))
{
_functions[pair.Key] = pair.Value;
}
}
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal static void CloseConnection(SQLiteConnectionHandle db)
{
lock (_lock)
{
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_close_interop(db);
#else
ResetConnection(db);
int n = UnsafeNativeMethods.sqlite3_close(db);
#endif
if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
}
}
internal static void FinalizeStatement(SQLiteConnectionHandle hdl, IntPtr stmt)
{
if ((hdl == null) || (stmt == IntPtr.Zero)) return;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
#if !SQLITE_STANDARD
SQLiteErrorCode n = UnsafeNativeMethods.sqlite3_finalize_interop(stmt);
#else
SQLiteErrorCode n = UnsafeNativeMethods.sqlite3_finalize(stmt);
#endif
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
}
}
}
internal static void ResetConnection(SQLiteConnectionHandle db)
{
lock (_lock)
{
IntPtr stmt = IntPtr.Zero;
int n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
if (IsAutocommit(db) == false) // a transaction is pending on the connection
{
n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
if (n > 0) throw new SQLiteException(n, SQLiteLastError(db));
}
}
}
internal static bool ResetConnection(SQLiteConnectionHandle hdl, IntPtr db, bool canThrow)
{
if ((hdl == null) || (db == IntPtr.Zero)) return false;
bool result = false;
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
#if PLATFORM_COMPACTFRAMEWORK
lock (hdl.syncRoot)
#else
lock (hdl)
#endif
{
if (canThrow && hdl.IsInvalid)
throw new InvalidOperationException("The connection handle is invalid.");
if (canThrow && hdl.IsClosed)
throw new InvalidOperationException("The connection handle is closed.");
if (!hdl.IsInvalid && !hdl.IsClosed)
{
IntPtr stmt = IntPtr.Zero;
SQLiteErrorCode n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
//
// NOTE: Is a transaction NOT pending on the connection?
//
if (IsAutocommit(hdl, db))
{
result = true;
}
else
{
n = UnsafeNativeMethods.sqlite3_exec(
db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero,
ref stmt);
if (n == SQLiteErrorCode.Ok)
{
result = true;
}
else if (canThrow)
{
throw new SQLiteException(n, GetLastError(hdl, db));
}
}
}
}
}
GC.KeepAlive(hdl);
return result;
}
internal static bool IsAutocommit(SQLiteConnectionHandle hdl)
{
return (UnsafeNativeMethods.sqlite3_get_autocommit(hdl) == 1);
}
///////////////////////////////////////////////////////////////////////////////////////////////
// These statics are here for lack of a better place to put them.
// They exist here because they are called during the finalization of
// a SQLiteStatementHandle, SQLiteConnectionHandle, and SQLiteFunctionCookieHandle.
// Therefore these functions have to be static, and have to be low-level.
internal static string GetLastError(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero))
return "null connection or database handle";
lock (hdl)
{
if (hdl.IsClosed || hdl.IsInvalid)
return "closed or invalid connection handle";
#if !SQLITE_STANDARD
int len;
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg_interop(db, out len), len);
#else
return UTF8ToString(UnsafeNativeMethods.sqlite3_errmsg(db), -1);
#endif
}
#pragma warning disable 162
GC.KeepAlive(hdl); /* NOTE: Unreachable code. */
#pragma warning restore 162
}
///////////////////////////////////////////////////////////////////////
/// <summary>
/// Adds a connection to the pool of those associated with the
/// specified database file name.
/// </summary>
/// <param name="fileName">
/// The database file name.
/// </param>
/// <param name="handle">
/// The database connection handle.
/// </param>
/// <param name="version">
/// The connection pool version at the point the database connection
/// handle was received from the connection pool. This is also the
/// connection pool version that the database connection handle was
/// created under.
/// </param>
internal static void Add(
string fileName,
SQLiteConnectionHandle handle,
int version
)
{
ISQLiteConnectionPool connectionPool = GetConnectionPool();
if (connectionPool != null)
{
connectionPool.Add(fileName, handle, version);
}
else
{
lock (_syncRoot)
{
//
// NOTE: If the queue does not exist in the pool, then it
// must have been cleared sometime after the
// connection was created.
//
PoolQueue queue;
if (_queueList.TryGetValue(fileName, out queue) &&
(version == queue.PoolVersion))
{
ResizePool(queue, true);
Queue<WeakReference> poolQueue = queue.Queue;
if (poolQueue == null) return;
poolQueue.Enqueue(new WeakReference(handle, false));
Interlocked.Increment(ref _poolClosed);
}
else
{
handle.Close();
}
GC.KeepAlive(handle);
}
}
}
internal static void FinalizeStatement(SQLiteConnectionHandle hdl, IntPtr stmt)
{
if ((hdl == null) || (stmt == IntPtr.Zero)) return;
lock (hdl)
{
#if !SQLITE_STANDARD
int n = UnsafeNativeMethods.sqlite3_finalize_interop(stmt);
#else
int n = UnsafeNativeMethods.sqlite3_finalize(stmt);
#endif
if (n > 0) throw new SQLiteException(n, null);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
// 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(bool canThrow)
{
if (_sql != null)
{
if (_usePool)
{
if (SQLiteBase.ResetConnection(_sql, _sql, canThrow))
{
SQLiteConnectionPool.Add(_fileName, _sql, _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Close (Pool) Success: {0}", _sql));
#endif
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
else
{
Trace.WriteLine(String.Format("Close (Pool) Failure: {0}", _sql));
}
#endif
}
else
{
_sql.Dispose();
}
_sql = null;
}
}
internal static void ResetConnection(SQLiteConnectionHandle hdl, IntPtr db)
{
if ((hdl == null) || (db == IntPtr.Zero)) return;
if (hdl.IsClosed || hdl.IsInvalid) return;
lock (hdl)
{
IntPtr stmt = IntPtr.Zero;
int n;
do
{
stmt = UnsafeNativeMethods.sqlite3_next_stmt(db, stmt);
if (stmt != IntPtr.Zero)
{
#if !SQLITE_STANDARD
n = UnsafeNativeMethods.sqlite3_reset_interop(stmt);
#else
n = UnsafeNativeMethods.sqlite3_reset(stmt);
#endif
}
} while (stmt != IntPtr.Zero);
if (IsAutocommit(hdl, db) == false) // a transaction is pending on the connection
{
n = UnsafeNativeMethods.sqlite3_exec(db, ToUTF8("ROLLBACK"), IntPtr.Zero, IntPtr.Zero, out stmt);
if (n > 0) throw new SQLiteException(n, GetLastError(hdl, db));
}
}
GC.KeepAlive(hdl);
}
internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
if (_sql != null) return;
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db;
SQLiteErrorCode n;
#if !SQLITE_STANDARD
if ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions)
{
n = UnsafeNativeMethods.sqlite3_open_interop(ToUTF8(strFilename), openFlags, out db);
}
else
#endif
{
n = UnsafeNativeMethods.sqlite3_open_v2(ToUTF8(strFilename), out db, openFlags, IntPtr.Zero);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
_sql = new SQLiteConnectionHandle(db);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
_functionsArray = SQLiteFunction.BindFunctions(this, connectionFlags);
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal override void Open(string strFilename, string vfsName, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
//
// NOTE: If the database connection is currently open, attempt to
// close it now. This must be done because the file name or
// other parameters that may impact the underlying database
// connection may have changed.
//
if (_sql != null)
{
Close(false);
}
//
// NOTE: If the connection was not closed successfully, throw an
// exception now.
//
if (_sql != null)
{
throw new SQLiteException("connection handle is still active");
}
_usePool = usePool;
_fileName = strFilename;
_flags = connectionFlags;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.OpenedFromPool, null, null,
null, null, _sql, strFilename, new object[] {
typeof(SQLite3_UTF16), strFilename, vfsName,
connectionFlags, openFlags, maxPoolSize, usePool,
_poolVersion
}));
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(HelperMethods.StringFormat(
CultureInfo.CurrentCulture,
"Open16 (Pool): {0}",
HandleToString()));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db = IntPtr.Zero;
SQLiteErrorCode n;
int extFuncs = HelperMethods.HasFlags(connectionFlags, SQLiteConnectionFlags.NoExtensionFunctions) ? 0 : 1;
#if !SQLITE_STANDARD
if ((vfsName != null) || (extFuncs != 0))
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), ToUTF8(vfsName), openFlags, extFuncs, ref db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
}
if (vfsName != null)
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, HelperMethods.StringFormat(
CultureInfo.CurrentCulture,
"cannot open using UTF-16 and VFS \"{0}\": need interop assembly", vfsName));
}
n = UnsafeNativeMethods.sqlite3_open16(strFilename, ref db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(HelperMethods.StringFormat(
CultureInfo.CurrentCulture,
"Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok)
{
throw new SQLiteException(n, null);
}
_sql = new SQLiteConnectionHandle(db, true);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null,
null, null, null, _sql, strFilename, new object[] {
typeof(SQLite3_UTF16), strFilename, vfsName,
connectionFlags, openFlags, maxPoolSize, usePool
}));
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
if (!HelperMethods.HasFlags(connectionFlags, SQLiteConnectionFlags.NoBindFunctions))
{
if (_functions == null)
{
_functions = new Dictionary <SQLiteFunctionAttribute, SQLiteFunction>();
}
foreach (KeyValuePair <SQLiteFunctionAttribute, SQLiteFunction> pair
in SQLiteFunction.BindFunctions(this, connectionFlags))
{
_functions[pair.Key] = pair.Value;
}
}
SetTimeout(0);
GC.KeepAlive(_sql);
}
/// <summary>
/// Return a connection to the pool for someone else to use.
/// </summary>
/// <param name="fileName">The filename of the pool to use</param>
/// <param name="hdl">The connection handle to pool</param>
/// <param name="version">The pool version the handle was created under</param>
/// <remarks>
/// If the version numbers don't match between the connection and the pool, then the handle is discarded.
/// </remarks>
internal static void Add(string fileName, SQLiteConnectionHandle hdl, int version)
{
lock (_connections)
{
// If the queue doesn't exist in the pool, then it must've been cleared sometime after the connection was created.
Pool queue;
if (_connections.TryGetValue(fileName, out queue) == true && version == queue.PoolVersion)
{
ResizePool(queue, true);
Queue<WeakReference> poolQueue = queue.Queue;
if (poolQueue == null) return;
poolQueue.Enqueue(new WeakReference(hdl, false));
Interlocked.Increment(ref _poolClosed);
}
else
{
hdl.Close();
}
GC.KeepAlive(hdl);
}
}
internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
//
// NOTE: If the database connection is currently open, attempt to
// close it now. This must be done because the file name or
// other parameters that may impact the underlying database
// connection may have changed.
//
if (_sql != null)
{
Close(true);
}
//
// NOTE: If the connection was not closed successfully, throw an
// exception now.
//
if (_sql != null)
{
throw new SQLiteException("connection handle is still active");
}
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16 (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db = IntPtr.Zero;
SQLiteErrorCode n;
#if !SQLITE_STANDARD
if ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions)
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), openFlags, ref db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
}
n = UnsafeNativeMethods.sqlite3_open16(strFilename, ref db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok)
{
throw new SQLiteException(n, null);
}
_sql = new SQLiteConnectionHandle(db, true);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(
SQLiteConnectionEventType.NewCriticalHandle, null, null,
null, null, _sql, strFilename, new object[] { strFilename,
connectionFlags, openFlags, maxPoolSize, usePool }));
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions)
{
if (_functions == null)
{
_functions = new List <SQLiteFunction>();
}
_functions.AddRange(new List <SQLiteFunction>(SQLiteFunction.BindFunctions(this, connectionFlags)));
}
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal override void Open(string strFilename, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
//
// NOTE: If the database connection is currently open, attempt to
// close it now. This must be done because the file name or
// other parameters that may impact the underlying database
// connection may have changed.
//
if (_sql != null) Close(true);
//
// NOTE: If the connection was not closed successfully, throw an
// exception now.
//
if (_sql != null)
throw new SQLiteException("connection handle is still active");
_usePool = usePool;
_fileName = strFilename;
if (usePool)
{
_sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out _poolVersion);
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16 (Pool): {0}", (_sql != null) ? _sql.ToString() : "<null>"));
#endif
}
if (_sql == null)
{
try
{
// do nothing.
}
finally /* NOTE: Thread.Abort() protection. */
{
IntPtr db;
SQLiteErrorCode n;
#if !SQLITE_STANDARD
if ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions)
{
n = UnsafeNativeMethods.sqlite3_open16_interop(ToUTF8(strFilename), openFlags, out db);
}
else
#endif
{
//
// NOTE: This flag check is designed to enforce the constraint that opening
// a database file that does not already exist requires specifying the
// "Create" flag, even when a native API is used that does not accept
// a flags parameter.
//
if (((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create) && !File.Exists(strFilename))
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
n = UnsafeNativeMethods.sqlite3_open16(strFilename, out db);
}
#if !NET_COMPACT_20 && TRACE_CONNECTION
Trace.WriteLine(String.Format("Open16: {0}", db));
#endif
if (n != SQLiteErrorCode.Ok) throw new SQLiteException(n, null);
_sql = new SQLiteConnectionHandle(db, true);
}
lock (_sql) { /* HACK: Force the SyncBlock to be "created" now. */ }
}
// Bind functions to this connection. If any previous functions of the same name
// were already bound, then the new bindings replace the old.
if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions)
{
if (_functions == null)
_functions = new List<SQLiteFunction>();
_functions.AddRange(new List<SQLiteFunction>(SQLiteFunction.BindFunctions(this, connectionFlags)));
}
SetTimeout(0);
GC.KeepAlive(_sql);
}
internal SQLiteBackupHandle(SQLiteConnectionHandle cnn, IntPtr backup)
: this()
{
this.cnn = cnn;
SetHandle(backup);
}
///////////////////////////////////////////////////////////////////////////////////////////////
// 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, _sql);
SQLiteConnectionPool.Add(_fileName, _sql, _poolVersion);
#if DEBUG && !NET_COMPACT_20
Trace.WriteLine(String.Format("Close (Pool): {0}", _sql));
#endif
}
else
{
_sql.Dispose();
}
_sql = null;
}
}