activerecord 4.2.0.beta4 → 4.2.0.rc1

data/lib/active_record/relation/calculations.rb

@@ -254,6 +254,7 @@ module ActiveRecord
         select_value = operation_over_aggregate_column(column, operation, distinct)
 
         column_alias = select_value.alias
+        column_alias ||= @klass.connection.column_name_for_operation(operation, select_value)
         relation.select_values = [select_value]
 
         query_builder = relation.arel

data/lib/active_record/relation/finder_methods.rb

@@ -82,12 +82,16 @@ module ActiveRecord
     #   Post.find_by "published_at < ?", 2.weeks.ago
     def find_by(*args)
       where(*args).take
+    rescue RangeError
+      nil
     end
 
     # Like <tt>find_by</tt>, except that if no record is found, raises
     # an <tt>ActiveRecord::RecordNotFound</tt> error.
     def find_by!(*args)
       where(*args).take!
+    rescue RangeError
+      raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range value"
     end
 
     # Gives a record (or N records if a parameter is supplied) without any implied
@@ -433,6 +437,8 @@ module ActiveRecord
       else
         find_some(ids)
       end
+    rescue RangeError
+      raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"
     end
 
     def find_one(id)
@@ -444,10 +450,7 @@ module ActiveRecord
         MSG
       end
 
-      column = columns_hash[primary_key]
-      substitute = connection.substitute_at(column, bind_values.length)
-      relation = where(table[primary_key].eq(substitute))
-      relation.bind_values += [[column, id]]
+      relation = where(primary_key => id)
       record = relation.take
 
       raise_record_not_found_exception!(id, 0, 1) unless record
@@ -456,7 +459,7 @@ module ActiveRecord
     end
 
     def find_some(ids)
-      result = where(table[primary_key].in(ids)).to_a
+      result = where(primary_key => ids).to_a
 
       expected_size =
         if limit_value && ids.size > limit_value

data/lib/active_record/relation/merger.rb

@@ -118,18 +118,6 @@ module ActiveRecord
         where_values = kept + rhs_wheres
         bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
 
-        conn = relation.klass.connection
-        bv_index = 0
-        where_values.map! do |node|
-          if Arel::Nodes::Equality === node && Arel::Nodes::BindParam === node.right
-            substitute = conn.substitute_at(bind_values[bv_index].first, bv_index)
-            bv_index += 1
-            Arel::Nodes::Equality.new(node.left, substitute)
-          else
-            node
-          end
-        end
-
         relation.where_values = where_values
         relation.bind_values  = bind_values
 

data/lib/active_record/relation/predicate_builder/relation_handler.rb

@@ -6,7 +6,7 @@ module ActiveRecord
           value = value.select(value.klass.arel_table[value.klass.primary_key])
         end
 
-        attribute.in(value.arel.ast)
+        attribute.in(value.arel)
       end
     end
   end

data/lib/active_record/relation/query_methods.rb

@@ -427,19 +427,17 @@ module ActiveRecord
     #   => SELECT "users".* FROM "users" LEFT JOIN bookmarks ON bookmarks.bookmarkable_type = 'Post' AND bookmarks.user_id = users.id
     def joins(*args)
       check_if_method_has_arguments!(:joins, args)
-
-      args.compact!
-      args.flatten!
-
       spawn.joins!(*args)
     end
 
     def joins!(*args) # :nodoc:
+      args.compact!
+      args.flatten!
       self.joins_values += args
       self
     end
 
-    def bind(value)
+    def bind(value) # :nodoc:
       spawn.bind!(value)
     end
 
@@ -881,13 +879,6 @@ module ActiveRecord
       arel.from(build_from) if from_value
       arel.lock(lock_value) if lock_value
 
-      # Reorder bind indexes if joins produced bind values
-      bvs = arel.bind_values + bind_values
-      arel.ast.grep(Arel::Nodes::BindParam).each_with_index do |bp, i|
-        column = bvs[i].first
-        bp.replace connection.substitute_at(column, i)
-      end
-
       arel
     end
 
@@ -958,8 +949,7 @@ module ActiveRecord
       when Hash
         opts = PredicateBuilder.resolve_column_aliases(klass, opts)
 
-        bv_len = bind_values.length
-        tmp_opts, bind_values = create_binds(opts, bv_len)
+        tmp_opts, bind_values = create_binds(opts)
         self.bind_values += bind_values
 
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, tmp_opts)
@@ -971,7 +961,7 @@ module ActiveRecord
       end
     end
 
-    def create_binds(opts, idx)
+    def create_binds(opts)
       bindable, non_binds = opts.partition do |column, value|
         case value
         when String, Integer, ActiveRecord::StatementCache::Substitute
@@ -981,12 +971,23 @@ module ActiveRecord
         end
       end
 
+      association_binds, non_binds = non_binds.partition do |column, value|
+        value.is_a?(Hash) && association_for_table(column)
+      end
+
       new_opts = {}
       binds = []
 
-      bindable.each_with_index do |(column,value), index|
+      bindable.each do |(column,value)|
         binds.push [@klass.columns_hash[column.to_s], value]
-        new_opts[column] = connection.substitute_at(column, index + idx)
+        new_opts[column] = connection.substitute_at(column)
+      end
+
+      association_binds.each do |(column, value)|
+        association_relation = association_for_table(column).klass.send(:relation)
+        association_new_opts, association_bind = association_relation.send(:create_binds, value)
+        new_opts[column] = association_new_opts
+        binds += association_bind
       end
 
       non_binds.each { |column,value| new_opts[column] = value }
@@ -994,6 +995,12 @@ module ActiveRecord
       [new_opts, binds]
     end
 
+    def association_for_table(table_name)
+      table_name = table_name.to_s
+      @klass._reflect_on_association(table_name) ||
+        @klass._reflect_on_association(table_name.singularize)
+    end
+
     def build_from
       opts, name = from_value
       case opts
@@ -1050,8 +1057,13 @@ module ActiveRecord
     def build_select(arel, selects)
       if !selects.empty?
         expanded_select = selects.map do |field|
-          columns_hash.key?(field.to_s) ? arel_table[field] : field
+          if (Symbol === field || String === field) && columns_hash.key?(field.to_s)
+            arel_table[field]
+          else
+            field
+          end
         end
+
         arel.project(*expanded_select)
       else
         arel.project(@klass.arel_table[Arel.star])

data/lib/active_record/sanitization.rb

@@ -87,6 +87,9 @@ module ActiveRecord
       #   { address: Address.new("123 abc st.", "chicago") }
       #     # => "address_street='123 abc st.' and address_city='chicago'"
       def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
+        ActiveSupport::Deprecation.warn(<<-EOWARN)
+sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
+        EOWARN
         attrs = PredicateBuilder.resolve_column_aliases self, attrs
         attrs = expand_hash_conditions_for_aggregates(attrs)
 
@@ -134,7 +137,7 @@ module ActiveRecord
         raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
         bound = values.dup
         c = connection
-        statement.gsub('?') do
+        statement.gsub(/\?/) do
           replace_bind_variable(bound.shift, c)
         end
       end

data/lib/active_record/schema_dumper.rb

@@ -244,12 +244,7 @@ HEADER
 
       def ignored?(table_name)
         ['schema_migrations', ignore_tables].flatten.any? do |ignored|
-          case ignored
-          when String; remove_prefix_and_suffix(table_name) == ignored
-          when Regexp; remove_prefix_and_suffix(table_name) =~ ignored
-          else
-            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
-          end
+          ignored === remove_prefix_and_suffix(table_name)
         end
       end
   end

data/lib/active_record/scoping/named.rb

@@ -139,7 +139,7 @@ module ActiveRecord
         #   Article.published.featured.latest_article
         #   Article.featured.titles
         def scope(name, body, &block)
-          unless body.respond_to?:call
+          unless body.respond_to?(:call)
             raise ArgumentError, 'The scope body needs to be callable.'
           end
 

data/lib/active_record/statement_cache.rb

@@ -1,22 +1,33 @@
 module ActiveRecord
 
   # Statement cache is used to cache a single statement in order to avoid creating the AST again.
-  # Initializing the cache is done by passing the statement in the initialization block:
+  # Initializing the cache is done by passing the statement in the create block:
   #
-  #   cache = ActiveRecord::StatementCache.new do
-  #     Book.where(name: "my book").limit(100)
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: "my book").where("author_id > 3")
   #   end
   #
   # The cached statement is executed by using the +execute+ method:
   #
-  #   cache.execute
+  #   cache.execute([], Book, Book.connection)
   #
   # The relation returned by the block is cached, and for each +execute+ call the cached relation gets duped.
   # Database is queried when +to_a+ is called on the relation.
-  class StatementCache
-    class Substitute; end
+  #
+  # If you want to cache the statement without the values you can use the +bind+ method of the
+  # block parameter.
+  #
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: params.bind)
+  #   end
+  #
+  # And pass the bind values as the first argument of +execute+ call.
+  #
+  #   cache.execute(["my book"], Book, Book.connection)
+  class StatementCache # :nodoc:
+    class Substitute; end # :nodoc:
 
-    class Query
+    class Query # :nodoc:
       def initialize(sql)
         @sql = sql
       end
@@ -26,7 +37,7 @@ module ActiveRecord
       end
     end
 
-    class PartialQuery < Query
+    class PartialQuery < Query # :nodoc:
       def initialize values
         @values = values
         @indexes = values.each_with_index.find_all { |thing,i|
@@ -51,11 +62,11 @@ module ActiveRecord
       PartialQuery.new collected
     end
 
-    class Params
+    class Params # :nodoc:
       def bind; Substitute.new; end
     end
 
-    class BindMap
+    class BindMap # :nodoc:
       def initialize(bind_values)
         @indexes   = []
         @bind_values = bind_values

data/lib/active_record/tasks/database_tasks.rb

@@ -197,18 +197,27 @@ module ActiveRecord
         load_schema_current(format, file)
       end
 
+      def schema_file(format = ActiveSupport::Base.schema_format)
+        case format
+        when :ruby
+          File.join(db_dir, "schema.rb")
+        when :sql
+          File.join(db_dir, "structure.sql")
+        end
+      end
+
       # This method is the successor of +load_schema+. We should rename it
       # after +load_schema+ went through a deprecation cycle. (Rails > 4.2)
       def load_schema_for(configuration, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+        file ||= schema_file(format)
+
         case format
         when :ruby
-          file ||= File.join(db_dir, "schema.rb")
           check_schema_file(file)
           purge(configuration)
           ActiveRecord::Base.establish_connection(configuration)
           load(file)
         when :sql
-          file ||= File.join(db_dir, "structure.sql")
           check_schema_file(file)
           purge(configuration)
           structure_load(configuration, file)
@@ -217,6 +226,12 @@ module ActiveRecord
         end
       end
 
+      def load_schema_current_if_exists(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+        if File.exist?(file || schema_file(format))
+          load_schema_current(format, file, environment)
+        end
+      end
+
       def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
         each_current_configuration(environment) { |configuration|
           load_schema_for configuration, format, file

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -31,6 +31,7 @@ module ActiveRecord
           end
           establish_connection configuration
         else
+          $stderr.puts error.inspect
           $stderr.puts "Couldn't create database for #{configuration.inspect}, #{creation_options.inspect}"
           $stderr.puts "(If you set the charset manually, make sure you have a matching collation)" if configuration['encoding']
         end

data/lib/active_record/type.rb

@@ -4,6 +4,7 @@ require 'active_record/type/numeric'
 require 'active_record/type/time_value'
 require 'active_record/type/value'
 
+require 'active_record/type/big_integer'
 require 'active_record/type/binary'
 require 'active_record/type/boolean'
 require 'active_record/type/date'

data/lib/active_record/type/big_integer.rb

@@ -0,0 +1,13 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -1,8 +1,8 @@
-require 'active_record/type/integer'
+require 'active_record/type/big_integer'
 
 module ActiveRecord
   module Type
-    class DecimalWithoutScale < Integer # :nodoc:
+    class DecimalWithoutScale < BigInteger # :nodoc:
       def type
         :decimal
       end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -3,16 +3,14 @@ module ActiveRecord
     class HashLookupTypeMap < TypeMap # :nodoc:
       delegate :key?, to: :@mapping
 
-      def lookup(type, *args)
-        @mapping.fetch(type, proc { default_value }).call(type, *args)
+      def alias_type(type, alias_type)
+        register_type(type) { |_, *args| lookup(alias_type, *args) }
       end
 
-      def fetch(type, *args, &block)
-        @mapping.fetch(type, block).call(type, *args)
-      end
+      private
 
-      def alias_type(type, alias_type)
-        register_type(type) { |_, *args| lookup(alias_type, *args) }
+      def perform_fetch(type, *args, &block)
+        @mapping.fetch(type, block).call(type, *args)
       end
     end
   end

data/lib/active_record/type/integer.rb

@@ -3,21 +3,49 @@ module ActiveRecord
     class Integer < Value # :nodoc:
       include Numeric
 
+      def initialize(*)
+        super
+        @range = -max_value...max_value
+      end
+
       def type
         :integer
       end
 
       alias type_cast_for_database type_cast
 
+      def type_cast_from_database(value)
+        return if value.nil?
+        value.to_i
+      end
+
+      protected
+
+      attr_reader :range
+
       private
 
       def cast_value(value)
         case value
         when true then 1
         when false then 0
-        else value.to_i rescue nil
+        else
+          result = value.to_i rescue nil
+          ensure_in_range(result) if result
+          result
         end
       end
+
+      def ensure_in_range(value)
+        unless range.cover?(value)
+          raise RangeError, "#{value} is out of range for #{self.class} with limit #{limit || 4}"
+        end
+      end
+
+      def max_value
+        limit = self.limit || 4
+        1 << (limit * 8 - 1) # 8 bits per byte with one bit for sign
+      end
     end
   end
 end