activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -1,20 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
-    class Transaction #:nodoc:
-      attr_reader :connection
-
-      def initialize(connection)
-        @connection = connection
-        @state = TransactionState.new
-      end
-
-      def state
-        @state
-      end
-    end
-
     class TransactionState
-      attr_accessor :parent
+      attr_reader :parent
 
       VALID_STATES = Set.new([:committed, :rolledback, nil])
 
@@ -35,6 +22,10 @@ module ActiveRecord
         @state == :rolledback
       end
 
+      def completed?
+        committed? || rolledback?
+      end
+
       def set_state(state)
         if !VALID_STATES.include?(state)
           raise ArgumentError, "Invalid transaction state: #{state}"
@@ -43,82 +34,24 @@ module ActiveRecord
       end
     end
 
-    class ClosedTransaction < Transaction #:nodoc:
-      def number
-        0
-      end
-
-      def begin(options = {})
-        RealTransaction.new(connection, self, options)
-      end
-
-      def closed?
-        true
-      end
-
-      def open?
-        false
-      end
-
-      def joinable?
-        false
-      end
-
-      # This is a noop when there are no open transactions
-      def add_record(record)
-      end
+    class NullTransaction #:nodoc:
+      def initialize; end
+      def closed?; true; end
+      def open?; false; end
+      def joinable?; false; end
+      def add_record(record); end
     end
 
-    class OpenTransaction < Transaction #:nodoc:
-      attr_reader :parent, :records
-      attr_writer :joinable
-
-      def initialize(connection, parent, options = {})
-        super connection
-
-        @parent    = parent
-        @records   = []
-        @finishing = false
-        @joinable  = options.fetch(:joinable, true)
-      end
-
-      # This state is necessary so that we correctly handle stuff that might
-      # happen in a commit/rollback. But it's kinda distasteful. Maybe we can
-      # find a better way to structure it in the future.
-      def finishing?
-        @finishing
-      end
-
-      def joinable?
-        @joinable && !finishing?
-      end
-
-      def number
-        if finishing?
-          parent.number
-        else
-          parent.number + 1
-        end
-      end
-
-      def begin(options = {})
-        if finishing?
-          parent.begin
-        else
-          SavepointTransaction.new(connection, self, options)
-        end
-      end
+    class Transaction #:nodoc:
 
-      def rollback
-        @finishing = true
-        perform_rollback
-        parent
-      end
+      attr_reader :connection, :state, :records, :savepoint_name
+      attr_writer :joinable
 
-      def commit
-        @finishing = true
-        perform_commit
-        parent
+      def initialize(connection, options)
+        @connection = connection
+        @state = TransactionState.new
+        @records = []
+        @joinable = options.fetch(:joinable, true)
       end
 
       def add_record(record)
@@ -129,41 +62,82 @@ module ActiveRecord
         end
       end
 
-      def rollback_records
+      def rollback
         @state.set_state(:rolledback)
-        records.uniq.each do |record|
+      end
+
+      def rollback_records
+        ite = records.uniq
+        while record = ite.shift
           begin
-            record.rolledback!(parent.closed?)
+            record.rolledback! full_rollback?
           rescue => e
+            raise if ActiveRecord::Base.raise_in_transactional_callbacks
             record.logger.error(e) if record.respond_to?(:logger) && record.logger
           end
         end
+      ensure
+        ite.each do |i|
+          i.rolledback!(full_rollback?, false)
+        end
       end
 
-      def commit_records
+      def commit
         @state.set_state(:committed)
-        records.uniq.each do |record|
+      end
+
+      def commit_records
+        ite = records.uniq
+        while record = ite.shift
           begin
             record.committed!
           rescue => e
+            raise if ActiveRecord::Base.raise_in_transactional_callbacks
             record.logger.error(e) if record.respond_to?(:logger) && record.logger
           end
         end
+      ensure
+        ite.each do |i|
+          i.committed!(false)
+        end
       end
 
-      def closed?
-        false
+      def full_rollback?; true; end
+      def joinable?; @joinable; end
+      def closed?; false; end
+      def open?; !closed?; end
+    end
+
+    class SavepointTransaction < Transaction
+
+      def initialize(connection, savepoint_name, options)
+        super(connection, options)
+        if options[:isolation]
+          raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
+        end
+        connection.create_savepoint(@savepoint_name = savepoint_name)
       end
 
-      def open?
-        true
+      def rollback
+        connection.rollback_to_savepoint(savepoint_name)
+        super
+        rollback_records
       end
-    end
 
-    class RealTransaction < OpenTransaction #:nodoc:
-      def initialize(connection, parent, options = {})
+      def commit
+        connection.release_savepoint(savepoint_name)
         super
+        parent = connection.transaction_manager.current_transaction
+        records.each { |r| parent.add_record(r) }
+      end
+
+      def full_rollback?; false; end
+    end
 
+    class RealTransaction < Transaction
+
+      def initialize(connection, options)
+        super
         if options[:isolation]
           connection.begin_isolated_db_transaction(options[:isolation])
         else
@@ -171,38 +145,69 @@ module ActiveRecord
         end
       end
 
-      def perform_rollback
+      def rollback
         connection.rollback_db_transaction
+        super
         rollback_records
       end
 
-      def perform_commit
+      def commit
         connection.commit_db_transaction
+        super
         commit_records
       end
     end
 
-    class SavepointTransaction < OpenTransaction #:nodoc:
-      def initialize(connection, parent, options = {})
-        if options[:isolation]
-          raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
-        end
+    class TransactionManager #:nodoc:
+      def initialize(connection)
+        @stack = []
+        @connection = connection
+      end
 
-        super
-        connection.create_savepoint
+      def begin_transaction(options = {})
+        transaction =
+          if @stack.empty?
+            RealTransaction.new(@connection, options)
+          else
+            SavepointTransaction.new(@connection, "active_record_#{@stack.size}", options)
+          end
+        @stack.push(transaction)
+        transaction
       end
 
-      def perform_rollback
-        connection.rollback_to_savepoint
-        rollback_records
+      def commit_transaction
+        @stack.pop.commit
       end
 
-      def perform_commit
-        @state.set_state(:committed)
-        @state.parent = parent.state
-        connection.release_savepoint
-        records.each { |r| parent.add_record(r) }
+      def rollback_transaction
+        @stack.pop.rollback
+      end
+
+      def within_new_transaction(options = {})
+        transaction = begin_transaction options
+        yield
+      rescue Exception => error
+        rollback_transaction if transaction
+        raise
+      ensure
+        begin
+          commit_transaction unless error
+        rescue Exception
+          transaction.rollback unless transaction.state.completed?
+          raise
+        end
+      end
+
+      def open_transactions
+        @stack.size
       end
+
+      def current_transaction
+        @stack.last || NULL_TRANSACTION
+      end
+
+      private
+        NULL_TRANSACTION = NullTransaction.new
     end
   end
 end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -1,17 +1,23 @@
 require 'date'
 require 'bigdecimal'
 require 'bigdecimal/util'
+require 'active_record/type'
 require 'active_support/core_ext/benchmark'
 require 'active_record/connection_adapters/schema_cache'
 require 'active_record/connection_adapters/abstract/schema_dumper'
 require 'active_record/connection_adapters/abstract/schema_creation'
 require 'monitor'
+require 'arel/collectors/bind'
+require 'arel/collectors/sql_string'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     extend ActiveSupport::Autoload
 
-    autoload :Column
+    autoload_at 'active_record/connection_adapters/column' do
+      autoload :Column
+      autoload :NullColumn
+    end
     autoload :ConnectionSpecification
 
     autoload_at 'active_record/connection_adapters/abstract/schema_definitions' do
@@ -39,7 +45,8 @@ module ActiveRecord
     end
 
     autoload_at 'active_record/connection_adapters/abstract/transaction' do
-      autoload :ClosedTransaction
+      autoload :TransactionManager
+      autoload :NullTransaction
       autoload :RealTransaction
       autoload :SavepointTransaction
       autoload :TransactionState
@@ -71,8 +78,8 @@ module ActiveRecord
       define_callbacks :checkout, :checkin
 
       attr_accessor :visitor, :pool
-      attr_reader :schema_cache, :last_use, :in_use, :logger
-      alias :in_use? :in_use
+      attr_reader :schema_cache, :owner, :logger
+      alias :in_use? :owner
 
       def self.type_cast_config_to_integer(config)
         if config =~ SIMPLE_INT
@@ -90,13 +97,14 @@ module ActiveRecord
         end
       end
 
+      attr_reader :prepared_statements
+
       def initialize(connection, logger = nil, pool = nil) #:nodoc:
         super()
 
         @connection          = connection
-        @in_use              = false
+        @owner               = nil
         @instrumenter        = ActiveSupport::Notifications.instrumenter
-        @last_use            = false
         @logger              = logger
         @pool                = pool
         @schema_cache        = SchemaCache.new self
@@ -104,6 +112,26 @@ module ActiveRecord
         @prepared_statements = false
       end
 
+      class BindCollector < Arel::Collectors::Bind
+        def compile(bvs, conn)
+          super(bvs.map { |bv| conn.quote(*bv.reverse) })
+        end
+      end
+
+      class SQLString < Arel::Collectors::SQLString
+        def compile(bvs, conn)
+          super(bvs)
+        end
+      end
+
+      def collector
+        if prepared_statements
+          SQLString.new
+        else
+          BindCollector.new
+        end
+      end
+
       def valid_type?(type)
         true
       end
@@ -114,9 +142,8 @@ module ActiveRecord
 
       def lease
         synchronize do
-          unless in_use
-            @in_use   = true
-            @last_use = Time.now
+          unless in_use?
+            @owner = Thread.current
           end
         end
       end
@@ -127,19 +154,14 @@ module ActiveRecord
       end
 
       def expire
-        @in_use = false
-      end
-
-      def unprepared_visitor
-        self.class::BindSubstitution.new self
+        @owner = nil
       end
 
       def unprepared_statement
         old_prepared_statements, @prepared_statements = @prepared_statements, false
-        old_visitor, @visitor = @visitor, unprepared_visitor
         yield
       ensure
-        @visitor, @prepared_statements = old_visitor, old_prepared_statements
+        @prepared_statements = old_prepared_statements
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one
@@ -148,28 +170,19 @@ module ActiveRecord
         'Abstract'
       end
 
-      # Does this adapter support migrations? Backend specific, as the
-      # abstract adapter always returns +false+.
+      # Does this adapter support migrations?
       def supports_migrations?
         false
       end
 
       # Can this adapter determine the primary key for tables not attached
-      # to an Active Record class, such as join tables? Backend specific, as
-      # the abstract adapter always returns +false+.
+      # to an Active Record class, such as join tables?
       def supports_primary_key?
         false
       end
 
-      # Does this adapter support using DISTINCT within COUNT? This is +true+
-      # for all adapters except sqlite.
-      def supports_count_distinct?
-        true
-      end
-
       # Does this adapter support DDL rollbacks in transactions? That is, would
-      # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
-      # SQL Server, and others support this. MySQL and others do not.
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction?
       def supports_ddl_transactions?
         false
       end
@@ -178,8 +191,7 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support savepoints? PostgreSQL and MySQL do,
-      # SQLite < 3.6.8 does not.
+      # Does this adapter support savepoints?
       def supports_savepoints?
         false
       end
@@ -187,7 +199,6 @@ module ActiveRecord
       # Should primary key values be selected from their corresponding
       # sequence before the insert statement? If true, next_sequence_value
       # is called before each insert to set the record's primary key.
-      # This is false for all adapters but Firebird.
       def prefetch_primary_key?(table_name = nil)
         false
       end
@@ -202,8 +213,7 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support explain? As of this writing sqlite3,
-      # mysql2, and postgresql are the only ones that do.
+      # Does this adapter support explain?
       def supports_explain?
         false
       end
@@ -213,12 +223,22 @@ module ActiveRecord
         false
       end
 
-      # Does this adapter support database extensions? As of this writing only
-      # postgresql does.
+      # Does this adapter support database extensions?
       def supports_extensions?
         false
       end
 
+      # Does this adapter support creating indexes in the same statement as
+      # creating the table?
+      def supports_indexes_in_create?
+        false
+      end
+
+      # Does this adapter support creating foreign key constraints?
+      def supports_foreign_keys?
+        false
+      end
+
       # This is meant to be implemented by the adapters that support extensions
       def disable_extension(name)
       end
@@ -227,14 +247,12 @@ module ActiveRecord
       def enable_extension(name)
       end
 
-      # A list of extensions, to be filled in by adapters that support them. At
-      # the moment only postgresql does.
+      # A list of extensions, to be filled in by adapters that support them.
       def extensions
         []
       end
 
       # A list of index algorithms, to be filled by adapters that support them.
-      # MySQL and PostgreSQL have support for them right now.
       def index_algorithms
         {}
       end
@@ -262,12 +280,6 @@ module ActiveRecord
       def active?
       end
 
-      # Adapter should redefine this if it needs a threadsafe way to approximate
-      # if the connection is active
-      def active_threadsafe?
-        active?
-      end
-
       # Disconnects from the database if already connected, and establishes a
       # new connection with the database. Implementors should call super if they
       # override the default implementation.
@@ -301,7 +313,6 @@ module ActiveRecord
       end
 
       # Returns true if its required to reload the connection between requests for development mode.
-      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
       def requires_reloading?
         false
       end
@@ -323,10 +334,6 @@ module ActiveRecord
         @connection
       end
 
-      def open_transactions
-        @transaction.number
-      end
-
       def create_savepoint(name = nil)
       end
 
@@ -336,16 +343,22 @@ module ActiveRecord
       def release_savepoint(name = nil)
       end
 
-      def case_sensitive_modifier(node)
+      def case_sensitive_modifier(node, table_attribute)
         node
       end
 
+      def case_sensitive_comparison(table, attribute, column, value)
+        table_attr = table[attribute]
+        value = case_sensitive_modifier(value, table_attr) unless value.nil?
+        table_attr.eq(value)
+      end
+
       def case_insensitive_comparison(table, attribute, column, value)
         table[attribute].lower.eq(table.lower(value))
       end
 
       def current_savepoint_name
-        "active_record_#{open_transactions}"
+        current_transaction.savepoint_name
       end
 
       # Check the connection back in to the connection pool
@@ -353,15 +366,82 @@ module ActiveRecord
         pool.checkin self
       end
 
+      def type_map # :nodoc:
+        @type_map ||= Type::TypeMap.new.tap do |mapping|
+          initialize_type_map(mapping)
+        end
+      end
+
+      def new_column(name, default, cast_type, sql_type = nil, null = true)
+        Column.new(name, default, cast_type, sql_type, null)
+      end
+
+      def lookup_cast_type(sql_type) # :nodoc:
+        type_map.lookup(sql_type)
+      end
+
       protected
 
-      def translate_exception_class(e, sql)
-        begin
-          message = "#{e.class.name}: #{e.message}: #{sql}"
-        rescue Encoding::CompatibilityError
-          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+      def initialize_type_map(m) # :nodoc:
+        register_class_with_limit m, %r(boolean)i,   Type::Boolean
+        register_class_with_limit m, %r(char)i,      Type::String
+        register_class_with_limit m, %r(binary)i,    Type::Binary
+        register_class_with_limit m, %r(text)i,      Type::Text
+        register_class_with_limit m, %r(date)i,      Type::Date
+        register_class_with_limit m, %r(time)i,      Type::Time
+        register_class_with_limit m, %r(datetime)i,  Type::DateTime
+        register_class_with_limit m, %r(float)i,     Type::Float
+        register_class_with_limit m, %r(int)i,       Type::Integer
+
+        m.alias_type %r(blob)i,      'binary'
+        m.alias_type %r(clob)i,      'text'
+        m.alias_type %r(timestamp)i, 'datetime'
+        m.alias_type %r(numeric)i,   'decimal'
+        m.alias_type %r(number)i,    'decimal'
+        m.alias_type %r(double)i,    'float'
+
+        m.register_type(%r(decimal)i) do |sql_type|
+          scale = extract_scale(sql_type)
+          precision = extract_precision(sql_type)
+
+          if scale == 0
+            # FIXME: Remove this class as well
+            Type::DecimalWithoutScale.new(precision: precision)
+          else
+            Type::Decimal.new(precision: precision, scale: scale)
+          end
         end
+      end
+
+      def reload_type_map # :nodoc:
+        type_map.clear
+        initialize_type_map(type_map)
+      end
 
+      def register_class_with_limit(mapping, key, klass) # :nodoc:
+        mapping.register_type(key) do |*args|
+          limit = extract_limit(args.last)
+          klass.new(limit: limit)
+        end
+      end
+
+      def extract_scale(sql_type) # :nodoc:
+        case sql_type
+          when /\((\d+)\)/ then 0
+          when /\((\d+)(,(\d+))\)/ then $3.to_i
+        end
+      end
+
+      def extract_precision(sql_type) # :nodoc:
+        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+      end
+
+      def extract_limit(sql_type) # :nodoc:
+        $1.to_i if sql_type =~ /\((.*)\)/
+      end
+
+      def translate_exception_class(e, sql)
+        message = "#{e.class.name}: #{e.message}: #{sql}"
         @logger.error message if @logger
         exception = translate_exception(e, message)
         exception.set_backtrace e.backtrace
@@ -386,7 +466,13 @@ module ActiveRecord
       end
 
       def without_prepared_statement?(binds)
-        !@prepared_statements || binds.empty?
+        !prepared_statements || binds.empty?
+      end
+
+      def column_for(table_name, column_name) # :nodoc:
+        column_name = column_name.to_s
+        columns(table_name).detect { |c| c.name == column_name } ||
+          raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")
       end
     end
   end