activerecord 3.1.12 → 3.2.0.rc1

data/lib/active_record/relation/predicate_builder.rb

@@ -1,47 +1,44 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
+    def self.build_from_hash(engine, attributes, default_table)
       predicates = attributes.map do |column, value|
         table = default_table
 
-        if allow_table_name && value.is_a?(Hash)
+        if value.is_a?(Hash)
           table = Arel::Table.new(column, engine)
-
-          if value.empty?
-            '1 = 2'
-          else
-            build_from_hash(engine, value, table, false)
-          end
+          build_from_hash(engine, value, table)
         else
           column = column.to_s
 
-          if allow_table_name && column.include?('.')
+          if column.include?('.')
             table_name, column = column.split('.', 2)
             table = Arel::Table.new(table_name, engine)
           end
 
-          attribute = table[column]
+          attribute = table[column.to_sym]
 
           case value
           when ActiveRecord::Relation
             value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
             attribute.in(value.arel.ast)
           when Array, ActiveRecord::Associations::CollectionProxy
-            values = value.to_a.map { |x|
-              x.is_a?(ActiveRecord::Base) ? x.id : x
-            }
+            values = value.to_a.map {|x| x.is_a?(ActiveRecord::Base) ? x.id : x}
+            ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
+
+            array_predicates = ranges.map {|range| attribute.in(range)}
 
             if values.include?(nil)
               values = values.compact
               if values.empty?
-                attribute.eq nil
+                array_predicates << attribute.eq(nil)
               else
-                attribute.in(values.compact).or attribute.eq(nil)
+                array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
               end
             else
-              attribute.in(values)
+              array_predicates << attribute.in(values)
             end
 
+            array_predicates.inject {|composite, predicate| composite.or(predicate)}
           when Range, Arel::Relation
             attribute.in(value)
           when ActiveRecord::Base

data/lib/active_record/relation/query_methods.rb

@@ -9,7 +9,8 @@ module ActiveRecord
                   :select_values, :group_values, :order_values, :joins_values,
                   :where_values, :having_values, :bind_values,
                   :limit_value, :offset_value, :lock_value, :readonly_value, :create_with_value,
-                  :from_value, :reorder_value, :reverse_order_value
+                  :from_value, :reorder_value, :reverse_order_value,
+                  :uniq_value
 
     def includes(*args)
       args.reject! {|a| a.blank? }
@@ -38,7 +39,7 @@ module ActiveRecord
     end
 
     # Works in two unique ways.
-    # 
+    #
     # First: takes a block so it can be used just like Array#select.
     #
     #   Model.scoped.select { |m| m.field == value }
@@ -176,6 +177,58 @@ module ActiveRecord
       relation
     end
 
+    # Specifies whether the records should be unique or not. For example:
+    #
+    #   User.select(:name)
+    #   # => Might return two records with the same name
+    #
+    #   User.select(:name).uniq
+    #   # => Returns 1 record per unique name
+    #
+    #   User.select(:name).uniq.uniq(false)
+    #   # => You can also remove the uniqueness
+    def uniq(value = true)
+      relation = clone
+      relation.uniq_value = value
+      relation
+    end
+
+    # Used to extend a scope with additional methods, either through
+    # a module or through a block provided.
+    #
+    # The object returned is a relation, which can be further extended.
+    #
+    # === Using a module
+    #
+    #   module Pagination
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #
+    #   scope = Model.scoped.extending(Pagination)
+    #   scope.page(params[:page])
+    #
+    # You can also pass a list of modules:
+    #
+    #   scope = Model.scoped.extending(Pagination, SomethingElse)
+    #
+    # === Using a block
+    #
+    #   scope = Model.scoped.extending do
+    #     def page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
+    #   scope.page(params[:page])
+    #
+    # You can also use a block and a module list:
+    #
+    #   scope = Model.scoped.extending(Pagination) do
+    #     def per_page(number)
+    #       # pagination code goes here
+    #     end
+    #   end
     def extending(*modules)
       modules << Module.new(&Proc.new) if block_given?
 
@@ -206,7 +259,7 @@ module ActiveRecord
       arel.having(*@having_values.uniq.reject{|h| h.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.skip(@offset_value) if @offset_value
 
       arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
 
@@ -216,6 +269,7 @@ module ActiveRecord
 
       build_select(arel, @select_values.uniq)
 
+      arel.distinct(@uniq_value)
       arel.from(@from_value) if @from_value
       arel.lock(@lock_value) if @lock_value
 
@@ -331,10 +385,11 @@ module ActiveRecord
 
       order_query.map do |o|
         case o
-        when Arel::Nodes::Ascending, Arel::Nodes::Descending
+        when Arel::Nodes::Ordering
           o.reverse
         when String, Symbol
           o.to_s.split(',').collect do |s|
+            s.strip!
             s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
           end
         else

data/lib/active_record/result.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   ###
   # This class encapsulates a Result returned from calling +exec_query+ on any
-  # database connection adapter.  For example:
+  # database connection adapter. For example:
   #
   #   x = ActiveRecord::Base.connection.exec_query('SELECT * FROM foo')
   #   x # => #<ActiveRecord::Result:0xdeadbeef>

data/lib/active_record/sanitization.rb

@@ -0,0 +1,194 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Sanitization
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def quote_value(value, column = nil) #:nodoc:
+        connection.quote(value,column)
+      end
+
+      # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
+      def sanitize(object) #:nodoc:
+        connection.quote(object)
+      end
+
+      protected
+
+      # 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' 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?
+
+        case condition
+        when Array; sanitize_sql_array(condition)
+        when Hash;  sanitize_sql_hash_for_conditions(condition, table_name)
+        else        condition
+        end
+      end
+      alias_method :sanitize_sql, :sanitize_sql_for_conditions
+
+      # 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)
+        case assignments
+          when Array; sanitize_sql_array(assignments)
+          when Hash;  sanitize_sql_hash_for_assignment(assignments)
+          else        assignments
+        end
+      end
+
+      # Accepts a hash of SQL conditions and replaces those attributes
+      # that correspond to a +composed_of+ relationship with their expanded
+      # aggregate attribute values.
+      # Given:
+      #     class Person < ActiveRecord::Base
+      #       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" }
+      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)
+            mapping.each do |field_attr, aggregate_attr|
+              if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+                expanded_attrs[field_attr] = value
+              else
+                expanded_attrs[field_attr] = value.send(aggregate_attr)
+              end
+            end
+          else
+            expanded_attrs[attr] = value
+          end
+        end
+        expanded_attrs
+      end
+
+      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
+      #   { :name => "foo'bar", :group_id => 4 }
+      #     # => "name='foo''bar' and group_id= 4"
+      #   { :status => nil, :group_id => [1,2,3] }
+      #     # => "status IS NULL and group_id IN (1,2,3)"
+      #   { :age => 13..18 }
+      #     # => "age BETWEEN 13 AND 18"
+      #   { '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_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|
+          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 = NULL , group_id = 1"
+      def sanitize_sql_hash_for_assignment(attrs)
+        attrs.map do |attr, value|
+          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value)}"
+        end.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'"
+      def sanitize_sql_array(ary)
+        statement, *values = ary
+        if values.first.is_a?(Hash) && statement =~ /:\w+/
+          replace_named_bind_variables(statement, values.first)
+        elsif statement.include?('?')
+          replace_bind_variables(statement, values)
+        elsif statement.blank?
+          statement
+        else
+          statement % values.collect { |value| connection.quote_string(value.to_s) }
+        end
+      end
+
+      alias_method :sanitize_conditions, :sanitize_sql
+
+      def replace_bind_variables(statement, values) #:nodoc:
+        raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
+        bound = values.dup
+        c = connection
+        statement.gsub('?') { quote_bound_value(bound.shift, c) }
+      end
+
+      def replace_named_bind_variables(statement, bind_vars) #:nodoc:
+        statement.gsub(/(:?):([a-zA-Z]\w*)/) do
+          if $1 == ':' # skip postgresql casts
+            $& # return the whole match
+          elsif bind_vars.include?(match = $2.to_sym)
+            quote_bound_value(bind_vars[match])
+          else
+            raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
+          end
+        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?
+            c.quote(nil)
+          else
+            value.map { |v| c.quote(v) }.join(',')
+          end
+        else
+          c.quote(value)
+        end
+      end
+
+      def raise_if_bind_arity_mismatch(statement, expected, provided) #:nodoc:
+        unless expected == provided
+          raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
+        end
+      end
+    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)
+    end
+  end
+end

data/lib/active_record/schema_dumper.rb

@@ -40,7 +40,7 @@ module ActiveRecord
       def header(stream)
         define_params = @version ? ":version => #{@version}" : ""
 
-        if stream.respond_to?(:external_encoding) && stream.external_encoding
+        if stream.respond_to?(:external_encoding)
           stream.puts "# encoding: #{stream.external_encoding.name}"
         end
 
@@ -110,7 +110,7 @@ HEADER
             spec = {}
             spec[:name]      = column.name.inspect
 
-            # AR has an optimisation which handles zero-scale decimals as integers.  This
+            # AR has an optimization which handles zero-scale decimals as integers. This
             # code ensures that the dumper still dumps the column as a decimal.
             spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
                                  'decimal'
@@ -190,6 +190,9 @@ HEADER
             index_lengths = (index.lengths || []).compact
             statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
 
+            index_orders = (index.orders || {})
+            statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
+
             '  ' + statement_parts.join(', ')
           end
 

data/lib/active_record/scoping.rb

@@ -0,0 +1,152 @@
+require 'active_support/concern'
+
+module ActiveRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+    end
+
+    module ClassMethods
+      # with_scope lets you apply options to inner block incrementally. It takes a hash and the keys must be
+      # <tt>:find</tt> or <tt>:create</tt>. <tt>:find</tt> parameter is <tt>Relation</tt> while
+      # <tt>:create</tt> parameters are an attributes hash.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.create_with_scope
+      #       with_scope(:find => where(:blog_id => 1), :create => { :blog_id => 1 }) do
+      #         find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
+      #         a = create(1)
+      #         a.blog_id # => 1
+      #       end
+      #     end
+      #   end
+      #
+      # In nested scopings, all previous parameters are overwritten by the innermost rule, with the exception of
+      # <tt>where</tt>, <tt>includes</tt>, and <tt>joins</tt> operations in <tt>Relation</tt>, which are merged.
+      #
+      # <tt>joins</tt> operations are uniqued so multiple scopes can join in the same table without table aliasing
+      # problems. If you need to join multiple tables, but still want one of the tables to be uniqued, use the
+      # array of strings format for your joins.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1), :create => { :blog_id => 1 }) do
+      #         with_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 LIMIT 10
+      #         end
+      #         with_scope(:find => where(:author_id => 3)) do
+      #           all # => SELECT * from articles WHERE blog_id = 1 AND author_id = 3 LIMIT 1
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # You can ignore any previous scopings by using the <tt>with_exclusive_scope</tt> method.
+      #
+      #   class Article < ActiveRecord::Base
+      #     def self.find_with_exclusive_scope
+      #       with_scope(:find => where(:blog_id => 1).limit(1)) do
+      #         with_exclusive_scope(:find => limit(10)) do
+      #           all # => SELECT * from articles LIMIT 10
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
+      def with_scope(scope = {}, action = :merge, &block)
+        # If another Active Record class has been passed in, get its current scope
+        scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
+
+        previous_scope = self.current_scope
+
+        if scope.is_a?(Hash)
+          # Dup first and second level of hash (method and params).
+          scope = scope.dup
+          scope.each do |method, params|
+            scope[method] = params.dup unless params == true
+          end
+
+          scope.assert_valid_keys([ :find, :create ])
+          relation = construct_finder_arel(scope[:find] || {})
+          relation.default_scoped = true unless action == :overwrite
+
+          if previous_scope && previous_scope.create_with_value && scope[:create]
+            scope_for_create = if action == :merge
+              previous_scope.create_with_value.merge(scope[:create])
+            else
+              scope[:create]
+            end
+
+            relation = relation.create_with(scope_for_create)
+          else
+            scope_for_create = scope[:create]
+            scope_for_create ||= previous_scope.create_with_value if previous_scope
+            relation = relation.create_with(scope_for_create) if scope_for_create
+          end
+
+          scope = relation
+        end
+
+        scope = previous_scope.merge(scope) if previous_scope && action == :merge
+
+        self.current_scope = scope
+        begin
+          yield
+        ensure
+          self.current_scope = previous_scope
+        end
+      end
+
+      protected
+
+      # Works like with_scope, but discards any nested properties.
+      def with_exclusive_scope(method_scoping = {}, &block)
+        if method_scoping.values.any? { |e| e.is_a?(ActiveRecord::Relation) }
+          raise ArgumentError, <<-MSG
+  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+
+  User.unscoped.where(:active => true)
+
+  Or call unscoped with a block:
+
+  User.unscoped do
+  User.where(:active => true).all
+  end
+
+  MSG
+        end
+        with_scope(method_scoping, :overwrite, &block)
+      end
+
+      def current_scope #:nodoc:
+        Thread.current["#{self}_current_scope"]
+      end
+
+      def current_scope=(scope) #:nodoc:
+        Thread.current["#{self}_current_scope"] = scope
+      end
+
+      private
+
+      def construct_finder_arel(options = {}, scope = nil)
+        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
+        relation = scope.merge(relation) if scope
+        relation
+      end
+
+    end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att,value|
+        send("#{att}=", value) if respond_to?("#{att}=")
+      end
+    end
+
+  end
+end