System.Data.SQLite

        </tr>
        <tr valign="top">
          <td>SQLite_ForceLogPrepare</td>
          <td>If this environment variable is set [to anything], all calls to
          prepare a SQL query will be logged, regardless of the flags for the
          associated connection.</td>
        </tr>
        <tr valign="top">
          <td>SQLite_ForceLogLifecycle</td>
          <td>If this environment variable is set [to anything], calls into
          key members pertaining to the lifecycle of connections and their
          associated classes (e.g. LINQ, EF6, etc) will be logged.</td>
        </tr>
        <tr valign="top">
          <td>TypeName_SQLiteProviderServices</td>
          <td>If this environment variable is set [to anything], it will be
          used by the System.Data.SQLite.SQLiteFactory class as the type name
          containing the System.Data.Common.DbProviderServices implementation
          that should be used.</td>
        </tr>

        public object GetService(
            Type serviceType
            )
        {
            if ((serviceType == typeof(ISQLiteSchemaExtensions)) ||
                (serviceType == typeof(DbProviderServices)))
            {
                object result = SQLiteProviderServices.Instance;

                if (SQLite3.ForceLogLifecycle())
                {
                    SQLiteLog.LogMessage(HelperMethods.StringFormat(
                        CultureInfo.CurrentCulture,
                        "Success of \"{0}\" from SQLiteProviderFactory.GetService(\"{1}\")...",
                        (result != null) ? result.ToString() : "<null>",
                        (serviceType != null) ? serviceType.ToString() : "<null>"));
                }

                return result;
            }

            if (SQLite3.ForceLogLifecycle())
            {
                SQLiteLog.LogMessage(HelperMethods.StringFormat(
                    CultureInfo.CurrentCulture,
                    "Failure of SQLiteProviderFactory.GetService(\"{0}\")...",
                    (serviceType != null) ? serviceType.ToString() : "<null>"));
            }

            return null;
        }
        #endregion

        ///////////////////////////////////////////////////////////////////////

        NOTE: If this environment variable is set [to anything], all calls to
              prepare a SQL query will be logged, regardless of the flags for
              the associated connection.
    -->
    <!--
    <add key="SQLite_ForceLogPrepare" value="1" />
    -->

    <!--
        NOTE: If this environment variable is set [to anything], calls into
              key members pertaining to the lifecycle of connections and their
              associated classes (e.g. LINQ, EF6, etc) will be logged.
    -->
    <!--
    <add key="SQLite_ForceLogLifecycle" value="1" />
    -->

    <!--
        NOTE: If this environment variable is set [to anything], it will be
              used by the System.Data.SQLite.SQLiteFactory class as the type
              name containing the System.Data.Common.DbProviderServices
              implementation that should be used.
    -->

/********************************************************
 * ADO.NET 2.0 Data Provider for SQLite Version 3.X
 * Written by Robert Simpson (robert@blackcastlesoft.com)
 * 
 * Released to the public domain, use at your own risk!
 ********************************************************/

namespace System.Data.SQLite
{
  using System.Globalization;
  using System.Data.Common;

  public sealed partial class SQLiteConnection
  {
    /// <summary>
    /// Returns the <see cref="SQLiteFactory" /> instance.
    /// </summary>
    protected override DbProviderFactory DbProviderFactory
    {
      get
      {
        DbProviderFactory result = SQLiteFactory.Instance;

        if (SQLite3.ForceLogLifecycle())
        {
          SQLiteLog.LogMessage(HelperMethods.StringFormat(
            CultureInfo.CurrentCulture,
            "Returning \"{0}\" from SQLiteConnection.DbProviderFactory...",
            (result != null) ? result.ToString() : "<null>"));
        }

        return result;
      }
    }
  }
}

    //       situation may need to change.
    //
    private static readonly string DefaultTypeName =
      "System.Data.SQLite.Linq.SQLiteProviderServices, System.Data.SQLite.Linq, " +
      "Version={0}, Culture=neutral, PublicKeyToken=db937bc2d44ff139";

    private static readonly BindingFlags DefaultBindingFlags =
        BindingFlags.NonPublic | BindingFlags.Static;

    ///////////////////////////////////////////////////////////////////////////

    private static Type _dbProviderServicesType;
    private static object _sqliteServices;

    ///////////////////////////////////////////////////////////////////////////

    static SQLiteFactory()
    {
      InitializeDbProviderServices();
    }

    ///////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// This method is called to perform preliminary static initialization
    /// necessary for this class.
    /// </summary>
    internal static void PreInitialize()
    {
#if (SQLITE_STANDARD || USE_INTEROP_DLL || PLATFORM_COMPACTFRAMEWORK) && PRELOAD_NATIVE_LIBRARY
        UnsafeNativeMethods.Initialize();
#endif

        SQLiteLog.Initialize(typeof(SQLiteFactory).Name);
    }

    ///////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// This method is called to perform some of the static initialization
    /// necessary for this class.
    /// </summary>
    private static void InitializeDbProviderServices()
    {
        PreInitialize();

        string version =
#if NET_40 || NET_45 || NET_451 || NET_452 || NET_46 || NET_461 || NET_462 || NET_47 || NET_471 || NET_472 || NET_STANDARD_20 || NET_STANDARD_21
            "4.0.0.0";
#else
            "3.5.0.0";
#endif

        _dbProviderServicesType = Type.GetType(HelperMethods.StringFormat(CultureInfo.InvariantCulture, "System.Data.Common.DbProviderServices, System.Data.Entity, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089", version), false);
    }

    ///////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// Will provide a <see cref="IServiceProvider" /> object in .NET 3.5.
    /// </summary>
    /// <param name="serviceType">The class or interface type to query for.</param>
    /// <returns></returns>
    object IServiceProvider.GetService(Type serviceType)
    {
      if (serviceType == typeof(ISQLiteSchemaExtensions) ||
        (_dbProviderServicesType != null && serviceType == _dbProviderServicesType))
      {
        object result = GetSQLiteProviderServicesInstance();

        if (SQLite3.ForceLogLifecycle())
        {
          SQLiteLog.LogMessage(HelperMethods.StringFormat(
            CultureInfo.CurrentCulture,
            "Success of \"{0}\" from SQLiteFactory.GetService(\"{1}\")...",
            (result != null) ? result.ToString() : "<null>",
            (serviceType != null) ? serviceType.ToString() : "<null>"));
        }

        return result;
      }

      if (SQLite3.ForceLogLifecycle())
      {
        SQLiteLog.LogMessage(HelperMethods.StringFormat(
          CultureInfo.CurrentCulture,
          "Failure of SQLiteFactory.GetService(\"{0}\")...",
          (serviceType != null) ? serviceType.ToString() : "<null>"));
      }

      return null;
    }

    ///////////////////////////////////////////////////////////////////////////

#if !NET_STANDARD_20 && !NET_STANDARD_21
    [ReflectionPermission(SecurityAction.Assert, MemberAccess = true)]
#endif
    private object GetSQLiteProviderServicesInstance()
    {
        if (_sqliteServices == null)
        {
            string typeName = UnsafeNativeMethods.GetSettingValue(

                FieldInfo field = type.GetField(
                    "Instance", DefaultBindingFlags);

                if (field != null)
                    _sqliteServices = field.GetValue(null);
            }
        }

        return _sqliteServices;
    }
  }
}

    /// "SQLite_ForceLogPrepare" environment variable has been queried.  If so,
    /// it will only be non-zero if the environment variable was present.
    /// </summary>
    private static bool? forceLogPrepare = null;

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// This field is used to keep track of whether or not the
    /// "SQLite_ForceLogLifecycle" environment variable has been queried.  If
    /// so, it will only be non-zero if the environment variable was present.
    /// </summary>
    private static bool? forceLogLifecycle = null;

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// Determines if all calls to prepare a SQL query will be logged,
    /// regardless of the flags for the associated connection.
    /// </summary>
    /// <returns>
    /// Non-zero to log all calls to prepare a SQL query.
    /// </returns>

                    forceLogPrepare = false;
                }
            }

            return (bool)forceLogPrepare;
        }
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    /// <summary>
    /// Determines if calls into key members pertaining to the lifecycle of
    /// connections and their associated classes will be logged, regardless
    /// of the flags for the associated connection.
    /// </summary>
    /// <returns>
    /// Non-zero to log calls into key members pertaining to the lifecycle of
    /// connections and their associated classes (e.g. LINQ, EF6, etc).
    /// </returns>
    internal static bool ForceLogLifecycle()
    {
        lock (syncRoot)
        {
            if (forceLogLifecycle == null)
            {
                if (UnsafeNativeMethods.GetSettingValue(
                        "SQLite_ForceLogLifecycle", null) != null)
                {
                    forceLogLifecycle = true;
                }
                else
                {
                    forceLogLifecycle = false;
                }
            }

            return (bool)forceLogLifecycle;
        }
    }
    #endregion

    ///////////////////////////////////////////////////////////////////////////////////////////////

    internal override SQLiteStatement Prepare(SQLiteConnection cnn, string strSql, SQLiteStatement previous, uint timeoutMS, ref string strRemain)
    {
      if (!String.IsNullOrEmpty(strSql)) strSql = strSql.Trim();

                        '$(NetFx451)' != 'false' Or
                        '$(NetFx452)' != 'false' Or
                        '$(NetFx46)' != 'false' Or
                        '$(NetFx461)' != 'false' Or
                        '$(NetFx462)' != 'false' Or
                        '$(NetFx47)' != 'false' Or
                        '$(NetFx471)' != 'false' Or
                        '$(NetFx472)' != 'false' Or
                        '$(NetStandard21)' != 'false'"
             Include="LINQ\SQLiteConnection_Linq.cs">
      <SubType>Component</SubType>
    </Compile>
    <Compile Condition="'$(NetFx35)' != 'false' Or
                        '$(NetFx40)' != 'false' Or
                        '$(NetFx45)' != 'false' Or
                        '$(NetFx451)' != 'false' Or
                        '$(NetFx452)' != 'false' Or
                        '$(NetFx46)' != 'false' Or
                        '$(NetFx461)' != 'false' Or
                        '$(NetFx462)' != 'false' Or
                        '$(NetFx47)' != 'false' Or
                        '$(NetFx471)' != 'false' Or
                        '$(NetFx472)' != 'false' Or
                        '$(NetStandard21)' != 'false'"
             Include="LINQ\SQLiteFactory_Linq.cs">
      <SubType>Code</SubType>
    </Compile>
    <EmbeddedResource Include="Resources\SQLiteCommand.bmp" />
    <EmbeddedResource Include="Resources\SQLiteConnection.bmp" />
    <EmbeddedResource Include="Resources\SQLiteDataAdapter.bmp" />
  </ItemGroup>

<!--
 *
 * System.Data.SQLite.Properties.targets -
 *
 * Written by Joe Mistachkin.
 * Released to the public domain, use at your own risk!
 *
-->
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!--
  ******************************************************************************
  **                           Platform Properties                            **
  ******************************************************************************
  -->

  <PropertyGroup>
    <NetStandard21 Condition="'$(NetStandard21)' == '' And ('$(IsDotNetStandard)' == 'false' Or ('$(TargetFramework)' != 'netstandard2.1' And '$(TargetFramework)' != 'netcoreapp3.0'))">false</NetStandard21>
    <NetStandard21 Condition="'$(NetStandard21)' == '' And ('$(IsDotNetStandard)' != 'false' And ('$(TargetFramework)' == 'netstandard2.1' Or '$(TargetFramework)' == 'netcoreapp3.0'))">true</NetStandard21>
  </PropertyGroup>

  <!--
  ******************************************************************************
  **                        Platform Define Constants                         **
  ******************************************************************************
  -->

  <!--
      NOTE: Only use functionality available in the .NET Framework 2.0?  By
            default, this is disabled.  This must be enabled to successfully
            build the project using Visual Studio 2005 and/or the .NET