private object GetSQLiteProviderServicesInstance() { if (_sqliteServices == null) { string typeName = UnsafeNativeMethods.GetSettingValue( "TypeName_SQLiteProviderServices", null); Version version = this.GetType().Assembly.GetName().Version; if (typeName != null) { typeName = HelperMethods.StringFormat( CultureInfo.InvariantCulture, typeName, version); } else { typeName = HelperMethods.StringFormat( CultureInfo.InvariantCulture, DefaultTypeName, version); } Type type = Type.GetType(typeName, false); if (type != null) { FieldInfo field = type.GetField( "Instance", DefaultBindingFlags); if (field != null) { _sqliteServices = field.GetValue(null); } } } return(_sqliteServices); }
/////////////////////////////////////////////////////////////////////// /// <summary> /// Initializes the SQLite logging facilities. /// </summary> /// <param name="className"> /// The name of the managed class that called this method. This /// parameter may be null. /// </param> internal static void Initialize( string className ) { // // NOTE: See if the logging subsystem has been totally disabled. // If so, do nothing. // if (UnsafeNativeMethods.GetSettingValue( "No_SQLiteLog", null) != null) { return; } /////////////////////////////////////////////////////////////// // // NOTE: Keep track of exactly how many times this method is // called (i.e. per-AppDomain, of course). // Interlocked.Increment(ref _initializeCallCount); /////////////////////////////////////////////////////////////// // // NOTE: First, check if the managed logging subsystem is always // supposed to at least attempt to initialize itself. In // order to do this, several fairly complex steps must be // taken, including calling a P/Invoke (interop) method; // therefore, by default, attempt to perform these steps // once. // if (UnsafeNativeMethods.GetSettingValue( "Initialize_SQLiteLog", null) == null) { if (Interlocked.Increment(ref _attemptedInitialize) > 1) { Interlocked.Decrement(ref _attemptedInitialize); return; } } /////////////////////////////////////////////////////////////////// // // BUFXIX: Cannot initialize the logging interface if the SQLite // core library has already been initialized anywhere in // the process (see ticket [2ce0870fad]). // if (SQLite3.StaticIsInitialized()) { return; } /////////////////////////////////////////////////////////////////// #if !PLATFORM_COMPACTFRAMEWORK // // BUGFIX: To avoid nasty situations where multiple AppDomains are // attempting to initialize and/or shutdown what is really // a shared native resource (i.e. the SQLite core library // is loaded per-process and has only one logging callback, // not one per-AppDomain, which it knows nothing about), // prevent all non-default AppDomains from registering a // log handler unless the "Force_SQLiteLog" environment // variable is used to manually override this safety check. // if (!AppDomain.CurrentDomain.IsDefaultAppDomain() && UnsafeNativeMethods.GetSettingValue("Force_SQLiteLog", null) == null) { return; } #endif /////////////////////////////////////////////////////////////////// lock (syncRoot) { #if !PLATFORM_COMPACTFRAMEWORK // // NOTE: Add an event handler for the DomainUnload event so // that we can unhook our logging managed function // pointer from the native SQLite code prior to it // being invalidated. // // BUGFIX: Make sure this event handler is only added one // time (per-AppDomain). // if (_domainUnload == null) { _domainUnload = new EventHandler(DomainUnload); AppDomain.CurrentDomain.DomainUnload += _domainUnload; } #endif /////////////////////////////////////////////////////////////// #if USE_INTEROP_DLL && INTEROP_LOG // // NOTE: Attempt to setup interop assembly log callback. // This may fail, e.g. if the SQLite core library // has somehow been initialized. An exception will // be raised in that case. // SQLiteErrorCode rc = SQLite3.ConfigureLogForInterop( className); if (rc != SQLiteErrorCode.Ok) { throw new SQLiteException(rc, "Failed to configure interop assembly logging."); } #else // // NOTE: Create an instance of the SQLite wrapper class. // if (_sql == null) { _sql = new SQLite3( SQLiteDateFormats.Default, DateTimeKind.Unspecified, null, IntPtr.Zero, null, false); } // // NOTE: Create a single "global" (i.e. per-process) callback // to register with SQLite. This callback will pass the // event on to any registered handler. We only want to // do this once. // if (_callback == null) { _callback = new SQLiteLogCallback(LogCallback); SQLiteErrorCode rc = _sql.SetLogCallback(_callback); if (rc != SQLiteErrorCode.Ok) { _callback = null; /* UNDO */ throw new SQLiteException(rc, "Failed to configure managed assembly logging."); } } #endif /////////////////////////////////////////////////////////////// // // NOTE: Logging is enabled by default unless the configuration // setting "Disable_SQLiteLog" is present. // if (UnsafeNativeMethods.GetSettingValue( "Disable_SQLiteLog", null) == null) { _enabled = true; } /////////////////////////////////////////////////////////////// // // NOTE: For now, always setup the default log event handler. // AddDefaultHandler(); } }
static SQLiteFunction() { _registeredFunctions = new List <SQLiteFunctionAttribute>(); try { #if !PLATFORM_COMPACTFRAMEWORK // // NOTE: If the "No_SQLiteFunctions" environment variable is set, // skip all our special code and simply return. // if (UnsafeNativeMethods.GetSettingValue("No_SQLiteFunctions", null) != null) { return; } SQLiteFunctionAttribute at; System.Reflection.Assembly[] arAssemblies = System.AppDomain.CurrentDomain.GetAssemblies(); int w = arAssemblies.Length; System.Reflection.AssemblyName sqlite = System.Reflection.Assembly.GetExecutingAssembly().GetName(); for (int n = 0; n < w; n++) { Type[] arTypes; bool found = false; System.Reflection.AssemblyName[] references; try { // Inspect only assemblies that reference SQLite references = arAssemblies[n].GetReferencedAssemblies(); int t = references.Length; for (int z = 0; z < t; z++) { if (references[z].Name == sqlite.Name) { found = true; break; } } if (found == false) { continue; } arTypes = arAssemblies[n].GetTypes(); } catch (Reflection.ReflectionTypeLoadException e) { arTypes = e.Types; } int v = arTypes.Length; for (int x = 0; x < v; x++) { if (arTypes[x] == null) { continue; } object[] arAtt = arTypes[x].GetCustomAttributes(typeof(SQLiteFunctionAttribute), false); int u = arAtt.Length; for (int y = 0; y < u; y++) { at = arAtt[y] as SQLiteFunctionAttribute; if (at != null) { at.InstanceType = arTypes[x]; _registeredFunctions.Add(at); } } } } #endif } catch // SQLite provider can continue without being able to find built-in functions { } }
/////////////////////////////////////////////////////////////////////// /// <summary> /// Initializes the SQLite logging facilities. /// </summary> public static void Initialize() { // // BUFXIX: We cannot initialize the logging interface if the SQLite // core library has already been initialized anywhere in // the process (see ticket [2ce0870fad]). // if (SQLite3.StaticIsInitialized()) { return; } #if !PLATFORM_COMPACTFRAMEWORK // // BUGFIX: To avoid nasty situations where multiple AppDomains are // attempting to initialize and/or shutdown what is really // a shared native resource (i.e. the SQLite core library // is loaded per-process and has only one logging callback, // not one per-AppDomain, which it knows nothing about), // prevent all non-default AppDomains from registering a // log handler unless the "Force_SQLiteLog" environment // variable is used to manually override this safety check. // if (!AppDomain.CurrentDomain.IsDefaultAppDomain() && UnsafeNativeMethods.GetSettingValue("Force_SQLiteLog", null) == null) { return; } #endif lock (syncRoot) { #if !PLATFORM_COMPACTFRAMEWORK // // NOTE: Add an event handler for the DomainUnload event so // that we can unhook our logging managed function // pointer from the native SQLite code prior to it // being invalidated. // // BUGFIX: Make sure this event handler is only added one // time (per-AppDomain). // if (_domainUnload == null) { _domainUnload = new EventHandler(DomainUnload); AppDomain.CurrentDomain.DomainUnload += _domainUnload; } #endif // // NOTE: Create an instance of the SQLite wrapper class. // if (_sql == null) { _sql = new SQLite3( SQLiteDateFormats.Default, DateTimeKind.Unspecified, null, IntPtr.Zero, null, false); } // // NOTE: Create a single "global" (i.e. per-process) callback // to register with SQLite. This callback will pass the // event on to any registered handler. We only want to // do this once. // if (_callback == null) { _callback = new SQLiteLogCallback(LogCallback); SQLiteErrorCode rc = _sql.SetLogCallback(_callback); if (rc != SQLiteErrorCode.Ok) { throw new SQLiteException(rc, "Failed to initialize logging."); } } // // NOTE: Logging is enabled by default. // _enabled = true; // // NOTE: For now, always setup the default log event handler. // AddDefaultHandler(); } }