activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/errors.rb

@@ -22,7 +22,7 @@ module ActiveRecord
   #   end
   #
   #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
-  #   @ticket.patches << Comment.new(:content => "Please attach tests to your patch.")
+  #   @ticket.patches << Comment.new(content: "Please attach tests to your patch.")
   class AssociationTypeMismatch < ActiveRecordError
   end
 
@@ -30,17 +30,18 @@ module ActiveRecord
   class SerializationTypeMismatch < ActiveRecordError
   end
 
-  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt>
-  # misses adapter field).
+  # Raised when adapter not specified on connection (or configuration file
+  # +config/database.yml+ misses adapter field).
   class AdapterNotSpecified < ActiveRecordError
   end
 
-  # Raised when Active Record cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
+  # Raised when Active Record cannot find database adapter specified in
+  # +config/database.yml+ 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).
+  # Raised when connection to the database could not been established (for
+  # example when +connection=+ is given a nil object).
   class ConnectionNotEstablished < ActiveRecordError
   end
 
@@ -51,28 +52,48 @@ module ActiveRecord
   # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
   # saved because record is invalid.
   class RecordNotSaved < ActiveRecordError
-  end
+    attr_reader :record
 
-  # 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
+    def initialize(message, record = nil)
+      @record = record
+      super(message)
+    end
   end
 
-  # Raised when SQL statement is invalid and the application gets a blank result.
-  class ThrowResult < ActiveRecordError
+  # Raised by ActiveRecord::Base.destroy! when a call to destroy would return false.
+  #
+  #   begin
+  #     complex_operation_that_internally_calls_destroy!
+  #   rescue ActiveRecord::RecordNotDestroyed => invalid
+  #     puts invalid.record.errors
+  #   end
+  #
+  class RecordNotDestroyed < ActiveRecordError
+    attr_reader :record
+
+    def initialize(message, record = nil)
+      @record = record
+      super(message)
+    end
   end
 
-  # Parent class for all specific exceptions which wrap database driver exceptions
-  # provides access to the original exception also.
-  class WrappedDatabaseException < StatementInvalid
+  # Superclass for all database execution errors.
+  #
+  # Wraps the underlying database error as +original_exception+.
+  class StatementInvalid < ActiveRecordError
     attr_reader :original_exception
 
-    def initialize(message, original_exception)
+    def initialize(message, original_exception = nil)
       super(message)
       @original_exception = original_exception
     end
   end
 
+  # Defunct wrapper class kept for compatibility.
+  # +StatementInvalid+ wraps the original exception now.
+  class WrappedDatabaseException < StatementInvalid
+  end
+
   # Raised when a record cannot be inserted because it would violate a uniqueness constraint.
   class RecordNotUnique < WrappedDatabaseException
   end
@@ -81,38 +102,40 @@ module ActiveRecord
   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.
+  # Raised when number of bind variables in statement given to +:condition+ key
+  # (for example, when using +find+ method) does not match number of expected
+  # values supplied.
   #
-  # For example, in
+  # For example, when there are two placeholders with only one value supplied:
   #
   #   Location.where("lat = ? AND lng = ?", 53.7362)
-  #
-  # two placeholders are given but only one variable to fill them.
   class PreparedStatementInvalid < ActiveRecordError
   end
 
+  # Raised when a given database does not exist.
+  class NoDatabaseError < StatementInvalid
+  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.
+  # Read more about optimistic locking in ActiveRecord::Locking module
+  # documentation.
   class StaleObjectError < ActiveRecordError
     attr_reader :record, :attempted_action
 
     def initialize(record, attempted_action)
+      super("Attempted to #{attempted_action} a stale object: #{record.class.name}")
       @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.
+  # 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
 
@@ -150,23 +173,34 @@ module ActiveRecord
   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).
+  # 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
+
+    attr_reader :record, :attribute
+
+    def initialize(record, attribute)
+      @record = record
+      @attribute = attribute.to_s
+      super("unknown attribute '#{attribute}' for #{@record.class}.")
+    end
+
   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
+  # +attributes=+ 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)
+      super(message)
       @exception = exception
       @attribute = attribute
-      @message = message
     end
   end
 
@@ -175,21 +209,45 @@ module ActiveRecord
   # 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.
+  # Raised when a primary key is needed, but not specified in the schema or model.
   class UnknownPrimaryKey < ActiveRecordError
     attr_reader :model
 
-    def initialize(model)
+    def initialize(model, description = nil)
+      message = "Unknown primary key for table #{model.table_name} in model #{model}."
+      message += "\n#{description}" if description
+      super(message)
       @model = model
     end
+  end
 
-    def message
-      "Unknown primary key for table #{model.table_name} in model #{model}."
-    end
+  # Raised when a relation cannot be mutated because it's already loaded.
+  #
+  #   class Task < ActiveRecord::Base
+  #   end
+  #
+  #   relation = Task.all
+  #   relation.loaded? # => true
+  #
+  #   # Methods which try to mutate a loaded relation fail.
+  #   relation.where!(title: 'TODO')  # => ActiveRecord::ImmutableRelation
+  #   relation.limit!(5)              # => ActiveRecord::ImmutableRelation
+  class ImmutableRelation < ActiveRecordError
+  end
+
+  # TransactionIsolationError will be raised under the following conditions:
+  #
+  # * The adapter does not support setting the isolation level
+  # * You are joining an existing open transaction
+  # * You are creating a nested (savepoint) transaction
+  #
+  # The mysql, mysql2 and postgresql adapters support setting the transaction isolation level.
+  class TransactionIsolationError < ActiveRecordError
   end
 end

data/lib/active_record/explain.rb

@@ -1,62 +1,22 @@
-require 'active_support/core_ext/class/attribute'
+require 'active_support/lazy_load_hooks'
+require 'active_record/explain_registry'
 
 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.
+    # Executes the block with the collect flag enabled. Queries are collected
+    # asynchronously by the subscriber and returned.
     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]
+      ExplainRegistry.collect = true
+      yield
+      ExplainRegistry.queries
     ensure
-      # Note that the return value above does not depend on this assigment.
-      current[:available_queries_for_explain] = original
+      ExplainRegistry.reset
     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|
+      str = queries.map do |sql, bind|
         [].tap do |msg|
           msg << "EXPLAIN for: #{sql}"
           unless bind.empty?
@@ -66,21 +26,13 @@ module ActiveRecord
           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
+      # Overriding inspect to be more human readable, especially in the console.
+      def str.inspect
+        self
+      end
+
+      str
     end
   end
 end

data/lib/active_record/explain_registry.rb

@@ -0,0 +1,30 @@
+require 'active_support/per_thread_registry'
+
+module ActiveRecord
+  # This is a thread locals registry for EXPLAIN. For example
+  #
+  #   ActiveRecord::ExplainRegistry.queries
+  #
+  # returns the collected queries local to the current thread.
+  #
+  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # for further details.
+  class ExplainRegistry # :nodoc:
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_accessor :queries, :collect
+
+    def initialize
+      reset
+    end
+
+    def collect?
+      @collect
+    end
+
+    def reset
+      @collect = false
+      @queries = []
+    end
+  end
+end

data/lib/active_record/explain_subscriber.rb

@@ -1,11 +1,15 @@
 require 'active_support/notifications'
+require 'active_record/explain_registry'
 
 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)
+    def start(name, id, payload)
+      # unused
+    end
+
+    def finish(name, id, payload)
+      if ExplainRegistry.collect? && !ignore_payload?(payload)
+        ExplainRegistry.queries << payload.values_at(:sql, :binds)
       end
     end
 
@@ -15,7 +19,7 @@ module ActiveRecord
     # 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
+    EXPLAINED_SQLS = /\A\s*(with|select|update|delete|insert)\b/i
     def ignore_payload?(payload)
       payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name]) || payload[:sql] !~ EXPLAINED_SQLS
     end

data/lib/active_record/fixture_set/file.rb

@@ -0,0 +1,56 @@
+require 'erb'
+require 'yaml'
+
+module ActiveRecord
+  class FixtureSet
+    class File # :nodoc:
+      include Enumerable
+
+      ##
+      # Open a fixture file named +file+.  When called with a block, the block
+      # is called with the filehandle and the filehandle is automatically closed
+      # when the block finishes.
+      def self.open(file)
+        x = new file
+        block_given? ? yield(x) : x
+      end
+
+      def initialize(file)
+        @file = file
+        @rows = nil
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+
+      private
+        def rows
+          return @rows if @rows
+
+          begin
+            data = YAML.load(render(IO.read(@file)))
+          rescue ArgumentError, Psych::SyntaxError => error
+            raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
+          end
+          @rows = data ? validate(data).to_a : []
+        end
+
+        def render(content)
+          context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new
+          ERB.new(content).result(context.get_binding)
+        end
+
+        # Validate our unmarshalled data.
+        def validate(data)
+          unless Hash === data || YAML::Omap === data
+            raise Fixture::FormatError, 'fixture is not a hash'
+          end
+
+          raise Fixture::FormatError unless data.all? { |name, row| Hash === row }
+          data
+        end
+    end
+  end
+end