System.Data.SQLite

//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.8.*")]

      return "?";
    }

#if !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// Obsolete
    /// </summary>
#if !BETA1
    [Obsolete]
#endif
    protected override DbProviderFactory ProviderFactory
    {
      get 
      {
        return new SQLiteFactory();
      }
    }

    /// </summary>
    internal SQLiteBase          _sql;
    /// <summary>
    /// Commands associated with this connection
    /// </summary>
    internal List<SQLiteCommand> _commandList;

#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
    /// <event/>
    /// <summary>
    /// This event is raised whenever the database is opened or closed.
    /// </summary>
    public override event StateChangeEventHandler StateChange;
#endif

              _sql.Execute(String.Format("ATTACH DATABASE '{0}' AS [{1}]", row[1], row[0]));
            }
          }
        }
      }
    }

#if PLATFORM_COMPACTFRAMEWORK && !BETA1
    public override int ConnectionTimeout
    {
      get
      {
        return 30;
      }
    }

    }

    internal void OnStateChange(ConnectionState newState)
    {
      ConnectionState oldState = _connectionState;
      _connectionState = newState;

#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
      if (StateChange != null && oldState != newState)
      {
        StateChangeEventArgs e = new StateChangeEventArgs(oldState, newState);
        StateChange(this, e);
      }
#endif
    }

  /// be automatically freed for you (and Dispose() called if the item supports IDisposable) when the statement completes.
  /// </remarks>
  public abstract class SQLiteFunction : IDisposable
  {

    private SQLiteBase              _base;
    private int                     _interopCookie;
#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
    private SortedList<int, object> _contextDataList;
#else
    private SortedList _contextDataList;
#endif

    private SQLiteCallback  _InvokeFunc;
    private SQLiteCallback  _StepFunc;
    private SQLiteCallback  _FinalFunc;
    private SQLiteCollation _CompareFunc;

    /// <summary>
    /// This static list contains all the user-defined functions declared using the proper attributes.
    /// </summary>
    private static List<SQLiteFunctionAttribute> _registeredFunctions = new List<SQLiteFunctionAttribute>();

    /// <summary>
    /// Internal constructor, initializes the function's internal variables.
    /// </summary>
    protected SQLiteFunction()
    {
#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
      _contextDataList = new SortedList<int, object>();
#else
      _contextDataList = new SortedList();
#endif
      _InvokeFunc = null;
      _StepFunc = null;
      _FinalFunc = null;

    /// </summary>
    public void Dispose()
    {
      Dispose(true);

      IDisposable disp;

#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
      foreach (KeyValuePair<int, object> kv in _contextDataList)
#else
      foreach (DictionaryEntry kv in _contextDataList)
#endif
      {
        disp = kv.Value as IDisposable;
        if (disp != null)

      _CompareFunc = null;
      _base = null;
      _contextDataList = null;

      GC.SuppressFinalize(this);
    }

#if !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// Using reflection, enumerate all assemblies in the current appdomain looking for classes that
    /// have a SQLiteFunctionAttribute attribute, and registering them accordingly.
    /// </summary>
    static SQLiteFunction()
    {
      SQLiteFunctionAttribute at;

              at.InstanceType = arTypes[x];
              _registeredFunctions.Add(at);
            }
          }
        }
      }
    }
#else
    /// <summary>
    /// Manual method of registering a function.  The type must still have the SQLiteFunctionAttributes in order to work
    /// properly, but this is a workaround for the Compact Framework where enumerating assemblies is not currently supported.
    /// </summary>
    /// <param name="typ">The type of the function to register</param>
    public static void RegisterFunction(Type typ)
    {

        if (at != null)
        {
          at.InstanceType = typ;
          _registeredFunctions.Add(at);
        }
      }
    }
#endif

    /// <summary>
    /// Called by SQLiteBase derived classes, this function binds all user-defined functions to a connection.
    /// It is done this way so that all user-defined functions will access the database using the same encoding scheme
    /// as the connection (UTF-8 or UTF-16).
    /// </summary>
    /// <remarks>

    /// 
    /// </summary>
    public override int Count
    {
      get { return _parameterList.Count; }
    }

#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameterName"></param>
    /// <returns></returns>
    protected override DbParameter GetParameter(string parameterName)
    {

    /// <param name="index"></param>
    public override void RemoveAt(int index)
    {
      _unboundFlag = true;
      _parameterList.RemoveAt(index);
    }

#if !PLATFORM_COMPACTFRAMEWORK && !BETA1
    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameterName"></param>
    /// <param name="value"></param>
    protected override void SetParameter(string parameterName, DbParameter value)
    {