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();
}
}