activerecord 1.14.4 → 1.15.0

data/lib/active_record/calculations.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module Calculations #:nodoc:
-    CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset]
+    CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset, :include]
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -9,7 +9,7 @@ module ActiveRecord
       # Count operates using three different approaches. 
       #
       # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-      # * Count by conditions or joins: For backwards compatibility, you can pass in +conditions+ and +joins+ as individual parameters.
+      # * Count by conditions or joins: This API has been deprecated and will be removed in Rails 2.0
       # * Count using options will find the row count matched by the options used.
       #
       # The last approach, count using options, accepts an option hash as the only parameter. The options are:
@@ -29,7 +29,7 @@ module ActiveRecord
       # Examples for counting all:
       #   Person.count         # returns the total count of all people
       #
-      # Examples for count by +conditions+ and +joins+ (for backwards compatibility):
+      # Examples for count by +conditions+ and +joins+ (this has been deprecated):
       #   Person.count("age > 26")  # returns the number of people older than 26
       #   Person.find("age > 26 AND job.salary > 60000", "LEFT JOIN jobs on jobs.person_id = person.id") # returns the total number of rows matching the conditions and joins fetched by SELECT COUNT(*).
       #
@@ -42,29 +42,7 @@ module ActiveRecord
       #
       # Note: Person.count(:all) will not work because it will use :all as the condition.  Use Person.count instead.
       def count(*args)
-        options     = {}
-        column_name = :all
-        # For backwards compatibility, we need to handle both count(conditions=nil, joins=nil) or count(options={}) or count(column_name=:all, options={}).
-        if args.size >= 0 && args.size <= 2
-          if args.first.is_a?(Hash)
-            options     = args.first
-          elsif args[1].is_a?(Hash)
-            options     = args[1]
-            column_name = args.first
-          else
-            # Handle legacy paramter options: def count(conditions=nil, joins=nil)
-            options.merge!(:conditions => args[0]) if args.length > 0
-            options.merge!(:joins => args[1])      if args.length > 1
-          end
-        else
-          raise(ArgumentError, "Unexpected parameters passed to count(*args): expected either count(conditions=nil, joins=nil) or count(options={})")
-        end
-
-        if options[:include] || scope(:find, :include)
-          count_with_associations(options)
-        else
-          calculate(:count, column_name, options)
-        end
+        calculate(:count, *construct_count_options_from_legacy_args(*args))
       end
 
       # Calculates average value on a given column.  The value is returned as a float.  See #calculate for examples with options.
@@ -136,44 +114,115 @@ module ActiveRecord
         column_name     = options[:select] if options[:select]
         column_name     = '*' if column_name == :all
         column          = column_for column_name
-        aggregate       = select_aggregate(operation, column_name, options)
-        aggregate_alias = column_alias_for(operation, column_name)
-        if options[:group]
-          execute_grouped_calculation(operation, column_name, column, aggregate, aggregate_alias, options)
-        else
-          execute_simple_calculation(operation, column_name, column, aggregate, aggregate_alias, options)
+        catch :invalid_query do
+          if options[:group]
+            return execute_grouped_calculation(operation, column_name, column, options)
+          else
+            return execute_simple_calculation(operation, column_name, column, options)
+          end
         end
+        0
       end
 
       protected
-        def construct_calculation_sql(aggregate, aggregate_alias, options) #:nodoc:
-          scope = scope(:find)
-          sql  = "SELECT #{aggregate} AS #{aggregate_alias}"
+        def construct_count_options_from_legacy_args(*args)
+          options     = {}
+          column_name = :all
+
+          # We need to handle
+          #   count()
+          #   count(options={})
+          #   count(column_name=:all, options={})
+          #   count(conditions=nil, joins=nil)      # deprecated
+          if args.size > 2
+            raise ArgumentError, "Unexpected parameters passed to count(options={}): #{args.inspect}"
+          elsif args.size > 0
+            if args[0].is_a?(Hash)
+              options = args[0]
+            elsif args[1].is_a?(Hash)
+              column_name, options = args
+            else
+              # Deprecated count(conditions, joins=nil)
+              ActiveSupport::Deprecation.warn(
+                "You called count(#{args[0].inspect}, #{args[1].inspect}), which is a deprecated API call. " +
+                "Instead you should use count(column_name, options). Passing the conditions and joins as " +
+                "string parameters will be removed in Rails 2.0.", caller(2)
+              )
+              options.merge!(:conditions => args[0])
+              options.merge!(:joins      => args[1]) if args[1]
+            end
+          end
+
+          [column_name, options]
+        end
+
+        def construct_calculation_sql(operation, column_name, options) #:nodoc:
+          operation = operation.to_s.downcase
+          options = options.symbolize_keys          
+          
+          scope           = scope(:find)
+          merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
+          aggregate_alias = column_alias_for(operation, column_name)
+          use_workaround  = !Base.connection.supports_count_distinct? && options[:distinct] && operation.to_s.downcase == 'count'
+          join_dependency = nil
+
+          if merged_includes.any? && operation.to_s.downcase == 'count'
+            options[:distinct] = true
+            column_name = options[:select] || [table_name, primary_key] * '.'
+          end
+
+          sql  = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
+
+          # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
+          sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
+          
           sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
+          sql << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
           sql << " FROM #{table_name} "
+          if merged_includes.any?
+            join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
+            sql << join_dependency.join_associations.collect{|join| join.association_join }.join
+          end
           add_joins!(sql, options, scope)
           add_conditions!(sql, options[:conditions], scope)
-          sql << " GROUP BY #{options[:group_field]}" if options[:group]
-          sql << " HAVING #{options[:having]}" if options[:group] && options[:having]
-          sql << " ORDER BY #{options[:order]}" if options[:order]
-          add_limit!(sql, options)
+          add_limited_ids_condition!(sql, options, join_dependency) if join_dependency && !using_limitable_reflections?(join_dependency.reflections) && ((scope && scope[:limit]) || options[:limit])
+
+          if options[:group]
+            group_key = Base.connection.adapter_name == 'FrontBase' ?  :group_alias : :group_field
+            sql << " GROUP BY #{options[group_key]} "
+          end
+
+          if options[:group] && options[:having]
+            # FrontBase requires identifiers in the HAVING clause and chokes on function calls
+            if Base.connection.adapter_name == 'FrontBase'
+              options[:having].downcase!
+              options[:having].gsub!(/#{operation}\s*\(\s*#{column_name}\s*\)/, aggregate_alias)
+            end
+              
+            sql << " HAVING #{options[:having]} "
+          end
+
+          sql << " ORDER BY #{options[:order]} "       if options[:order]
+          add_limit!(sql, options, scope)
+          sql << ')' if use_workaround
           sql
         end
 
-        def execute_simple_calculation(operation, column_name, column, aggregate, aggregate_alias, options) #:nodoc:
-          value     = connection.select_value(construct_calculation_sql(aggregate, aggregate_alias, options))
+        def execute_simple_calculation(operation, column_name, column, options) #:nodoc:
+          value = connection.select_value(construct_calculation_sql(operation, column_name, options))
           type_cast_calculated_value(value, column, operation)
         end
 
-        def execute_grouped_calculation(operation, column_name, column, aggregate, aggregate_alias, options) #:nodoc:
+        def execute_grouped_calculation(operation, column_name, column, options) #:nodoc:
           group_attr      = options[:group].to_s
           association     = reflect_on_association(group_attr.to_sym)
           associated      = association && association.macro == :belongs_to # only count belongs_to associations
           group_field     = (associated ? "#{options[:group]}_id" : options[:group]).to_s
           group_alias     = column_alias_for(group_field)
           group_column    = column_for group_field
-          sql             = construct_calculation_sql(aggregate, aggregate_alias, options.merge(:group_field => group_field, :group_alias => group_alias))
+          sql             = construct_calculation_sql(operation, column_name, options.merge(:group_field => group_field, :group_alias => group_alias))
           calculated_data = connection.select_all(sql)
+          aggregate_alias = column_alias_for(operation, column_name)
 
           if association
             key_ids     = calculated_data.collect { |row| row[group_alias] }
@@ -181,7 +230,7 @@ module ActiveRecord
             key_records = key_records.inject({}) { |hsh, r| hsh.merge(r.id => r) }
           end
 
-          calculated_data.inject(OrderedHash.new) do |all, row|
+          calculated_data.inject(ActiveSupport::OrderedHash.new) do |all, row|
             key   = associated ? key_records[row[group_alias].to_i] : type_cast_calculated_value(row[group_alias], group_column)
             value = row[aggregate_alias]
             all << [key, type_cast_calculated_value(value, column, operation)]
@@ -190,15 +239,7 @@ module ActiveRecord
 
       private
         def validate_calculation_options(operation, options = {})
-          if operation.to_s == 'count'
-            options.assert_valid_keys(CALCULATIONS_OPTIONS + [:include])
-          else
-            options.assert_valid_keys(CALCULATIONS_OPTIONS)
-          end
-        end
-
-        def select_aggregate(operation, column_name, options)
-          "#{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name})"
+          options.assert_valid_keys(CALCULATIONS_OPTIONS)
         end
 
         # converts a given key to the value that the database adapter returns as
@@ -208,7 +249,7 @@ module ActiveRecord
         #   count(distinct users.id) #=> count_distinct_users_id
         #   count(*) #=> count_all
         def column_alias_for(*keys)
-          keys.join(' ').downcase.gsub(/\*/, 'all').gsub(/\W+/, ' ').strip.gsub(/ +/, '_')
+          connection.table_alias_for(keys.join(' ').downcase.gsub(/\*/, 'all').gsub(/\W+/, ' ').strip.gsub(/ +/, '_'))
         end
 
         def column_for(field)

data/lib/active_record/callbacks.rb

@@ -158,6 +158,12 @@ module ActiveRecord
   # after_initialize will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
   # callback types will be called.
   #
+  # == before_validation* returning statements
+  #
+  # If the returning value of a before_validation callback can be evaluated to false, the process will be aborted and Base#save will return false.
+  # If Base#save! is called it will raise a RecordNotSave error.
+  # Nothing will be appended to the errors object.
+  #
   # == Cancelling callbacks
   #
   # If a before_* callback returns false, all the later callbacks and the associated action are cancelled. If an after_* callback returns
@@ -170,34 +176,17 @@ module ActiveRecord
       after_validation_on_update before_destroy after_destroy
     )
 
-    def self.append_features(base) #:nodoc:
-      super
-
+    def self.included(base) #:nodoc:
       base.extend(ClassMethods)
       base.class_eval do
         class << self
           include Observable
-          alias_method :instantiate_without_callbacks, :instantiate
-          alias_method :instantiate, :instantiate_with_callbacks
+          alias_method_chain :instantiate, :callbacks
         end
 
-        alias_method :initialize_without_callbacks, :initialize
-        alias_method :initialize, :initialize_with_callbacks
-
-        alias_method :create_or_update_without_callbacks, :create_or_update
-        alias_method :create_or_update, :create_or_update_with_callbacks
-
-        alias_method :valid_without_callbacks, :valid?
-        alias_method :valid?, :valid_with_callbacks
-
-        alias_method :create_without_callbacks, :create
-        alias_method :create, :create_with_callbacks
-
-        alias_method :update_without_callbacks, :update
-        alias_method :update, :update_with_callbacks
-
-        alias_method :destroy_without_callbacks, :destroy
-        alias_method :destroy, :destroy_with_callbacks
+        [:initialize, :create_or_update, :valid?, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
       end
 
       CALLBACKS.each do |method|
@@ -302,12 +291,12 @@ module ActiveRecord
     # existing objects that have a record.
     def after_validation_on_update()  end
 
-    def valid_with_callbacks #:nodoc:
+    def valid_with_callbacks? #:nodoc:
       return false if callback(:before_validation) == false
       if new_record? then result = callback(:before_validation_on_create) else result = callback(:before_validation_on_update) end
       return false if result == false
 
-      result = valid_without_callbacks
+      result = valid_without_callbacks?
 
       callback(:after_validation)
       if new_record? then callback(:after_validation_on_create) else callback(:after_validation_on_update) end

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

@@ -86,6 +86,16 @@ module ActiveRecord
           conn.disconnect!
         end
       end
+      
+      # Clears the cache which maps classes 
+      def clear_reloadable_connections!
+        @@active_connections.each do |name, conn|
+          if conn.requires_reloading?
+            conn.disconnect!
+            @@active_connections.delete(name)
+          end
+        end
+      end
 
       # Verify active connections.
       def verify_active_connections! #:nodoc:
@@ -248,7 +258,8 @@ module ActiveRecord
       if spec.kind_of?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
         active_connections[name] = spec
       elsif spec.kind_of?(ConnectionSpecification)
-        self.connection = self.send(spec.adapter_method, spec.config)
+        config = spec.config.reverse_merge(:allow_concurrency => @@allow_concurrency)
+        self.connection = self.send(spec.adapter_method, config)
       elsif spec.nil?
         raise ConnectionNotEstablished
       else

data/lib/active_record/connection_adapters/abstract/connection_specification.rb.rej

@@ -0,0 +1,21 @@
+***************
+*** 90,97 ****
+        # Clears the cache which maps classes 
+        def clear_reloadable_connections!
+          @@active_connections.each do |name, conn|
+-           conn.disconnect! if conn.supports_reloading?
+-           @@active_connections.delete(name)
+          end
+        end
+  
+--- 90,99 ----
+        # Clears the cache which maps classes 
+        def clear_reloadable_connections!
+          @@active_connections.each do |name, conn|
++           if conn.requires_reloading?
++             conn.disconnect!
++             @@active_connections.delete(name)
++           end
+          end
+        end
+  

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

@@ -4,11 +4,14 @@ module ActiveRecord
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
       def select_all(sql, name = nil)
+        select(sql, name)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
       def select_one(sql, name = nil)
+        result = select(sql, name)
+        result.first if result
       end
 
       # Returns a single value from a record
@@ -25,19 +28,24 @@ module ActiveRecord
       end
 
       # Executes the SQL statement in the context of this connection.
-      # This abstract method raises a NotImplementedError.
       def execute(sql, name = nil)
         raise NotImplementedError, "execute is an abstract method"
       end
 
       # Returns the last auto-generated ID from the affected table.
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) end
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        raise NotImplementedError, "insert is an abstract method"
+      end
 
       # Executes the update statement and returns the number of rows affected.
-      def update(sql, name = nil) end
+      def update(sql, name = nil)
+        execute(sql, name)
+      end
 
       # Executes the delete statement and returns the number of rows affected.
-      def delete(sql, name = nil) end
+      def delete(sql, name = nil)
+        update(sql, name)
+      end
 
       # Wrap a block in a transaction.  Returns result of block.
       def transaction(start_db_transaction = true)
@@ -91,6 +99,17 @@ module ActiveRecord
         end
       end
 
+      # Appends a locking clause to a SQL statement. *Modifies the +sql+ parameter*.
+      #   # SELECT * FROM suppliers FOR UPDATE
+      #   add_lock! 'SELECT * FROM suppliers', :lock => true
+      #   add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
+      def add_lock!(sql, options)
+        case lock = options[:lock]
+          when true:   sql << ' FOR UPDATE'
+          when String: sql << " #{lock}"
+        end
+      end
+
       def default_sequence_name(table, column)
         nil
       end
@@ -99,6 +118,13 @@ module ActiveRecord
       def reset_sequence!(table, column, sequence = nil)
         # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
       end
+
+      protected
+        # Returns an array of record hashes with the column names as keys and
+        # column values as values.
+        def select(sql, name = nil)
+          raise NotImplementedError, "select is an abstract method"
+        end
     end
   end
 end

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

@@ -4,22 +4,29 @@ module ActiveRecord
       # Quotes the column value to help prevent
       # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
       def quote(value, column = nil)
+        # records are quoted as their primary key
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
         case value
-          when String
+          when String, ActiveSupport::Multibyte::Chars
+            value = value.to_s
             if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
               "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
-            elsif column && [:integer, :float].include?(column.type) 
+            elsif column && [:integer, :float].include?(column.type)
+              value = column.type == :integer ? value.to_i : value.to_f
               value.to_s
             else
               "'#{quote_string(value)}'" # ' (for ruby-mode)
             end
-          when NilClass              then "NULL"
-          when TrueClass             then (column && column.type == :integer ? '1' : quoted_true)
-          when FalseClass            then (column && column.type == :integer ? '0' : quoted_false)
-          when Float, Fixnum, Bignum then value.to_s
-          when Date                  then "'#{value.to_s}'"
-          when Time, DateTime        then "'#{quoted_date(value)}'"
-          else                            "'#{quote_string(value.to_yaml)}'"
+          when NilClass                 then "NULL"
+          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
+          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
+          when Float, Fixnum, Bignum    then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal               then value.to_s('F')
+          when Date                     then "'#{value.to_s}'"
+          when Time, DateTime           then "'#{quoted_date(value)}'"
+          else                          "'#{quote_string(value.to_yaml)}'"
         end
       end