activerecord 3.2.22.5 → 4.2.11.3

data/lib/active_record/result.rb

@@ -3,36 +3,127 @@ module ActiveRecord
   # This class encapsulates a Result returned from calling +exec_query+ on any
   # database connection adapter. For example:
   #
-  #   x = ActiveRecord::Base.connection.exec_query('SELECT * FROM foo')
-  #   x # => #<ActiveRecord::Result:0xdeadbeef>
+  #   result = ActiveRecord::Base.connection.exec_query('SELECT id, title, body FROM posts')
+  #   result # => #<ActiveRecord::Result:0xdeadbeef>
+  #
+  #   # Get the column names of the result:
+  #   result.columns
+  #   # => ["id", "title", "body"]
+  #
+  #   # Get the record values of the result:
+  #   result.rows
+  #   # => [[1, "title_1", "body_1"],
+  #         [2, "title_2", "body_2"],
+  #         ...
+  #        ]
+  #
+  #   # Get an array of hashes representing the result (column => value):
+  #   result.to_hash
+  #   # => [{"id" => 1, "title" => "title_1", "body" => "body_1"},
+  #         {"id" => 2, "title" => "title_2", "body" => "body_2"},
+  #         ...
+  #        ]
+  #
+  #   # ActiveRecord::Result also includes Enumerable.
+  #   result.each do |row|
+  #     puts row['title'] + " " + row['body']
+  #   end
   class Result
     include Enumerable
 
-    attr_reader :columns, :rows
+    IDENTITY_TYPE = Type::Value.new # :nodoc:
+
+    attr_reader :columns, :rows, :column_types
+
+    def initialize(columns, rows, column_types = {})
+      @columns      = columns
+      @rows         = rows
+      @hash_rows    = nil
+      @column_types = column_types
+    end
 
-    def initialize(columns, rows)
-      @columns   = columns
-      @rows      = rows
-      @hash_rows = nil
+    def length
+      @rows.length
     end
 
     def each
-      hash_rows.each { |row| yield row }
+      if block_given?
+        hash_rows.each { |row| yield row }
+      else
+        hash_rows.to_enum { @rows.size }
+      end
     end
 
     def to_hash
       hash_rows
     end
 
+    alias :map! :map
+    alias :collect! :map
+
+    # Returns true if there are no records.
+    def empty?
+      rows.empty?
+    end
+
+    def to_ary
+      hash_rows
+    end
+
+    def [](idx)
+      hash_rows[idx]
+    end
+
+    def last
+      hash_rows.last
+    end
+
+    def cast_values(type_overrides = {}) # :nodoc:
+      types = columns.map { |name| column_type(name, type_overrides) }
+      result = rows.map do |values|
+        types.zip(values).map { |type, value| type.type_cast_from_database(value) }
+      end
+
+      columns.one? ? result.map!(&:first) : result
+    end
+
+    def initialize_copy(other)
+      @columns      = columns.dup
+      @rows         = rows.dup
+      @column_types = column_types.dup
+      @hash_rows    = nil
+    end
+
     private
+
+    def column_type(name, type_overrides = {})
+      type_overrides.fetch(name) do
+        column_types.fetch(name, IDENTITY_TYPE)
+      end
+    end
+
     def hash_rows
       @hash_rows ||=
         begin
           # We freeze the strings to prevent them getting duped when
-          # used as keys in ActiveRecord::Model's @attributes hash
+          # used as keys in ActiveRecord::Base's @attributes hash
           columns = @columns.map { |c| c.dup.freeze }
           @rows.map { |row|
-            Hash[columns.zip(row)]
+            # In the past we used Hash[columns.zip(row)]
+            #  though elegant, the verbose way is much more efficient
+            #  both time and memory wise cause it avoids a big array allocation
+            #  this method is called a lot and needs to be micro optimised
+            hash = {}
+
+            index = 0
+            length = columns.length
+
+            while index < length
+              hash[columns[index]] = row[index]
+              index += 1
+            end
+
+            hash
           }
         end
     end

data/lib/active_record/runtime_registry.rb

@@ -0,0 +1,22 @@
+require 'active_support/per_thread_registry'
+
+module ActiveRecord
+  # This is a thread locals registry for Active Record. For example:
+  #
+  #   ActiveRecord::RuntimeRegistry.connection_handler
+  #
+  # returns the connection handler local to the current thread.
+  #
+  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # for further details.
+  class RuntimeRegistry # :nodoc:
+    extend ActiveSupport::PerThreadRegistry
+
+    attr_accessor :connection_handler, :sql_runtime, :connection_id
+
+    [:connection_handler, :sql_runtime, :connection_id].each do |val|
+      class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
+      class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
+    end
+  end
+end

data/lib/active_record/sanitization.rb

@@ -1,12 +1,10 @@
-require 'active_support/concern'
-
 module ActiveRecord
   module Sanitization
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def quote_value(value, column = nil) #:nodoc:
-        connection.quote(value,column)
+      def quote_value(value, column) #:nodoc:
+        connection.quote(value, column)
       end
 
       # Used to sanitize objects before they're used in an SQL SELECT statement. Delegates to <tt>connection.quote</tt>.
@@ -19,7 +17,7 @@ module ActiveRecord
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a WHERE clause.
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
-      #   { :name => "foo'bar", :group_id => 4 }  returns "name='foo''bar' and group_id='4'"
+      #   { name: "foo'bar", group_id: 4 }  returns "name='foo''bar' and group_id='4'"
       #   "name='foo''bar' and group_id='4'" returns "name='foo''bar' and group_id='4'"
       def sanitize_sql_for_conditions(condition, table_name = self.table_name)
         return nil if condition.blank?
@@ -31,15 +29,16 @@ module ActiveRecord
         end
       end
       alias_method :sanitize_sql, :sanitize_sql_for_conditions
+      alias_method :sanitize_conditions, :sanitize_sql
 
       # Accepts an array, hash, or string of SQL conditions and sanitizes
       # them into a valid SQL fragment for a SET clause.
-      #   { :name => nil, :group_id => 4 }  returns "name = NULL , group_id='4'"
-      def sanitize_sql_for_assignment(assignments)
+      #   { name: nil, group_id: 4 }  returns "name = NULL , group_id='4'"
+      def sanitize_sql_for_assignment(assignments, default_table_name = self.table_name)
         case assignments
-          when Array; sanitize_sql_array(assignments)
-          when Hash;  sanitize_sql_hash_for_assignment(assignments)
-          else        assignments
+        when Array; sanitize_sql_array(assignments)
+        when Hash;  sanitize_sql_hash_for_assignment(assignments, default_table_name)
+        else        assignments
         end
       end
 
@@ -48,17 +47,17 @@ module ActiveRecord
       # aggregate attribute values.
       # Given:
       #     class Person < ActiveRecord::Base
-      #       composed_of :address, :class_name => "Address",
-      #         :mapping => [%w(address_street street), %w(address_city city)]
+      #       composed_of :address, class_name: "Address",
+      #         mapping: [%w(address_street street), %w(address_city city)]
       #     end
       # Then:
-      #     { :address => Address.new("813 abc st.", "chicago") }
-      #       # => { :address_street => "813 abc st.", :address_city => "chicago" }
+      #     { address: Address.new("813 abc st.", "chicago") }
+      #       # => { address_street: "813 abc st.", address_city: "chicago" }
       def expand_hash_conditions_for_aggregates(attrs)
         expanded_attrs = {}
         attrs.each do |attr, value|
-          unless (aggregation = reflect_on_aggregation(attr.to_sym)).nil?
-            mapping = aggregate_mapping(aggregation)
+          if aggregation = reflect_on_aggregation(attr.to_sym)
+            mapping = aggregation.mapping
             mapping.each do |field_attr, aggregate_attr|
               if mapping.size == 1 && !value.respond_to?(aggregate_attr)
                 expanded_attrs[field_attr] = value
@@ -74,38 +73,50 @@ module ActiveRecord
       end
 
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
-      #   { :name => "foo'bar", :group_id => 4 }
+      #   { name: "foo'bar", group_id: 4 }
       #     # => "name='foo''bar' and group_id= 4"
-      #   { :status => nil, :group_id => [1,2,3] }
+      #   { status: nil, group_id: [1,2,3] }
       #     # => "status IS NULL and group_id IN (1,2,3)"
-      #   { :age => 13..18 }
+      #   { age: 13..18 }
       #     # => "age BETWEEN 13 AND 18"
       #   { 'other_records.id' => 7 }
       #     # => "`other_records`.`id` = 7"
-      #   { :other_records => { :id => 7 } }
+      #   { other_records: { id: 7 } }
       #     # => "`other_records`.`id` = 7"
       # And for value objects on a composed_of relationship:
-      #   { :address => Address.new("123 abc st.", "chicago") }
+      #   { address: Address.new("123 abc st.", "chicago") }
       #     # => "address_street='123 abc st.' and address_city='chicago'"
       def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
+        ActiveSupport::Deprecation.warn(<<-EOWARN)
+sanitize_sql_hash_for_conditions is deprecated, and will be removed in Rails 5.0
+        EOWARN
+        attrs = PredicateBuilder.resolve_column_aliases self, attrs
         attrs = expand_hash_conditions_for_aggregates(attrs)
 
-        table = Arel::Table.new(table_name).alias(default_table_name)
-        PredicateBuilder.build_from_hash(arel_engine, attrs, table).map { |b|
-          connection.visitor.accept b
+        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
+        PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
+          connection.visitor.compile b
         }.join(' AND ')
       end
       alias_method :sanitize_sql_hash, :sanitize_sql_hash_for_conditions
 
       # Sanitizes a hash of attribute/value pairs into SQL conditions for a SET clause.
-      #   { :status => nil, :group_id => 1 }
+      #   { status: nil, group_id: 1 }
       #     # => "status = NULL , group_id = 1"
-      def sanitize_sql_hash_for_assignment(attrs)
+      def sanitize_sql_hash_for_assignment(attrs, table)
+        c = connection
         attrs.map do |attr, value|
-          "#{connection.quote_column_name(attr)} = #{quote_bound_value(value)}"
+          "#{c.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value, c, columns_hash[attr.to_s])}"
         end.join(', ')
       end
 
+      # Sanitizes a +string+ so that it is safe to use within an SQL
+      # LIKE statement. This method uses +escape_character+ to escape all occurrences of "\", "_" and "%"
+      def sanitize_sql_like(string, escape_character = "\\")
+        pattern = Regexp.union(escape_character, "%", "_")
+        string.gsub(pattern) { |x| [escape_character, x].join }
+      end
+
       # Accepts an array of conditions. The array has each value
       # sanitized and interpolated into the SQL statement.
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  "name='foo''bar' and group_id='4'"
@@ -122,13 +133,21 @@ module ActiveRecord
         end
       end
 
-      alias_method :sanitize_conditions, :sanitize_sql
-
       def replace_bind_variables(statement, values) #:nodoc:
         raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size)
         bound = values.dup
         c = connection
-        statement.gsub('?') { quote_bound_value(bound.shift, c) }
+        statement.gsub(/\?/) do
+          replace_bind_variable(bound.shift, c)
+        end
+      end
+
+      def replace_bind_variable(value, c = connection) #:nodoc:
+        if ActiveRecord::Relation === value
+          value.to_sql
+        else
+          quote_bound_value(value, c)
+        end
       end
 
       def replace_named_bind_variables(statement, bind_vars) #:nodoc:
@@ -136,32 +155,17 @@ module ActiveRecord
           if $1 == ':' # skip postgresql casts
             $& # return the whole match
           elsif bind_vars.include?(match = $2.to_sym)
-            quote_bound_value(bind_vars[match])
+            replace_bind_variable(bind_vars[match])
           else
             raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
           end
         end
       end
 
-      def expand_range_bind_variables(bind_vars) #:nodoc:
-        expanded = []
-
-        bind_vars.each do |var|
-          next if var.is_a?(Hash)
-
-          if var.is_a?(Range)
-            expanded << var.first
-            expanded << var.last
-          else
-            expanded << var
-          end
-        end
-
-        expanded
-      end
-
-      def quote_bound_value(value, c = connection) #:nodoc:
-        if value.respond_to?(:map) && !value.acts_like?(:string)
+      def quote_bound_value(value, c = connection, column = nil) #:nodoc:
+        if column
+          c.quote(value, column)
+        elsif value.respond_to?(:map) && !value.acts_like?(:string)
           if value.respond_to?(:empty?) && value.empty?
             c.quote(nil)
           else
@@ -180,15 +184,8 @@ module ActiveRecord
     end
 
     # TODO: Deprecate this
-    def quoted_id #:nodoc:
-      quote_value(id, column_for_attribute(self.class.primary_key))
-    end
-
-    private
-
-    # Quote strings appropriately for SQL statements.
-    def quote_value(value, column = nil)
-      self.class.connection.quote(value, column)
+    def quoted_id
+      self.class.quote_value(id, column_for_attribute(self.class.primary_key))
     end
   end
 end

data/lib/active_record/schema.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/blank'
-
 module ActiveRecord
   # = Active Record Schema
   #
@@ -12,16 +10,16 @@ module ActiveRecord
   #
   #   ActiveRecord::Schema.define do
   #     create_table :authors do |t|
-  #       t.string :name, :null => false
+  #       t.string :name, null: false
   #     end
   #
   #     add_index :authors, :name, :unique
   #
   #     create_table :posts do |t|
-  #       t.integer :author_id, :null => false
+  #       t.integer :author_id, null: false
   #       t.string :subject
   #       t.text :body
-  #       t.boolean :private, :default => false
+  #       t.boolean :private, default: false
   #     end
   #
   #     add_index :posts, :author_id
@@ -30,10 +28,24 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration
+
+    # Returns the migrations paths.
+    #
+    #   ActiveRecord::Schema.new.migrations_paths
+    #   # => ["db/migrate"] # Rails migration path by default.
     def migrations_paths
       ActiveRecord::Migrator.migrations_paths
     end
 
+    def define(info, &block) # :nodoc:
+      instance_eval(&block)
+
+      unless info[:version].blank?
+        initialize_schema_migrations_table
+        connection.assume_migrated_upto_version(info[:version], migrations_paths)
+      end
+    end
+
     # Eval the given block. All methods available to the current connection
     # adapter are available within the block, so you can easily use the
     # database definition DSL to build up your schema (+create_table+,
@@ -42,17 +54,11 @@ module ActiveRecord
     # The +info+ hash is optional, and if given is used to define metadata
     # about the current schema (currently, only the schema's version):
     #
-    #   ActiveRecord::Schema.define(:version => 20380119000001) do
+    #   ActiveRecord::Schema.define(version: 20380119000001) do
     #     ...
     #   end
     def self.define(info={}, &block)
-      schema = new
-      schema.instance_eval(&block)
-
-      unless info[:version].blank?
-        initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], schema.migrations_paths)
-      end
+      new.define(info, &block)
     end
   end
 end