internal static IDictionary <SQLiteFunctionAttribute, SQLiteFunction> BindFunctions(SQLiteBase sqlbase, SQLiteConnectionFlags flags) { SQLiteFunction sQLiteFunction; IDictionary <SQLiteFunctionAttribute, SQLiteFunction> sQLiteFunctionAttributes = new Dictionary <SQLiteFunctionAttribute, SQLiteFunction>(); foreach (KeyValuePair <SQLiteFunctionAttribute, object> _registeredFunction in SQLiteFunction._registeredFunctions) { SQLiteFunctionAttribute key = _registeredFunction.Key; if (key == null) { continue; } if (!SQLiteFunction.CreateFunction(key, out sQLiteFunction)) { sQLiteFunctionAttributes[key] = null; } else { SQLiteFunction.BindFunction(sqlbase, key, sQLiteFunction, flags); sQLiteFunctionAttributes[key] = sQLiteFunction; } } return(sQLiteFunctionAttributes); }
internal static bool UnbindFunction(SQLiteBase sqliteBase, SQLiteFunctionAttribute functionAttribute, SQLiteFunction function, SQLiteConnectionFlags flags) { if (sqliteBase == null) { throw new ArgumentNullException("sqliteBase"); } if (functionAttribute == null) { throw new ArgumentNullException("functionAttribute"); } if (function == null) { throw new ArgumentNullException("function"); } FunctionType funcType = functionAttribute.FuncType; string name = functionAttribute.Name; if (funcType == FunctionType.Collation) { return(sqliteBase.CreateCollation(name, null, null, false) == SQLiteErrorCode.Ok); } bool flag = function is SQLiteFunctionEx; return(sqliteBase.CreateFunction(name, functionAttribute.Arguments, flag, null, null, null, false) == SQLiteErrorCode.Ok); }
internal static bool UnbindAllFunctions(SQLiteBase sqlbase, SQLiteConnectionFlags flags, bool registered) { SQLiteFunction sQLiteFunction; if (sqlbase == null) { return(false); } IDictionary <SQLiteFunctionAttribute, SQLiteFunction> functions = sqlbase.Functions; if (functions == null) { return(false); } bool flag = true; if (!registered) { functions = new Dictionary <SQLiteFunctionAttribute, SQLiteFunction>(functions); foreach (KeyValuePair <SQLiteFunctionAttribute, SQLiteFunction> function in functions) { SQLiteFunctionAttribute key = function.Key; if (key == null) { continue; } SQLiteFunction value = function.Value; if (value == null || !SQLiteFunction.UnbindFunction(sqlbase, key, value, flags)) { flag = false; } else { sqlbase.Functions.Remove(key); } } } else { foreach (KeyValuePair <SQLiteFunctionAttribute, object> _registeredFunction in SQLiteFunction._registeredFunctions) { SQLiteFunctionAttribute sQLiteFunctionAttribute = _registeredFunction.Key; if (sQLiteFunctionAttribute == null || functions.TryGetValue(sQLiteFunctionAttribute, out sQLiteFunction) && sQLiteFunction != null && SQLiteFunction.UnbindFunction(sqlbase, sQLiteFunctionAttribute, sQLiteFunction, flags)) { continue; } flag = false; } } return(flag); }
//[FileIOPermission(SecurityAction.Assert, AllFiles=FileIOPermissionAccess.PathDiscovery)] static SQLiteFunction() { Type[] types; SQLiteFunction._registeredFunctions = new Dictionary <SQLiteFunctionAttribute, object>(); try { if (UnsafeNativeMethods.GetSettingValue("No_SQLiteFunctions", null) == null) { Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies(); int length = (int)assemblies.Length; AssemblyName name = Assembly.GetExecutingAssembly().GetName(); for (int i = 0; i < length; i++) { bool flag = false; try { AssemblyName[] referencedAssemblies = assemblies[i].GetReferencedAssemblies(); int num = (int)referencedAssemblies.Length; int num1 = 0; while (num1 < num) { if (referencedAssemblies[num1].Name != name.Name) { num1++; } else { flag = true; break; } } if (flag) { types = assemblies[i].GetTypes(); } else { goto Label0; } } catch (ReflectionTypeLoadException reflectionTypeLoadException) { types = reflectionTypeLoadException.Types; } int length1 = (int)types.Length; for (int j = 0; j < length1; j++) { if (types[j] != null) { object[] customAttributes = types[j].GetCustomAttributes(typeof(SQLiteFunctionAttribute), false); int length2 = (int)customAttributes.Length; for (int k = 0; k < length2; k++) { SQLiteFunctionAttribute sQLiteFunctionAttribute = customAttributes[k] as SQLiteFunctionAttribute; if (sQLiteFunctionAttribute != null) { sQLiteFunctionAttribute.InstanceType = types[j]; SQLiteFunction.ReplaceFunction(sQLiteFunctionAttribute, null); } } } } Label0: break; } } } catch { } }
private static bool CreateFunction(SQLiteFunctionAttribute functionAttribute, out SQLiteFunction function) { if (functionAttribute == null) { function = null; return(false); } if (functionAttribute.Callback1 != null || functionAttribute.Callback2 != null) { function = new SQLiteDelegateFunction(functionAttribute.Callback1, functionAttribute.Callback2); return(true); } if (functionAttribute.InstanceType == null) { function = null; return(false); } function = (SQLiteFunction)Activator.CreateInstance(functionAttribute.InstanceType); return(true); }
internal static void BindFunction(SQLiteBase sqliteBase, SQLiteFunctionAttribute functionAttribute, SQLiteFunction function, SQLiteConnectionFlags flags) { SQLiteCallback sQLiteCallback; SQLiteCallback sQLiteCallback1; SQLiteFinalCallback sQLiteFinalCallback; SQLiteCollation sQLiteCollation; SQLiteCollation sQLiteCollation1; if (sqliteBase == null) { throw new ArgumentNullException("sqliteBase"); } if (functionAttribute == null) { throw new ArgumentNullException("functionAttribute"); } if (function == null) { throw new ArgumentNullException("function"); } FunctionType funcType = functionAttribute.FuncType; function._base = sqliteBase; function._flags = flags; SQLiteFunction sQLiteFunction = function; if (funcType == FunctionType.Scalar) { sQLiteCallback = new SQLiteCallback(function.ScalarCallback); } else { sQLiteCallback = null; } sQLiteFunction._InvokeFunc = sQLiteCallback; SQLiteFunction sQLiteFunction1 = function; if (funcType == FunctionType.Aggregate) { sQLiteCallback1 = new SQLiteCallback(function.StepCallback); } else { sQLiteCallback1 = null; } sQLiteFunction1._StepFunc = sQLiteCallback1; SQLiteFunction sQLiteFunction2 = function; if (funcType == FunctionType.Aggregate) { sQLiteFinalCallback = new SQLiteFinalCallback(function.FinalCallback); } else { sQLiteFinalCallback = null; } sQLiteFunction2._FinalFunc = sQLiteFinalCallback; SQLiteFunction sQLiteFunction3 = function; if (funcType == FunctionType.Collation) { sQLiteCollation = new SQLiteCollation(function.CompareCallback); } else { sQLiteCollation = null; } sQLiteFunction3._CompareFunc = sQLiteCollation; SQLiteFunction sQLiteFunction4 = function; if (funcType == FunctionType.Collation) { sQLiteCollation1 = new SQLiteCollation(function.CompareCallback16); } else { sQLiteCollation1 = null; } sQLiteFunction4._CompareFunc16 = sQLiteCollation1; string name = functionAttribute.Name; if (funcType == FunctionType.Collation) { sqliteBase.CreateCollation(name, function._CompareFunc, function._CompareFunc16, true); return; } bool flag = function is SQLiteFunctionEx; sqliteBase.CreateFunction(name, functionAttribute.Arguments, flag, function._InvokeFunc, function._StepFunc, function._FinalFunc, true); }
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); }
public override bool FindFunction(SQLiteVirtualTable table, int argumentCount, string name, ref SQLiteFunction function, ref IntPtr pClientData) { this.CheckDisposed(); return(this.ResultCodeToFindFunctionResult(this.GetMethodResultCode("FindFunction"))); }
internal abstract CollationSequence GetCollationSequence(SQLiteFunction func, IntPtr context);
internal abstract void BindFunction(SQLiteFunctionAttribute functionAttribute, SQLiteFunction function, SQLiteConnectionFlags flags);