activerecord 3.0.0 → 4.0.0

data/lib/active_record/result.rb

@@ -0,0 +1,67 @@
+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>
+  class Result
+    include Enumerable
+
+    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 each
+      hash_rows.each { |row| yield row }
+    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 initialize_copy(other)
+      @columns   = columns.dup
+      @rows      = rows.dup
+      @hash_rows = nil
+    end
+
+    private
+    def hash_rows
+      @hash_rows ||=
+        begin
+          # We freeze the strings to prevent them getting duped when
+          # used as keys in ActiveRecord::Base's @attributes hash
+          columns = @columns.map { |c| c.dup.freeze }
+          @rows.map { |row|
+            Hash[columns.zip(row)]
+          }
+        end
+    end
+  end
+end

data/lib/active_record/runtime_registry.rb

@@ -0,0 +1,17 @@
+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
+  end
+end

data/lib/active_record/sanitization.rb

@@ -0,0 +1,168 @@
+module ActiveRecord
+  module Sanitization
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def quote_value(value, column = nil) #: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>.
+      def sanitize(object) #:nodoc:
+        connection.quote(object)
+      end
+
+      protected
+
+      # 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' 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?
+
+        case condition
+        when Array; sanitize_sql_array(condition)
+        when Hash;  sanitize_sql_hash_for_conditions(condition, table_name)
+        else        condition
+        end
+      end
+      alias_method :sanitize_sql, :sanitize_sql_for_conditions
+
+      # 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, default_table_name = self.table_name)
+        case assignments
+        when Array; sanitize_sql_array(assignments)
+        when Hash;  sanitize_sql_hash_for_assignment(assignments, default_table_name)
+        else        assignments
+        end
+      end
+
+      # Accepts a hash of SQL conditions and replaces those attributes
+      # that correspond to a +composed_of+ relationship with their expanded
+      # aggregate attribute values.
+      # Given:
+      #     class Person < ActiveRecord::Base
+      #       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" }
+      def expand_hash_conditions_for_aggregates(attrs)
+        expanded_attrs = {}
+        attrs.each do |attr, value|
+          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
+              else
+                expanded_attrs[field_attr] = value.send(aggregate_attr)
+              end
+            end
+          else
+            expanded_attrs[attr] = value
+          end
+        end
+        expanded_attrs
+      end
+
+      # Sanitizes a hash of attribute/value pairs into SQL conditions for a WHERE clause.
+      #   { name: "foo'bar", group_id: 4 }
+      #     # => "name='foo''bar' and group_id= 4"
+      #   { status: nil, group_id: [1,2,3] }
+      #     # => "status IS NULL and group_id IN (1,2,3)"
+      #   { age: 13..18 }
+      #     # => "age BETWEEN 13 AND 18"
+      #   { '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_street='123 abc st.' and address_city='chicago'"
+      def sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
+        attrs = expand_hash_conditions_for_aggregates(attrs)
+
+        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
+        PredicateBuilder.build_from_hash(self.class, attrs, table).map { |b|
+          connection.visitor.accept 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 = NULL , group_id = 1"
+      def sanitize_sql_hash_for_assignment(attrs, table)
+        attrs.map do |attr, value|
+          "#{connection.quote_table_name_for_assignment(table, attr)} = #{quote_bound_value(value)}"
+        end.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'"
+      def sanitize_sql_array(ary)
+        statement, *values = ary
+        if values.first.is_a?(Hash) && statement =~ /:\w+/
+          replace_named_bind_variables(statement, values.first)
+        elsif statement.include?('?')
+          replace_bind_variables(statement, values)
+        elsif statement.blank?
+          statement
+        else
+          statement % values.collect { |value| connection.quote_string(value.to_s) }
+        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) }
+      end
+
+      def replace_named_bind_variables(statement, bind_vars) #:nodoc:
+        statement.gsub(/(:?):([a-zA-Z]\w*)/) do
+          if $1 == ':' # skip postgresql casts
+            $& # return the whole match
+          elsif bind_vars.include?(match = $2.to_sym)
+            quote_bound_value(bind_vars[match])
+          else
+            raise PreparedStatementInvalid, "missing value for :#{match} in #{statement}"
+          end
+        end
+      end
+
+      def quote_bound_value(value, c = connection) #:nodoc:
+        if value.respond_to?(:map) && !value.acts_like?(:string)
+          if value.respond_to?(:empty?) && value.empty?
+            c.quote(nil)
+          else
+            value.map { |v| c.quote(v) }.join(',')
+          end
+        else
+          c.quote(value)
+        end
+      end
+
+      def raise_if_bind_arity_mismatch(statement, expected, provided) #:nodoc:
+        unless expected == provided
+          raise PreparedStatementInvalid, "wrong number of bind variables (#{provided} for #{expected}) in: #{statement}"
+        end
+      end
+    end
+
+    # TODO: Deprecate this
+    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,4 +1,3 @@
-require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Schema
@@ -12,16 +11,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 +29,22 @@ module ActiveRecord
   # ActiveRecord::Schema is only supported by database adapters that also
   # support migrations, the two features being very similar.
   class Schema < Migration
-    private_class_method :new
 
-    def self.migrations_path
-      ActiveRecord::Migrator.migrations_path
+    # 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
@@ -44,16 +55,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)
-      instance_eval(&block)
-
-      unless info[:version].blank?
-        initialize_schema_migrations_table
-        assume_migrated_upto_version(info[:version], migrations_path)
-      end
+      new.define(info, &block)
     end
   end
 end

data/lib/active_record/schema_dumper.rb

@@ -24,6 +24,7 @@ module ActiveRecord
 
     def dump(stream)
       header(stream)
+      extensions(stream)
       tables(stream)
       trailer(stream)
       stream
@@ -38,7 +39,11 @@ module ActiveRecord
       end
 
       def header(stream)
-        define_params = @version ? ":version => #{@version}" : ""
+        define_params = @version ? "version: #{@version}" : ""
+
+        if stream.respond_to?(:external_encoding) && stream.external_encoding
+          stream.puts "# encoding: #{stream.external_encoding.name}"
+        end
 
         stream.puts <<HEADER
 # This file is auto-generated from the current state of the database. Instead
@@ -51,7 +56,7 @@ module ActiveRecord
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
 # you'll amass, the slower it'll run and the greater likelihood for issues).
 #
-# It's strongly recommended to check this file into your version control system.
+# It's strongly recommended that you check this file into your version control system.
 
 ActiveRecord::Schema.define(#{define_params}) do
 
@@ -62,12 +67,24 @@ HEADER
         stream.puts "end"
       end
 
+      def extensions(stream)
+        return unless @connection.supports_extensions?
+        extensions = @connection.extensions
+        if extensions.any?
+          stream.puts "  # These are extensions that must be enabled in order to support this database"
+          extensions.each do |extension|
+            stream.puts "  enable_extension #{extension.inspect}"
+          end
+          stream.puts
+        end
+      end
+
       def tables(stream)
         @connection.tables.sort.each do |tbl|
           next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
             case ignored
-            when String; tbl == ignored
-            when Regexp; tbl =~ ignored
+            when String; remove_prefix_and_suffix(tbl) == ignored
+            when Regexp; remove_prefix_and_suffix(tbl) =~ ignored
             else
               raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
             end
@@ -83,50 +100,38 @@ HEADER
 
           # first dump primary key column
           if @connection.respond_to?(:pk_and_sequence_for)
-            pk, pk_seq = @connection.pk_and_sequence_for(table)
+            pk, _ = @connection.pk_and_sequence_for(table)
           elsif @connection.respond_to?(:primary_key)
             pk = @connection.primary_key(table)
           end
 
-          tbl.print "  create_table #{table.inspect}"
+          tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
           if columns.detect { |c| c.name == pk }
             if pk != 'id'
-              tbl.print %Q(, :primary_key => "#{pk}")
+              tbl.print %Q(, primary_key: "#{pk}")
             end
           else
-            tbl.print ", :id => false"
+            tbl.print ", id: false"
           end
-          tbl.print ", :force => true"
+          tbl.print ", force: true"
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
           column_specs = columns.map do |column|
-            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            spec = {}
-            spec[:name]      = column.name.inspect
-
-            # AR has an optimisation which handles zero-scale decimals as integers.  This
-            # code ensures that the dumper still dumps the column as a decimal.
-            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
-                                 'decimal'
-                               else
-                                 column.type.to_s
-                               end
-            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-            spec[:precision] = column.precision.inspect if !column.precision.nil?
-            spec[:scale]     = column.scale.inspect if !column.scale.nil?
-            spec[:null]      = 'false' if !column.null
-            spec[:default]   = default_string(column.default) if column.has_default?
-            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
-            spec
+            @connection.column_spec(column, @types)
           end.compact
 
           # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
+          keys = @connection.migration_keys
 
           # figure out the lengths for each column based on above keys
-          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+          lengths = keys.map { |key|
+            column_specs.map { |spec|
+              spec[key] ? spec[key].length + 2 : 0
+            }.max
+          }
 
           # the string we're going to sprintf our values against, with standardized column widths
           format_string = lengths.map{ |len| "%-#{len}s" }
@@ -162,27 +167,27 @@ HEADER
         stream
       end
 
-      def default_string(value)
-        case value
-        when BigDecimal
-          value.to_s
-        when Date, DateTime, Time
-          "'" + value.to_s(:db) + "'"
-        else
-          value.inspect
-        end
-      end
-
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
-            statement_parts = [ ('add_index ' + index.table.inspect) ]
-            statement_parts << index.columns.inspect
-            statement_parts << (':name => ' + index.name.inspect)
-            statement_parts << ':unique => true' if index.unique
+            statement_parts = [
+              ('add_index ' + remove_prefix_and_suffix(index.table).inspect),
+              index.columns.inspect,
+              ('name: ' + index.name.inspect),
+            ]
+            statement_parts << 'unique: true' if index.unique
+
+            index_lengths = (index.lengths || []).compact
+            statement_parts << ('length: ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+
+            index_orders = (index.orders || {})
+            statement_parts << ('order: ' + index.orders.inspect) unless index_orders.empty?
 
-            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
-            statement_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
+            statement_parts << ('where: ' + index.where.inspect) if index.where
+
+            statement_parts << ('using: ' + index.using.inspect) if index.using
+
+            statement_parts << ('type: ' + index.type.inspect) if index.type
 
             '  ' + statement_parts.join(', ')
           end
@@ -191,5 +196,9 @@ HEADER
           stream.puts
         end
       end
+
+      def remove_prefix_and_suffix(table)
+        table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+      end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -0,0 +1,39 @@
+require 'active_record/scoping/default'
+require 'active_record/scoping/named'
+require 'active_record/base'
+
+module ActiveRecord
+  class SchemaMigration < ActiveRecord::Base
+
+    def self.table_name
+      "#{Base.table_name_prefix}schema_migrations#{Base.table_name_suffix}"
+    end
+
+    def self.index_name
+      "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
+    end
+
+    def self.create_table(limit=nil)
+      unless connection.table_exists?(table_name)
+        version_options = {null: false}
+        version_options[:limit] = limit if limit
+
+        connection.create_table(table_name, id: false) do |t|
+          t.column :version, :string, version_options
+        end
+        connection.add_index table_name, :version, unique: true, name: index_name
+      end
+    end
+
+    def self.drop_table
+      if connection.table_exists?(table_name)
+        connection.remove_index table_name, name: index_name
+        connection.drop_table(table_name)
+      end
+    end
+
+    def version
+      super.to_i
+    end
+  end
+end

data/lib/active_record/scoping/default.rb

@@ -0,0 +1,146 @@
+module ActiveRecord
+  module Scoping
+    module Default
+      extend ActiveSupport::Concern
+
+      included do
+        # Stores the default scope for the class.
+        class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+
+        self.default_scopes = []
+
+        def self.default_scopes?
+          ActiveSupport::Deprecation.warn(
+            "#default_scopes? is deprecated. Do something like #default_scopes.empty? instead."
+          )
+
+          !!self.default_scopes
+        end
+      end
+
+      module ClassMethods
+        # Returns a scope for the model without the +default_scope+.
+        #
+        #   class Post < ActiveRecord::Base
+        #     def self.default_scope
+        #       where published: true
+        #     end
+        #   end
+        #
+        #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
+        #   Post.unscoped.all # Fires "SELECT * FROM posts"
+        #
+        # This method also accepts a block. All queries inside the block will
+        # not use the +default_scope+:
+        #
+        #   Post.unscoped {
+        #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+        #   }
+        def unscoped
+          block_given? ? relation.scoping { yield } : relation
+        end
+
+        def before_remove_const #:nodoc:
+          self.current_scope = nil
+        end
+
+        protected
+
+        # Use this macro in your model to set a default scope for all operations on
+        # the model.
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_scope { where(published: true) }
+        #   end
+        #
+        #   Article.all # => SELECT * FROM articles WHERE published = true
+        #
+        # The +default_scope+ is also applied while creating/building a record.
+        # It is not applied while updating a record.
+        #
+        #   Article.new.published    # => true
+        #   Article.create.published # => true
+        #
+        # (You can also pass any object which responds to +call+ to the
+        # +default_scope+ macro, and it will be called when building the
+        # default scope.)
+        #
+        # If you use multiple +default_scope+ declarations in your model then
+        # they will be merged together:
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_scope { where(published: true) }
+        #     default_scope { where(rating: 'G') }
+        #   end
+        #
+        #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+        #
+        # This is also the case with inheritance and module includes where the
+        # parent or module defines a +default_scope+ and the child or including
+        # class defines a second one.
+        #
+        # If you need to do more complex things with a default scope, you can
+        # alternatively define it as a class method:
+        #
+        #   class Article < ActiveRecord::Base
+        #     def self.default_scope
+        #       # Should return a scope, you can call 'super' here etc.
+        #     end
+        #   end
+        def default_scope(scope = nil)
+          scope = Proc.new if block_given?
+
+          if scope.is_a?(Relation) || !scope.respond_to?(:call)
+            ActiveSupport::Deprecation.warn(
+              "Calling #default_scope without a block is deprecated. For example instead " \
+              "of `default_scope where(color: 'red')`, please use " \
+              "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+              "self.default_scope.)"
+            )
+          end
+
+          self.default_scopes += [scope]
+        end
+
+        def build_default_scope # :nodoc:
+          if !Base.is_a?(method(:default_scope).owner)
+            # The user has defined their own default scope method, so call that
+            evaluate_default_scope { default_scope }
+          elsif default_scopes.any?
+            evaluate_default_scope do
+              default_scopes.inject(relation) do |default_scope, scope|
+                if !scope.is_a?(Relation) && scope.respond_to?(:call)
+                  default_scope.merge(unscoped { scope.call })
+                else
+                  default_scope.merge(scope)
+                end
+              end
+            end
+          end
+        end
+
+        def ignore_default_scope? # :nodoc:
+          ScopeRegistry.value_for(:ignore_default_scope, self)
+        end
+
+        def ignore_default_scope=(ignore) # :nodoc:
+          ScopeRegistry.set_value_for(:ignore_default_scope, self, ignore)
+        end
+
+        # The ignore_default_scope flag is used to prevent an infinite recursion
+        # situation where a default scope references a scope which has a default
+        # scope which references a scope...
+        def evaluate_default_scope # :nodoc:
+          return if ignore_default_scope?
+
+          begin
+            self.ignore_default_scope = true
+            yield
+          ensure
+            self.ignore_default_scope = false
+          end
+        end
+      end
+    end
+  end
+end