internal static bool IsAutocommit(SQLiteConnectionHandle hdl, IntPtr db)
{
if (hdl == null || db == IntPtr.Zero)
{
return(false);
}
bool flag = false;
try
{
}
finally
{
lock (hdl)
{
if (!hdl.IsInvalid && !hdl.IsClosed)
{
flag = UnsafeNativeMethods.sqlite3_get_autocommit(db) == 1;
}
}
}
GC.KeepAlive(hdl);
return(flag);
}
internal SQLiteBlobHandle(SQLiteConnectionHandle cnn, IntPtr blob) : this()
{
this.cnn = cnn;
base.SetHandle(blob);
}
internal SQLiteMemoryChangeSet(byte[] rawData, SQLiteConnectionHandle handle, SQLiteConnectionFlags flags) : base(handle, flags)
{
this.rawData = rawData;
}
internal static SQLiteConnectionHandle Remove(string fileName, int maxPoolSize, out int version)
{
int num;
Queue <WeakReference> queue;
SQLiteConnectionPool.PoolQueue poolQueue;
SQLiteConnectionPool.PoolQueue poolQueue1;
bool flag;
SQLiteConnectionHandle sQLiteConnectionHandle;
ISQLiteConnectionPool connectionPool = SQLiteConnectionPool.GetConnectionPool();
if (connectionPool != null)
{
return(connectionPool.Remove(fileName, maxPoolSize, out version) as SQLiteConnectionHandle);
}
lock (SQLiteConnectionPool._syncRoot)
{
version = SQLiteConnectionPool._poolVersion;
if (SQLiteConnectionPool._queueList.TryGetValue(fileName, out poolQueue))
{
int poolVersion = poolQueue.PoolVersion;
num = poolVersion;
version = poolVersion;
poolQueue.MaxPoolSize = maxPoolSize;
SQLiteConnectionPool.ResizePool(poolQueue, false);
queue = poolQueue.Queue;
if (queue != null)
{
SQLiteConnectionPool._queueList.Remove(fileName);
queue = new Queue <WeakReference>(queue);
goto Label0;
}
else
{
sQLiteConnectionHandle = null;
}
}
else
{
poolQueue = new SQLiteConnectionPool.PoolQueue(SQLiteConnectionPool._poolVersion, maxPoolSize);
SQLiteConnectionPool._queueList.Add(fileName, poolQueue);
sQLiteConnectionHandle = null;
}
}
return(sQLiteConnectionHandle);
Label0:
try
{
while (queue.Count > 0)
{
WeakReference weakReference = queue.Dequeue();
if (weakReference == null)
{
continue;
}
SQLiteConnectionHandle target = weakReference.Target as SQLiteConnectionHandle;
if (target == null)
{
continue;
}
GC.SuppressFinalize(target);
try
{
GC.WaitForPendingFinalizers();
if (!target.IsInvalid && !target.IsClosed)
{
Interlocked.Increment(ref SQLiteConnectionPool._poolOpened);
sQLiteConnectionHandle = target;
return(sQLiteConnectionHandle);
}
}
finally
{
GC.ReRegisterForFinalize(target);
}
GC.KeepAlive(target);
}
}
finally
{
lock (SQLiteConnectionPool._syncRoot)
{
if (!SQLiteConnectionPool._queueList.TryGetValue(fileName, out poolQueue1))
{
flag = true;
poolQueue1 = new SQLiteConnectionPool.PoolQueue(num, maxPoolSize);
}
else
{
flag = false;
}
Queue <WeakReference> weakReferences = poolQueue1.Queue;
while (queue.Count > 0)
{
weakReferences.Enqueue(queue.Dequeue());
}
SQLiteConnectionPool.ResizePool(poolQueue1, false);
if (flag)
{
SQLiteConnectionPool._queueList.Add(fileName, poolQueue1);
}
}
}
return(null);
}
internal override void Open(string strFilename, string vfsName, SQLiteConnectionFlags connectionFlags, SQLiteOpenFlagsEnum openFlags, int maxPoolSize, bool usePool)
{
SQLiteErrorCode sQLiteErrorCode;
if (this._sql != null)
{
this.Close(true);
}
if (this._sql != null)
{
throw new SQLiteException("connection handle is still active");
}
this._usePool = usePool;
this._fileName = strFilename;
this._flags = connectionFlags;
if (usePool)
{
this._sql = SQLiteConnectionPool.Remove(strFilename, maxPoolSize, out this._poolVersion);
SQLiteConnectionHandle sQLiteConnectionHandle = this._sql;
object[] objArray = new object[] { typeof(SQLite3_UTF16), strFilename, vfsName, connectionFlags, openFlags, maxPoolSize, usePool, this._poolVersion };
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(SQLiteConnectionEventType.OpenedFromPool, null, null, null, null, sQLiteConnectionHandle, strFilename, objArray));
}
if (this._sql == null)
{
try
{
}
finally
{
IntPtr zero = IntPtr.Zero;
int num = ((connectionFlags & SQLiteConnectionFlags.NoExtensionFunctions) != SQLiteConnectionFlags.NoExtensionFunctions ? 1 : 0);
if (vfsName != null || num != 0)
{
sQLiteErrorCode = UnsafeNativeMethods.sqlite3_open16_interop(SQLiteConvert.ToUTF8(strFilename), SQLiteConvert.ToUTF8(vfsName), openFlags, num, ref zero);
}
else
{
if ((openFlags & SQLiteOpenFlagsEnum.Create) != SQLiteOpenFlagsEnum.Create && !File.Exists(strFilename))
{
throw new SQLiteException(SQLiteErrorCode.CantOpen, strFilename);
}
if (vfsName != null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray1 = new object[] { vfsName };
throw new SQLiteException(SQLiteErrorCode.CantOpen, HelperMethods.StringFormat(currentCulture, "cannot open using UTF-16 and VFS \"{0}\": need interop assembly", objArray1));
}
sQLiteErrorCode = UnsafeNativeMethods.sqlite3_open16(strFilename, ref zero);
}
if (sQLiteErrorCode != SQLiteErrorCode.Ok)
{
throw new SQLiteException(sQLiteErrorCode, null);
}
this._sql = new SQLiteConnectionHandle(zero, true);
}
lock (this._sql)
{
}
SQLiteConnectionHandle sQLiteConnectionHandle1 = this._sql;
object[] objArray2 = new object[] { typeof(SQLite3_UTF16), strFilename, vfsName, connectionFlags, openFlags, maxPoolSize, usePool };
SQLiteConnection.OnChanged(null, new ConnectionEventArgs(SQLiteConnectionEventType.NewCriticalHandle, null, null, null, null, sQLiteConnectionHandle1, strFilename, objArray2));
}
if ((connectionFlags & SQLiteConnectionFlags.NoBindFunctions) != SQLiteConnectionFlags.NoBindFunctions)
{
if (this._functions == null)
{
this._functions = new Dictionary <SQLiteFunctionAttribute, SQLiteFunction>();
}
foreach (KeyValuePair <SQLiteFunctionAttribute, SQLiteFunction> value in SQLiteFunction.BindFunctions(this, connectionFlags))
{
this._functions[value.Key] = value.Value;
}
}
this.SetTimeout(0);
GC.KeepAlive(this._sql);
}
internal SQLiteStatementHandle(SQLiteConnectionHandle cnn, IntPtr stmt) : this()
{
this.cnn = cnn;
base.SetHandle(stmt);
}
internal SQLiteStreamChangeSet(Stream inputStream, Stream outputStream, SQLiteConnectionHandle handle, SQLiteConnectionFlags flags) : base(handle, flags)
{
this.inputStream = inputStream;
this.outputStream = outputStream;
}
public SQLiteSession(SQLiteConnectionHandle handle, SQLiteConnectionFlags flags, string databaseName) : base(handle, flags, true)
{
this.databaseName = databaseName;
this.InitializeHandle();
}
internal SQLiteBackupHandle(SQLiteConnectionHandle cnn, IntPtr backup) : this()
{
this.cnn = cnn;
base.SetHandle(backup);
}
internal SQLiteChangeSetBase(SQLiteConnectionHandle handle, SQLiteConnectionFlags flags) : base(handle, flags, true)
{
}