activerecord 4.1.15 → 4.2.0.beta1

data/lib/active_record/relation/query_methods.rb

@@ -67,6 +67,7 @@ module ActiveRecord
                                              #
         def #{name}_values=(values)          # def select_values=(values)
           raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+          check_cached_relation
           @values[:#{name}] = values         #   @values[:select] = values
         end                                  # end
       CODE
@@ -84,11 +85,22 @@ module ActiveRecord
       class_eval <<-CODE, __FILE__, __LINE__ + 1
         def #{name}_value=(value)            # def readonly_value=(value)
           raise ImmutableRelation if @loaded #   raise ImmutableRelation if @loaded
+          check_cached_relation
           @values[:#{name}] = value          #   @values[:readonly] = value
         end                                  # end
       CODE
     end
 
+    def check_cached_relation # :nodoc:
+      if defined?(@arel) && @arel
+        @arel = nil
+        ActiveSupport::Deprecation.warn <<-WARNING
+Modifying already cached Relation. The cache will be reset.
+Use a cloned Relation to prevent this warning.
+WARNING
+      end
+    end
+
     def create_with_value # :nodoc:
       @values[:create_with] || {}
     end
@@ -173,7 +185,7 @@ module ActiveRecord
 
     # Use to indicate that the given +table_names+ are referenced by an SQL string,
     # and should therefore be JOINed in any query rather than loaded separately.
-    # This method only works in conjuction with +includes+.
+    # This method only works in conjunction with +includes+.
     # See #includes for more details.
     #
     #   User.includes(:posts).where("posts.name = 'foo'")
@@ -207,7 +219,7 @@ module ActiveRecord
     # fields are retrieved:
     #
     #   Model.select(:field)
-    #   # => [#<Model field:value>]
+    #   # => [#<Model id: nil, field: "value">]
     #
     # Although in the above example it looks as though this method returns an
     # array, it actually returns a relation object and can have other query
@@ -216,12 +228,12 @@ module ActiveRecord
     # The argument to the method can also be an array of fields.
     #
     #   Model.select(:field, :other_field, :and_one_more)
-    #   # => [#<Model field: "value", other_field: "value", and_one_more: "value">]
+    #   # => [#<Model id: nil, field: "value", other_field: "value", and_one_more: "value">]
     #
     # You can also use one or more strings, which will be used unchanged as SELECT fields.
     #
     #   Model.select('field AS field_one', 'other_field AS field_two')
-    #   # => [#<Model field: "value", other_field: "value">]
+    #   # => [#<Model id: nil, field: "value", other_field: "value">]
     #
     # If an alias was specified, it will be accessible from the resulting objects:
     #
@@ -229,7 +241,7 @@ module ActiveRecord
     #   # => "value"
     #
     # Accessing attributes of an object that do not have fields retrieved by a select
-    # will throw <tt>ActiveModel::MissingAttributeError</tt>:
+    # except +id+ will throw <tt>ActiveModel::MissingAttributeError</tt>:
     #
     #   Model.select(:field).first.other_field
     #   # => ActiveModel::MissingAttributeError: missing attribute: other_field
@@ -266,6 +278,10 @@ module ActiveRecord
     #
     #   User.group('name AS grouped_name, age')
     #   => [#<User id: 3, name: "Foo", age: 21, ...>, #<User id: 2, name: "Oscar", age: 21, ...>, #<User id: 5, name: "Foo", age: 23, ...>]
+    #
+    # Passing in an array of attributes to group by is also supported.
+    #   User.select([:id, :first_name]).group(:id, :first_name).first(3)
+    #   => [#<User id: 1, first_name: "Bill">, #<User id: 2, first_name: "Earl">, #<User id: 3, first_name: "Beto">]
     def group(*args)
       check_if_method_has_arguments!(:group, args)
       spawn.group!(*args)
@@ -280,15 +296,6 @@ module ActiveRecord
 
     # Allows to specify an order attribute:
     #
-    #   User.order('name')
-    #   => SELECT "users".* FROM "users" ORDER BY name
-    #
-    #   User.order('name DESC')
-    #   => SELECT "users".* FROM "users" ORDER BY name DESC
-    #
-    #   User.order('name DESC, email')
-    #   => SELECT "users".* FROM "users" ORDER BY name DESC, email
-    #
     #   User.order(:name)
     #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC
     #
@@ -297,6 +304,15 @@ module ActiveRecord
     #
     #   User.order(:name, email: :desc)
     #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC
+    #
+    #   User.order('name')
+    #   => SELECT "users".* FROM "users" ORDER BY name
+    #
+    #   User.order('name DESC')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC
+    #
+    #   User.order('name DESC, email')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC, email
     def order(*args)
       check_if_method_has_arguments!(:order, args)
       spawn.order!(*args)
@@ -560,18 +576,14 @@ module ActiveRecord
       end
     end
 
-    def where!(opts = :chain, *rest) # :nodoc:
-      if opts == :chain
-        WhereChain.new(self)
-      else
-        if Hash === opts
-          opts = sanitize_forbidden_attributes(opts)
-          references!(PredicateBuilder.references(opts))
-        end
-
-        self.where_values += build_where(opts, rest)
-        self
+    def where!(opts, *rest) # :nodoc:
+      if Hash === opts
+        opts = sanitize_forbidden_attributes(opts)
+        references!(PredicateBuilder.references(opts))
       end
+
+      self.where_values += build_where(opts, rest)
+      self
     end
 
     # Allows you to change a previously set where condition for a given attribute, instead of appending to that condition.
@@ -677,11 +689,11 @@ module ActiveRecord
     #   end
     #
     def none
-      where("1=0").extending!(NullRelation)
+      extending(NullRelation)
     end
 
     def none! # :nodoc:
-      where!("1=0").extending!(NullRelation)
+      extending!(NullRelation)
     end
 
     # Sets readonly attributes for the returned relation. If value is
@@ -833,7 +845,9 @@ module ActiveRecord
     end
 
     def reverse_order! # :nodoc:
-      self.reverse_order_value = !reverse_order_value
+      orders = order_values.uniq
+      orders.reject!(&:blank?)
+      self.order_values = reverse_sql_order(orders)
       self
     end
 
@@ -849,25 +863,26 @@ module ActiveRecord
 
       build_joins(arel, joins_values.flatten) unless joins_values.empty?
 
-      collapse_wheres(arel, (where_values - ['']).uniq)
+      collapse_wheres(arel, (where_values - [''])) #TODO: Add uniq with real value comparison / ignore uniqs that have binds
 
       arel.having(*having_values.uniq.reject(&:blank?)) unless having_values.empty?
 
       arel.take(connection.sanitize_limit(limit_value)) if limit_value
       arel.skip(offset_value.to_i) if offset_value
-      arel.group(*arel_columns(group_values.uniq.reject(&:blank?))) unless group_values.empty?
+
+      arel.group(*group_values.uniq.reject(&:blank?)) unless group_values.empty?
 
       build_order(arel)
 
-      build_select(arel)
+      build_select(arel, select_values.uniq)
 
       arel.distinct(distinct_value)
       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
-      if bvs.any?
+      if arel.bind_values.any?
+        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)
@@ -887,8 +902,9 @@ module ActiveRecord
 
       case scope
       when :order
-        self.reverse_order_value = false
         result = []
+      when :where
+        self.bind_values = []
       else
         result = [] unless single_val_method
       end
@@ -939,18 +955,15 @@ module ActiveRecord
     def build_where(opts, other = [])
       case opts
       when String, Array
-        #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
-        values = Hash === other.first ? other.first.values : other
-
-        values.grep(ActiveRecord::Relation) do |rel|
-          self.bind_values += rel.bind_values
-        end
-
         [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
       when Hash
         opts = PredicateBuilder.resolve_column_aliases(klass, opts)
-        attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
 
+        bv_len = bind_values.length
+        tmp_opts, bind_values = create_binds(opts, bv_len)
+        self.bind_values += bind_values
+
+        attributes = @klass.send(:expand_hash_conditions_for_aggregates, tmp_opts)
         add_relations_to_bind_values(attributes)
 
         PredicateBuilder.build_from_hash(klass, attributes, table)
@@ -959,6 +972,29 @@ module ActiveRecord
       end
     end
 
+    def create_binds(opts, idx)
+      bindable, non_binds = opts.partition do |column, value|
+        case value
+        when String, Integer, ActiveRecord::StatementCache::Substitute
+          @klass.columns_hash.include? column.to_s
+        else
+          false
+        end
+      end
+
+      new_opts = {}
+      binds = []
+
+      bindable.each_with_index do |(column,value), index|
+        binds.push [@klass.columns_hash[column.to_s], value]
+        new_opts[column] = connection.substitute_at(column, index + idx)
+      end
+
+      non_binds.each { |column,value| new_opts[column] = value }
+
+      [new_opts, binds]
+    end
+
     def build_from
       opts, name = from_value
       case opts
@@ -1000,33 +1036,29 @@ module ActiveRecord
         join_list
       )
 
-      joins = join_dependency.join_constraints stashed_association_joins
+      join_infos = join_dependency.join_constraints stashed_association_joins
 
-      joins.each { |join| manager.from(join) }
+      join_infos.each do |info|
+        info.joins.each { |join| manager.from(join) }
+        manager.bind_values.concat info.binds
+      end
 
       manager.join_sources.concat(join_list)
 
       manager
     end
 
-    def build_select(arel)
-      if select_values.any?
-        arel.project(*arel_columns(select_values.uniq))
+    def build_select(arel, selects)
+      if !selects.empty?
+        expanded_select = selects.map do |field|
+          columns_hash.key?(field.to_s) ? arel_table[field] : field
+        end
+        arel.project(*expanded_select)
       else
         arel.project(@klass.arel_table[Arel.star])
       end
     end
 
-    def arel_columns(columns)
-      columns.map do |field|
-        if columns_hash.key?(field.to_s)
-          arel_table[field]
-        else
-          field
-        end
-      end
-    end
-
     def reverse_sql_order(order_query)
       order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
 
@@ -1052,15 +1084,19 @@ module ActiveRecord
     def build_order(arel)
       orders = order_values.uniq
       orders.reject!(&:blank?)
-      orders = reverse_sql_order(orders) if reverse_order_value
 
       arel.order(*orders) unless orders.empty?
     end
 
+    VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC,
+                        'asc', 'desc', 'ASC', 'DESC'] # :nodoc:
+
     def validate_order_args(args)
-      args.grep(Hash) do |h|
-        unless (h.values - [:asc, :desc]).empty?
-          raise ArgumentError, 'Direction should be :asc or :desc'
+      args.each do |arg|
+        next unless arg.is_a?(Hash)
+        arg.each do |_key, value|
+          raise ArgumentError, "Direction \"#{value}\" is invalid. Valid " \
+                               "directions are: #{VALID_DIRECTIONS.inspect}" unless VALID_DIRECTIONS.include?(value)
         end
       end
     end
@@ -1082,7 +1118,7 @@ module ActiveRecord
         when Hash
           arg.map { |field, dir|
             field = klass.attribute_alias(field) if klass.attribute_alias?(field)
-            table[field].send(dir)
+            table[field].send(dir.downcase)
           }
         else
           arg

data/lib/active_record/relation/spawn_methods.rb

@@ -12,7 +12,6 @@ module ActiveRecord
 
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
     # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
-    #
     #   Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
     #   # Performs a single join query with both where conditions.
     #
@@ -38,14 +37,11 @@ module ActiveRecord
     end
 
     def merge!(other) # :nodoc:
-      if other.is_a?(Hash)
-        Relation::HashMerger.new(self, other).merge
-      elsif other.is_a?(Relation)
-        Relation::Merger.new(self, other).merge
-      elsif other.respond_to?(:to_proc)
+      if !other.is_a?(Relation) && other.respond_to?(:to_proc)
         instance_exec(&other)
       else
-        raise ArgumentError, "#{other.inspect} is not an ActiveRecord::Relation"
+        klass = other.is_a?(Hash) ? Relation::HashMerger : Relation::Merger
+        klass.new(self, other).merge
       end
     end
 
@@ -62,6 +58,9 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
+      if onlies.any? { |o| o == :where }
+        onlies << :bind
+      end
       relation_with values.slice(*onlies)
     end
 

data/lib/active_record/relation.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+require 'arel/collectors/bind'
 
 module ActiveRecord
   # = Active Record Relation
@@ -11,6 +12,7 @@ module ActiveRecord
 
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
                             :reverse_order, :distinct, :create_with, :uniq]
+    INVALID_METHODS_FOR_DELETE_ALL = [:limit, :distinct, :offset, :group, :having]
 
     VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
@@ -230,6 +232,7 @@ module ActiveRecord
     # Please see further details in the
     # {Active Record Query Interface guide}[http://guides.rubyonrails.org/active_record_querying.html#running-explain].
     def explain
+      #TODO: Fix for binds.
       exec_explain(collecting_queries_for_explain { exec_queries })
     end
 
@@ -239,6 +242,11 @@ module ActiveRecord
       @records
     end
 
+    # Serializes the relation objects Array.
+    def encode_with(coder)
+      coder.represent_seq(nil, to_a)
+    end
+
     def as_json(options = nil) #:nodoc:
       to_a.as_json(options)
     end
@@ -330,7 +338,8 @@ module ActiveRecord
         stmt.wheres = arel.constraints
       end
 
-      @klass.connection.update stmt, 'SQL', bind_values
+      bvs = bind_values + arel.bind_values
+      @klass.connection.update stmt, 'SQL', bvs
     end
 
     # Updates an object (or multiple objects) and saves it to the database, if validations pass.
@@ -434,12 +443,21 @@ module ActiveRecord
     # If you need to destroy dependent associations or call your <tt>before_*</tt> or
     # +after_destroy+ callbacks, use the +destroy_all+ method instead.
     #
-    # If a limit scope is supplied, +delete_all+ raises an ActiveRecord error:
+    # If an invalid method is supplied, +delete_all+ raises an ActiveRecord error:
     #
     #   Post.limit(100).delete_all
-    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope
+    #   # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit
     def delete_all(conditions = nil)
-      raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value
+      invalid_methods = INVALID_METHODS_FOR_DELETE_ALL.select { |method|
+        if MULTI_VALUE_METHODS.include?(method)
+          send("#{method}_values").any?
+        else
+          send("#{method}_value")
+        end
+      }
+      if invalid_methods.any?
+        raise ActiveRecordError.new("delete_all doesn't support #{invalid_methods.join(', ')}")
+      end
 
       if conditions
         where(conditions).delete_all
@@ -523,11 +541,11 @@ module ActiveRecord
                       find_with_associations { |rel| relation = rel }
                     end
 
-                    ast   = relation.arel.ast
-                    binds = relation.bind_values.dup
-                    visitor.accept(ast) do
-                      connection.quote(*binds.shift.reverse)
-                    end
+                    arel  = relation.arel
+                    binds = (arel.bind_values + relation.bind_values).dup
+                    binds.map! { |bv| connection.quote(*bv.reverse) }
+                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    collect.substitute_binds(binds).join
                   end
     end
 
@@ -544,7 +562,13 @@ module ActiveRecord
 
       Hash[equalities.map { |where|
         name = where.left.name
-        [name, binds.fetch(name.to_s) { where.right }]
+        [name, binds.fetch(name.to_s) {
+          case where.right
+          when Array then where.right.map(&:val)
+          else
+            where.right.val
+          end
+        }]
       }]
     end
 
@@ -608,7 +632,7 @@ module ActiveRecord
     private
 
     def exec_queries
-      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, bind_values)
+      @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel, arel.bind_values + bind_values)
 
       preload = preload_values
       preload +=  includes_values unless eager_loading?

data/lib/active_record/result.rb

@@ -31,7 +31,7 @@ module ActiveRecord
   class Result
     include Enumerable
 
-    IDENTITY_TYPE = Class.new { def type_cast(v); v; end }.new # :nodoc:
+    IDENTITY_TYPE = Type::Value.new # :nodoc:
 
     attr_reader :columns, :rows, :column_types
 
@@ -42,14 +42,6 @@ module ActiveRecord
       @column_types = column_types
     end
 
-    def identity_type # :nodoc:
-      IDENTITY_TYPE
-    end
-
-    def column_type(name)
-      @column_types[name] || identity_type
-    end
-
     def each
       if block_given?
         hash_rows.each { |row| yield row }
@@ -82,6 +74,15 @@ module ActiveRecord
       hash_rows.last
     end
 
+    def cast_values(type_overrides = {}) # :nodoc:
+      types = columns.map { |name| column_type(name, type_overrides) }
+      result = rows.map do |values|
+        types.zip(values).map { |type, value| type.type_cast_from_database(value) }
+      end
+
+      columns.one? ? result.map!(&:first) : result
+    end
+
     def initialize_copy(other)
       @columns      = columns.dup
       @rows         = rows.dup
@@ -91,6 +92,12 @@ module ActiveRecord
 
     private
 
+    def column_type(name, type_overrides = {})
+      type_overrides.fetch(name) do
+        column_types.fetch(name, IDENTITY_TYPE)
+      end
+    end
+
     def hash_rows
       @hash_rows ||=
         begin

data/lib/active_record/sanitization.rb

@@ -92,7 +92,7 @@ module ActiveRecord
 
         table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
         PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-          connection.visitor.accept b
+          connection.visitor.compile b
         }.join(' AND ')
       end
       alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
@@ -107,6 +107,13 @@ module ActiveRecord
         end.join(', ')
       end
 
+      # Sanitizes a +string+ so that it is safe to use within an SQL
+      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%"
+      def sanitize_sql_like(string, escape_character = "\\")
+        pattern = Regexp.union(escape_character, "%", "_")
+        string.gsub(pattern) { |x| [escape_character, x].join }
+      end
+
       # Accepts an array of conditions. The array has each value
       # sanitized and interpolated into the SQL statement.
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"

data/lib/active_record/schema.rb

@@ -1,4 +1,3 @@
-
 module ActiveRecord
   # = Active Record Schema
   #

data/lib/active_record/schema_dumper.rb

@@ -91,16 +91,17 @@ HEADER
       end
 
       def tables(stream)
-        @connection.tables.sort.each do |tbl|
-          next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
-            case ignored
-            when String; remove_prefix_and_suffix(tbl) == ignored
-            when Regexp; remove_prefix_and_suffix(tbl) =~ ignored
-            else
-              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
-            end
+        sorted_tables = @connection.tables.sort
+
+        sorted_tables.each do |table_name|
+          table(table_name, stream) unless ignored?(table_name)
+        end
+
+        # dump foreign keys at the end to make sure all dependent tables exist.
+        if @connection.supports_foreign_keys?
+          sorted_tables.each do |tbl|
+            foreign_keys(tbl, stream)
           end
-          table(tbl, stream)
         end
       end
 
@@ -213,8 +214,49 @@ HEADER
         end
       end
 
+      def foreign_keys(table, stream)
+        if (foreign_keys = @connection.foreign_keys(table)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            parts = [
+                     'add_foreign_key ' + remove_prefix_and_suffix(foreign_key.from_table).inspect,
+                     remove_prefix_and_suffix(foreign_key.to_table).inspect,
+                    ]
+
+            if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table)
+              parts << ('column: ' + foreign_key.column.inspect)
+            end
+
+            if foreign_key.custom_primary_key?
+              parts << ('primary_key: ' + foreign_key.primary_key.inspect)
+            end
+
+            if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
+              parts << ('name: ' + foreign_key.name.inspect)
+            end
+
+            parts << ('on_update: ' + foreign_key.on_update.inspect) if foreign_key.on_update
+            parts << ('on_delete: ' + foreign_key.on_delete.inspect) if foreign_key.on_delete
+
+            '  ' + parts.join(', ')
+          end
+
+          stream.puts add_foreign_key_statements.sort.join("\n")
+        end
+      end
+
       def remove_prefix_and_suffix(table)
         table.gsub(/^(#{@options[:table_name_prefix]})(.+)(#{@options[:table_name_suffix]})$/,  "\\2")
       end
+
+      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
+        end
+      end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -43,6 +43,10 @@ module ActiveRecord
       def normalize_migration_number(number)
         "%.3d" % number.to_i
       end
+
+      def normalized_versions
+        pluck(:version).map { |v| normalize_migration_number v }
+      end
     end
 
     def version

data/lib/active_record/scoping/default.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       end
 
       module ClassMethods
-        # Returns a scope for the model without the +default_scope+.
+        # Returns a scope for the model without the previously set scopes.
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
@@ -19,11 +19,12 @@ module ActiveRecord
         #     end
         #   end
         #
-        #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
-        #   Post.unscoped.all # Fires "SELECT * FROM posts"
+        #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
+        #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
+        #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
         #
         # This method also accepts a block. All queries inside the block will
-        # not use the +default_scope+:
+        # not use the previously set scopes.
         #
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"