protected virtual void Dispose(bool disposing)
{
try
{
if (!this.disposed && this.statement != IntPtr.Zero)
{
try
{
if (HelperMethods.LogPrepare(this.GetFlags()))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { (disposing ? "disposed" : "finalized"), this.statement };
SQLiteLog.LogMessage(SQLiteErrorCode.Misuse, HelperMethods.StringFormat(currentCulture, "Connection lock object was {0} with statement {1}", objArray));
}
}
catch
{
}
}
}
finally
{
this.disposed = true;
}
}
private static void LogEventHandler(object sender, LogEventArgs e)
{
if (e == null)
{
return;
}
string message = e.Message;
if (message != null)
{
message = message.Trim();
if (message.Length == 0)
{
message = "<empty>";
}
}
else
{
message = "<null>";
}
object errorCode = e.ErrorCode;
string str = "error";
if (errorCode as SQLiteErrorCode? != SQLiteErrorCode.Ok || errorCode is int)
{
SQLiteErrorCode sQLiteErrorCode = (SQLiteErrorCode)((int)(errorCode ?? -1));
sQLiteErrorCode &= SQLiteErrorCode.NonExtendedMask;
if (sQLiteErrorCode == SQLiteErrorCode.Ok)
{
str = "message";
}
else if (sQLiteErrorCode == SQLiteErrorCode.Notice)
{
str = "notice";
}
else if (sQLiteErrorCode == SQLiteErrorCode.Warning)
{
str = "warning";
}
else if (sQLiteErrorCode == SQLiteErrorCode.Row || sQLiteErrorCode == SQLiteErrorCode.Done)
{
str = "data";
}
}
else if (errorCode == null)
{
str = "trace";
}
if (errorCode == null || object.ReferenceEquals(errorCode, string.Empty))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { str, message };
Trace.WriteLine(HelperMethods.StringFormat(currentCulture, "SQLite {0}: {1}", objArray));
return;
}
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
object[] objArray1 = new object[] { str, errorCode, message };
Trace.WriteLine(HelperMethods.StringFormat(cultureInfo, "SQLite {0} ({1}): {2}", objArray1));
}
static SQLiteModuleCommon()
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] name = new object[] { typeof(SQLiteModuleCommon).Name };
SQLiteModuleCommon.declareSql = HelperMethods.StringFormat(invariantCulture, "CREATE TABLE {0}(x);", name);
}
internal SQLiteStatement(SQLiteBase sqlbase, SQLiteConnectionFlags flags, SQLiteStatementHandle stmt, string strCommand, SQLiteStatement previous)
{
this._sql = sqlbase;
this._sqlite_stmt = stmt;
this._sqlStatement = strCommand;
this._flags = flags;
int num = 0;
int num1 = this._sql.Bind_ParamCount(this, this._flags);
if (num1 > 0)
{
if (previous != null)
{
num = previous._unnamedParameters;
}
this._paramNames = new string[num1];
this._paramValues = new SQLiteParameter[num1];
for (int i = 0; i < num1; i++)
{
string str = this._sql.Bind_ParamName(this, this._flags, i + 1);
if (string.IsNullOrEmpty(str))
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] objArray = new object[] { num };
str = HelperMethods.StringFormat(invariantCulture, ";{0}", objArray);
num++;
this._unnamedParameters++;
}
this._paramNames[i] = str;
this._paramValues[i] = null;
}
}
}
private static string GetStockErrorMessage(SQLiteErrorCode errorCode, string message)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] errorString = new object[] { SQLiteException.GetErrorString(errorCode), Environment.NewLine, message };
return(HelperMethods.StringFormat(currentCulture, "{0}{1}{2}", errorString).Trim());
}
private System.Data.IsolationLevel GetSystemDataIsolationLevel(SQLiteConnection connection, Transaction transaction, System.Data.IsolationLevel defaultIsolationLevel, bool throwOnUnavailable, bool throwOnUnsupported)
{
if (transaction == null)
{
if (connection != null)
{
return(connection.GetDefaultIsolationLevel());
}
if (throwOnUnavailable)
{
throw new InvalidOperationException("isolation level is unavailable");
}
return(defaultIsolationLevel);
}
System.Transactions.IsolationLevel isolationLevel = transaction.IsolationLevel;
switch (isolationLevel)
{
case System.Transactions.IsolationLevel.Serializable:
{
return(System.Data.IsolationLevel.Serializable);
}
case System.Transactions.IsolationLevel.RepeatableRead:
{
return(System.Data.IsolationLevel.RepeatableRead);
}
case System.Transactions.IsolationLevel.ReadCommitted:
{
return(System.Data.IsolationLevel.ReadCommitted);
}
case System.Transactions.IsolationLevel.ReadUncommitted:
{
return(System.Data.IsolationLevel.ReadUncommitted);
}
case System.Transactions.IsolationLevel.Snapshot:
{
return(System.Data.IsolationLevel.Snapshot);
}
case System.Transactions.IsolationLevel.Chaos:
{
return(System.Data.IsolationLevel.Chaos);
}
case System.Transactions.IsolationLevel.Unspecified:
{
return(System.Data.IsolationLevel.Unspecified);
}
}
if (throwOnUnsupported)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { isolationLevel };
throw new InvalidOperationException(HelperMethods.StringFormat(currentCulture, "unsupported isolation level {0}", objArray));
}
return(defaultIsolationLevel);
}
protected UnsafeNativeMethods.xSessionConflict GetDelegate(SessionConflictCallback conflictCallback, object clientData)
{
if (conflictCallback == null)
{
return(null);
}
return((IntPtr context, SQLiteChangeSetConflictType type, IntPtr iterator) => {
SQLiteChangeSetConflictResult sQLiteChangeSetConflictResult;
try
{
ISQLiteChangeSetMetadataItem sQLiteChangeSetMetadataItem = this.CreateMetadataItem(iterator);
if (sQLiteChangeSetMetadataItem == null)
{
throw new SQLiteException("could not create metadata item");
}
sQLiteChangeSetConflictResult = conflictCallback(clientData, type, sQLiteChangeSetMetadataItem);
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(base.GetFlags()))
{
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(CultureInfo.CurrentCulture, "Caught exception in \"{0}\" method: {1}", new object[] { "xSessionConflict", exception }));
}
}
catch
{
}
return SQLiteChangeSetConflictResult.Abort;
}
return sQLiteChangeSetConflictResult;
});
}
internal int CompareCallback16(IntPtr ptr, int len1, IntPtr ptr1, int len2, IntPtr ptr2)
{
int num;
try
{
num = this.Compare(SQLite3_UTF16.UTF16ToString(ptr1, len1), SQLite3_UTF16.UTF16ToString(ptr2, len2));
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(this._flags))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Compare (UTF16)", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
if (this._base != null && this._base.IsOpen())
{
this._base.Cancel();
}
return(0);
}
return(num);
}
//[ReflectionPermission(SecurityAction.Assert, MemberAccess=true)]
private object GetSQLiteProviderServicesInstance()
{
if (SQLiteFactory._sqliteServices == null)
{
string settingValue = EntityWorker.SQLite.UnsafeNativeMethods.GetSettingValue("TypeName_SQLiteProviderServices", null);
Version version = base.GetType().Assembly.GetName().Version;
if (settingValue == null)
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
string defaultTypeName = SQLiteFactory.DefaultTypeName;
object[] objArray = new object[] { version };
settingValue = HelperMethods.StringFormat(invariantCulture, defaultTypeName, objArray);
}
else
{
CultureInfo cultureInfo = CultureInfo.InvariantCulture;
object[] objArray1 = new object[] { version };
settingValue = HelperMethods.StringFormat(cultureInfo, settingValue, objArray1);
}
Type type = Type.GetType(settingValue, false);
if (type != null)
{
FieldInfo field = type.GetField("Instance", SQLiteFactory.DefaultBindingFlags);
if (field != null)
{
SQLiteFactory._sqliteServices = field.GetValue(null);
}
}
}
return(SQLiteFactory._sqliteServices);
}
protected override string GetParameterName(int parameterOrdinal)
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] objArray = new object[] { parameterOrdinal };
return(HelperMethods.StringFormat(invariantCulture, "@param{0}", objArray));
}
private int Filter(IntPtr context, IntPtr pTblName)
{
int num;
try
{
num = (this.tableFilterCallback(this.tableFilterClientData, SQLiteString.StringFromUtf8IntPtr(pTblName)) ? 1 : 0);
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(base.GetFlags()))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "xSessionFilter", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
return(0);
}
return(num);
}
protected UnsafeNativeMethods.xSessionFilter GetDelegate(SessionTableFilterCallback tableFilterCallback, object clientData)
{
if (tableFilterCallback == null)
{
return(null);
}
return((IntPtr context, IntPtr pTblName) => {
int num;
try
{
string str = SQLiteString.StringFromUtf8IntPtr(pTblName);
num = (tableFilterCallback(clientData, str) ? 1 : 0);
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(base.GetFlags()))
{
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(CultureInfo.CurrentCulture, "Caught exception in \"{0}\" method: {1}", new object[] { "xSessionFilter", exception }));
}
}
catch
{
}
return 0;
}
return num;
});
}
public override SQLiteErrorCode Update(SQLiteVirtualTable table, SQLiteValue[] values, ref long rowId)
{
this.CheckDisposed();
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] tableName = new object[] { table.TableName };
this.SetTableError(table, HelperMethods.StringFormat(currentCulture, "virtual table \"{0}\" is read-only", tableName));
return(SQLiteErrorCode.Error);
}
public override SQLiteErrorCode Rename(SQLiteVirtualTable table, string newName)
{
this.CheckDisposed();
if (table.Rename(newName))
{
return(SQLiteErrorCode.Ok);
}
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] tableName = new object[] { table.TableName, newName };
this.SetTableError(table, HelperMethods.StringFormat(currentCulture, "failed to rename virtual table from \"{0}\" to \"{1}\"", tableName));
return(SQLiteErrorCode.Error);
}
static SQLiteFactory()
{
SQLiteFactory.Instance = new SQLiteFactory();
SQLiteFactory.DefaultTypeName = "EntityWorker.SQLite.Linq.SQLiteProviderServices, EntityWorker.SQLite.Linq, Version={0}, Culture=neutral, PublicKeyToken=db937bc2d44ff139";
SQLiteFactory.DefaultBindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic;
EntityWorker.SQLite.UnsafeNativeMethods.Initialize();
SQLiteLog.Initialize();
string str = "3.5.0.0";
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] objArray = new object[] { str };
SQLiteFactory._dbProviderServicesType = Type.GetType(HelperMethods.StringFormat(invariantCulture, "System.Data.Common.DbProviderServices, System.Data.Entity, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089", objArray), false);
}
public override SQLiteErrorCode BestIndex(SQLiteVirtualTable table, SQLiteIndex index)
{
this.CheckDisposed();
if (table.BestIndex(index))
{
return(SQLiteErrorCode.Ok);
}
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] tableName = new object[] { table.TableName };
this.SetTableError(table, HelperMethods.StringFormat(currentCulture, "failed to select best index for virtual table \"{0}\"", tableName));
return(SQLiteErrorCode.Error);
}
protected virtual SQLiteErrorCode CursorTypeMismatchError(SQLiteVirtualTableCursor cursor, Type type)
{
if (type == null)
{
this.SetCursorError(cursor, "cursor type mismatch");
}
else
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { type };
this.SetCursorError(cursor, HelperMethods.StringFormat(currentCulture, "not a \"{0}\" cursor", objArray));
}
return(SQLiteErrorCode.Error);
}
internal static void MaybeBreakIntoDebugger()
{
lock (HelperMethods.staticSyncRoot)
{
if (HelperMethods.debuggerBreak.HasValue)
{
return;
}
}
if (UnsafeNativeMethods.GetSettingValue("PreLoadSQLite_BreakIntoDebugger", null) != null)
{
try
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] processId = new object[] { HelperMethods.GetProcessId() };
Console.WriteLine(HelperMethods.StringFormat(currentCulture, "Attach a debugger to process {0} and press any key to continue.", processId));
Console.ReadKey();
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
object[] objArray = new object[] { typeof(Console), exception };
Trace.WriteLine(HelperMethods.StringFormat(cultureInfo, "Failed to issue debugger prompt, {0} may be unusable: {1}", objArray));
}
catch
{
}
}
try
{
Debugger.Break();
lock (HelperMethods.staticSyncRoot)
{
HelperMethods.debuggerBreak = new bool?(true);
}
}
catch
{
lock (HelperMethods.staticSyncRoot)
{
HelperMethods.debuggerBreak = new bool?(false);
}
throw;
}
}
}
public override object Final(object contextData)
{
if (this.callback2 == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Final" };
throw new InvalidOperationException(HelperMethods.StringFormat(currentCulture, "No \"{0}\" callback is set.", objArray));
}
SQLiteFinalDelegate sQLiteFinalDelegate = this.callback2 as SQLiteFinalDelegate;
if (sQLiteFinalDelegate != null)
{
return(sQLiteFinalDelegate("Final", contextData));
}
return(this.callback1.DynamicInvoke(this.GetFinalArgs(contextData, false)));
}
public override object Invoke(object[] args)
{
if (this.callback1 == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Invoke" };
throw new InvalidOperationException(HelperMethods.StringFormat(currentCulture, "No \"{0}\" callback is set.", objArray));
}
SQLiteInvokeDelegate sQLiteInvokeDelegate = this.callback1 as SQLiteInvokeDelegate;
if (sQLiteInvokeDelegate != null)
{
return(sQLiteInvokeDelegate("Invoke", args));
}
return(this.callback1.DynamicInvoke(this.GetInvokeArgs(args, false)));
}
internal KeyQuery(SQLiteConnection cnn, string database, string table, params string[] columns)
{
using (SQLiteCommandBuilder sQLiteCommandBuilder = new SQLiteCommandBuilder())
{
this._command = cnn.CreateCommand();
for (int i = 0; i < (int)columns.Length; i++)
{
columns[i] = sQLiteCommandBuilder.QuoteIdentifier(columns[i]);
}
}
SQLiteCommand sQLiteCommand = this._command;
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] objArray = new object[] { string.Join(",", columns), database, table };
sQLiteCommand.CommandText = HelperMethods.StringFormat(invariantCulture, "SELECT {0} FROM [{1}].[{2}] WHERE ROWID = ?", objArray);
this._command.Parameters.AddWithValue(null, (long)0);
}
internal void FinalCallback(IntPtr context)
{
SQLiteFunction.AggregateData aggregateDatum;
try
{
object obj = null;
if (this._base != null)
{
IntPtr intPtr = this._base.AggregateContext(context);
if (this._contextDataList != null && this._contextDataList.TryGetValue(intPtr, out aggregateDatum))
{
obj = aggregateDatum._data;
this._contextDataList.Remove(intPtr);
}
}
try
{
this._context = context;
this.SetReturnValue(context, this.Final(obj));
}
finally
{
IDisposable disposable = obj as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(this._flags))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Final", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
}
}
private SQLiteErrorCode Input(IntPtr context, IntPtr pData, ref int nData)
{
SQLiteErrorCode sQLiteErrorCode;
try
{
Stream stream = this.stream;
if (stream != null)
{
if (nData > 0)
{
byte[] numArray = new byte[nData];
int num = stream.Read(numArray, 0, nData);
if (num > 0 && pData != IntPtr.Zero)
{
Marshal.Copy(numArray, 0, pData, num);
}
nData = num;
}
sQLiteErrorCode = SQLiteErrorCode.Ok;
}
else
{
sQLiteErrorCode = SQLiteErrorCode.Misuse;
}
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(this.GetFlags()))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "xSessionInput", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
return(SQLiteErrorCode.IoErr_Read);
}
return(sQLiteErrorCode);
}
internal void StepCallback(IntPtr context, int nArgs, IntPtr argsptr)
{
try
{
SQLiteFunction.AggregateData aggregateDatum = null;
if (this._base != null)
{
IntPtr intPtr = this._base.AggregateContext(context);
if (this._contextDataList != null && !this._contextDataList.TryGetValue(intPtr, out aggregateDatum))
{
aggregateDatum = new SQLiteFunction.AggregateData();
this._contextDataList[intPtr] = aggregateDatum;
}
}
if (aggregateDatum == null)
{
aggregateDatum = new SQLiteFunction.AggregateData();
}
try
{
this._context = context;
this.Step(this.ConvertParams(nArgs, argsptr), aggregateDatum._count, ref aggregateDatum._data);
}
finally
{
aggregateDatum._count++;
}
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(this._flags))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Step", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
}
}
public void LoadDifferencesFromTable(string fromDatabaseName, string tableName)
{
this.CheckDisposed();
this.CheckHandle();
if (fromDatabaseName == null)
{
throw new ArgumentNullException("fromDatabaseName");
}
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
IntPtr zero = IntPtr.Zero;
try
{
SQLiteErrorCode sQLiteErrorCode = UnsafeNativeMethods.sqlite3session_diff(this.session, SQLiteString.GetUtf8BytesFromString(fromDatabaseName), SQLiteString.GetUtf8BytesFromString(tableName), ref zero);
if (sQLiteErrorCode != SQLiteErrorCode.Ok)
{
string str = null;
if (zero != IntPtr.Zero)
{
str = SQLiteString.StringFromUtf8IntPtr(zero);
if (!string.IsNullOrEmpty(str))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { str };
str = HelperMethods.StringFormat(currentCulture, ": {0}", objArray);
}
}
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
object[] objArray1 = new object[] { "sqlite3session_diff", str };
throw new SQLiteException(sQLiteErrorCode, HelperMethods.StringFormat(cultureInfo, "{0}{1}", objArray1));
}
}
finally
{
if (zero != IntPtr.Zero)
{
SQLiteMemory.Free(zero);
zero = IntPtr.Zero;
}
}
}
public override void Step(object[] args, int stepNumber, ref object contextData)
{
if (this.callback1 == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Step" };
throw new InvalidOperationException(HelperMethods.StringFormat(currentCulture, "No \"{0}\" callback is set.", objArray));
}
SQLiteStepDelegate sQLiteStepDelegate = this.callback1 as SQLiteStepDelegate;
if (sQLiteStepDelegate != null)
{
sQLiteStepDelegate("Step", args, stepNumber, ref contextData);
return;
}
object[] stepArgs = this.GetStepArgs(args, stepNumber, contextData, false);
this.callback1.DynamicInvoke(stepArgs);
this.UpdateStepArgs(stepArgs, ref contextData, false);
}
public static string ToDisplayString(object value)
{
if (value == null)
{
return("<nullObject>");
}
string str = value.ToString();
if (str.Length == 0)
{
return("<emptyString>");
}
if (str.IndexOfAny(HelperMethods.SpaceChars) < 0)
{
return(str);
}
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
object[] objArray = new object[] { str };
return(HelperMethods.StringFormat(invariantCulture, "\"{0}\"", objArray));
}
internal void ScalarCallback(IntPtr context, int nArgs, IntPtr argsptr)
{
try
{
this._context = context;
this.SetReturnValue(context, this.Invoke(this.ConvertParams(nArgs, argsptr)));
}
catch (Exception exception1)
{
Exception exception = exception1;
try
{
if (HelperMethods.LogCallbackExceptions(this._flags))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Invoke", exception };
SQLiteLog.LogMessage(-2146233088, HelperMethods.StringFormat(currentCulture, "Caught exception in \"{0}\" method: {1}", objArray));
}
}
catch
{
}
}
}
public override int Compare(string param1, string param2)
{
if (this.callback1 == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
object[] objArray = new object[] { "Compare" };
throw new InvalidOperationException(HelperMethods.StringFormat(currentCulture, "No \"{0}\" callback is set.", objArray));
}
SQLiteCompareDelegate sQLiteCompareDelegate = this.callback1 as SQLiteCompareDelegate;
if (sQLiteCompareDelegate != null)
{
return(sQLiteCompareDelegate("Compare", param1, param2));
}
object obj = this.callback1.DynamicInvoke(this.GetCompareArgs(param1, param2, false));
if (!(obj is int))
{
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
object[] objArray1 = new object[] { "Compare" };
throw new InvalidOperationException(HelperMethods.StringFormat(cultureInfo, "\"{0}\" result must be Int32.", objArray1));
}
return((int)obj);
}
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);
}