[sqlite3] implement "flags", read_uncommited transaction isolation level

Author: dr-itz

lib/arjdbc/sqlite3/adapter.rb

@@ -16,6 +16,33 @@
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 
+module SQLite3
+  module Constants
+    module Open
+      READONLY       = 0x00000001
+      READWRITE      = 0x00000002
+      CREATE         = 0x00000004
+      DELETEONCLOSE  = 0x00000008
+      EXCLUSIVE      = 0x00000010
+      AUTOPROXY      = 0x00000020
+      URI            = 0x00000040
+      MEMORY         = 0x00000080
+      MAIN_DB        = 0x00000100
+      TEMP_DB        = 0x00000200
+      TRANSIENT_DB   = 0x00000400
+      MAIN_JOURNAL   = 0x00000800
+      TEMP_JOURNAL   = 0x00001000
+      SUBJOURNAL     = 0x00002000
+      MASTER_JOURNAL = 0x00004000
+      NOMUTEX        = 0x00008000
+      FULLMUTEX      = 0x00010000
+      SHAREDCACHE    = 0x00020000
+      PRIVATECACHE   = 0x00040000
+      WAL            = 0x00080000
+    end
+  end
+end
+
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
   # The constants at the front of this file are to allow the rest of the file to remain with no modifications
@@ -69,6 +96,10 @@ def supports_savepoints?
       true
     end
 
+    def supports_transaction_isolation?
+      true
+    end
+
     def supports_partial_index?
       database_version >= "3.9.0"
     end
@@ -321,6 +352,10 @@ def build_insert_sql(insert) # :nodoc:
       sql
     end
 
+    def shared_cache?
+      config[:properties] && config[:properties][:shared_cache] == true
+    end
+
     def get_database_version # :nodoc:
       SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
     end
@@ -665,7 +700,9 @@ def supports_transaction_isolation?
     end
 
     def begin_isolated_db_transaction(isolation)
-      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+      raise ActiveRecord::TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+      raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+      super
     end
 
     # SQLite driver doesn't support all types of insert statements with executeUpdate so

lib/arjdbc/sqlite3/connection_methods.rb

@@ -35,7 +35,17 @@ def sqlite3_connection(config)
       # * http://sqlite.org/c3ref/open.html
       # * http://sqlite.org/c3ref/c_open_autoproxy.html
       # => 0x01 = readonly, 0x40 = uri (default in JDBC)
-      config[:properties][:open_mode] = 0x01 | 0x40
+      config[:properties][:open_mode] = ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+    end
+
+    if config[:flags]
+      config[:properties][:open_mode] ||= 0
+      config[:properties][:open_mode] |= config[:flags]
+
+      # JDBC driver has an extra flag for it
+      if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+        config[:properties][:shared_cache] = true
+      end
     end
 
     timeout = config[:timeout]

src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -359,7 +359,7 @@ public IRubyObject commit(final ThreadContext context) {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.commit();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.runtime.newBoolean(true);
                 }
                 finally {
@@ -380,7 +380,7 @@ public IRubyObject rollback(final ThreadContext context) {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.tru;
                 } finally {
                     connection.setAutoCommit(true);
@@ -516,7 +516,7 @@ private Map<IRubyObject, Savepoint> getSavepoints(final boolean init) {
         return null;
     }
 
-    protected boolean resetSavepoints(final ThreadContext context) {
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
         if ( hasInternalVariable("savepoints") ) {
             removeInternalVariable("savepoints");
             return true;
@@ -1098,6 +1098,28 @@ public IRubyObject execute_query(final ThreadContext context, final IRubyObject
         });
     }
 
+    @JRubyMethod(required = 1)
+    public IRubyObject get_first_value(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
+                statement.execute(query);
+                ResultSet rs = statement.getResultSet();
+                if (rs == null || !rs.next()) return context.nil;
+
+                return jdbcToRuby(context, context.getRuntime(), 1, rs.getMetaData().getColumnType(1), rs);
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
+            }
+        });
+    }
+
     /**
      * Prepares a query, returns a wrapped PreparedStatement. This takes care of exception wrapping
      * @param context which context this method is executing on.

src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -370,10 +370,9 @@ private static boolean useSavepointAPI(final ThreadContext context) {
     }
 
     @Override
-    public IRubyObject begin(ThreadContext context, IRubyObject level) {
-        throw context.runtime.newRaiseException(getTransactionIsolationError(context.runtime),
-                "SQLite3 does not support isolation levels"
-        );
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
+        connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
+        return super.resetSavepoints(context, connection);
     }
 
     @Override

test/rails/excludes/sqlite3/SQLite3TransactionTest.rb

@@ -0,0 +1 @@
+exclude :test_set_the_read_uncommited_PRAGMA_to_its_previous_value, 'uses sqlite3-ruby internals'