Use extended result codes

Author: reftel

src/main/java/org/sqlite/SQLiteConfig.java

@@ -53,6 +53,7 @@ public class SQLiteConfig
     public DatePrecision datePrecision;
     public long dateMultiplier;
     public String dateStringFormat;
+    private boolean extendedResultCodesUsed;
 
     /**
      * Default constructor.
@@ -88,6 +89,7 @@ public SQLiteConfig(Properties prop) {
         datePrecision = DatePrecision.getPrecision(pragmaTable.getProperty(Pragma.DATE_PRECISION.pragmaName, DatePrecision.MILLISECONDS.name()));
         dateMultiplier = (datePrecision == DatePrecision.MILLISECONDS) ? 1L : 1000L;
         dateStringFormat = pragmaTable.getProperty(Pragma.DATE_STRING_FORMAT.pragmaName, DEFAULT_DATE_STRING_FORMAT);
+        extendedResultCodesUsed = Boolean.valueOf(pragmaTable.getProperty(Pragma.EXTENDED_RESULT_CODES.pragmaName, "FALSE"));
 
         busyTimeout = Integer.parseInt(pragmaTable.getProperty(Pragma.BUSY_TIMEOUT.pragmaName, "3000"));
     }
@@ -119,6 +121,7 @@ public void apply(Connection conn) throws SQLException {
         pragmaParams.remove(Pragma.DATE_PRECISION.pragmaName);
         pragmaParams.remove(Pragma.DATE_CLASS.pragmaName);
         pragmaParams.remove(Pragma.DATE_STRING_FORMAT.pragmaName);
+        pragmaParams.remove(Pragma.EXTENDED_RESULT_CODES.pragmaName);
 
         Statement stat = conn.createStatement();
         try {
@@ -213,6 +216,7 @@ public Properties toProperties() {
         pragmaTable.setProperty(Pragma.DATE_CLASS.pragmaName, dateClass.getValue());
         pragmaTable.setProperty(Pragma.DATE_PRECISION.pragmaName, datePrecision.getValue());
         pragmaTable.setProperty(Pragma.DATE_STRING_FORMAT.pragmaName, dateStringFormat);
+        pragmaTable.setProperty(Pragma.EXTENDED_RESULT_CODES.pragmaName, Boolean.toString(extendedResultCodesUsed));
 
         return pragmaTable;
     }
@@ -237,6 +241,10 @@ static DriverPropertyInfo[] getDriverPropertyInfo() {
 
     private static final String[] OnOff = new String[] { "true", "false" };
 
+    public boolean isExtendedResultCodesUsed() {
+        return extendedResultCodesUsed;
+    }
+
     public static enum Pragma {
 
         // Parameters requiring SQLite3 API invocation
@@ -275,7 +283,8 @@ public static enum Pragma {
         DATE_PRECISION("date_precision", "\"seconds\": Read and store integer dates as seconds from the Unix Epoch (SQLite standard).\n\"milliseconds\": (DEFAULT) Read and store integer dates as milliseconds from the Unix Epoch (Java standard).", toStringArray(DatePrecision.values())),
         DATE_CLASS("date_class", "\"integer\": (Default) store dates as number of seconds or milliseconds from the Unix Epoch\n\"text\": store dates as a string of text\n\"real\": store dates as Julian Dates", toStringArray(DateClass.values())),
         DATE_STRING_FORMAT("date_string_format", "Format to store and retrieve dates stored as text. Defaults to \"yyyy-MM-dd HH:mm:ss.SSS\"", null),
-        BUSY_TIMEOUT("busy_timeout", null);
+        BUSY_TIMEOUT("busy_timeout", null),
+        EXTENDED_RESULT_CODES("extended result codes", OnOff);
 
         public final String   pragmaName;
         public final String[] choices;

src/main/java/org/sqlite/SQLiteErrorCode.java

@@ -24,6 +24,8 @@
 //--------------------------------------
 package org.sqlite;
 
+import java.sql.SQLException;
+
 /**
  * SQLite3 error code
  * 
@@ -63,7 +65,53 @@ public enum SQLiteErrorCode {
     SQLITE_RANGE(25, " 2nd parameter to sqlite3_bind out of range"),
     SQLITE_NOTADB(26, " File opened that is not a database file"),
     SQLITE_ROW(100, " sqlite3_step() has another row ready"),
-    SQLITE_DONE(101, " sqlite3_step() has finished executing");
+    SQLITE_DONE(101, " sqlite3_step() has finished executing"),
+    /* Beginning of extended error codes */
+    SQLITE_BUSY_RECOVERY(261, " Another process is busy recovering a WAL mode database file following a crash"),
+    SQLITE_LOCKED_SHAREDCACHE(262, " Contention with a different database connection that shares the cache"),
+    SQLITE_READONLY_RECOVERY(264, " The database file needs to be recovered"),
+    SQLITE_IOERR_READ(266, " I/O error in the VFS layer while trying to read from a file on disk"),
+    SQLITE_CORRUPT_VTAB(267, " Content in the virtual table is corrupt"),
+    SQLITE_CONSTRAINT_CHECK(275, " A CHECK constraint failed"),
+    SQLITE_ABORT_ROLLBACK(516, " The transaction that was active when the SQL statement first started was rolled back"),
+    SQLITE_BUSY_SNAPSHOT(517, " Another database connection has already written to the database"),
+    SQLITE_READONLY_CANTLOCK(520, " The shared-memory file associated with that database is read-only"),
+    SQLITE_IOERR_SHORT_READ(522, " The VFS layer was unable to obtain as many bytes as was requested"),
+    SQLITE_CANTOPEN_ISDIR(526, " The file is really a directory"),
+    SQLITE_CONSTRAINT_COMMITHOOK(531, " A commit hook callback returned non-zero"),
+    SQLITE_READONLY_ROLLBACK(776, "  Hot journal needs to be rolled back"),
+    SQLITE_IOERR_WRITE(778, " I/O error in the VFS layer while trying to write to a file on disk"),
+    SQLITE_CANTOPEN_FULLPATH(782, " The operating system was unable to convert the filename into a full pathname"),
+    SQLITE_CONSTRAINT_FOREIGNKEY(787, " A foreign key constraint failed"),
+    SQLITE_READONLY_DBMOVED(1032, " The database file has been moved since it was opened"),
+    SQLITE_IOERR_FSYNC(1034, " I/O error in the VFS layer while trying to flush previously written content"),
+    SQLITE_CANTOPEN_CONVPATH(1038, " cygwin_conv_path() system call failed while trying to open a file"),
+    SQLITE_CONSTRAINT_FUNCTION(1043, " Error reported by extension function"),
+    SQLITE_IOERR_DIR_FSYNC(1290, " I/O error in the VFS layer while trying to invoke fsync() on a directory"),
+    SQLITE_CONSTRAINT_NOTNULL(1299, " A NOT NULL constraint failed"),
+    SQLITE_IOERR_TRUNCATE(1546, " I/O error in the VFS layer while trying to truncate a file to a smaller size"),
+    SQLITE_CONSTRAINT_PRIMARYKEY(1555, " A PRIMARY KEY constraint failed"),
+    SQLITE_IOERR_FSTAT(1802, " I/O error in the VFS layer while trying to invoke fstat()"),
+    SQLITE_CONSTRAINT_TRIGGER(1811, " A RAISE function within a trigger fired, causing the SQL statement to abort"),
+    SQLITE_IOERR_UNLOCK(2058, " I/O error within xUnlock"),
+    SQLITE_CONSTRAINT_UNIQUE(2067, " A UNIQUE constraint failed"),
+    SQLITE_IOERR_RDLOCK(2314, " I/O error within xLock"),
+    SQLITE_CONSTRAINT_VTAB(2323, " Error reported by application-defined virtual table"),
+    SQLITE_IOERR_DELETE(2570, " I/O error within xDelete"),
+    SQLITE_CONSTRAINT_ROWID(2579, " rowid is not unique"),
+    SQLITE_IOERR_NOMEM(3082, " Unable to allocate sufficient memory"),
+    SQLITE_IOERR_ACCESS(3338, " I/O error within the xAccess"),
+    SQLITE_IOERR_CHECKRESERVEDLOCK(3594, " I/O error within xCheckReservedLock"),
+    SQLITE_IOERR_LOCK(3850, " I/O error in the advisory file locking logic"),
+    SQLITE_IOERR_CLOSE(4106, " I/O error within xClose"),
+    SQLITE_IOERR_SHMOPEN(4618, " I/O error within xShmMap while trying to open a new shared memory segment"),
+    SQLITE_IOERR_SHMSIZE(4874, " I/O error within xShmMap while trying to resize an existing shared memory segment"),
+    SQLITE_IOERR_SHMMAP(5386, " I/O error within xShmMap while trying to map a shared memory segment"),
+    SQLITE_IOERR_SEEK(5642, " I/O error while trying to seek a file descriptor"),
+    SQLITE_IOERR_DELETE_NOENT(5898, " The file being deleted does not exist"),
+    SQLITE_IOERR_MMAP(6154, " I/O error while trying to map or unmap part of the database file"),
+    SQLITE_IOERR_GETTEMPPATH(6410, " Unable to determine a suitable directory in which to place temporary files"),
+    SQLITE_IOERR_CONVPATH(6666, " cygwin_conv_path() system call failed");
 
     public final int code;
     public final String message;
@@ -85,14 +133,29 @@ private SQLiteErrorCode(int code, String message)
      */
     public static SQLiteErrorCode getErrorCode(int errorCode)
     {
+        return fromVendorCode(errorCode);
+    }
+
+    public static SQLiteErrorCode fromVendorCode(int vendorCode) {
         for (SQLiteErrorCode each : SQLiteErrorCode.values())
         {
-            if (errorCode == each.code)
+            if (vendorCode == each.code)
                 return each;
         }
         return UNKNOWN_ERROR;
     }
 
+    public static SQLiteErrorCode fromException(SQLException e) {
+        return fromVendorCode(e.getErrorCode());
+    }
+
+    public int toVendorCode(boolean useExtendedResultCodes) {
+        if (useExtendedResultCodes) {
+            return code;
+        }
+        return code & 0xff;
+    }
+
     /**
      * @see java.lang.Enum#toString()
      */

src/main/java/org/sqlite/core/CoreConnection.java

@@ -29,6 +29,7 @@ public abstract class CoreConnection {
     private static final String RESOURCE_NAME_PREFIX = ":resource:";
 
     private final String url;
+    private final boolean useExtendedResultCodes;
     private String fileName;
     protected DB db = null;
     protected CoreDatabaseMetaData meta = null;
@@ -72,6 +73,7 @@ protected CoreConnection(String url, String fileName, Properties prop) throws SQ
         this.datePrecision = config.datePrecision;
         this.transactionMode = config.getTransactionMode();
         this.openModeFlags = config.getOpenModeFlags();
+        this.useExtendedResultCodes = config.isExtendedResultCodesUsed();
 
         open(openModeFlags, config.busyTimeout);
 
@@ -394,4 +396,8 @@ public void close() throws SQLException {
         db.close();
         db = null;
     }
+
+    public boolean isExtendedResultCodesUsed() {
+        return useExtendedResultCodes;
+    }
 }

src/main/java/org/sqlite/core/CoreStatement.java

@@ -112,7 +112,7 @@ protected boolean exec(String sql) throws SQLException {
 
     protected void internalClose() throws SQLException {
         if (db.conn.isClosed())
-            throw DB.newSQLException(SQLITE_ERROR, "Connection is closed");
+            throw db.newSQLException(SQLITE_ERROR, "Connection is closed");
 
         if (pointer == 0)
             return;
@@ -123,7 +123,7 @@ protected void internalClose() throws SQLException {
         int resp = db.finalize(this);
 
         if (resp != SQLITE_OK && resp != SQLITE_MISUSE)
-            db.throwex();
+            db.throwex(resp);
     }
 
     public abstract ResultSet executeQuery(String sql, boolean closeStmt) throws SQLException;

src/main/java/org/sqlite/core/DB.java

@@ -132,14 +132,15 @@ public final synchronized void exec(String sql) throws SQLException {
         long pointer = 0;
         try {
             pointer = prepare(sql);
-            switch (step(pointer)) {
+            int rc = step(pointer);
+            switch (rc) {
             case SQLITE_DONE:
                 ensureAutoCommit();
                 return;
             case SQLITE_ROW:
                 return;
             default:
-                throwex();
+                throwex(rc);
             }
         }
         finally {
@@ -749,8 +750,9 @@ final synchronized int[] executeBatch(long stmt, int count, Object[] vals) throw
             for (int i = 0; i < count; i++) {
                 reset(stmt);
                 for (int j = 0; j < params; j++) {
-                    if (sqlbind(stmt, j, vals[(i * params) + j]) != SQLITE_OK) {
-                        throwex();
+                    rc = sqlbind(stmt, j, vals[(i * params) + j]);
+                    if (rc != SQLITE_OK) {
+                        throwex(rc);
                     }
                 }
 
@@ -760,7 +762,7 @@ final synchronized int[] executeBatch(long stmt, int count, Object[] vals) throw
                     if (rc == SQLITE_ROW) {
                         throw new BatchUpdateException("batch entry " + i + ": query returns results", changes);
                     }
-                    throwex();
+                    throwex(rc);
                 }
 
                 changes[i] = changes();
@@ -790,8 +792,9 @@ public final synchronized boolean execute(CoreStatement stmt, Object[] vals) thr
             }
 
             for (int i = 0; i < params; i++) {
-                if (sqlbind(stmt.pointer, i, vals[i]) != SQLITE_OK) {
-                    throwex();
+                int rc = sqlbind(stmt.pointer, i, vals[i]);
+                if (rc != SQLITE_OK) {
+                    throwex(rc);
                 }
             }
         }
@@ -891,9 +894,11 @@ final void throwex(int errorCode, String errorMessage) throws SQLException {
      * @return Formated SQLException with error code and message.
      * @throws SQLException
      */
-    public static SQLException newSQLException(int errorCode, String errorMessage) throws SQLException {
+    public SQLException newSQLException(int errorCode, String errorMessage) throws SQLException {
         SQLiteErrorCode code = SQLiteErrorCode.getErrorCode(errorCode);
-        SQLException e = new SQLException(String.format("%s (%s)", code, errorMessage), null, code.code);
+        SQLException e = new SQLException(
+            String.format("%s (%s)", code, errorMessage), null, code.toVendorCode(conn.isExtendedResultCodesUsed())
+        );
         return e;
     }
 
@@ -956,9 +961,10 @@ final void ensureAutoCommit() throws SQLException {
              {
                 return; // assume we are in a transaction
             }
-            if (step(commit) != SQLITE_DONE) {
+            int rc = step(commit);
+            if (rc != SQLITE_DONE) {
                 reset(commit);
-                throwex();
+                throwex(rc);
             }
             //throw new SQLException("unable to auto-commit");
         }