activerecord 3.1.12 → 3.2.22.1

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,5 +1,4 @@
 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'
@@ -8,26 +7,11 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     class SQLiteColumn < Column #:nodoc:
       class <<  self
-        def string_to_binary(value)
-          value.gsub(/\0|\%/n) do |b|
-            case b
-              when "\0" then "%00"
-              when "%"  then "%25"
-            end
-          end
-        end
-
         def binary_to_string(value)
           if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
             value = value.force_encoding(Encoding::ASCII_8BIT)
           end
-
-          value.gsub(/%00|%25/n) do |b|
-            case b
-              when "%00" then "\0"
-              when "%25" then "%"
-            end
-          end
+          value
         end
       end
     end
@@ -95,15 +79,11 @@ module ActiveRecord
         @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
+          @visitor = Arel::Visitors::SQLite.new self
         else
-          BindSubstitution.new pool
+          @visitor = BindSubstitution.new self
         end
       end
 
@@ -137,6 +117,11 @@ module ActiveRecord
         true
       end
 
+      # Returns true.
+      def supports_explain?
+        true
+      end
+
       def requires_reloading?
         true
       end
@@ -169,6 +154,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,
@@ -216,7 +205,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
-            value.encode! 'utf-8'
+            value = value.encode Encoding::UTF_8
           end
           value
         end
@@ -230,6 +219,25 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
+        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 +311,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|
@@ -346,12 +359,12 @@ module ActiveRecord
 
       # Returns an array of indexes for the given table.
       def indexes(table_name, name = nil) #:nodoc:
-        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", name).map do |row|
+        exec_query("PRAGMA index_list(#{quote_table_name(table_name)})", 'SCHEMA').map do |row|
           IndexDefinition.new(
             table_name,
             row['name'],
             row['unique'] != 0,
-            exec_query("PRAGMA index_info('#{row['name']}')").map { |col|
+            exec_query("PRAGMA index_info('#{row['name']}')", 'SCHEMA').map { |col|
               col['name']
             })
         end
@@ -393,8 +406,15 @@ 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?
-        column_names.flatten.each do |column_name|
+        raise ArgumentError.new("You must specify at least one column name. Example: remove_column(:people, :first_name)") if column_names.empty?
+
+        if column_names.flatten!
+          message = 'Passing array to remove_columns is deprecated, please use ' +
+                    'multiple arguments, like: `remove_columns(:posts, :foo, :bar)`'
+          ActiveSupport::Deprecation.warn message, caller
+        end
+
+        column_names.each do |column_name|
           alter_table(table_name) do |definition|
             definition.columns.delete(definition[column_name])
           end
@@ -425,6 +445,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
@@ -468,7 +490,11 @@ module ActiveRecord
         end
 
         def copy_table(from, to, options = {}) #:nodoc:
-          options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
+          from_primary_key = primary_key(from)
+          options[:primary_key] = from_primary_key if from_primary_key != 'id'
+          unless options[:primary_key]
+            options[:id] = !columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == from_primary_key
+          end
           create_table(to, options) do |definition|
             @definition = definition
             columns(from).each do |column|
@@ -479,9 +505,10 @@ 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)
+            @definition.primary_key(from_primary_key) if from_primary_key
             yield @definition if block_given?
           end
 
@@ -507,7 +534,7 @@ module ActiveRecord
 
             unless columns.empty?
               # index name can't be the same
-              opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
+              opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_") }
               opts[:unique] = true if index.unique
               add_index(to, columns, opts)
             end

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
@@ -19,15 +19,20 @@ module ActiveRecord
       counters.each do |association|
         has_many_association = reflect_on_association(association.to_sym)
 
-        expected_name = if has_many_association.options[:as]
+        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.class_name == expected_name }
+        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({
@@ -65,7 +70,7 @@ module ActiveRecord
     #   Post.update_counters [10, 15], :comment_count => 1
     #   # Executes the following SQL:
     #   # UPDATE posts
-    #   #    SET comment_count = COALESCE(comment_count, 0) + 1,
+    #   #    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|

data/lib/active_record/dynamic_finder_match.rb

@@ -18,6 +18,10 @@ module ActiveRecord
       when /^find_by_([_a-zA-Z]\w*)\!$/
         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
         names = $2
@@ -52,5 +56,13 @@ module ActiveRecord
     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/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,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

data/lib/active_record/fixtures/file.rb

@@ -0,0 +1,65 @@
+begin
+  require 'psych'
+rescue LoadError
+end
+
+require 'erb'
+require 'yaml'
+
+module ActiveRecord
+  class Fixtures
+    class File
+      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
+
+      RESCUE_ERRORS = [ ArgumentError ] # :nodoc:
+
+      private
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        RESCUE_ERRORS << Psych::SyntaxError
+      end
+
+      def rows
+        return @rows if @rows
+
+        begin
+          data = YAML.load(render(IO.read(@file)))
+        rescue *RESCUE_ERRORS => 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)
+        ERB.new(content).result
+      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