activerecord 2.3.18 → 3.2.22

data/lib/active_record/counter_cache.rb

@@ -0,0 +1,123 @@
+module ActiveRecord
+  # = Active Record Counter Cache
+  module CounterCache
+    # Resets one or more counter caches to their correct value using an SQL
+    # count query. This is useful when adding new counter caches, or if the
+    # counter has been corrupted or modified directly by SQL.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - The id of the object you wish to reset a counter on.
+    # * +counters+ - One or more counter names to reset
+    #
+    # ==== Examples
+    #
+    #   # For Post with id #1 records reset the comments_count
+    #   Post.reset_counters(1, :comments)
+    def reset_counters(id, *counters)
+      object = find(id)
+      counters.each do |association|
+        has_many_association = reflect_on_association(association.to_sym)
+
+        if has_many_association.options[:as]
+          has_many_association.options[:as].to_s.classify
+        else
+          self.name
+        end
+
+        if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection
+          has_many_association = has_many_association.through_reflection
+        end
+
+        foreign_key  = has_many_association.foreign_key.to_s
+        child_class  = has_many_association.klass
+        belongs_to   = child_class.reflect_on_all_associations(:belongs_to)
+        reflection   = belongs_to.find { |e| e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
+        counter_name = reflection.counter_cache_column
+
+        stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
+          arel_table[counter_name] => object.send(association).count
+        })
+        connection.update stmt
+      end
+      return true
+    end
+
+    # A generic "counter updater" implementation, intended primarily to be
+    # used by increment_counter and decrement_counter, but which may also
+    # be useful on its own. It simply does a direct SQL update for the record
+    # with the given ID, altering the given hash of counters by the amount
+    # given by the corresponding value:
+    #
+    # ==== Parameters
+    #
+    # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
+    # * +counters+ - An Array of Hashes containing the names of the fields
+    #   to update as keys and the amount to update the field by as values.
+    #
+    # ==== Examples
+    #
+    #   # For the Post with id of 5, decrement the comment_count by 1, and
+    #   # increment the action_count by 1
+    #   Post.update_counters 5, :comment_count => -1, :action_count => 1
+    #   # Executes the following SQL:
+    #   # UPDATE posts
+    #   #    SET comment_count = COALESCE(comment_count, 0) - 1,
+    #   #        action_count = COALESCE(action_count, 0) + 1
+    #   #  WHERE id = 5
+    #
+    #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+    #   Post.update_counters [10, 15], :comment_count => 1
+    #   # Executes the following SQL:
+    #   # UPDATE posts
+    #   #    SET comment_count = COALESCE(comment_count, 0) + 1
+    #   #  WHERE id IN (10, 15)
+    def update_counters(id, counters)
+      updates = counters.map do |counter_name, value|
+        operator = value < 0 ? '-' : '+'
+        quoted_column = connection.quote_column_name(counter_name)
+        "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+      end
+
+      IdentityMap.remove_by_id(symbolized_base_class, id) if IdentityMap.enabled?
+
+      update_all(updates.join(', '), primary_key => id )
+    end
+
+    # Increment a number field by one, usually representing a count.
+    #
+    # This is used for caching aggregate values, so that they don't need to be computed every time.
+    # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
+    # shown it would have to run an SQL query to find how many posts and comments there are.
+    #
+    # ==== Parameters
+    #
+    # * +counter_name+ - The name of the field that should be incremented.
+    # * +id+ - The id of the object that should be incremented.
+    #
+    # ==== Examples
+    #
+    #   # Increment the post_count column for the record with an id of 5
+    #   DiscussionBoard.increment_counter(:post_count, 5)
+    def increment_counter(counter_name, id)
+      update_counters(id, counter_name => 1)
+    end
+
+    # Decrement a number field by one, usually representing a count.
+    #
+    # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
+    #
+    # ==== Parameters
+    #
+    # * +counter_name+ - The name of the field that should be decremented.
+    # * +id+ - The id of the object that should be decremented.
+    #
+    # ==== Examples
+    #
+    #   # Decrement the post_count column for the record with an id of 5
+    #   DiscussionBoard.decrement_counter(:post_count, 5)
+    def decrement_counter(counter_name, id)
+      update_counters(id, counter_name => -1)
+    end
+  end
+end

data/lib/active_record/dynamic_finder_match.rb

@@ -1,41 +1,68 @@
 module ActiveRecord
+
+  # = Active Record Dynamic Finder Match
+  #
+  # Refer to ActiveRecord::Base documentation for Dynamic attribute-based finders for detailed info
+  #
   class DynamicFinderMatch
     def self.match(method)
-      df_match = self.new(method)
-      df_match.finder ? df_match : nil
-    end
+      finder       = :first
+      bang         = false
+      instantiator = nil
 
-    def initialize(method)
-      @finder = :first
       case method.to_s
-      when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
-        @finder = :last if $1 == 'last_by'
-        @finder = :all if $1 == 'all_by'
+      when /^find_(all_|last_)?by_([_a-zA-Z]\w*)$/
+        finder = :last if $1 == 'last_'
+        finder = :all if $1 == 'all_'
         names = $2
       when /^find_by_([_a-zA-Z]\w*)\!$/
-        @bang = true
+        bang = true
+        names = $1
+      when /^find_or_create_by_([_a-zA-Z]\w*)\!$/
+        bang = true
+        instantiator = :create
         names = $1
       when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
-        @instantiator = $1 == 'initialize' ? :new : :create
+        instantiator = $1 == 'initialize' ? :new : :create
         names = $2
       else
-        @finder = nil
+        return nil
       end
-      @attribute_names = names && names.split('_and_')
+
+      new(finder, instantiator, bang, names.split('_and_'))
+    end
+
+    def initialize(finder, instantiator, bang, attribute_names)
+      @finder          = finder
+      @instantiator    = instantiator
+      @bang            = bang
+      @attribute_names = attribute_names
     end
 
     attr_reader :finder, :attribute_names, :instantiator
 
     def finder?
-      !@finder.nil? && @instantiator.nil?
+      @finder && !@instantiator
     end
 
     def instantiator?
-      @finder == :first && !@instantiator.nil?
+      @finder == :first && @instantiator
+    end
+
+    def creator?
+      @finder == :first && @instantiator == :create
     end
 
     def bang?
       @bang
     end
+
+    def save_record?
+      @instantiator == :create
+    end
+
+    def save_method
+      bang? ? :save! : :save
+    end
   end
 end

data/lib/active_record/dynamic_matchers.rb

@@ -0,0 +1,84 @@
+module ActiveRecord
+  module DynamicMatchers
+    def respond_to?(method_id, include_private = false)
+      if match = DynamicFinderMatch.match(method_id)
+        return true if all_attributes_exists?(match.attribute_names)
+      elsif match = DynamicScopeMatch.match(method_id)
+        return true if all_attributes_exists?(match.attribute_names)
+      end
+
+      super
+    end
+
+    private
+
+    # Enables dynamic finders like <tt>User.find_by_user_name(user_name)</tt> and
+    # <tt>User.scoped_by_user_name(user_name). Refer to Dynamic attribute-based finders
+    # section at the top of this file for more detailed information.
+    #
+    # It's even possible to use all the additional parameters to +find+. For example, the
+    # full interface for +find_all_by_amount+ is actually <tt>find_all_by_amount(amount, options)</tt>.
+    #
+    # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it
+    # is first invoked, so that future attempts to use it do not run through method_missing.
+    def method_missing(method_id, *arguments, &block)
+      if match = (DynamicFinderMatch.match(method_id) || DynamicScopeMatch.match(method_id))
+        attribute_names = match.attribute_names
+        super unless all_attributes_exists?(attribute_names)
+        if !(match.is_a?(DynamicFinderMatch) && match.instantiator? && arguments.first.is_a?(Hash)) && arguments.size < attribute_names.size
+          method_trace = "#{__FILE__}:#{__LINE__}:in `#{method_id}'"
+          backtrace = [method_trace] + caller
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{attribute_names.size})", backtrace
+        end
+        if match.respond_to?(:scope?) && match.scope?
+          self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
+              attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
+                                                                            #
+              scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
+            end                                                             # end
+          METHOD
+          send(method_id, *arguments)
+        elsif match.finder?
+          options = if arguments.length > attribute_names.size
+                      arguments.extract_options!
+                    else
+                      {}
+                    end
+
+          relation = options.any? ? scoped(options) : scoped
+          relation.send :find_by_attributes, match, attribute_names, *arguments, &block
+        elsif match.instantiator?
+          scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
+        end
+      else
+        super
+      end
+    end
+
+    # Similar in purpose to +expand_hash_conditions_for_aggregates+.
+    def expand_attribute_names_for_aggregates(attribute_names)
+      attribute_names.map { |attribute_name|
+        unless (aggregation = reflect_on_aggregation(attribute_name.to_sym)).nil?
+          aggregate_mapping(aggregation).map do |field_attr, _|
+            field_attr.to_sym
+          end
+        else
+          attribute_name.to_sym
+        end
+      }.flatten
+    end
+
+    def all_attributes_exists?(attribute_names)
+      (expand_attribute_names_for_aggregates(attribute_names) -
+       column_methods_hash.keys).empty?
+    end
+
+    def aggregate_mapping(reflection)
+      mapping = reflection.options[:mapping] || [reflection.name, reflection.name]
+      mapping.first.is_a?(Array) ? mapping : [mapping]
+    end
+
+
+  end
+end

data/lib/active_record/dynamic_scope_match.rb

@@ -1,25 +1,23 @@
 module ActiveRecord
+
+  # = Active Record Dynamic Scope Match
+  #
+  # Provides dynamic attribute-based scopes such as <tt>scoped_by_price(4.99)</tt>
+  # if, for example, the <tt>Product</tt> has an attribute with that name. You can
+  # chain more <tt>scoped_by_* </tt> methods after the other. It acts like a named
+  # scope except that it's dynamic.
   class DynamicScopeMatch
     def self.match(method)
-      ds_match = self.new(method)
-      ds_match.scope ? ds_match : nil
+      return unless method.to_s =~ /^scoped_by_([_a-zA-Z]\w*)$/
+      new(true, $1 && $1.split('_and_'))
     end
 
-    def initialize(method)
-      @scope = true
-      case method.to_s
-      when /^scoped_by_([_a-zA-Z]\w*)$/
-        names = $1
-      else
-        @scope = nil
-      end
-      @attribute_names = names && names.split('_and_')
+    def initialize(scope, attribute_names)
+      @scope           = scope
+      @attribute_names = attribute_names
     end
 
     attr_reader :scope, :attribute_names
-
-    def scope?
-      !@scope.nil?
-    end
+    alias :scope? :scope
   end
 end

data/lib/active_record/errors.rb

@@ -0,0 +1,195 @@
+module ActiveRecord
+
+  # = Active Record Errors
+  #
+  # Generic Active Record exception class.
+  class ActiveRecordError < StandardError
+  end
+
+  # Raised when the single-table inheritance mechanism fails to locate the subclass
+  # (for example due to improper usage of column that +inheritance_column+ points to).
+  class SubclassNotFound < ActiveRecordError #:nodoc:
+  end
+
+  # Raised when an object assigned to an association has an incorrect type.
+  #
+  #   class Ticket < ActiveRecord::Base
+  #     has_many :patches
+  #   end
+  #
+  #   class Patch < ActiveRecord::Base
+  #     belongs_to :ticket
+  #   end
+  #
+  #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
+  #   @ticket.patches << Comment.new(:content => "Please attach tests to your patch.")
+  class AssociationTypeMismatch < ActiveRecordError
+  end
+
+  # Raised when unserialized object's type mismatches one specified for serializable field.
+  class SerializationTypeMismatch < ActiveRecordError
+  end
+
+  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt>
+  # misses adapter field).
+  class AdapterNotSpecified < ActiveRecordError
+  end
+
+  # Raised when Active Record cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
+  class AdapterNotFound < ActiveRecordError
+  end
+
+  # Raised when connection to the database could not been established (for example when <tt>connection=</tt>
+  # is given a nil object).
+  class ConnectionNotEstablished < ActiveRecordError
+  end
+
+  # Raised when Active Record cannot find record by given id or set of ids.
+  class RecordNotFound < ActiveRecordError
+  end
+
+  # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
+  # saved because record is invalid.
+  class RecordNotSaved < ActiveRecordError
+  end
+
+  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for
+  # MySQL when Ruby driver used is too old).
+  class StatementInvalid < ActiveRecordError
+  end
+
+  # Raised when SQL statement is invalid and the application gets a blank result.
+  class ThrowResult < ActiveRecordError
+  end
+
+  # Parent class for all specific exceptions which wrap database driver exceptions
+  # provides access to the original exception also.
+  class WrappedDatabaseException < StatementInvalid
+    attr_reader :original_exception
+
+    def initialize(message, original_exception)
+      super(message)
+      @original_exception = original_exception
+    end
+  end
+
+  # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
+  class RecordNotUnique < WrappedDatabaseException
+  end
+
+  # Raised when a record cannot be inserted or updated because it references a non-existent record.
+  class InvalidForeignKey < WrappedDatabaseException
+  end
+
+  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example,
+  # when using +find+ method)
+  # does not match number of expected variables.
+  #
+  # For example, in
+  #
+  #   Location.where("lat = ? AND lng = ?", 53.7362)
+  #
+  # two placeholders are given but only one variable to fill them.
+  class PreparedStatementInvalid < ActiveRecordError
+  end
+
+  # Raised on attempt to save stale record. Record is stale when it's being saved in another query after
+  # instantiation, for example, when two users edit the same wiki page and one starts editing and saves
+  # the page before the other.
+  #
+  # Read more about optimistic locking in ActiveRecord::Locking module RDoc.
+  class StaleObjectError < ActiveRecordError
+    attr_reader :record, :attempted_action
+
+    def initialize(record, attempted_action)
+      @record = record
+      @attempted_action = attempted_action
+    end
+
+    def message
+      "Attempted to #{attempted_action} a stale object: #{record.class.name}"
+    end
+  end
+
+  # Raised when association is being configured improperly or
+  # user tries to use offset and limit together with has_many or has_and_belongs_to_many associations.
+  class ConfigurationError < ActiveRecordError
+  end
+
+  # Raised on attempt to update record that is instantiated as read only.
+  class ReadOnlyRecord < ActiveRecordError
+  end
+
+  # ActiveRecord::Transactions::ClassMethods.transaction uses this exception
+  # to distinguish a deliberate rollback from other exceptional situations.
+  # Normally, raising an exception will cause the +transaction+ method to rollback
+  # the database transaction *and* pass on the exception. But if you raise an
+  # ActiveRecord::Rollback exception, then the database transaction will be rolled back,
+  # without passing on the exception.
+  #
+  # For example, you could do this in your controller to rollback a transaction:
+  #
+  #   class BooksController < ActionController::Base
+  #     def create
+  #       Book.transaction do
+  #         book = Book.new(params[:book])
+  #         book.save!
+  #         if today_is_friday?
+  #           # The system must fail on Friday so that our support department
+  #           # won't be out of job. We silently rollback this transaction
+  #           # without telling the user.
+  #           raise ActiveRecord::Rollback, "Call tech support!"
+  #         end
+  #       end
+  #       # ActiveRecord::Rollback is the only exception that won't be passed on
+  #       # by ActiveRecord::Base.transaction, so this line will still be reached
+  #       # even on Friday.
+  #       redirect_to root_url
+  #     end
+  #   end
+  class Rollback < ActiveRecordError
+  end
+
+  # Raised when attribute has a name reserved by Active Record (when attribute has name of one of Active Record instance methods).
+  class DangerousAttributeError < ActiveRecordError
+  end
+
+  # Raised when unknown attributes are supplied via mass assignment.
+  class UnknownAttributeError < NoMethodError
+  end
+
+  # Raised when an error occurred while doing a mass assignment to an attribute through the
+  # <tt>attributes=</tt> method. The exception has an +attribute+ property that is the name of the
+  # offending attribute.
+  class AttributeAssignmentError < ActiveRecordError
+    attr_reader :exception, :attribute
+    def initialize(message, exception, attribute)
+      @exception = exception
+      @attribute = attribute
+      @message = message
+    end
+  end
+
+  # Raised when there are multiple errors while doing a mass assignment through the +attributes+
+  # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
+  # objects, each corresponding to the error while assigning to an attribute.
+  class MultiparameterAssignmentErrors < ActiveRecordError
+    attr_reader :errors
+    def initialize(errors)
+      @errors = errors
+    end
+  end
+
+  # Raised when a primary key is needed, but there is not one specified in the schema or model.
+  class UnknownPrimaryKey < ActiveRecordError
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def message
+      "Unknown primary key for table #{model.table_name} in model #{model}."
+    end
+  end
+end

data/lib/active_record/explain.rb

@@ -0,0 +1,86 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActiveRecord
+  module Explain
+    def self.extended(base)
+      base.class_eval do
+        # If a query takes longer than these many seconds we log its query plan
+        # automatically. nil disables this feature.
+        class_attribute :auto_explain_threshold_in_seconds, :instance_writer => false
+        self.auto_explain_threshold_in_seconds = nil
+      end
+    end
+
+    # If the database adapter supports explain and auto explain is enabled,
+    # this method triggers EXPLAIN logging for the queries triggered by the
+    # block if it takes more than the threshold as a whole. That is, the
+    # threshold is not checked against each individual query, but against the
+    # duration of the entire block. This approach is convenient for relations.
+
+    #
+    # The available_queries_for_explain thread variable collects the queries
+    # to be explained. If the value is nil, it means queries are not being
+    # currently collected. A false value indicates collecting is turned
+    # off. Otherwise it is an array of queries.
+    def logging_query_plan # :nodoc:
+      return yield unless logger
+
+      threshold = auto_explain_threshold_in_seconds
+      current   = Thread.current
+      if connection.supports_explain? && threshold && current[:available_queries_for_explain].nil?
+        begin
+          queries = current[:available_queries_for_explain] = []
+          start = Time.now
+          result = yield
+          logger.warn(exec_explain(queries)) if Time.now - start > threshold
+          result
+        ensure
+          current[:available_queries_for_explain] = nil
+        end
+      else
+        yield
+      end
+    end
+
+    # Relation#explain needs to be able to collect the queries regardless of
+    # whether auto explain is enabled. This method serves that purpose.
+    def collecting_queries_for_explain # :nodoc:
+      current = Thread.current
+      original, current[:available_queries_for_explain] = current[:available_queries_for_explain], []
+      return yield, current[:available_queries_for_explain]
+    ensure
+      # Note that the return value above does not depend on this assigment.
+      current[:available_queries_for_explain] = original
+    end
+
+    # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
+    # Returns a formatted string ready to be logged.
+    def exec_explain(queries) # :nodoc:
+      queries && queries.map do |sql, bind|
+        [].tap do |msg|
+          msg << "EXPLAIN for: #{sql}"
+          unless bind.empty?
+            bind_msg = bind.map {|col, val| [col.name, val]}.inspect
+            msg.last << " #{bind_msg}"
+          end
+          msg << connection.explain(sql, bind)
+        end.join("\n")
+      end.join("\n")
+    end
+
+    # Silences automatic EXPLAIN logging for the duration of the block.
+    #
+    # This has high priority, no EXPLAINs will be run even if downwards
+    # the threshold is set to 0.
+    #
+    # As the name of the method suggests this only applies to automatic
+    # EXPLAINs, manual calls to +ActiveRecord::Relation#explain+ run.
+    def silence_auto_explain
+      current = Thread.current
+      original, current[:available_queries_for_explain] = current[:available_queries_for_explain], false
+      yield
+    ensure
+      current[:available_queries_for_explain] = original
+    end
+  end
+end

data/lib/active_record/explain_subscriber.rb

@@ -0,0 +1,25 @@
+require 'active_support/notifications'
+
+module ActiveRecord
+  class ExplainSubscriber # :nodoc:
+    def call(*args)
+      if queries = Thread.current[:available_queries_for_explain]
+        payload = args.last
+        queries << payload.values_at(:sql, :binds) unless ignore_payload?(payload)
+      end
+    end
+
+    # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
+    # our own EXPLAINs now matter how loopingly beautiful that would be.
+    #
+    # On the other hand, we want to monitor the performance of our real database
+    # queries, not the performance of the access to the query cache.
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE)
+    EXPLAINED_SQLS = /\A\s*(select|update|delete|insert)\b/i
+    def ignore_payload?(payload)
+      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
+    end
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", new)
+  end
+end