sequel-activerecord_connection 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4078a41f54331cbb97fc266abdbe24cf8c297be14bb7f92b3bf605bf9b549bd
-  data.tar.gz: af466cd9b062279a7781106136a05151f02339830469136cdf9b58d629397b98
+  metadata.gz: f8e137f0937e4f17511d40529df10648276b7dae834cef50f4bc6615206c486b
+  data.tar.gz: e25287b365a78b34c55afb084b0ebad4a24c8c00944323c1a2b455505fd4a251
 SHA512:
-  metadata.gz: e28881de46188d6dc143952a473e00254b0742c497e7888e8d334ff33b627d3d90d9174675809cc3248b15cfcc800908bc83dda5a8da3fee93c4048c44282424
-  data.tar.gz: 7c0a46d18a45e76ca4a7af11d467b957035dd4b62adbdcaf64d8e9cafe1bfb406fa40c3d4feadff10c823d2535cab978111203ade32ea519f991e828ed1df033
+  metadata.gz: '033781eeae71623aa992f2a882c04a1fd718109435b3aa428b0710df4322f1f267664abb4670a9909e3aefa570029a37c8a6a6947d54d2b38e119b80c938245b'
+  data.tar.gz: c013ca47766a5cfae058353094df8a88e74a992de924f7b2107c6e50a5f76af72c74fab0f957032666f7b3442b80af886ca56f5bd3635d67c141fa67ff7be5d8

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.4.0 (2020-09-28)
+
+* Return correct result of `Database#in_transaction?` after ActiveRecord transaction exited (@janko)
+
+* Make ActiveRecord create a savepoint inside a Sequel transaction with `auto_savepoint: true` (@janko)
+
+* Make Sequel create a savepoint inside ActiveRecord transaction with `joinable: false` (@janko)
+
+* Improve reliability of nested transactions when combining Sequel and ActiveRecord (@janko)
+
+* Raise error when attempting to add an `after_commit`/`after_rollback` hook on ActiveRecord transaction (@janko)
+
+* Fix infinite loop that could happen with transactional Rails tests (@janko)
+
 ## 0.3.0 (2020-07-24)
 
 * Fully support Sequel transaction API (all transaction options, transaction/savepoint hooks etc.) (@janko)

data/README.md

@@ -42,8 +42,7 @@ appropriate Sequel adapter and load the `activerecord_connection` extension:
 ```rb
 require "sequel"
 
-DB = Sequel.postgres(test: false) # avoid creating a connection
-DB.extension :activerecord_connection
+DB = Sequel.postgres(extensions: :activerecord_connection)
 ```
 
 Now any Sequel operations that you make will internaly be done using the
@@ -75,13 +74,13 @@ ActiveRecord adapters, just make sure to initialize the corresponding Sequel
 adapter before loading the extension.
 
 ```rb
-DB = Sequel.postgres(test: false) # for "postgresql" adapter
+DB = Sequel.postgres(extensions: :activerecord_connection) # for "postgresql" adapter
 # or
-DB = Sequel.mysql2(test: false) # for "mysql2" adapter
+DB = Sequel.mysql2(extensions: :activerecord_connection) # for "mysql2" adapter
 # or
-DB = Sequel.sqlite(test: false) # for "sqlite3" adapter
+DB = Sequel.sqlite(extensions: :activerecord_connection) # for "sqlite3" adapter
 # or
-DB = Sequel.jdbc(test: false) # for JDBC adapter
+DB = Sequel.jdbc(extensions: :activerecord_connection) # for JDBC adapter
 ```
 
 ### Transactions
@@ -101,39 +100,36 @@ Sequel's transaction API is fully supported:
 
 ```rb
 DB.transaction(isolation: :serializable) do
-  DB.after_commit { ... } # call block after transaction commits
+  DB.after_commit { ... } # executed after transaction commits
   DB.transaction(savepoint: true) do # creates a savepoint
-    # ...
+    DB.after_commit(savepoint: true) { ... } # executed if all enclosing savepoints have been released
   end
 end
 ```
 
-One caveat to keep in mind is that Sequel's transaction hooks
-(`after_commit`, `after_rollback`) will *not* run if ActiveRecord holds the
-outer transaction:
+One caveat to keep in mind is that using Sequel's transaction/savepoint hooks
+currently don't work if ActiveRecord holds the corresponding
+transaction/savepoint. This is because it's difficult to be notified when
+ActiveRecord commits or rolls back the transaction/savepoint.
 
 ```rb
 DB.transaction do
   DB.after_commit { ... } # will get executed
 end
 
-ActiveRecord::Base.transaction do
-  DB.after_commit { ... } # won't get executed
+DB.transaction do
+  DB.transaction(savepoint: true) do
+    DB.after_commit(savepoint: true) { ... } # will get executed
+  end
 end
 
 ActiveRecord::Base.transaction do
-  DB.transaction do
-    DB.after_commit { ... } # won't get executed
-  end
+  DB.after_commit { ... } # not allowed (will raise Sequel::ActiveRecordConnection::Error)
 end
-```
 
-Savepoint hooks should still work, though:
-
-```rb
-ActiveRecord::Base.transaction do
-  DB.transaction(savepoint: true) do
-    DB.after_commit { ... } # will get executed after savepoint is released
+DB.transaction do
+  ActiveRecord::Base.transaction(requires_new: true) do
+    DB.after_commit(savepoint: true) { ... } # not allowed (will raise Sequel::ActiveRecordConnection::Error)
   end
 end
 ```

data/lib/sequel/extensions/activerecord_connection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequel
   module ActiveRecordConnection
     Error = Class.new(Sequel::Error)
@@ -41,38 +43,43 @@ module Sequel
 
     private
 
-    # Backfills any ActiveRecord transactions/savepoints that have been opened
-    # directly via ActiveRecord::Base.transaction. Sequel uses this information
-    # to know whether we're in a transaction, whether to create a savepoint,
-    # when to run transaction/savepoint hooks etc.
+    # Synchronizes transaction state with ActiveRecord. Sequel uses this
+    # information to know whether we're in a transaction, whether to create a
+    # savepoint, when to run transaction/savepoint hooks etc.
     def _trans(conn)
-      Sequel.synchronize do
-        result = @transactions[conn]
-
-        if activerecord_connection.transaction_open?
-          result ||= { savepoints: [] }
-          while result[:savepoints].length < activerecord_connection.open_transactions
-            result[:savepoints].unshift({ activerecord: true })
-          end
-        end
+      hash = super || { savepoints: [], activerecord: true }
 
-        @transactions[conn] = result if result
-        result
+      # add any ActiveRecord transactions/savepoints that have been opened
+      # directly via ActiveRecord::Base.transaction
+      while hash[:savepoints].length < activerecord_connection.open_transactions
+        hash[:savepoints] << { activerecord: true }
+      end
+
+      # remove any ActiveRecord transactions/savepoints that have been closed
+      # directly via ActiveRecord::Base.transaction
+      while hash[:savepoints].length > activerecord_connection.open_transactions && hash[:savepoints].last[:activerecord]
+        hash[:savepoints].pop
+      end
+
+      # sync knowledge about joinability of current ActiveRecord transaction/savepoint
+      if activerecord_connection.transaction_open? && !activerecord_connection.current_transaction.joinable?
+        hash[:savepoints].last[:auto_savepoint] = true
+      end
+
+      if hash[:savepoints].empty? && hash[:activerecord]
+        Sequel.synchronize { @transactions.delete(conn) }
+      else
+        Sequel.synchronize { @transactions[conn] = hash }
       end
-    end
 
-    # First delete any transactions/savepoints opened directly via
-    # ActiveRecord::Base.transaction, so that Sequel can detect when the last
-    # Sequel transaction has been closed and clear transaction information.
-    def transaction_finished?(conn)
-      _trans(conn)[:savepoints].shift while _trans(conn)[:savepoints].first[:activerecord]
       super
     end
 
     def begin_transaction(conn, opts = {})
       isolation = TRANSACTION_ISOLATION_MAP.fetch(opts[:isolation]) if opts[:isolation]
+      joinable  = !opts[:auto_savepoint]
 
-      activerecord_connection.begin_transaction(isolation: isolation)
+      activerecord_connection.begin_transaction(isolation: isolation, joinable: joinable)
     end
 
     def commit_transaction(conn, opts = {})
@@ -84,8 +91,20 @@ module Sequel
       activerecord_connection.transaction_manager.send(:after_failure_actions, activerecord_connection.current_transaction, $!) if activerecord_connection.transaction_manager.respond_to?(:after_failure_actions)
     end
 
-    def savepoint_level(conn)
-      activerecord_connection.open_transactions
+    def add_transaction_hook(conn, type, block)
+      if _trans(conn)[:activerecord]
+        fail Error, "cannot add transaction hook when ActiveRecord holds the outer transaction"
+      end
+
+      super
+    end
+
+    def add_savepoint_hook(conn, type, block)
+      if _trans(conn)[:savepoints].last[:activerecord]
+        fail Error, "cannot add savepoint hook when ActiveRecord holds the current savepoint"
+      end
+
+      super
     end
 
     def activerecord_raw_connection

data/sequel-activerecord_connection.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "sequel-activerecord_connection"
-  spec.version       = "0.3.0"
+  spec.version       = "0.4.0"
   spec.authors       = ["Janko Marohnić"]
   spec.email         = ["janko.marohnic@gmail.com"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-activerecord_connection
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-24 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel