System.Data.SQLite

#if !PLATFORM_COMPACTFRAMEWORK
  [Serializable()]
  public sealed class SQLiteException : DbException, ISerializable
#else
  public sealed class SQLiteException : Exception
#endif
  {
    #region Private Constants
    /// <summary>
    /// This value was copied from the "WinError.h" file included with the
    /// Platform SDK for Windows 10.
    /// </summary>
    private const int FACILITY_SQLITE = 1967;
    #endregion

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

    private SQLiteErrorCode _errorCode;

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

#if !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// Private constructor for use with serialization.
    /// </summary>
    /// <param name="info">
    /// Holds the serialized object data about the exception being thrown.
    /// </param>
    /// <param name="context">
    /// Contains contextual information about the source or destination.
    /// </param>
    private SQLiteException(SerializationInfo info, StreamingContext context)
      : base(info, context)
    {
      _errorCode = (SQLiteErrorCode)info.GetInt32("errorCode");

      Initialize();
    }
#endif

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

    /// <summary>
    /// Public constructor for generating a SQLite exception given the error
    /// code and message.
    /// </summary>
    /// <param name="errorCode">
    /// The SQLite return code to report.
    /// </param>
    /// <param name="message">
    /// Message text to go along with the return code message text.
    /// </param>
    public SQLiteException(SQLiteErrorCode errorCode, string message)
      : base(GetStockErrorMessage(errorCode, message))
    {
      _errorCode = errorCode;

      Initialize();
    }

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

    /// <summary>
    /// Public constructor that uses the base class constructor for the error
    /// message.
    /// </summary>
    /// <param name="message">Error message text.</param>
    public SQLiteException(string message)
      : this(SQLiteErrorCode.Unknown, message)
    {
        // do nothing.
    }

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

    /// <summary>
    /// Public constructor that uses the default base class constructor.
    /// </summary>
    public SQLiteException()
        : base()
    {
        Initialize();
    }

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

    /// <summary>
    /// Public constructor that uses the base class constructor for the error
    /// message and inner exception.
    /// </summary>
    /// <param name="message">Error message text.</param>
    /// <param name="innerException">The original (inner) exception.</param>
    public SQLiteException(string message, Exception innerException)
      : base(message, innerException)
    {
        Initialize();
    }

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

#if !PLATFORM_COMPACTFRAMEWORK
    /// <summary>
    /// Adds extra information to the serialized object data specific to this

    public override int ErrorCode
#else
    public int ErrorCode
#endif
    {
      get { return (int)_errorCode; }
    }

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

    /// <summary>
    /// This method performs extra initialization tasks.  It may be called by
    /// any of the constructors of this class.  It must not throw exceptions.
    /// </summary>
    private void Initialize()
    {
        if (HResult == unchecked((int)0x80004005)) /* E_FAIL */
        {
            int? localHResult = GetHResultForErrorCode(ResultCode);

            if (localHResult != null)
                HResult = (int)localHResult;
        }
    }

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

    /// <summary>
    /// Maps a Win32 error code to an HRESULT.
    /// </summary>
    /// <param name="errorCode">
    /// The specified Win32 error code.  It must be within the range of zero
    /// (0) to 0xFFFF (65535).
    /// </param>
    /// <param name="success">
    /// Non-zero if the HRESULT should indicate success; otherwise, zero.
    /// </param>
    /// <returns>
    /// The integer value of the HRESULT.
    /// </returns>
    private static int MakeHResult(
        int errorCode,
        bool success
        )
    {
        return (errorCode & 0xFFFF) | FACILITY_SQLITE |
            (success ? 0 : unchecked((int)0x80000000));
    }

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

    /// <summary>
    /// Attempts to map the specified <see cref="SQLiteErrorCode" /> onto an
    /// existing HRESULT -OR- a Win32 error code wrapped in an HRESULT.  The
    /// mappings may not have perfectly matching semantics; however, they do
    /// have the benefit of being unique within the context of this exception
    /// type.
    /// </summary>
    /// <param name="errorCode">
    /// The <see cref="SQLiteErrorCode" /> to map.
    /// </param>
    /// <returns>
    /// The integer HRESULT value -OR- null if there is no known mapping.
    /// </returns>
    private static int? GetHResultForErrorCode(
        SQLiteErrorCode errorCode
        )
    {
        switch (errorCode & SQLiteErrorCode.NonExtendedMask)
        {
            case SQLiteErrorCode.Ok:
                {
                    return 0; /* S_OK */
                }
            case SQLiteErrorCode.Error:
                {
                    return MakeHResult(0x0057, false); /* E_INVALIDARG */
                }
            case SQLiteErrorCode.Internal:
                {
                    return unchecked((int)0x8000FFFF); /* E_UNEXPECTED */
                }
            case SQLiteErrorCode.Perm:
                {
                    return MakeHResult(0x0005, false); /* E_ACCESSDENIED */
                }
            case SQLiteErrorCode.Abort:
                {
                    return unchecked((int)0x80004004); /* E_ABORT */
                }
            case SQLiteErrorCode.Busy:
                {
                    return MakeHResult(0x00AA, false); /* ERROR_BUSY */
                }
            case SQLiteErrorCode.Locked:
                {
                    return MakeHResult(0x00D4, false); /* ERROR_LOCKED */
                }
            case SQLiteErrorCode.NoMem:
                {
                    return MakeHResult(0x000E, false); /* E_OUTOFMEMORY */
                }
            case SQLiteErrorCode.ReadOnly:
                {
                    return MakeHResult(0x1779, false); /* ERROR_FILE_READ_ONLY */
                }
            case SQLiteErrorCode.Interrupt:
                {
                    return MakeHResult(0x04C7, false); /* ERROR_CANCELLED */
                }
            case SQLiteErrorCode.IoErr:
                {
                    return MakeHResult(0x045D, false); /* ERROR_IO_DEVICE */
                }
            case SQLiteErrorCode.Corrupt:
                {
                    return MakeHResult(0x054E, false); /* ERROR_INTERNAL_DB_CORRUPTION */
                }
            case SQLiteErrorCode.NotFound:
                {
                    return MakeHResult(0x0032, false); /* ERROR_NOT_SUPPORTED */
                }
            case SQLiteErrorCode.Full:
                {
                    return MakeHResult(0x0070, false); /* ERROR_DISK_FULL */
                }
            case SQLiteErrorCode.CantOpen:
                {
                    return MakeHResult(0x03F3, false); /* ERROR_CANTOPEN */
                }
            case SQLiteErrorCode.Protocol:
                {
                    return MakeHResult(0x05B4, false); /* ERROR_TIMEOUT */
                }
            case SQLiteErrorCode.Empty:
                {
                    return MakeHResult(0x10D2, false); /* ERROR_EMPTY */
                }
            case SQLiteErrorCode.Schema:
                {
                    return MakeHResult(0x078B, false); /* ERROR_CONTEXT_EXPIRED */
                }
            case SQLiteErrorCode.TooBig:
                {
                    return unchecked((int)0x800288C5); /* TYPE_E_SIZETOOBIG */
                }
            case SQLiteErrorCode.Constraint:
                {
                    return MakeHResult(0x202F, false); /* ERROR_DS_CONSTRAINT_VIOLATION */
                }
            case SQLiteErrorCode.Mismatch:
                {
                    return MakeHResult(0x065D, false); /* ERROR_DATATYPE_MISMATCH */
                }
            case SQLiteErrorCode.Misuse:
                {
                    return MakeHResult(0x0649, false); /* ERROR_INVALID_HANDLE_STATE */
                }
            case SQLiteErrorCode.NoLfs:
                {
                    return MakeHResult(0x0646, false); /* ERROR_UNKNOWN_FEATURE */
                }
            case SQLiteErrorCode.Auth:
                {
                    return MakeHResult(0x078F, false); /* ERROR_AUTHENTICATION_FIREWALL_FAILED */
                }
            case SQLiteErrorCode.Format:
                {
                    return MakeHResult(0x000B, false); /* ERROR_BAD_FORMAT */
                }
            case SQLiteErrorCode.Range:
                {
                    return unchecked((int)0x80028CA1); /* TYPE_E_OUTOFBOUNDS */
                }
            case SQLiteErrorCode.NotADb:
                {
                    return MakeHResult(0x0570, false); /* ERROR_FILE_CORRUPT */
                }
            case SQLiteErrorCode.Notice:
            case SQLiteErrorCode.Warning:
            case SQLiteErrorCode.Row:
            case SQLiteErrorCode.Done:
                {
                    //
                    // NOTE: These result codes are not errors, per se;
                    //       therefore, mask off all HRESULT bits that
                    //       are not part of the "code" portion (e.g.
                    //       the severity, facility, etc).  This will
                    //       have the effect of creating an HRESULT
                    //       that indicates success, while (hopefully)
                    //       preserving the specified result code.  At
                    //       the time this method was written (2018-02),
                    //       no SQLite result codes were outside of the
                    //       supported range for HRESULT codes (e.g.
                    //       0x0000 to 0xFFFF, inclusive), which made
                    //       the following masking operation a harmless
                    //       NOOP.
                    //
                    return MakeHResult((int)errorCode, true);
                }
        }

        return null;
    }

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

    /// <summary>
    /// Returns the error message for the specified SQLite return code.
    /// </summary>
    /// <param name="errorCode">The SQLite return code.</param>

      System.Data.SQLite.SQLiteException $errCode "ioerr message."]

  normalizeExceptionMessage [$exception ToString]
} -cleanup {
  unset -nocomplain exception errCode
} -constraints {eagle command.object SQLite System.Data.SQLite} -match \
regexp -result {^code = IoErr_Delete_NoEnt \(5898\), message =\
System\.Data\.SQLite\.SQLiteException(?: \(0x8[0-9A-Fa-f]{7}\))?: disk I/O\
error ==> ioerr message\.$}}

###############################################################################

runTest {test tkt-53962f9eff-1.2 {SQLiteException ToString Ok} -body {
  set errCode [object invoke -create Enum Parse \
      System.Data.SQLite.SQLiteErrorCode Ok_Load_Permanently false]

  set exception [object create -alias \
      System.Data.SQLite.SQLiteException $errCode "ok message."]

  normalizeExceptionMessage [$exception ToString]
} -cleanup {
  unset -nocomplain exception errCode
} -constraints {eagle command.object SQLite System.Data.SQLite} -match \
regexp -result {^code = Ok_Load_Permanently \(256\), message =\
System\.Data\.SQLite\.SQLiteException(?: \(0x0[0-9A-Fa-f]{7}\))?: not an\
error ==> ok message.$}}

###############################################################################

runTest {test tkt-53962f9eff-1.3 {SQLiteException ToString unknown} -body {
  set errCode [object invoke -create Enum Parse \
      System.Data.SQLite.SQLiteErrorCode 999 false]

  set exception [object create -alias \
      System.Data.SQLite.SQLiteException $errCode "unknown message."]

  normalizeExceptionMessage [$exception ToString]
} -cleanup {
  unset -nocomplain exception errCode
} -constraints {eagle command.object SQLite System.Data.SQLite} -match \
regexp -result {^code = 999 \(999\), message =\
System\.Data\.SQLite\.SQLiteException(?: \(0x8[0-9A-Fa-f]{7}\))?: unknown\
error ==> unknown message\.$}}

###############################################################################

runSQLiteTestEpilogue
runTestEpilogue

    proc extractSystemDataSQLiteExceptionMessage { value } {
      #
      # NOTE: If the string conforms to format of the normal exception
      #       error strings, extract and return only the error message
      #       portion itself.
      #
      set patterns [list \
      {System\.Data\.SQLite\.SQLiteException \(0x(?:0|8)[0-9A-Fa-f]{7}\):\
          (.+?)  (?: )?at} \
      {System\.Data\.SQLite\.SQLiteException: (.+?)  (?: )?at} \
      {Eagle\._Components\.Public\.ScriptException: (.+?)  (?: )?at}]

      foreach pattern $patterns {
        if {[regexp -- $pattern $value dummy message]} then {
          set message [string map [list \r\n \n] [string trim $message]]
          set lines [split $message \n]