activerecord 4.0.13 → 4.1.0.beta1

data/lib/active_record/base.rb

@@ -4,7 +4,7 @@ require 'active_support/benchmarkable'
 require 'active_support/dependencies'
 require 'active_support/descendants_tracker'
 require 'active_support/time'
-require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/class/delegating_attributes'
 require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/hash/deep_merge'
@@ -18,6 +18,7 @@ require 'arel'
 require 'active_record/errors'
 require 'active_record/log_subscriber'
 require 'active_record/explain_subscriber'
+require 'active_record/relation/delegation'
 
 module ActiveRecord #:nodoc:
   # = Active Record
@@ -290,8 +291,11 @@ module ActiveRecord #:nodoc:
     extend Translation
     extend DynamicMatchers
     extend Explain
+    extend Enum
+    extend Delegation::DelegateCache
 
     include Persistence
+    include NoTouching
     include ReadonlyAttributes
     include ModelSchema
     include Inheritance

data/lib/active_record/callbacks.rb

@@ -302,11 +302,11 @@ module ActiveRecord
       run_callbacks(:save) { super }
     end
 
-    def _create_record #:nodoc:
+    def create_record #:nodoc:
       run_callbacks(:create) { super }
     end
 
-    def _update_record(*) #:nodoc:
+    def update_record(*) #:nodoc:
       run_callbacks(:update) { super }
     end
   end

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

@@ -332,11 +332,6 @@ module ActiveRecord
         end
       end
 
-      def clear_stale_cached_connections! # :nodoc:
-        reap
-      end
-      deprecate :clear_stale_cached_connections! => "Please use #reap instead"
-
       # Check-out a database connection from the pool, indicating that you want
       # to use it. You should call #checkin when you no longer need this.
       #
@@ -398,7 +393,7 @@ module ActiveRecord
         synchronize do
           stale = Time.now - @dead_connection_timeout
           connections.dup.each do |conn|
-            if conn.in_use? && stale > conn.last_use && !conn.active_threadsafe?
+            if conn.in_use? && stale > conn.last_use && !conn.active?
               remove conn
             end
           end
@@ -629,7 +624,7 @@ module ActiveRecord
         end
 
         response
-      rescue
+      rescue Exception
         ActiveRecord::Base.clear_active_connections! unless testing
         raise
       end

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

@@ -18,18 +18,15 @@ module ActiveRecord
         end
       end
 
-      # Returns an array of record hashes with the column names as keys and
-      # column values as values.
+      # Returns an ActiveRecord::Result instance.
       def select_all(arel, name = nil, binds = [])
-        arel, binds = binds_from_relation arel, binds
         select(to_sql(arel, binds), name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
       def select_one(arel, name = nil, binds = [])
-        result = select_all(arel, name, binds)
-        result.first if result
+        select_all(arel, name, binds).first
       end
 
       # Returns a single value from a record
@@ -42,13 +39,13 @@ module ActiveRecord
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
       def select_values(arel, name = nil)
-        arel, binds = binds_from_relation arel, []
-        select_rows(to_sql(arel, binds), name, binds).map(&:first)
+        select_rows(to_sql(arel, []), name)
+          .map { |v| v[0] }
       end
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(sql, name = nil, binds = [])
+      def select_rows(sql, name = nil)
       end
       undef_method :select_rows
 
@@ -289,6 +286,10 @@ module ActiveRecord
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
+        execute fixture_sql(fixture, table_name), 'Fixture Insert'
+      end
+
+      def fixture_sql(fixture, table_name)
         columns = schema_cache.columns_hash(table_name)
 
         key_list   = []
@@ -297,17 +298,13 @@ module ActiveRecord
           quote(value, columns[name])
         end
 
-        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
+        "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})"
       end
 
       def empty_insert_statement_value
         "DEFAULT VALUES"
       end
 
-      def case_sensitive_equality_operator
-        "="
-      end
-
       def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
         "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
       end
@@ -356,8 +353,7 @@ module ActiveRecord
           subselect
         end
 
-        # Returns an array of record hashes with the column names as keys and
-        # column values as values.
+        # Returns an ActiveRecord::Result instance.
         def select(sql, name = nil, binds = [])
         end
         undef_method :select
@@ -386,13 +382,6 @@ module ActiveRecord
           row = result.rows.first
           row && row.first
         end
-
-        def binds_from_relation(relation, binds)
-          if relation.is_a?(Relation) && binds.blank?
-            relation, binds = relation.arel, relation.bind_values
-          end
-          [relation, binds]
-        end
     end
   end
 end

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

@@ -9,10 +9,10 @@ module ActiveRecord
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
-              def #{method_name}(*)                         # def update_with_query_dirty(*)
-                clear_query_cache if @query_cache_enabled   #   clear_query_cache if @query_cache_enabled
-                super                                       #   super
-              end                                           # end
+              def #{method_name}(*)
+                clear_query_cache if @query_cache_enabled
+                super
+              end
             end_code
           end
         end
@@ -20,13 +20,19 @@ module ActiveRecord
 
       attr_reader :query_cache, :query_cache_enabled
 
+      def initialize(*)
+        super
+        @query_cache         = Hash.new { |h,sql| h[sql] = {} }
+        @query_cache_enabled = false
+      end
+
       # Enable the query cache within the block.
       def cache
         old, @query_cache_enabled = @query_cache_enabled, true
         yield
       ensure
-        clear_query_cache
         @query_cache_enabled = old
+        clear_query_cache unless @query_cache_enabled
       end
 
       def enable_query_cache!
@@ -57,7 +63,6 @@ module ActiveRecord
 
       def select_all(arel, name = nil, binds = [])
         if @query_cache_enabled && !locked?(arel)
-          arel, binds = binds_from_relation arel, binds
           sql = to_sql(arel, binds)
           cache_sql(sql, binds) { super(sql, name, binds) }
         else
@@ -76,14 +81,7 @@ module ActiveRecord
           else
             @query_cache[sql][binds] = yield
           end
-
-        # FIXME: we should guarantee that all cached items are Result
-        # objects.  Then we can avoid this conditional
-        if ActiveRecord::Result === result
-          result.dup
-        else
-          result.collect { |row| row.dup }
-        end
+        result.dup
       end
 
       # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such

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

@@ -15,7 +15,6 @@ module ActiveRecord
           return "'#{quote_string(value)}'" unless column
 
           case column.type
-          when :binary then "'#{quote_string(column.string_to_binary(value))}'"
           when :integer then value.to_i.to_s
           when :float then value.to_f.to_s
           else
@@ -44,9 +43,7 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column)
-        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
-          return value.id
-        end
+        return value.id if value.respond_to?(:quoted_id)
 
         case value
         when String, ActiveSupport::Multibyte::Chars
@@ -54,7 +51,6 @@ module ActiveRecord
           return value unless column
 
           case column.type
-          when :binary then value
           when :integer then value.to_i
           when :float then value.to_f
           else

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

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Savepoints #:nodoc:
+      def supports_savepoints?
+        true
+      end
+
+      def create_savepoint(name = current_savepoint_name)
+        execute("SAVEPOINT #{name}")
+      end
+
+      def rollback_to_savepoint(name = current_savepoint_name)
+        execute("ROLLBACK TO SAVEPOINT #{name}")
+      end
+
+      def release_savepoint(name = current_savepoint_name)
+        execute("RELEASE SAVEPOINT #{name}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      class SchemaCreation # :nodoc:
+        def initialize(conn)
+          @conn = conn
+          @cache = {}
+        end
+
+        def accept(o)
+          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+          send m, o
+        end
+
+        def visit_AddColumn(o)
+          sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+          sql = "ADD #{quote_column_name(o.name)} #{sql_type}"
+          add_column_options!(sql, column_options(o))
+        end
+
+        private
+
+          def visit_AlterTable(o)
+            sql = "ALTER TABLE #{quote_table_name(o.name)} "
+            sql << o.adds.map { |col| visit_AddColumn col }.join(' ')
+          end
+
+          def visit_ColumnDefinition(o)
+            sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+            column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+            add_column_options!(column_sql, column_options(o)) unless o.primary_key?
+            column_sql
+          end
+
+          def visit_TableDefinition(o)
+            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
+            create_sql << "#{quote_table_name(o.name)} "
+            create_sql << "(#{o.columns.map { |c| accept c }.join(', ')}) " unless o.as
+            create_sql << "#{o.options}"
+            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql
+          end
+
+          def column_options(o)
+            column_options = {}
+            column_options[:null] = o.null unless o.null.nil?
+            column_options[:default] = o.default unless o.default.nil?
+            column_options[:column] = o
+            column_options[:first] = o.first
+            column_options[:after] = o.after
+            column_options
+          end
+
+          def quote_column_name(name)
+            @conn.quote_column_name name
+          end
+
+          def quote_table_name(name)
+            @conn.quote_table_name name
+          end
+
+          def type_to_sql(type, limit, precision, scale)
+            @conn.type_to_sql type.to_sym, limit, precision, scale
+          end
+
+          def add_column_options!(sql, options)
+            sql << " DEFAULT #{@conn.quote(options[:default], options[:column])}" if options_include_default?(options)
+            # must explicitly check for :null to allow change_column to work on migrations
+            if options[:null] == false
+              sql << " NOT NULL"
+            end
+            if options[:auto_increment] == true
+              sql << " AUTO_INCREMENT"
+            end
+            sql
+          end
+
+          def options_include_default?(options)
+            options.include?(:default) && !(options[:null] == false && options[:default].nil?)
+          end
+      end
+    end
+  end
+end

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

@@ -15,16 +15,16 @@ module ActiveRecord
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key, :sql_type) #:nodoc:
-      def string_to_binary(value)
-        value
-      end
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :primary_key) #:nodoc:
 
       def primary_key?
         primary_key || type.to_sym == :primary_key
       end
     end
 
+    class ChangeColumnDefinition < Struct.new(:column, :type, :options) #:nodoc:
+    end
+
     # Represents the schema of an SQL table in an abstract way. This class
     # provides methods for manipulating the schema representation.
     #
@@ -49,14 +49,15 @@ module ActiveRecord
       # An array of ColumnDefinition objects, representing the column changes
       # that have been defined.
       attr_accessor :indexes
-      attr_reader :name, :temporary, :options
+      attr_reader :name, :temporary, :options, :as
 
-      def initialize(types, name, temporary, options)
+      def initialize(types, name, temporary, options, as = nil)
         @columns_hash = {}
         @indexes = {}
         @native = types
         @temporary = temporary
         @options = options
+        @as = as
         @name = name
       end
 
@@ -393,8 +394,8 @@ module ActiveRecord
       # Adds timestamps (+created_at+ and +updated_at+) columns to the table. See SchemaStatements#add_timestamps
       #
       #  t.timestamps
-      def timestamps(options = {})
-        @base.add_timestamps(@table_name, options)
+      def timestamps
+        @base.add_timestamps(@table_name)
       end
 
       # Changes the column's definition according to the new options.

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

@@ -120,9 +120,9 @@ module ActiveRecord
       #   The name of the primary key, if one is to be added automatically.
       #   Defaults to +id+. If <tt>:id</tt> is false this option is ignored.
       #
-      #   Note that Active Record models will automatically detect their
-      #   primary key. This can be avoided by using +self.primary_key=+ on the model
-      #   to define the key explicitly.
+      #   Also note that this just sets the primary key in the table. You additionally
+      #   need to configure the primary key in the model via +self.primary_key=+.
+      #   Models do NOT auto-detect the primary key from their table definition.
       #
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
@@ -131,6 +131,9 @@ module ActiveRecord
       # [<tt>:force</tt>]
       #   Set to true to drop the table before creating it.
       #   Defaults to false.
+      # [<tt>:as</tt>]
+      #   SQL to use to generate the table. When this option is used, the block is
+      #   ignored, as are the <tt>:id</tt> and <tt>:primary_key</tt> options.
       #
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #
@@ -169,19 +172,31 @@ module ActiveRecord
       #     supplier_id int
       #   )
       #
+      # ====== Create a temporary table based on a query
+      #
+      #   create_table(:long_query, temporary: true,
+      #     as: "SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id")
+      #
+      # generates:
+      #
+      #   CREATE TEMPORARY TABLE long_query AS
+      #     SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id
+      #
       # See also TableDefinition#column for details on how to create columns.
       def create_table(table_name, options = {})
-        td = create_table_definition table_name, options[:temporary], options[:options]
+        td = create_table_definition table_name, options[:temporary], options[:options], options[:as]
 
-        unless options[:id] == false
-          pk = options.fetch(:primary_key) {
-            Base.get_primary_key table_name.to_s.singularize
-          }
+        if !options[:as]
+          unless options[:id] == false
+            pk = options.fetch(:primary_key) {
+              Base.get_primary_key table_name.to_s.singularize
+            }
 
-          td.primary_key pk, options.fetch(:id, :primary_key), options
-        end
+            td.primary_key pk, options.fetch(:id, :primary_key), options
+          end
 
-        yield td if block_given?
+          yield td if block_given?
+        end
 
         if options[:force] && table_exists?(table_name)
           drop_table(table_name, options)
@@ -558,8 +573,8 @@ module ActiveRecord
         # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
         old_index_def = indexes(table_name).detect { |i| i.name == old_name }
         return unless old_index_def
-        remove_index(table_name, :name => old_name)
-        add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
+        add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
+        remove_index(table_name, name: old_name)
       end
 
       def index_name(table_name, options) #:nodoc:
@@ -606,7 +621,7 @@ module ActiveRecord
         index_options = options.delete(:index)
         add_column(table_name, "#{ref_name}_id", :integer, options)
         add_column(table_name, "#{ref_name}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) if polymorphic
-        add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : nil) if index_options
+        add_index(table_name, polymorphic ? %w[id type].map{ |t| "#{ref_name}_#{t}" } : "#{ref_name}_id", index_options.is_a?(Hash) ? index_options : {}) if index_options
       end
       alias :add_belongs_to :add_reference
 
@@ -694,32 +709,12 @@ module ActiveRecord
         end
       end
 
-      def add_column_options!(sql, options) #:nodoc:
-        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
-        # must explicitly check for :null to allow change_column to work on migrations
-        if options[:null] == false
-          sql << " NOT NULL"
-        end
-        if options[:auto_increment] == true
-          sql << " AUTO_INCREMENT"
-        end
-      end
-
-      # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
-      #
-      #   distinct("posts.id", ["posts.created_at desc"])
-      #
-      def distinct(columns, order_by)
-        ActiveSupport::Deprecation.warn("#distinct is deprecated and shall be removed from future releases.")
-        "DISTINCT #{columns_for_distinct(columns, order_by)}"
-      end
-
       # Given a set of columns and an ORDER BY clause, returns the columns for a SELECT DISTINCT.
       # Both PostgreSQL and Oracle overrides this for custom DISTINCT syntax - they
       # require the order columns appear in the SELECT.
       #
       #   columns_for_distinct("posts.id", ["posts.created_at desc"])
-      def columns_for_distinct(columns, orders) #:nodoc:
+      def columns_for_distinct(columns, orders) # :nodoc:
         columns
       end
 
@@ -727,9 +722,9 @@ module ActiveRecord
       #
       #   add_timestamps(:suppliers)
       #
-      def add_timestamps(table_name, options = {})
-        add_column table_name, :created_at, :datetime, options
-        add_column table_name, :updated_at, :datetime, options
+      def add_timestamps(table_name)
+        add_column table_name, :created_at, :datetime
+        add_column table_name, :updated_at, :datetime
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table definition.
@@ -741,10 +736,6 @@ module ActiveRecord
         remove_column table_name, :created_at
       end
 
-      def update_table_definition(table_name, base) #:nodoc:
-        Table.new(table_name, base)
-      end
-
       protected
         def add_index_sort_order(option_strings, column_names, options = {})
           if options.is_a?(Hash) && order = options[:order]
@@ -779,37 +770,23 @@ module ActiveRecord
           column_names = Array(column_name)
           index_name   = index_name(table_name, column: column_names)
 
-          if Hash === options # legacy support, since this param was a string
-            options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
-
-            index_type = options[:unique] ? "UNIQUE" : ""
-            index_type = options[:type].to_s if options.key?(:type)
-            index_name = options[:name].to_s if options.key?(:name)
-            max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
-
-            if options.key?(:algorithm)
-              algorithm = index_algorithms.fetch(options[:algorithm]) {
-                raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
-              }
-            end
+          options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
 
-            using = "USING #{options[:using]}" if options[:using].present?
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_type = options[:type].to_s if options.key?(:type)
+          index_name = options[:name].to_s if options.key?(:name)
+          max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
 
-            if supports_partial_index?
-              index_options = options[:where] ? " WHERE #{options[:where]}" : ""
-            end
-          else
-            if options
-              message = "Passing a string as third argument of `add_index` is deprecated and will" +
-                " be removed in Rails 4.1." +
-                " Use add_index(#{table_name.inspect}, #{column_name.inspect}, unique: true) instead"
+          if options.key?(:algorithm)
+            algorithm = index_algorithms.fetch(options[:algorithm]) {
+              raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
+            }
+          end
 
-              ActiveSupport::Deprecation.warn message
-            end
+          using = "USING #{options[:using]}" if options[:using].present?
 
-            index_type = options
-            max_index_length = allowed_index_name_length
-            algorithm = using = nil
+          if supports_partial_index?
+            index_options = options[:where] ? " WHERE #{options[:where]}" : ""
           end
 
           if index_name.length > max_index_length
@@ -841,12 +818,6 @@ module ActiveRecord
           index_name
         end
 
-        def columns_for_remove(table_name, *column_names)
-          ActiveSupport::Deprecation.warn("columns_for_remove is deprecated and will be removed in the future")
-          raise ArgumentError.new("You must specify at least one column name. Example: remove_columns(:people, :first_name)") if column_names.blank?
-          column_names.map {|column_name| quote_column_name(column_name) }
-        end
-
         def rename_table_indexes(table_name, new_name)
           indexes(new_name).each do |index|
             generated_index_name = index_name(table_name, column: index.columns)
@@ -869,20 +840,18 @@ module ActiveRecord
           end
         end
 
-        def quote_value(value, column)
-          column.sql_type ||= type_to_sql(column.type, column.limit, column.precision, column.scale)
-
-          quote(value, column)
-        end
-
       private
-      def create_table_definition(name, temporary, options)
-        TableDefinition.new native_database_types, name, temporary, options
+      def create_table_definition(name, temporary, options, as = nil)
+        TableDefinition.new native_database_types, name, temporary, options, as
       end
 
       def create_alter_table(name)
         AlterTable.new create_table_definition(name, false, {})
       end
+
+      def update_table_definition(table_name, base)
+        Table.new(table_name, base)
+      end
     end
   end
 end