System.Data.SQLite

  }

  /// <summary>
  /// These constants are used with the sqlite3_trace_v2() API and the
  /// callbacks registered by it.
  /// </summary>
  [Flags()]
  public enum SQLiteTraceFlags
  {
      SQLITE_TRACE_NONE = 0x0, // nil
      SQLITE_TRACE_STMT = 0x1, // pStmt, zSql
      SQLITE_TRACE_PROFILE = 0x2, // pStmt, piNsec64
      SQLITE_TRACE_ROW = 0x4, // pStmt
      SQLITE_TRACE_CLOSE = 0x8 // pDb
  }

    /// <summary>
    /// The extra behavioral flags for this connection, if any.  See the
    /// <see cref="SQLiteConnectionFlags" /> enumeration for a list of
    /// possible values.
    /// </summary>
    private SQLiteConnectionFlags _flags;

    /// <summary>
    /// The mask of zero or more <see cref="SQLiteTraceFlags" /> values that
    /// determine which events may be raised from the <see cref="Trace2" />
    /// event.
    /// </summary>
    private SQLiteTraceFlags _traceFlags;

    /// <summary>
    /// The cached values for all settings that have been fetched on behalf
    /// of this connection.  This cache may be cleared by calling the
    /// <see cref="ClearCachedSettings" /> method.
    /// </summary>
    private Dictionary<string, object> _cachedSettings;

    private event SQLiteBusyEventHandler _busyHandler;
    private event SQLiteProgressEventHandler _progressHandler;
    private event SQLiteAuthorizerEventHandler _authorizerHandler;
    private event SQLiteUpdateEventHandler _updateHandler;
    private event SQLiteCommitHandler _commitHandler;
    private event SQLiteTraceEventHandler _traceHandler;
    private event SQLiteTraceEventHandler _traceHandler2;
    private event EventHandler _rollbackHandler;

    private SQLiteBusyCallback _busyCallback;
    private SQLiteProgressCallback _progressCallback;
    private SQLiteAuthorizerCallback _authorizerCallback;
    private SQLiteUpdateCallback _updateCallback;
    private SQLiteCommitCallback _commitCallback;
    private SQLiteTraceCallback _traceCallback;
    private SQLiteTraceCallback2 _traceCallback2;
    private SQLiteRollbackCallback _rollbackCallback;
    #endregion

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

    private static string GetDefaultCatalogName()
    {

        : this()
    {
        _sql = new SQLite3(
            SQLiteDateFormats.Default, DateTimeKind.Unspecified, null,
            db, fileName, ownHandle);

        _flags = SQLiteConnectionFlags.None;
        _traceFlags = SQLiteTraceFlags.SQLITE_TRACE_NONE;

        _connectionState = (db != IntPtr.Zero) ?
            ConnectionState.Open : ConnectionState.Closed;

        _connectionString = null; /* unknown */

#if DEBUG

        if (_traceHandler == null)
        {
          if (_sql != null) _sql.SetTraceCallback(null);
            _traceCallback = null;
        }
      }
    }

    /// <summary>
    /// This event is raised when events matching the configured mask are
    /// raised for this connection.
    /// </summary>
    public event SQLiteTraceEventHandler Trace2
    {
        add
        {
            CheckDisposed();

            if (_traceHandler2 == null)
            {
                if (_traceFlags == SQLiteTraceFlags.SQLITE_TRACE_NONE)
                {
                    throw new InvalidOperationException(
                        "cannot add trace2 event handler with no flags set");
                }

                _traceCallback2 = new SQLiteTraceCallback2(TraceCallback2);
                if (_sql != null) _sql.SetTraceCallback2(_traceFlags, _traceCallback2);
            }
            _traceHandler2 += value;
        }
        remove
        {
            CheckDisposed();

            _traceHandler2 -= value;
            if (_traceHandler2 == null)
            {
                if (_traceFlags == SQLiteTraceFlags.SQLITE_TRACE_NONE)
                {
                    throw new InvalidOperationException(
                        "cannot remove trace2 event handler with no flags set");
                }

                if (_sql != null) _sql.SetTraceCallback2(_traceFlags, null);
                _traceCallback2 = null;
            }
        }
    }

    private void TraceCallback(
        IntPtr puser, /* NOT USED */
        IntPtr statement
        )
    {
        try

            }
            catch
            {
                // do nothing.
            }
        }
    }

    private void TraceCallback2(
        SQLiteTraceFlags flags,
        IntPtr pctx, /* NOT USED */
        IntPtr puser, /* NOT USED */
        IntPtr statement
        )
    {
        try
        {
            if (_traceHandler2 != null)
                _traceHandler2(this, new TraceEventArgs(flags,
                  SQLiteBase.UTF8ToString(statement, -1)));
        }
        catch (Exception e) /* NOTE: Must catch ALL. */
        {
            try
            {
                if (HelperMethods.LogCallbackExceptions(_flags))
                {
                    SQLiteLog.LogMessage(SQLiteBase.COR_E_EXCEPTION,
                        HelperMethods.StringFormat(CultureInfo.CurrentCulture,
                        UnsafeNativeMethods.ExceptionMessageFormat,
                        "Trace2", e)); /* throw */
                }
            }
            catch
            {
                // do nothing.
            }
        }
    }

    /// <summary>
    /// This property is used to configure the set of events that may be raised
    /// from the <see cref="Trace2" /> event.  The value of this property cannot
    /// be changed while an event handler is registered.
    /// </summary>
    public SQLiteTraceFlags TraceFlags
    {
        get { CheckDisposed(); return _traceFlags; }
        set
        {
            CheckDisposed();

            if (_traceCallback2 != null)
            {
                throw new InvalidOperationException(
                    "cannot change trace flags while an event handler is registered");
            }

            _traceFlags = value;
        }
    }

    /// <summary>
    /// This event is raised whenever SQLite is rolling back a transaction.
    /// </summary>
    public event EventHandler RollBack
    {
      add

  }

  /// <summary>
  /// Passed during an Trace callback, these event arguments contain the UTF-8 rendering of the SQL statement text
  /// </summary>
  public class TraceEventArgs : EventArgs
  {
    /// <summary>
    /// The flags associated with this trace event.
    /// </summary>
    public readonly SQLiteTraceFlags? Flags;

    /// <summary>
    /// SQL statement text as the statement first begins executing
    /// </summary>
    public readonly string Statement;

    internal TraceEventArgs(string statement)
    {
      Statement = statement;
    }

    internal TraceEventArgs(SQLiteTraceFlags flags, string statement)
    {
      Flags = flags;
      Statement = statement;
    }
  }
}