From b3420f5a2e3c38e5efc2b3d995354c39af09569e Mon Sep 17 00:00:00 2001
From: Jonathan Viney <jonathan@jonathan-desktop.(none)>
Date: Sun, 31 Aug 2008 21:09:16 +1200
Subject: Implement savepoints.

---
 .../connection_adapters/abstract/database_statements.rb  | 16 ++++++++++------
 .../connection_adapters/abstract_adapter.rb              | 15 +++++++++++++++
 .../active_record/connection_adapters/mysql_adapter.rb   | 11 +++++++++++
 .../connection_adapters/postgresql_adapter.rb            | 11 +++++++++++
 activerecord/lib/active_record/fixtures.rb               |  2 ++
 activerecord/lib/active_record/transactions.rb           | 12 ++++--------
 6 files changed, 53 insertions(+), 14 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 97c6cd4331..f23fe5a90c 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -55,12 +55,14 @@ module ActiveRecord
       end
 
       # Wrap a block in a transaction.  Returns result of block.
-      def transaction(start_db_transaction = true)
+      def transaction(start_db_transaction = false)
+        start_db_transaction ||= open_transactions.zero? || (open_transactions == 1 && transactional_fixtures)
         transaction_open = false
         begin
           if block_given?
             if start_db_transaction
-              begin_db_transaction
+              open_transactions.zero? ? begin_db_transaction : create_savepoint
+              increment_open_transactions
               transaction_open = true
             end
             yield
@@ -68,21 +70,23 @@ module ActiveRecord
         rescue Exception => database_transaction_rollback
           if transaction_open
             transaction_open = false
-            rollback_db_transaction
+            decrement_open_transactions
+            open_transactions.zero? ? rollback_db_transaction : rollback_to_savepoint
           end
           raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
         end
       ensure
         if transaction_open
+          decrement_open_transactions
           begin
-            commit_db_transaction
+            open_transactions.zero? ? commit_db_transaction : release_savepoint
           rescue Exception => database_transaction_rollback
-            rollback_db_transaction
+            open_transactions.zero? ? rollback_db_transaction : rollback_to_savepoint
             raise
           end
         end
       end
-
+      
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index c5183357a1..cb5c5740c3 100755
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -159,6 +159,21 @@ module ActiveRecord
       def decrement_open_transactions
         @open_transactions -= 1
       end
+      
+      def create_savepoint
+      end
+      
+      def rollback_to_savepoint
+      end
+      
+      def release_savepoint
+      end
+      
+      def current_savepoint_name
+        "rails_savepoint_#{open_transactions}"
+      end
+      
+      attr_accessor :transactional_fixtures
 
       def log_info(sql, name, seconds)
         if @logger && @logger.debug?
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 1e452ae88a..721b365bc7 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -343,6 +343,17 @@ module ActiveRecord
         # Transactions aren't supported
       end
 
+      def create_savepoint
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint
+        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def release_savepoint
+        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+      end
 
       def add_limit_offset!(sql, options) #:nodoc:
         if limit = options[:limit]
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 60ec01b95e..f34093f0ff 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -567,6 +567,17 @@ module ActiveRecord
         end
       end
 
+      def create_savepoint
+        execute("SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def rollback_to_savepoint
+        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
+      end
+
+      def release_savepoint(savepoint_number)
+        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+      end
 
       # SCHEMA STATEMENTS ========================================
 
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 114141a646..3d8b0e40a9 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -932,6 +932,7 @@ module Test #:nodoc:
           end
           ActiveRecord::Base.connection.increment_open_transactions
           ActiveRecord::Base.connection.begin_db_transaction
+          ActiveRecord::Base.connection.transactional_fixtures = true
         # Load fixtures for every test.
         else
           Fixtures.reset_cache
@@ -954,6 +955,7 @@ module Test #:nodoc:
         if use_transactional_fixtures? && ActiveRecord::Base.connection.open_transactions != 0
           ActiveRecord::Base.connection.rollback_db_transaction
           ActiveRecord::Base.connection.decrement_open_transactions
+          ActiveRecord::Base.connection.transactional_fixtures = false
         end
         ActiveRecord::Base.clear_active_connections!
       end
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index 27b5aca18f..56b62474d9 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -122,14 +122,10 @@ module ActiveRecord
     # One should restart the entire transaction if a StatementError occurred.
     module ClassMethods
       # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
-      def transaction(&block)
-        connection.increment_open_transactions
-
-        begin
-          connection.transaction(connection.open_transactions == 1, &block)
-        ensure
-          connection.decrement_open_transactions
-        end
+      def transaction(options = {}, &block)
+        options.assert_valid_keys :force
+        
+        connection.transaction(options[:force], &block)
       end
     end
 
-- 
cgit v1.2.3


From 47b594cc5a2adc86e14a6a3d331583edde56a22f Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 14:31:23 +0200
Subject: Improve documentation for DatabaseStatements#transactions and
 AbstractAdapter#transactional_fixtures, especially with regard to support for
 nested transactions.

---
 .../abstract/database_statements.rb                | 75 ++++++++++++++++++++--
 .../connection_adapters/abstract_adapter.rb        |  3 +
 activerecord/lib/active_record/transactions.rb     |  2 +
 3 files changed, 74 insertions(+), 6 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index f23fe5a90c..bd434f2efc 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -54,14 +54,65 @@ module ActiveRecord
         delete_sql(sql, name)
       end
 
-      # Wrap a block in a transaction.  Returns result of block.
+      # Runs the given block in a database transaction, and returns the result
+      # of the block.
+      #
+      # == Nested transactions support
+      #
+      # Most databases don't support true nested transactions. At the time of
+      # writing, the only database that supports true nested transactions that
+      # we're aware of, is MS-SQL.
+      #
+      # In order to get around this problem, #transaction will emulate the effect
+      # of nested transactions, by using savepoints:
+      # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
+      # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
+      #
+      # It is safe to call this method if a database transaction is already open,
+      # i.e. if #transaction is called within another #transaction block. In case
+      # of a nested call, #transaction will behave as follows:
+      #
+      # - The block will be run without doing anything. All database statements
+      #   that happen within the block are effectively appended to the already
+      #   open database transaction.
+      # - However, if +start_db_transaction+ is set to true, then the block will
+      #   be run inside a new database savepoint, effectively making the block
+      #   a sub-transaction.
+      # - If the #transactional_fixtures attribute is set to true, then the first
+      #   nested call to #transaction will create a new savepoint instead of
+      #   doing nothing. This makes it possible for toplevel transactions in unit
+      #   tests to behave like real transactions, even though a database
+      #   transaction has already been opened.
+      #
+      # === Caveats
+      #
+      # MySQL doesn't support DDL transactions. If you perform a DDL operation,
+      # then any created savepoints will be automatically released. For example,
+      # if you've created a savepoint, then you execute a CREATE TABLE statement,
+      # then the savepoint that was created will be automatically released.
+      #
+      # This means that, on MySQL, you shouldn't execute DDL operations inside
+      # a #transaction call that you know might create a savepoint. Otherwise,
+      # #transaction will raise exceptions when it tries to release the
+      # already-automatically-released savepoints:
+      #
+      #   Model.connection.transaction do  # BEGIN
+      #     Model.connection.transaction(true) do  # CREATE SAVEPOINT rails_savepoint_1
+      #       Model.connection.create_table(...)
+      #       # rails_savepoint_1 now automatically released
+      #     end  # RELEASE savepoint rails_savepoint_1  <--- BOOM! database error!
+      #   end
       def transaction(start_db_transaction = false)
-        start_db_transaction ||= open_transactions.zero? || (open_transactions == 1 && transactional_fixtures)
+        start_db_transaction ||= open_transactions == 0 || (open_transactions == 1 && transactional_fixtures)
         transaction_open = false
         begin
           if block_given?
             if start_db_transaction
-              open_transactions.zero? ? begin_db_transaction : create_savepoint
+              if open_transactions == 0
+                begin_db_transaction
+              else
+                create_savepoint
+              end
               increment_open_transactions
               transaction_open = true
             end
@@ -71,7 +122,11 @@ module ActiveRecord
           if transaction_open
             transaction_open = false
             decrement_open_transactions
-            open_transactions.zero? ? rollback_db_transaction : rollback_to_savepoint
+            if open_transactions == 0
+              rollback_db_transaction
+            else
+              rollback_to_savepoint
+            end
           end
           raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
         end
@@ -79,9 +134,17 @@ module ActiveRecord
         if transaction_open
           decrement_open_transactions
           begin
-            open_transactions.zero? ? commit_db_transaction : release_savepoint
+            if open_transactions == 0
+              commit_db_transaction
+            else
+              release_savepoint
+            end
           rescue Exception => database_transaction_rollback
-            open_transactions.zero? ? rollback_db_transaction : rollback_to_savepoint
+            if open_transactions == 0
+              rollback_db_transaction
+            else
+              rollback_to_savepoint
+            end
             raise
           end
         end
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index cb5c5740c3..45a6cff346 100755
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -173,6 +173,9 @@ module ActiveRecord
         "rails_savepoint_#{open_transactions}"
       end
       
+      # Whether this AbstractAdapter is currently being used inside a unit test
+      # with transactional fixtures turned on. See DatabaseStatements#transaction
+      # for more information about the effect of this option.
       attr_accessor :transactional_fixtures
 
       def log_info(sql, name, seconds)
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index 56b62474d9..4bac7b39d9 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -125,6 +125,8 @@ module ActiveRecord
       def transaction(options = {}, &block)
         options.assert_valid_keys :force
         
+        # See the API documentation for ConnectionAdapters::DatabaseStatements#transaction
+        # for useful information.
         connection.transaction(options[:force], &block)
       end
     end
-- 
cgit v1.2.3


From e383835e738a30cd992c322eff126380bd15094f Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 14:47:43 +0200
Subject: Revert "PostgreSQL: introduce transaction_active? rather than
 tracking activity ourselves" This commit conflicts with savepoint support.

This reverts commit 045713ee240fff815edb5962b25d668512649478.

Conflicts:

	activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
---
 .../connection_adapters/postgresql_adapter.rb      | 38 ----------------------
 1 file changed, 38 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index f34093f0ff..98501db816 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -529,44 +529,6 @@ module ActiveRecord
         execute "ROLLBACK"
       end
 
-      # ruby-pg defines Ruby constants for transaction status,
-      # ruby-postgres does not.
-      PQTRANS_IDLE = defined?(PGconn::PQTRANS_IDLE) ? PGconn::PQTRANS_IDLE : 0
-
-      # Check whether a transaction is active.
-      def transaction_active?
-        @connection.transaction_status != PQTRANS_IDLE
-      end
-
-      # Wrap a block in a transaction.  Returns result of block.
-      def transaction(start_db_transaction = true)
-        transaction_open = false
-        begin
-          if block_given?
-            if start_db_transaction
-              begin_db_transaction
-              transaction_open = true
-            end
-            yield
-          end
-        rescue Exception => database_transaction_rollback
-          if transaction_open && transaction_active?
-            transaction_open = false
-            rollback_db_transaction
-          end
-          raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
-        end
-      ensure
-        if transaction_open && transaction_active?
-          begin
-            commit_db_transaction
-          rescue Exception => database_transaction_rollback
-            rollback_db_transaction
-            raise
-          end
-        end
-      end
-
       def create_savepoint
         execute("SAVEPOINT #{current_savepoint_name}")
       end
-- 
cgit v1.2.3


From e981eaaf342d06e399b5138553c964adcfadd87c Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 14:52:02 +0200
Subject: Fix a stale typo in the PostgreSQL adapter. Fix a stale mock
 expection in transaction_test.

---
 .../lib/active_record/connection_adapters/postgresql_adapter.rb         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 98501db816..cfeef30d06 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -537,7 +537,7 @@ module ActiveRecord
         execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
       end
 
-      def release_savepoint(savepoint_number)
+      def release_savepoint
         execute("RELEASE SAVEPOINT #{current_savepoint_name}")
       end
 
-- 
cgit v1.2.3


From 885c11b8f9e18f34b12076023455e72166365f00 Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 15:41:56 +0200
Subject: Make SQLite3 pass the unit tests for savepoints.

---
 .../lib/active_record/connection_adapters/abstract_adapter.rb       | 6 ++++++
 activerecord/lib/active_record/connection_adapters/mysql_adapter.rb | 4 ++++
 .../lib/active_record/connection_adapters/postgresql_adapter.rb     | 4 ++++
 3 files changed, 14 insertions(+)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 45a6cff346..81260eeecc 100755
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -65,6 +65,12 @@ module ActiveRecord
       def supports_ddl_transactions?
         false
       end
+      
+      # Does this adapter support savepoints? PostgreSQL and MySQL do, SQLite
+      # does not.
+      def supports_savepoints?
+        false
+      end
 
       # Should primary key values be selected from their corresponding
       # sequence before the insert statement?  If true, next_sequence_value
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index 721b365bc7..76ade2a980 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -205,6 +205,10 @@ module ActiveRecord
       def supports_migrations? #:nodoc:
         true
       end
+      
+      def supports_savepoints? #:nodoc:
+        true
+      end
 
       def native_database_types #:nodoc:
         NATIVE_DATABASE_TYPES
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index cfeef30d06..828f321767 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -272,6 +272,10 @@ module ActiveRecord
       def supports_ddl_transactions?
         true
       end
+      
+      def supports_savepoints?
+        true
+      end
 
       # Returns the configured supported identifier length supported by PostgreSQL,
       # or report the default of 63 on PostgreSQL 7.x.
-- 
cgit v1.2.3


From e916aa7ea1613be966959c05ad41d13fee55a683 Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 16:24:15 +0200
Subject: Rename ActiveRecord::Base#transaction's :force option to :nest.
 Improve documentation for nested transactions.

---
 activerecord/lib/active_record/transactions.rb | 59 +++++++++++++++++++++++++-
 1 file changed, 57 insertions(+), 2 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index 4bac7b39d9..1e0185d39c 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -120,14 +120,69 @@ module ActiveRecord
     #   end
     #
     # One should restart the entire transaction if a StatementError occurred.
+    #
+    # == Nested transactions
+    #
+    # #transaction calls can be nested. By default, this makes all database
+    # statements in the nested transaction block become part of the parent
+    # transaction. For example:
+    #
+    #   User.transaction do
+    #     User.create(:username => 'Kotori')
+    #     User.transaction do
+    #       User.create(:username => 'Nemu')
+    #       raise ActiveRecord::Rollback
+    #     end
+    #   end
+    #   
+    #   User.find(:all)  # => empty
+    #
+    # It is also possible to treat a certain #transaction call as its own
+    # sub-transaction, by passing <tt>:nest => true</tt> to #transaction. If
+    # anything goes wrong inside that transaction block, then the parent
+    # transaction will remain unaffected. For example:
+    #
+    #   User.transaction do
+    #     User.create(:username => 'Kotori')
+    #     User.transaction(:nest => true) do
+    #       User.create(:username => 'Nemu')
+    #       raise ActiveRecord::Rollback
+    #     end
+    #   end
+    #   
+    #   User.find(:all)  # => Returns only Kotori
+    #
+    # Most databases don't support true nested transactions. At the time of
+    # writing, the only database that we're aware of that supports true nested
+    # transactions, is MS-SQL. Because of this, Active Record emulates nested
+    # transactions by using savepoints. See
+    # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
+    # for more information about savepoints.
+    #
+    # === Caveats
+    #
+    # If you're on MySQL, then do not use DDL operations in nested transactions
+    # blocks that are emulated with savepoints. That is, do not execute statements
+    # like 'CREATE TABLE' inside such blocks. This is because MySQL automatically
+    # releases all savepoints upon executing a DDL operation. When #transaction
+    # is finished and tries to release the savepoint it created earlier, a
+    # database error will occur because the savepoint has already been
+    # automatically released. The following example demonstrates the problem:
+    # 
+    #   Model.connection.transaction do          # BEGIN
+    #     Model.connection.transaction(true) do  # CREATE SAVEPOINT rails_savepoint_1
+    #       Model.connection.create_table(...)   # rails_savepoint_1 now automatically released
+    #     end                                    # RELEASE savepoint rails_savepoint_1
+    #                                            # ^^^^ BOOM! database error!
+    #   end
     module ClassMethods
       # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
       def transaction(options = {}, &block)
-        options.assert_valid_keys :force
+        options.assert_valid_keys :nest
         
         # See the API documentation for ConnectionAdapters::DatabaseStatements#transaction
         # for useful information.
-        connection.transaction(options[:force], &block)
+        connection.transaction(options[:nest], &block)
       end
     end
 
-- 
cgit v1.2.3


From fb2325e35855d62abd2c76ce03feaa3ca7992e4f Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Thu, 9 Oct 2008 17:57:49 +0200
Subject: Reimplement Jeremy's PostgreSQL automatic transaction state
 introspection code.

- Fixed compatibility with the old 'postgres' driver which doesn't support
  transaction state introspection.
- Added unit tests for it.
---
 .../abstract/database_statements.rb                  | 20 ++++++++++++++++++--
 .../connection_adapters/postgresql_adapter.rb        | 10 ++++++++++
 2 files changed, 28 insertions(+), 2 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index bd434f2efc..a9a63e5a9f 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -53,6 +53,20 @@ module ActiveRecord
       def delete(sql, name = nil)
         delete_sql(sql, name)
       end
+      
+      # Checks whether there is currently no transaction active. This is done
+      # by querying the database driver, and does not use the transaction
+      # house-keeping information recorded by #increment_open_transactions and
+      # friends.
+      #
+      # Returns true if there is no transaction active, false if there is a
+      # transaction active, and nil if this information is unknown.
+      #
+      # Not all adapters supports transaction state introspection. Currently,
+      # only the PostgreSQL adapter supports this.
+      def outside_transaction?
+        nil
+      end
 
       # Runs the given block in a database transaction, and returns the result
       # of the block.
@@ -119,7 +133,7 @@ module ActiveRecord
             yield
           end
         rescue Exception => database_transaction_rollback
-          if transaction_open
+          if transaction_open && !outside_transaction?
             transaction_open = false
             decrement_open_transactions
             if open_transactions == 0
@@ -131,7 +145,9 @@ module ActiveRecord
           raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
         end
       ensure
-        if transaction_open
+        if outside_transaction?
+          @open_transactions = 0
+        elsif transaction_open
           decrement_open_transactions
           begin
             if open_transactions == 0
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 828f321767..c4ef2be82e 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -532,6 +532,16 @@ module ActiveRecord
       def rollback_db_transaction
         execute "ROLLBACK"
       end
+      
+      if PGconn.public_method_defined?(:transaction_status)
+        # ruby-pg defines Ruby constants for transaction status,
+        # ruby-postgres does not.
+        PQTRANS_IDLE = defined?(PGconn::PQTRANS_IDLE) ? PGconn::PQTRANS_IDLE : 0
+        
+        def outside_transaction?
+          @connection.transaction_status == PQTRANS_IDLE
+        end
+      end
 
       def create_savepoint
         execute("SAVEPOINT #{current_savepoint_name}")
-- 
cgit v1.2.3


From ab0ce052ba23a4cce7a84ecade0d00d9cc518ebd Mon Sep 17 00:00:00 2001
From: Jeremy Kemper <jeremy@bitsweat.net>
Date: Sat, 10 Jan 2009 13:36:09 -0800
Subject: Introduce transaction_joinable flag to mark that the fixtures
 transaction can't joined, a new savepoint is required even if :requires_new
 is not set. Use :requires_new option instead of :nest. Update changelog.

[#383 state:committed]
---
 .../abstract/database_statements.rb                | 31 +++++++++++-----------
 .../connection_adapters/abstract_adapter.rb        | 19 +++++++------
 activerecord/lib/active_record/fixtures.rb         |  5 ++--
 activerecord/lib/active_record/transactions.rb     | 27 +++++++++----------
 4 files changed, 39 insertions(+), 43 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index cecbc6b3ac..39118583bd 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -89,14 +89,8 @@ module ActiveRecord
       # - The block will be run without doing anything. All database statements
       #   that happen within the block are effectively appended to the already
       #   open database transaction.
-      # - However, if +start_db_transaction+ is set to true, then the block will
-      #   be run inside a new database savepoint, effectively making the block
-      #   a sub-transaction.
-      # - If the #transactional_fixtures attribute is set to true, then the first
-      #   nested call to #transaction will create a new savepoint instead of
-      #   doing nothing. This makes it possible for toplevel transactions in unit
-      #   tests to behave like real transactions, even though a database
-      #   transaction has already been opened.
+      # - However, if +requires_new+ is set, the block will be wrapped in a
+      #   database savepoint acting as a sub-transaction.
       #
       # === Caveats
       #
@@ -111,20 +105,25 @@ module ActiveRecord
       # already-automatically-released savepoints:
       #
       #   Model.connection.transaction do  # BEGIN
-      #     Model.connection.transaction(true) do  # CREATE SAVEPOINT rails_savepoint_1
+      #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
       #       Model.connection.create_table(...)
-      #       # rails_savepoint_1 now automatically released
-      #     end  # RELEASE savepoint rails_savepoint_1  <--- BOOM! database error!
+      #       # active_record_1 now automatically released
+      #     end  # RELEASE SAVEPOINT active_record_1  <--- BOOM! database error!
       #   end
-      def transaction(start_db_transaction = false)
-        start_db_transaction ||= open_transactions == 0 || (open_transactions == 1 && transactional_fixtures)
+      def transaction(options = {})
+        options.assert_valid_keys :requires_new, :joinable
+
+        last_transaction_joinable, @transaction_joinable =
+          @transaction_joinable, options[:joinable] || true
+        requires_new = options[:requires_new] || !last_transaction_joinable
+
         transaction_open = false
         begin
           if block_given?
-            if start_db_transaction
+            if requires_new || open_transactions == 0
               if open_transactions == 0
                 begin_db_transaction
-              else
+              elsif requires_new
                 create_savepoint
               end
               increment_open_transactions
@@ -145,6 +144,8 @@ module ActiveRecord
           raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
         end
       ensure
+        @transaction_joinable = last_transaction_joinable
+
         if outside_transaction?
           @open_transactions = 0
         elsif transaction_open
diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
index 5137b0f78c..a8cd9f033b 100755
--- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb
@@ -165,24 +165,23 @@ module ActiveRecord
       def decrement_open_transactions
         @open_transactions -= 1
       end
-      
+
+      def transaction_joinable=(joinable)
+        @transaction_joinable = joinable
+      end
+
       def create_savepoint
       end
-      
+
       def rollback_to_savepoint
       end
-      
+
       def release_savepoint
       end
-      
+
       def current_savepoint_name
-        "rails_savepoint_#{open_transactions}"
+        "active_record_#{open_transactions}"
       end
-      
-      # Whether this AbstractAdapter is currently being used inside a unit test
-      # with transactional fixtures turned on. See DatabaseStatements#transaction
-      # for more information about the effect of this option.
-      attr_accessor :transactional_fixtures
 
       def log_info(sql, name, ms)
         if @logger && @logger.debug?
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 039d5a4e8e..0131d9fac5 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -516,7 +516,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
 
           all_loaded_fixtures.update(fixtures_map)
 
-          connection.transaction(connection.open_transactions.zero?) do
+          connection.transaction(:requires_new => true) do
             fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
             fixtures.each { |fixture| fixture.insert_fixtures }
 
@@ -937,8 +937,8 @@ module ActiveRecord
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
         ActiveRecord::Base.connection.increment_open_transactions
+        ActiveRecord::Base.connection.transaction_joinable = false
         ActiveRecord::Base.connection.begin_db_transaction
-        ActiveRecord::Base.connection.transactional_fixtures = true
       # Load fixtures for every test.
       else
         Fixtures.reset_cache
@@ -961,7 +961,6 @@ module ActiveRecord
       if run_in_transaction? && ActiveRecord::Base.connection.open_transactions != 0
         ActiveRecord::Base.connection.rollback_db_transaction
         ActiveRecord::Base.connection.decrement_open_transactions
-        ActiveRecord::Base.connection.transactional_fixtures = false
       end
       ActiveRecord::Base.clear_active_connections!
     end
diff --git a/activerecord/lib/active_record/transactions.rb b/activerecord/lib/active_record/transactions.rb
index aaa298dc49..0b6e52c79b 100644
--- a/activerecord/lib/active_record/transactions.rb
+++ b/activerecord/lib/active_record/transactions.rb
@@ -137,14 +137,14 @@ module ActiveRecord
     #   
     #   User.find(:all)  # => empty
     #
-    # It is also possible to treat a certain #transaction call as its own
-    # sub-transaction, by passing <tt>:nest => true</tt> to #transaction. If
-    # anything goes wrong inside that transaction block, then the parent
-    # transaction will remain unaffected. For example:
+    # It is also possible to requires a sub-transaction by passing
+    # <tt>:requires_new => true</tt>.  If anything goes wrong, the
+    # database rolls back to the beginning of the sub-transaction
+    # without rolling back the parent transaction. For example:
     #
     #   User.transaction do
     #     User.create(:username => 'Kotori')
-    #     User.transaction(:nest => true) do
+    #     User.transaction(:requires_new => true) do
     #       User.create(:username => 'Nemu')
     #       raise ActiveRecord::Rollback
     #     end
@@ -169,20 +169,17 @@ module ActiveRecord
     # database error will occur because the savepoint has already been
     # automatically released. The following example demonstrates the problem:
     # 
-    #   Model.connection.transaction do          # BEGIN
-    #     Model.connection.transaction(true) do  # CREATE SAVEPOINT rails_savepoint_1
-    #       Model.connection.create_table(...)   # rails_savepoint_1 now automatically released
-    #     end                                    # RELEASE savepoint rails_savepoint_1
-    #                                            # ^^^^ BOOM! database error!
+    #   Model.connection.transaction do                           # BEGIN
+    #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
+    #       Model.connection.create_table(...)                    # active_record_1 now automatically released
+    #     end                                                     # RELEASE savepoint active_record_1
+    #                                                             # ^^^^ BOOM! database error!
     #   end
     module ClassMethods
       # See ActiveRecord::Transactions::ClassMethods for detailed documentation.
       def transaction(options = {}, &block)
-        options.assert_valid_keys :nest
-        
-        # See the API documentation for ConnectionAdapters::DatabaseStatements#transaction
-        # for useful information.
-        connection.transaction(options[:nest], &block)
+        # See the ConnectionAdapters::DatabaseStatements#transaction API docs.
+        connection.transaction(options, &block)
       end
     end
 
-- 
cgit v1.2.3


From b6a94fc1c611216c6d1001bb6044973b01dbba38 Mon Sep 17 00:00:00 2001
From: Cody Fauser <codyfauser@gmail.com>
Date: Tue, 13 Jan 2009 13:45:10 -0600
Subject: Remove legacy reloadable? method from ActiveRecord::SessionStore
 [#1745 state:resolved] Signed-off-by: Joshua Peek <josh@joshpeek.com>

---
 activerecord/lib/active_record/session_store.rb | 5 -----
 1 file changed, 5 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/session_store.rb b/activerecord/lib/active_record/session_store.rb
index bd198c03b2..5e45cf65ab 100644
--- a/activerecord/lib/active_record/session_store.rb
+++ b/activerecord/lib/active_record/session_store.rb
@@ -53,11 +53,6 @@ module ActiveRecord
       before_save :raise_on_session_data_overflow!
 
       class << self
-        # Don't try to reload ARStore::Session in dev mode.
-        def reloadable? #:nodoc:
-          false
-        end
-
         def data_column_size_limit
           @data_column_size_limit ||= columns_hash[@@data_column_name].limit
         end
-- 
cgit v1.2.3


From 9bcf01b23c25e640da7908ac8b1b49fbf7d2e51a Mon Sep 17 00:00:00 2001
From: "Hongli Lai (Phusion)" <hongli@phusion.nl>
Date: Tue, 13 Jan 2009 16:01:44 +0100
Subject: Fix PostgreSQL unit test failures that only occur when using the old
 'postgres' driver.

[#1748 state:committed]

Signed-off-by: Jeremy Kemper <jeremy@bitsweat.net>
---
 .../connection_adapters/abstract/database_statements.rb      | 12 ++++++++----
 .../active_record/connection_adapters/postgresql_adapter.rb  | 10 ++++------
 2 files changed, 12 insertions(+), 10 deletions(-)

(limited to 'activerecord/lib')

diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index 39118583bd..08601da00a 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -89,7 +89,7 @@ module ActiveRecord
       # - The block will be run without doing anything. All database statements
       #   that happen within the block are effectively appended to the already
       #   open database transaction.
-      # - However, if +requires_new+ is set, the block will be wrapped in a
+      # - However, if +:requires_new+ is set, the block will be wrapped in a
       #   database savepoint acting as a sub-transaction.
       #
       # === Caveats
@@ -113,8 +113,12 @@ module ActiveRecord
       def transaction(options = {})
         options.assert_valid_keys :requires_new, :joinable
 
-        last_transaction_joinable, @transaction_joinable =
-          @transaction_joinable, options[:joinable] || true
+        last_transaction_joinable = @transaction_joinable
+        if options.has_key?(:joinable)
+          @transaction_joinable = options[:joinable]
+        else
+          @transaction_joinable = true
+        end
         requires_new = options[:requires_new] || !last_transaction_joinable
 
         transaction_open = false
@@ -141,7 +145,7 @@ module ActiveRecord
               rollback_to_savepoint
             end
           end
-          raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
+          raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
         end
       ensure
         @transaction_joinable = last_transaction_joinable
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index 5a8d99924d..913bb521ca 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -533,13 +533,11 @@ module ActiveRecord
         execute "ROLLBACK"
       end
       
-      if PGconn.public_method_defined?(:transaction_status)
-        # ruby-pg defines Ruby constants for transaction status,
-        # ruby-postgres does not.
-        PQTRANS_IDLE = defined?(PGconn::PQTRANS_IDLE) ? PGconn::PQTRANS_IDLE : 0
-        
+      if defined?(PGconn::PQTRANS_IDLE)
+        # The ruby-pg driver supports inspecting the transaction status,
+        # while the ruby-postgres driver does not.
         def outside_transaction?
-          @connection.transaction_status == PQTRANS_IDLE
+          @connection.transaction_status == PGconn::PQTRANS_IDLE
         end
       end
 
-- 
cgit v1.2.3