Ticket #5457: nested_transactions_with_implicit_transaction_config.3.patch

a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -55 +55 @@
-      end
-
-      # Wrap a block in a transaction.  Returns result of block.
-
+, savepoint_number = 1
-        transaction_open = false
+        savepoint_open = false
-        begin
-          if block_given?
-            if start_db_transaction
-
+
+
+
+
+
+
+
-              transaction_open = true
-            end
-            yield
@@ -68 +75 @@
-        rescue Exception => database_transaction_rollback
-          if transaction_open
-            transaction_open = false
-
+
+
+
+
+
+
-          end
-          raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
-        end
-      ensure
-        if transaction_open
-          begin
-
+
+
+
+
+
-          rescue Exception => database_transaction_rollback
-
+
+
+
+
+
-            raise
-          end
-        end
@@ -93 +113 @@
-      # done if the transaction block raises an exception or returns false.
-      def rollback_db_transaction() end
-
+      # abstract create_savepoint method that does nothing
+      def create_savepoint(sp_number)
+      end
+
+      # abstract rollback_to_savepoint method that does nothing
+      def rollback_to_savepoint(sp_number)
+      end
+
+      # abstract release_savepoint method that does nothing
+      def release_savepoint(sp_number)
+      end
+
-      # Alias for #add_limit_offset!.
-      def add_limit!(sql, options)
-        add_limit_offset!(sql, options) if options

a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -315 +315 @@
-        # Transactions aren't supported
-      end
-
+      def create_savepoint(sp_number)
+        execute("SAVEPOINT rails_nested_transaction_#{sp_number}")
+        return true
+      rescue Exception
+        # savepoints are not supported
+      end
+
+      def rollback_to_savepoint(sp_number)
+        execute("ROLLBACK TO SAVEPOINT rails_nested_transaction_#{sp_number}")
+      rescue Exception
+        # savepoints are not supported
+      end
+
+      def release_savepoint(sp_number)
+        execute("RELEASE SAVEPOINT rails_nested_transaction_#{sp_number}")
+      rescue Exception
+        # savepoints are not supported
+      end
+
-
-      def add_limit_offset!(sql, options) #:nodoc:
-        if limit = options[:limit]

a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -433 +433 @@
-        execute "ROLLBACK"
-      end
-
+      def create_savepoint(sp_number)
+        execute("SAVEPOINT rails_nested_transaction_#{sp_number}")
+        return true
+      rescue Exception
+        # savepoints are not supported
+      end
+
+      def rollback_to_savepoint(sp_number)
+        execute("ROLLBACK TO SAVEPOINT rails_nested_transaction_#{sp_number}")
+      rescue Exception
+        # savepoints are not supported
+      end
+
+      def release_savepoint(sp_number)
+        execute("RELEASE SAVEPOINT rails_nested_transaction_#{sp_number}")
+      rescue Exception
+        # savepoints are not supported
+      end
+
-      # SCHEMA STATEMENTS ========================================
-
-      # Returns the list of all tables in the schema search path or a specified schema.

a/activerecord/lib/active_record/fixtures.rb

@@ -927 +927 @@
-            load_fixtures
-            @@already_loaded_fixtures[self.class] = @loaded_fixtures
-          end
+          Thread.current['transactional_test'] = true
-          ActiveRecord::Base.send :increment_open_transactions
-          ActiveRecord::Base.connection.begin_db_transaction
-        # Load fixtures for every test.
@@ -949 +950 @@
-        end
-
-        # Rollback changes if a transaction is active.
-
-
-
+
+
+
+
+
+
-        end
-        ActiveRecord::Base.verify_active_connections!
-      end

a/activerecord/lib/active_record/transactions.rb

@@ -72 +72 @@
-    # should be ready to catch those in your application code. One exception is the ActiveRecord::Rollback exception, which will
-    # trigger a ROLLBACK when raised, but not be re-raised by the transaction block.
-    module ClassMethods
-
+options={}, 
-        previous_handler = trap('TERM') { raise TransactionError, "Transaction aborted" }
-        increment_open_transactions
-
-        begin
-Thread.current['start_db_transaction
+(options[:force] == true) || Thread.current['start_db_transaction'], Thread.current['open_transactions
-        ensure
-          decrement_open_transactions
-          trap('TERM', previous_handler)
-        end
-      end
-
+      # Sets the options for implicit transactions. For different
+      # action types.
+      #
+      # The action types are:
+      # * <tt>:save</tt> - transaction type for creating or updating a record.
+      # * <tt>:destroy</tt> - transaction type for deleting a record.
+      #
+      # The transaction types are:
+      # * <tt>:none</tt> - no transaction is created.
+      # * <tt>:flat</tt> - transaction is only created if non exist. This is the default.
+      # * <tt>:nested</tt> - transaction is created even if one exists. This only works if the database supports nested transactions, if it does not then the behaviour is the same as for :flat.
+      #
+      # Option examples:
+      #   set_transaction_types :save => :flat
+      #   set_transaction_types :save => :none, :destroy => :nested
+      #   set_transaction_types :nested
+      def set_transaction_types(options)
+        case options
+        when Symbol
+          options = { :save => options, :destroy => options }
+        when Hash
+          options[:save] ||= :flat
+          options[:destroy] ||= :flat
+        else
+          raise(ArgumentError, "Invalid transaction type(s): %s", options.inspect)
+        end
+
+        options.assert_valid_keys(:save, :destroy)
+
+        write_inheritable_attribute("transaction_types", options)
+      end
+
+      def get_transaction_type(action_type)
+        get_transaction_types[action_type] || :flat
+      end
+
+      def get_transaction_types
+        (read_inheritable_attribute("transaction_types") or write_inheritable_attribute("transaction_types", {}))
+      end
+
-      private
-        def increment_open_transactions #:nodoc:
-          open = Thread.current['open_transactions'] ||= 0
-
+ || (open == 1 && Thread.current['transactional_test'])
-          Thread.current['open_transactions'] = open + 1
-        end
-
@@ -96 +136 @@
-        end
-    end
-
-
-
+options={}, 
+options, 
-    end
-
-    def destroy_with_transactions #:nodoc:
-
+
+
+
+
+
+
+
-    end
-
-    def save_with_transactions(perform_validation = true) #:nodoc:
-
+
+
+
+
+
+
+
+
+
-    end
-
-    def save_with_transactions! #:nodoc:
-
+
+
+
+
+
+
+
+
+
-    end
-
-    # Reset id and @new_record if the transaction rolls back.

a/activerecord/test/abstract_unit.rb

@@ -63 +63 @@
-
-ActiveRecord::Base.connection.class.class_eval do
-  unless defined? IGNORED_SQL
-
+HOW FIELDS/, /^S
-
-    def execute_with_counting(sql, name = nil, &block)
-      $query_count ||= 0

a/activerecord/test/associations_test.rb

@@ -411 +411 @@
-
-  def test_not_resaved_when_unchanged
-    firm = Firm.find(:first, :include => :account)
-1
+3
-
-    firm = Firm.find(:first)
-    firm.account = Account.find(:first)
-1
+3
-
-    firm = Firm.find(:first).clone
-    firm.account = Account.find(:first)
-2
+4
-
-    firm = Firm.find(:first).clone
-    firm.account = Account.find(:first).clone
-2
+4
-  end
-
-  def test_save_still_works_after_accessing_nil_has_one
@@ -788 +788 @@
-    assert_equal 1, first_firm.clients_of_firm.size
-    first_firm.clients_of_firm.reset
-
-1
+3
-      first_firm.clients_of_firm.create(:name => "Superstars")
-    end
-

a/activerecord/test/transactions_test.rb

@@ -279 +279 @@
-    end
-  end
-end
+
+if current_adapter?(:PostgreSQLAdapter) or current_adapter?(:MysqlAdapter)
+  class NestedTransactionsTest < TransactionTest
+
+    def test_nested_explicit_transactions_with_forced_nesting
+      Topic.transaction do
+        @first.approved = true
+        @first.save
+        @second.approved = true
+        @second.save
+        begin
+          Topic.transaction :force => true do
+            @second.approved = false
+            @second.save
+            raise "Bad things!"
+          end
+        rescue
+          # ignore the exception
+        end
+      end
+
+      assert Topic.find(1).approved?, "First should have been approved"
+      assert Topic.find(2).approved?, "Second should have been approved"
+    end
+
+    def test_nested_explicit_transactions_without_forced_nesting
+      Topic.transaction do
+        @first.approved = true
+        @first.save
+        @second.approved = true
+        @second.save
+        begin
+          Topic.transaction do
+            @second.approved = false
+            @second.save
+            raise "Bad things!"
+          end
+        rescue
+          # ignore the exception
+        end
+      end
+
+      assert Topic.find(1).approved?, "First should have been approved"
+      assert !Topic.find(2).approved?, "Second should have been unapproved"
+    end
+
+    def test_transaction_type_save_none
+      with_topic_transaction_options :save => :none do
+        assert_queries(1) { @first.save! }
+      end
+    end
+
+    def test_transaction_type_save_flat
+      with_topic_transaction_options :save => :flat do
+        assert_queries(3) { @first.save! }
+      end
+    end
+
+    def test_transaction_type_save_flat_inside_transaction
+      with_topic_transaction_options :save => :flat do
+        Topic.transaction do
+          assert_queries(1) { @first.save! }
+        end
+      end
+    end
+
+    def test_transaction_type_save_nested
+      with_topic_transaction_options :save => :nested do
+        assert_queries(3) { @first.save! }
+      end
+    end
+
+    def test_transaction_type_save_nested_inside_transaction
+      with_topic_transaction_options :save => :nested do
+        Topic.transaction do
+          assert_queries(3) { @first.save! }
+        end
+      end
+    end
+
+    def test_transaction_type_destroy_none
+      with_topic_transaction_options :destroy => :none do
+        assert_queries(10) { assert @first.destroy }
+      end
+    end
+
+    def test_transaction_type_destroy_flat
+      with_topic_transaction_options :destroy => :flat do
+        assert_queries(12) { assert @first.destroy }
+      end
+    end
+
+    def test_transaction_type_destroy_nested
+      with_topic_transaction_options :destroy => :nested do
+        assert_queries(14) { assert @first.destroy }
+      end
+    end
+
+    private
+      def with_topic_transaction_options(options)
+        # NOTE Reply does not inherit this because the class
+        # has already been loaded
+        old_types_topic = Topic.send(:get_transaction_types)
+        old_types_reply = Topic.send(:get_transaction_types)
+
+        begin
+          Topic.send(:set_transaction_types, options)
+          Reply.send(:set_transaction_types, options)
+          yield
+        ensure
+          Topic.send(:set_transaction_types, old_types_topic)
+          Reply.send(:set_transaction_types, old_types_reply)
+        end
+      end
+  end
+end