activerecord 3.2.22.5 → 4.0.0.beta1

data/lib/active_record/relation/spawn_methods.rb

@@ -1,180 +1,73 @@
-require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'active_record/relation/merger'
 
 module ActiveRecord
   module SpawnMethods
-    def merge(r)
-      return self unless r
-      return to_a & r if r.is_a?(Array)
 
-      merged_relation = clone
-
-      r = r.with_default_scope if r.default_scoped? && r.klass != klass
-
-      Relation::ASSOCIATION_METHODS.each do |method|
-        value = r.send(:"#{method}_values")
-
-        unless value.empty?
-          if method == :includes
-            merged_relation = merged_relation.includes(value)
-          else
-            merge_relation_method(merged_relation, method, value)
-          end
-        end
-      end
-
-      (Relation::MULTI_VALUE_METHODS - [:joins, :where, :order]).each do |method|
-        value = r.send(:"#{method}_values")
-        merge_relation_method(merged_relation, method, value) if value.present?
-      end
-
-      merge_joins(merged_relation, r)
-
-      merged_wheres = @where_values + r.where_values
-
-      unless @where_values.empty?
-        # Remove duplicate ARel attributes. Last one wins.
-        seen = Hash.new { |h,table| h[table] = {} }
-        merged_wheres = merged_wheres.reverse.reject { |w|
-          nuke = false
-          if w.respond_to?(:operator) && w.operator == :== &&
-            w.left.respond_to?(:relation)
-            name              = w.left.name
-            table             = w.left.relation.name
-            nuke              = seen[table][name]
-            seen[table][name] = true
-          end
-          nuke
-        }.reverse
-      end
-
-      merged_relation.where_values = merged_wheres
+    # This is overridden by Associations::CollectionProxy
+    def spawn #:nodoc:
+      clone
+    end
 
-      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).each do |method|
-        value = r.send(:"#{method}_value")
-        merged_relation.send(:"#{method}_value=", value) unless value.nil?
+    # 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.
+    #
+    #   recent_posts = Post.order('created_at DESC').first(5)
+    #   Post.where(published: true).merge(recent_posts)
+    #   # Returns the intersection of all published posts with the 5 most recently created posts.
+    #   # (This is just an example. You'd probably want to do this with a single query!)
+    #
+    # Procs will be evaluated by merge:
+    #
+    #   Post.where(published: true).merge(-> { joins(:comments) })
+    #   # => Post.where(published: true).joins(:comments)
+    #
+    # This is mainly intended for sharing common conditions between multiple associations.
+    def merge(other)
+      if other.is_a?(Array)
+        to_a & other
+      elsif other
+        spawn.merge!(other)
+      else
+        self
       end
+    end
 
-      merged_relation.lock_value = r.lock_value unless merged_relation.lock_value
-
-      merged_relation = merged_relation.create_with(r.create_with_value) unless r.create_with_value.empty?
-
-      if (r.reordering_value)
-        # override any order specified in the original relation
-        merged_relation.reordering_value = true
-        merged_relation.order_values = r.order_values
+    def merge!(other) # :nodoc:
+      if !other.is_a?(Relation) && other.respond_to?(:to_proc)
+        instance_exec(&other)
       else
-        # merge in order_values from r
-        merged_relation.order_values += r.order_values
+        klass = other.is_a?(Hash) ? Relation::HashMerger : Relation::Merger
+        klass.new(self, other).merge
       end
-
-      # Apply scope extension modules
-      merged_relation.send :apply_modules, r.extensions
-
-      merged_relation
     end
 
     # Removes from the query the condition(s) specified in +skips+.
     #
-    # Example:
-    #
     #   Post.order('id asc').except(:order)                  # discards the order condition
     #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
-    #
     def except(*skips)
-      result = self.class.new(@klass, table)
-      result.default_scoped = default_scoped
-
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - skips).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values"))
-      end
-
-      (Relation::SINGLE_VALUE_METHODS - skips).each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value"))
-      end
-
-      # Apply scope extension modules
-      result.send(:apply_modules, extensions)
-
-      result
+      relation_with values.except(*skips)
     end
 
     # Removes any condition from the query other than the one(s) specified in +onlies+.
     #
-    # Example:
-    #
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
-    #
     def only(*onlies)
-      result = self.class.new(@klass, table)
-      result.default_scoped = default_scoped
-
-      ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) & onlies).each do |method|
-        result.send(:"#{method}_values=", send(:"#{method}_values"))
-      end
-
-      (Relation::SINGLE_VALUE_METHODS & onlies).each do |method|
-        result.send(:"#{method}_value=", send(:"#{method}_value"))
-      end
-
-      # Apply scope extension modules
-      result.send(:apply_modules, extensions)
-
-      result
-    end
-
-    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset, :extend,
-                           :order, :select, :readonly, :group, :having, :from, :lock ]
-
-    def apply_finder_options(options)
-      relation = clone
-      return relation unless options
-
-      options.assert_valid_keys(VALID_FIND_OPTIONS)
-      finders = options.dup
-      finders.delete_if { |key, value| value.nil? && key != :limit }
-
-      ([:joins, :select, :group, :order, :having, :limit, :offset, :from, :lock, :readonly] & finders.keys).each do |finder|
-        relation = relation.send(finder, finders[finder])
-      end
-
-      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
-      relation = relation.includes(finders[:include]) if options.has_key?(:include)
-      relation = relation.extending(finders[:extend]) if options.has_key?(:extend)
-
-      relation
+      relation_with values.slice(*onlies)
     end
 
     private
 
-      def merge_joins(relation, other)
-        values = other.joins_values
-        return if values.blank?
-
-        if other.klass >= relation.klass
-          relation.joins_values += values
-        else
-          joins_dependency, rest = values.partition do |join|
-            case join
-            when Hash, Symbol, Array
-              true
-            else
-              false
-            end
-          end
-
-          join_dependency = ActiveRecord::Associations::JoinDependency.new(
-            other.klass,
-            joins_dependency,
-            []
-          )
-
-          relation.joins_values += join_dependency.join_associations + rest
-        end
-      end
-
-      def merge_relation_method(relation, method, value)
-        relation.send(:"#{method}_values=", relation.send(:"#{method}_values") + value)
+      def relation_with(values) # :nodoc:
+        result = Relation.new(klass, table, values)
+        result.default_scoped = default_scoped
+        result.extend(*extending_values) if extending_values.any?
+        result
       end
   end
 end

data/lib/active_record/result.rb

@@ -8,12 +8,13 @@ module ActiveRecord
   class Result
     include Enumerable
 
-    attr_reader :columns, :rows
+    attr_reader :columns, :rows, :column_types
 
-    def initialize(columns, rows)
-      @columns   = columns
-      @rows      = rows
-      @hash_rows = nil
+    def initialize(columns, rows, column_types = {})
+      @columns      = columns
+      @rows         = rows
+      @hash_rows    = nil
+      @column_types = column_types
     end
 
     def each
@@ -24,12 +25,38 @@ module ActiveRecord
       hash_rows
     end
 
+    alias :map! :map
+    alias :collect! :map
+
+    # Returns true if there are no records.
+    def empty?
+      rows.empty?
+    end
+
+    def to_ary
+      hash_rows
+    end
+
+    def [](idx)
+      hash_rows[idx]
+    end
+
+    def last
+      hash_rows.last
+    end
+
+    def initialize_copy(other)
+      @columns   = columns.dup
+      @rows      = rows.dup
+      @hash_rows = nil
+    end
+
     private
     def hash_rows
       @hash_rows ||=
         begin
           # We freeze the strings to prevent them getting duped when
-          # used as keys in ActiveRecord::Model's @attributes hash
+          # used as keys in ActiveRecord::Base's @attributes hash
           columns = @columns.map { |c| c.dup.freeze }
           @rows.map { |row|
             Hash[columns.zip(row)]

data/lib/active_record/sanitization.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 module ActiveRecord
   module Sanitization
     extend ActiveSupport::Concern
@@ -19,7 +17,7 @@ module ActiveRecord
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a WHERE clause.
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
-      #   { :name => "foo'bar", :group_id => 4 }  returns "name='foo''bar' and group_id='4'"
+      #   { name: "foo'bar", group_id: 4 }  returns "name='foo''bar' and group_id='4'"
       #   "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
       def sanitize_sql_for_conditions(condition, table_name = self.table_name)
         return nil if condition.blank?
@@ -34,12 +32,12 @@ module ActiveRecord
 
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a SET clause.
-      #   { :name => nil, :group_id => 4 }  returns "name = NULL , group_id='4'"
-      def sanitize_sql_for_assignment(assignments)
+      #   { name: nil, group_id: 4 }  returns "name = NULL , group_id='4'"
+      def sanitize_sql_for_assignment(assignments, default_table_name = self.table_name)
         case assignments
-          when Array; sanitize_sql_array(assignments)
-          when Hash;  sanitize_sql_hash_for_assignment(assignments)
-          else        assignments
+        when Array; sanitize_sql_array(assignments)
+        when Hash;  sanitize_sql_hash_for_assignment(assignments, default_table_name)
+        else        assignments
         end
       end
 
@@ -48,17 +46,17 @@ module ActiveRecord
       # aggregate attribute values.
       # Given:
       #     class Person < ActiveRecord::Base
-      #       composed_of :address, :class_name => "Address",
-      #         :mapping => [%w(address_street street), %w(address_city city)]
+      #       composed_of :address, class_name: "Address",
+      #         mapping: [%w(address_street street), %w(address_city city)]
       #     end
       # Then:
-      #     { :address => Address.new("813 abc st.", "chicago") }
-      #       # => { :address_street => "813 abc st.", :address_city => "chicago" }
+      #     { address: Address.new("813 abc st.", "chicago") }
+      #       # => { address_street: "813 abc st.", address_city: "chicago" }
       def expand_hash_conditions_for_aggregates(attrs)
         expanded_attrs = {}
         attrs.each do |attr, value|
-          unless (aggregation = reflect_on_aggregation(attr.to_sym)).nil?
-            mapping = aggregate_mapping(aggregation)
+          if aggregation = reflect_on_aggregation(attr.to_sym)
+            mapping = aggregation.mapping
             mapping.each do |field_attr, aggregate_attr|
               if mapping.size == 1 && !value.respond_to?(aggregate_attr)
                 expanded_attrs[field_attr] = value
@@ -74,35 +72,35 @@ module ActiveRecord
       end
 
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      #   { :name => "foo'bar", :group_id => 4 }
+      #   { name: "foo'bar", group_id: 4 }
       #     # => "name='foo''bar' and group_id= 4"
-      #   { :status => nil, :group_id => [1,2,3] }
+      #   { status: nil, group_id: [1,2,3] }
       #     # => "status IS NULL and group_id IN (1,2,3)"
-      #   { :age => 13..18 }
+      #   { age: 13..18 }
       #     # => "age BETWEEN 13 AND 18"
       #   { 'other_records.id' => 7 }
       #     # => "`other_records`.`id` = 7"
-      #   { :other_records => { :id => 7 } }
+      #   { other_records: { id: 7 } }
       #     # => "`other_records`.`id` = 7"
       # And for value objects on a composed_of relationship:
-      #   { :address => Address.new("123 abc st.", "chicago") }
+      #   { 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)
         attrs = expand_hash_conditions_for_aggregates(attrs)
 
-        table = Arel::Table.new(table_name).alias(default_table_name)
-        PredicateBuilder.build_from_hash(arel_engine, attrs, table).map { |b|
+        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
+        PredicateBuilder.build_from_hash(self.class, attrs, table).map { |b|
           connection.visitor.accept b
         }.join(' AND ')
       end
       alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
 
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-      #   { :status => nil, :group_id => 1 }
+      #   { status: nil, group_id: 1 }
       #     # => "status = NULL , group_id = 1"
-      def sanitize_sql_hash_for_assignment(attrs)
+      def sanitize_sql_hash_for_assignment(attrs, table)
         attrs.map do |attr, value|
-          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value)}"
+          "#{connection.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value)}"
         end.join(', ')
       end
 
@@ -143,23 +141,6 @@ module ActiveRecord
         end
       end
 
-      def expand_range_bind_variables(bind_vars) #:nodoc:
-        expanded = []
-
-        bind_vars.each do |var|
-          next if var.is_a?(Hash)
-
-          if var.is_a?(Range)
-            expanded << var.first
-            expanded << var.last
-          else
-            expanded << var
-          end
-        end
-
-        expanded
-      end
-
       def quote_bound_value(value, c = connection) #:nodoc:
         if value.respond_to?(:map) && !value.acts_like?(:string)
           if value.respond_to?(:empty?) && value.empty?
@@ -180,15 +161,8 @@ module ActiveRecord
     end
 
     # TODO: Deprecate this
-    def quoted_id #:nodoc:
-      quote_value(id, column_for_attribute(self.class.primary_key))
-    end
-
-    private
-
-    # Quote strings appropriately for SQL statements.
-    def quote_value(value, column = nil)
-      self.class.connection.quote(value, column)
+    def quoted_id
+      self.class.quote_value(id, column_for_attribute(self.class.primary_key))
     end
   end
 end

data/lib/active_record/schema.rb

@@ -1,4 +1,3 @@
-require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Schema
@@ -12,16 +11,16 @@ module ActiveRecord
   #
   #   ActiveRecord::Schema.define do
   #     create_table :authors do |t|
-  #       t.string :name, :null => false
+  #       t.string :name, null: false
   #     end
   #
   #     add_index :authors, :name, :unique
   #
   #     create_table :posts do |t|
-  #       t.integer :author_id, :null => false
+  #       t.integer :author_id, null: false
   #       t.string :subject
   #       t.text :body
-  #       t.boolean :private, :default => false
+  #       t.boolean :private, default: false
   #     end
   #
   #     add_index :posts, :author_id
@@ -30,10 +29,24 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration
+
+    # Returns the migrations paths.
+    #
+    #   ActiveRecord::Schema.new.migrations_paths
+    #   # => ["db/migrate"] # Rails migration path by default.
     def migrations_paths
       ActiveRecord::Migrator.migrations_paths
     end
 
+    def define(info, &block) # :nodoc:
+      instance_eval(&block)
+
+      unless info[:version].blank?
+        initialize_schema_migrations_table
+        assume_migrated_upto_version(info[:version], migrations_paths)
+      end
+    end
+
     # Eval the given block. All methods available to the current connection
     # adapter are available within the block, so you can easily use the
     # database definition DSL to build up your schema (+create_table+,
@@ -42,17 +55,11 @@ module ActiveRecord
     # The +info+ hash is optional, and if given is used to define metadata
     # about the current schema (currently, only the schema's version):
     #
-    #   ActiveRecord::Schema.define(:version => 20380119000001) do
+    #   ActiveRecord::Schema.define(version: 20380119000001) do
     #     ...
     #   end
     def self.define(info={}, &block)
-      schema = new
-      schema.instance_eval(&block)
-
-      unless info[:version].blank?
-        initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], schema.migrations_paths)
-      end
+      new.define(info, &block)
     end
   end
 end