activerecord 3.1.12 → 3.2.0.rc1

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,8 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_support/core_ext/kernel/requires'
 require 'active_record/connection_adapters/statement_pool'
 require 'active_support/core_ext/string/encoding'
-require 'arel/visitors/bind_visitor'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
@@ -86,25 +84,12 @@ module ActiveRecord
         end
       end
 
-      class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
-        include Arel::Visitors::BindVisitor
-      end
-
       def initialize(connection, logger, config)
         super(connection, logger)
         @statements = StatementPool.new(@connection,
                                         config.fetch(:statement_limit) { 1000 })
         @config = config
-      end
-
-      def self.visitor_for(pool) # :nodoc:
-        config = pool.spec.config
-
-        if config.fetch(:prepared_statements) { true }
-          Arel::Visitors::SQLite.new pool
-        else
-          BindSubstitution.new pool
-        end
+        @visitor = Arel::Visitors::SQLite.new self
       end
 
       def adapter_name #:nodoc:
@@ -137,6 +122,11 @@ module ActiveRecord
         true
       end
 
+      # Returns true.
+      def supports_explain?
+        true
+      end
+
       def requires_reloading?
         true
       end
@@ -169,6 +159,10 @@ module ActiveRecord
         sqlite_version >= '3.1.0'
       end
 
+      def supports_index_sort_order?
+        sqlite_version >= '3.3.0'
+      end
+
       def native_database_types #:nodoc:
         {
           :primary_key => default_primary_key_type,
@@ -215,7 +209,7 @@ module ActiveRecord
 
           value = super
           if column.type == :string && value.encoding == Encoding::ASCII_8BIT
-            logger.error "Binary data inserted for `string` type on column `#{column.name}`" if logger
+            @logger.error "Binary data inserted for `string` type on column `#{column.name}`"
             value.encode! 'utf-8'
           end
           value
@@ -230,6 +224,25 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN #{to_sql(arel)}"
+        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
+      end
+
+      class ExplainPrettyPrinter
+        # Pretty prints the result of a EXPLAIN QUERY PLAN in a way that resembles
+        # the output of the SQLite shell:
+        #
+        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
+        #   0|1|1|SCAN TABLE posts (~100000 rows)
+        #
+        def pp(result) # :nodoc:
+          result.rows.map do |row|
+            row.join('|')
+          end.join("\n") + "\n"
+        end
+      end
+
       def exec_query(sql, name = nil, binds = [])
         log(sql, name, binds) do
 
@@ -303,31 +316,36 @@ module ActiveRecord
       end
 
       def begin_db_transaction #:nodoc:
-        @connection.transaction
+        log('begin transaction',nil) { @connection.transaction }
       end
 
       def commit_db_transaction #:nodoc:
-        @connection.commit
+        log('commit transaction',nil) { @connection.commit }
       end
 
       def rollback_db_transaction #:nodoc:
-        @connection.rollback
+        log('rollback transaction',nil) { @connection.rollback }
       end
 
       # SCHEMA STATEMENTS ========================================
 
-      def tables(name = 'SCHEMA') #:nodoc:
+      def tables(name = 'SCHEMA', table_name = nil) #:nodoc:
         sql = <<-SQL
           SELECT name
           FROM sqlite_master
           WHERE type = 'table' AND NOT name = 'sqlite_sequence'
         SQL
+        sql << " AND name = #{quote_table_name(table_name)}" if table_name
 
         exec_query(sql, name).map do |row|
           row['name']
         end
       end
 
+      def table_exists?(name)
+        name && tables('SCHEMA', name).any?
+      end
+
       # Returns an array of +SQLiteColumn+ objects for the table specified by +table_name+.
       def columns(table_name, name = nil) #:nodoc:
         table_structure(table_name).map do |field|
@@ -393,7 +411,7 @@ module ActiveRecord
       end
 
       def remove_column(table_name, *column_names) #:nodoc:
-        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
+        raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty?
         column_names.flatten.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
@@ -425,6 +443,8 @@ module ActiveRecord
             self.limit   = options[:limit] if options.include?(:limit)
             self.default = options[:default] if include_default
             self.null    = options[:null] if options.include?(:null)
+            self.precision = options[:precision] if options.include?(:precision)
+            self.scale   = options[:scale] if options.include?(:scale)
           end
         end
       end
@@ -479,6 +499,7 @@ module ActiveRecord
 
               @definition.column(column_name, column.type,
                 :limit => column.limit, :default => column.default,
+                :precision => column.precision, :scale => column.scale,
                 :null => column.null)
             end
             @definition.primary_key(primary_key(from)) if primary_key(from)

data/lib/active_record/counter_cache.rb

@@ -2,7 +2,7 @@ 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
+    # count query. This is useful when adding new counter caches, or if the
     # counter has been corrupted or modified directly by SQL.
     #
     # ==== Parameters

data/lib/active_record/dynamic_matchers.rb

@@ -0,0 +1,79 @@
+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 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 = arguments.extract_options!
+          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/errors.rb

@@ -87,7 +87,7 @@ module ActiveRecord
   #
   # For example, in
   #
-  #   Location.find :all, :conditions => ["lat = ? AND lng = ?", 53.7362]
+  #   Location.where("lat = ? AND lng = ?", 53.7362)
   #
   # two placeholders are given but only one variable to fill them.
   class PreparedStatementInvalid < ActiveRecordError
@@ -99,6 +99,16 @@ module ActiveRecord
   #
   # 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

data/lib/active_record/explain.rb

@@ -0,0 +1,83 @@
+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 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:
+      threshold = auto_explain_threshold_in_seconds
+      current   = Thread.current
+      if 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,21 @@
+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.
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN)
+    def ignore_payload?(payload)
+      payload[:exception] || IGNORED_PAYLOADS.include?(payload[:name])
+    end
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", new)
+  end
+end

data/lib/active_record/fixtures.rb

@@ -6,14 +6,13 @@ rescue LoadError
 end
 
 require 'yaml'
-require 'csv'
 require 'zlib'
 require 'active_support/dependencies'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/logger'
 require 'active_support/ordered_hash'
-require 'active_support/core_ext/module/deprecation'
+require 'active_record/fixtures/file'
 
 if defined? ActiveRecord
   class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
@@ -23,8 +22,6 @@ else
   end
 end
 
-class FixturesFileNotFound < StandardError; end
-
 module ActiveRecord
   # \Fixtures are a way of organizing data that you want to test against; in short, sample data.
   #
@@ -467,7 +464,7 @@ module ActiveRecord
               connection,
               table_name,
               class_names[table_name.to_sym] || table_name.classify,
-              File.join(fixtures_directory, path))
+              ::File.join(fixtures_directory, path))
           end
 
           all_loaded_fixtures.update(fixtures_map)
@@ -645,80 +642,25 @@ module ActiveRecord
       end
 
       def read_fixture_files
-        if File.file?(yaml_file_path)
-          read_yaml_fixture_files
-        elsif File.file?(csv_file_path)
-          read_csv_fixture_files
-        else
-          raise FixturesFileNotFound, "Could not find #{yaml_file_path} or #{csv_file_path}"
-        end
-      end
-
-      def read_yaml_fixture_files
-        yaml_string = (Dir["#{@fixture_path}/**/*.yml"].select { |f|
-          File.file?(f)
-        } + [yaml_file_path]).map { |file_path| IO.read(file_path) }.join
-
-        if yaml = parse_yaml_string(yaml_string)
-          # If the file is an ordered map, extract its children.
-          yaml_value =
-            if yaml.respond_to?(:type_id) && yaml.respond_to?(:value)
-              yaml.value
-            else
-              [yaml]
-            end
-
-          yaml_value.each do |fixture|
-            raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{fixture}" unless fixture.respond_to?(:each)
-            fixture.each do |name, data|
-              unless data
-                raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
-              end
-
-              fixtures[name] = ActiveRecord::Fixture.new(data, model_class)
+        yaml_files = Dir["#{@fixture_path}/**/*.yml"].select { |f|
+          ::File.file?(f)
+        } + [yaml_file_path]
+
+        yaml_files.each do |file|
+          Fixtures::File.open(file) do |fh|
+            fh.each do |name, row|
+              fixtures[name] = ActiveRecord::Fixture.new(row, model_class)
             end
           end
         end
       end
 
-      def read_csv_fixture_files
-        reader = CSV.parse(erb_render(IO.read(csv_file_path)))
-        header = reader.shift
-        i = 0
-        reader.each do |row|
-          data = {}
-          row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-          fixtures["#{@class_name.to_s.underscore}_#{i+=1}"] = ActiveRecord::Fixture.new(data, model_class)
-        end
-      end
-      deprecate :read_csv_fixture_files
-
       def yaml_file_path
         "#{@fixture_path}.yml"
       end
 
-      def csv_file_path
-        @fixture_path + ".csv"
-      end
-
       def yaml_fixtures_key(path)
-        File.basename(@fixture_path).split(".").first
-      end
-
-      RESCUE_ERRORS = [ ArgumentError ]
-
-      if defined?(Psych) && defined?(Psych::SyntaxError)
-        RESCUE_ERRORS << Psych::SyntaxError
-      end
-
-      def parse_yaml_string(fixture_content)
-        YAML::load(erb_render(fixture_content))
-      rescue *RESCUE_ERRORS => error
-        raise Fixture::FormatError, "a YAML error occurred parsing #{yaml_file_path}. 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
-
-      def erb_render(fixture_content)
-        ERB.new(fixture_content).result
+        ::File.basename(@fixture_path).split(".").first
       end
   end
 
@@ -794,7 +736,7 @@ module ActiveRecord
 
       def fixtures(*fixture_names)
         if fixture_names.first == :all
-          fixture_names = Dir["#{fixture_path}/**/*.{yml,csv}"]
+          fixture_names = Dir["#{fixture_path}/**/*.{yml}"]
           fixture_names.map! { |f| f[(fixture_path.size + 1)..-5] }
         else
           fixture_names = fixture_names.flatten.map { |n| n.to_s }
@@ -880,6 +822,7 @@ module ActiveRecord
       end
 
       @fixture_cache = {}
+      @fixture_connections = []
       @@already_loaded_fixtures ||= {}
 
       # Load fixtures once and begin transaction.
@@ -890,9 +833,12 @@ module ActiveRecord
           @loaded_fixtures = load_fixtures
           @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
-        ActiveRecord::Base.connection.increment_open_transactions
-        ActiveRecord::Base.connection.transaction_joinable = false
-        ActiveRecord::Base.connection.begin_db_transaction
+        @fixture_connections = enlist_fixture_connections
+        @fixture_connections.each do |connection|
+          connection.increment_open_transactions
+          connection.transaction_joinable = false
+          connection.begin_db_transaction
+        end
       # Load fixtures for every test.
       else
         ActiveRecord::Fixtures.reset_cache
@@ -912,13 +858,22 @@ module ActiveRecord
       end
 
       # Rollback changes if a transaction is active.
-      if run_in_transaction? && ActiveRecord::Base.connection.open_transactions != 0
-        ActiveRecord::Base.connection.rollback_db_transaction
-        ActiveRecord::Base.connection.decrement_open_transactions
+      if run_in_transaction?
+        @fixture_connections.each do |connection|
+          if connection.open_transactions != 0
+            connection.rollback_db_transaction
+            connection.decrement_open_transactions
+          end
+        end
+        @fixture_connections.clear
       end
       ActiveRecord::Base.clear_active_connections!
     end
 
+    def enlist_fixture_connections
+      ActiveRecord::Base.connection_handler.connection_pools.values.map(&:connection)
+    end
+
     private
       def load_fixtures
         fixtures = ActiveRecord::Fixtures.create_fixtures(fixture_path, fixture_table_names, fixture_class_names)