activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/explain.rb

@@ -1,86 +1,50 @@
-require 'active_support/core_ext/class/attribute'
+# frozen_string_literal: true
+
+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|
-        [].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")
+      str = queries.map do |sql, binds|
+        msg = "EXPLAIN for: #{sql}".dup
+        unless binds.empty?
+          msg << " "
+          msg << binds.map { |attr| render_bind(attr) }.inspect
+        end
+        msg << "\n"
+        msg << connection.explain(sql, binds)
       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
+
+    private
+
+      def render_bind(attr)
+        value = if attr.type.binary? && attr.value
+          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          connection.type_cast(attr.value_for_database)
+        end
+
+        [attr.name, value]
+      end
   end
 end

data/lib/active_record/explain_registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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 ActiveSupport::PerThreadRegistry
+  # 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,23 +1,32 @@
-require 'active_support/notifications'
+# frozen_string_literal: true
+
+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
 
     # 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.
+    # our own EXPLAINs no 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
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+    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
+      payload[:exception] ||
+        payload[:cached] ||
+        IGNORED_PAYLOADS.include?(payload[:name]) ||
+        payload[:sql] !~ EXPLAINED_SQLS
     end
 
     ActiveSupport::Notifications.subscribe("sql.active_record", new)

data/lib/active_record/fixture_set/file.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+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
+      end
+
+      def each(&block)
+        rows.each(&block)
+      end
+
+      def model_class
+        config_row["model_class"]
+      end
+
+      private
+        def rows
+          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == "_fixture" }
+        end
+
+        def config_row
+          @config_row ||= begin
+            row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
+            if row
+              row.last
+            else
+              { 'model_class': nil }
+            end
+          end
+        end
+
+        def raw_rows
+          @raw_rows ||= begin
+            data = YAML.load(render(IO.read(@file)))
+            data ? validate(data).to_a : []
+          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
+        end
+
+        def prepare_erb(content)
+          erb = ERB.new(content)
+          erb.filename = @file
+          erb
+        end
+
+        def render(content)
+          context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new
+          prepare_erb(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: #{@file}"
+          end
+
+          invalid = data.reject { |_, row| Hash === row }
+          if invalid.any?
+            raise Fixture::FormatError, "fixture key is not a hash: #{@file}, keys: #{invalid.keys.inspect}"
+          end
+          data
+        end
+    end
+  end
+end