activerecord 5.0.0.beta3 → 5.0.0.beta4

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -104,7 +104,7 @@ module ActiveRecord
 
               To silence this deprecation warning, add the following:
 
-                  config.active_record.time_zone_aware_types << :time
+                  config.active_record.time_zone_aware_types = [:datetime, :time]
             MESSAGE
           end
 

data/lib/active_record/attributes.rb

@@ -119,7 +119,7 @@ module ActiveRecord
       #
       #   class MoneyType < ActiveRecord::Type::Integer
       #     def cast(value)
-      #       if !value.kind_of(Numeric) && value.include?('$')
+      #       if !value.kind_of?(Numeric) && value.include?('$')
       #         price_in_dollars = value.gsub(/\$/, '').to_f
       #         super(price_in_dollars * 100)
       #       else
@@ -154,7 +154,7 @@ module ActiveRecord
       #   end
       #
       #   class MoneyType < Type::Value
-      #     def initialize(currency_converter)
+      #     def initialize(currency_converter:)
       #       @currency_converter = currency_converter
       #     end
       #
@@ -171,7 +171,7 @@ module ActiveRecord
       #
       #   class Product < ActiveRecord::Base
       #     currency_converter = ConversionRatesFromTheInternet.new
-      #     attribute :price_in_bitcoins, :money, currency_converter
+      #     attribute :price_in_bitcoins, :money, currency_converter: currency_converter
       #   end
       #
       #   Product.where(price_in_bitcoins: Money.new(5, "USD"))

data/lib/active_record/autosave_association.rb

@@ -22,7 +22,7 @@ module ActiveRecord
   #
   # == Validation
   #
-  # Children records are validated unless <tt>:validate</tt> is +false+.
+  # Child records are validated unless <tt>:validate</tt> is +false+.
   #
   # == Callbacks
   #

data/lib/active_record/base.rb

@@ -169,7 +169,8 @@ module ActiveRecord #:nodoc:
   # ActiveRecord::RecordNotFound error if they do not return any records,
   # like <tt>Person.find_by_last_name!</tt>.
   #
-  # It's also possible to use multiple attributes in the same find by separating them with "_and_".
+  # It's also possible to use multiple attributes in the same <tt>find_by_</tt> by separating them with
+  # "_and_".
   #
   #  Person.find_by(user_name: user_name, password: password)
   #  Person.find_by_user_name_and_password(user_name, password) # with dynamic finder

data/lib/active_record/collection_cache_key.rb

@@ -16,7 +16,7 @@ module ActiveRecord
 
         query = collection
           .unscope(:select)
-          .select("COUNT(*) AS size", "MAX(#{column}) AS timestamp")
+          .select("COUNT(*) AS #{connection.quote_column_name("size")}", "MAX(#{column}) AS timestamp")
           .unscope(:order)
         result = connection.select_one(query)
 

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -951,24 +951,5 @@ module ActiveRecord
         owner_to_pool && owner_to_pool[owner.name]
       end
     end
-
-    class ConnectionManagement
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        testing = env['rack.test']
-
-        status, headers, body = @app.call(env)
-        proxy = ::Rack::BodyProxy.new(body) do
-          ActiveRecord::Base.clear_active_connections! unless testing
-        end
-        [status, headers, proxy]
-      rescue Exception
-        ActiveRecord::Base.clear_active_connections! unless testing
-        raise
-      end
-    end
   end
 end

data/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -66,8 +66,8 @@ module ActiveRecord
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
       def select_rows(sql, name = nil, binds = [])
+        exec_query(sql, name, binds).rows
       end
-      undef_method :select_rows
 
       # Executes the SQL statement in the context of this connection and returns
       # the raw result from the connection adapter.
@@ -75,13 +75,14 @@ module ActiveRecord
       # method may be manually memory managed. Consider using the exec_query
       # wrapper instead.
       def execute(sql, name = nil)
+        raise NotImplementedError
       end
-      undef_method :execute
 
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+        raise NotImplementedError
       end
 
       # Executes insert +sql+ statement in the context of this connection using
@@ -125,18 +126,21 @@ module ActiveRecord
       end
       alias create insert
       alias insert_sql insert
+      deprecate insert_sql: :insert
 
       # Executes the update statement and returns the number of rows affected.
       def update(arel, name = nil, binds = [])
         exec_update(to_sql(arel, binds), name, binds)
       end
       alias update_sql update
+      deprecate update_sql: :update
 
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
         exec_delete(to_sql(arel, binds), name, binds)
       end
       alias delete_sql delete
+      deprecate delete_sql: :delete
 
       # Returns +true+ when the connection adapter supports prepared statement
       # caching, otherwise returns +false+
@@ -217,9 +221,7 @@ module ActiveRecord
       # * You are creating a nested (savepoint) transaction
       #
       # The mysql2 and postgresql adapters support setting the transaction
-      # isolation level. However, support is disabled for MySQL versions below 5,
-      # because they are affected by a bug[http://bugs.mysql.com/bug.php?id=39170]
-      # which means the isolation level gets persisted outside the transaction.
+      # isolation level.
       def transaction(requires_new: nil, isolation: nil, joinable: true)
         if !requires_new && current_transaction.joinable?
           if isolation
@@ -289,9 +291,6 @@ module ActiveRecord
         exec_rollback_to_savepoint(name)
       end
 
-      def exec_rollback_to_savepoint(name = nil) #:nodoc:
-      end
-
       def default_sequence_name(table, column)
         nil
       end

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -65,7 +65,7 @@ module ActiveRecord
         if @query_cache_enabled && !locked?(arel)
           arel, binds = binds_from_relation arel, binds
           sql = to_sql(arel, binds)
-          cache_sql(sql, binds) { super(sql, name, binds, preparable: visitor.preparable) }
+          cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
         else
           super
         end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -82,7 +82,7 @@ module ActiveRecord
 
       # Quotes the column name. Defaults to no quoting.
       def quote_column_name(column_name)
-        column_name
+        column_name.to_s
       end
 
       # Quotes the table name. Defaults to column name quoting.
@@ -146,6 +146,10 @@ module ActiveRecord
         end
       end
 
+      def quoted_time(value) # :nodoc:
+        quoted_date(value).sub(/\A2000-01-01 /, '')
+      end
+
       def prepare_binds_for_database(binds) # :nodoc:
         binds.map(&:value_for_database)
       end
@@ -166,6 +170,7 @@ module ActiveRecord
         # BigDecimals need to be put in a non-normalized form and quoted.
         when BigDecimal then value.to_s('F')
         when Numeric, ActiveSupport::Duration then value.to_s
+        when Type::Time::Value then "'#{quoted_time(value)}'"
         when Date, Time then "'#{quoted_date(value)}'"
         when Symbol     then "'#{quote_string(value.to_s)}'"
         when Class      then "'#{value}'"
@@ -181,6 +186,7 @@ module ActiveRecord
         when false      then unquoted_false
         # BigDecimals need to be put in a non-normalized form and quoted.
         when BigDecimal then value.to_s('F')
+        when Type::Time::Value then quoted_time(value)
         when Date, Time then quoted_date(value)
         when *types_which_need_no_typecasting
           value

data/lib/active_record/connection_adapters/abstract/savepoints.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
-    module Savepoints #:nodoc:
-      def supports_savepoints?
-        true
+    module Savepoints
+      def current_savepoint_name
+        current_transaction.savepoint_name
       end
 
       def create_savepoint(name = current_savepoint_name)

data/lib/active_record/connection_adapters/abstract/schema_creation.rb

@@ -53,8 +53,8 @@ module ActiveRecord
               statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
             end
 
-            create_sql << "(#{statements.join(', ')}) " if statements.present?
-            create_sql << "#{o.options}"
+            create_sql << "(#{statements.join(', ')})" if statements.present?
+            add_table_options!(create_sql, table_options(o))
             create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
             create_sql
           end
@@ -82,6 +82,19 @@ module ActiveRecord
             "DROP CONSTRAINT #{quote_column_name(name)}"
           end
 
+          def table_options(o)
+            table_options = {}
+            table_options[:comment] = o.comment
+            table_options[:options] = o.options
+            table_options
+          end
+
+          def add_table_options!(create_sql, options)
+            if options_sql = options[:options]
+              create_sql << " #{options_sql}"
+            end
+          end
+
           def column_options(o)
             column_options = {}
             column_options[:null] = o.null unless o.null.nil?
@@ -92,6 +105,7 @@ module ActiveRecord
             column_options[:auto_increment] = o.auto_increment
             column_options[:primary_key] = o.primary_key
             column_options[:collation] = o.collation
+            column_options[:comment] = o.comment
             column_options
           end
 

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -3,14 +3,14 @@ module ActiveRecord
     # Abstract representation of an index definition on a table. Instances of
     # this type are typically created and returned by methods in database
     # adapters. e.g. ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#indexes
-    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using) #:nodoc:
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using, :comment) #:nodoc:
     end
 
     # Abstract representation of a column definition. Instances of this type
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :auto_increment, :primary_key, :collation, :sql_type) #:nodoc:
+    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :auto_increment, :primary_key, :collation, :sql_type, :comment) #:nodoc:
 
       def primary_key?
         primary_key || type.to_sym == :primary_key
@@ -207,9 +207,9 @@ module ActiveRecord
       include ColumnMethods
 
       attr_accessor :indexes
-      attr_reader :name, :temporary, :options, :as, :foreign_keys
+      attr_reader :name, :temporary, :options, :as, :foreign_keys, :comment
 
-      def initialize(name, temporary, options, as = nil)
+      def initialize(name, temporary = false, options = nil, as = nil, comment: nil)
         @columns_hash = {}
         @indexes = {}
         @foreign_keys = []
@@ -218,6 +218,7 @@ module ActiveRecord
         @options = options
         @as = as
         @name = name
+        @comment = comment
       end
 
       def primary_keys(name = nil) # :nodoc:
@@ -330,6 +331,9 @@ module ActiveRecord
       end
 
       def foreign_key(table_name, options = {}) # :nodoc:
+        table_name_prefix = ActiveRecord::Base.table_name_prefix
+        table_name_suffix = ActiveRecord::Base.table_name_suffix
+        table_name = "#{table_name_prefix}#{table_name}#{table_name_suffix}"
         foreign_keys.push([table_name, options])
       end
 
@@ -373,6 +377,7 @@ module ActiveRecord
         column.auto_increment = options[:auto_increment]
         column.primary_key = type == :primary_key || options[:primary_key]
         column.collation   = options[:collation]
+        column.comment     = options[:comment]
         column
       end
 

data/lib/active_record/connection_adapters/abstract/schema_dumper.rb

@@ -7,15 +7,16 @@ module ActiveRecord
     # Adapter level by over-writing this code inside the database specific adapters
     module ColumnDumper
       def column_spec(column)
-        spec = prepare_column_options(column)
-        (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k}: ")}
+        spec = Hash[prepare_column_options(column).map { |k, v| [k, "#{k}: #{v}"] }]
+        spec[:name] = column.name.inspect
+        spec[:type] = schema_type(column).to_s
         spec
       end
 
       def column_spec_for_primary_key(column)
-        return if column.type == :integer
+        return {} if default_primary_key?(column)
         spec = { id: schema_type(column).inspect }
-        spec.merge!(prepare_column_options(column).delete_if { |key, _| [:name, :type].include?(key) })
+        spec.merge!(prepare_column_options(column).except!(:null))
       end
 
       # This can be overridden on an Adapter level basis to support other
@@ -23,9 +24,6 @@ module ActiveRecord
       # PostgreSQL::ColumnDumper)
       def prepare_column_options(column)
         spec = {}
-        spec[:name]      = column.name.inspect
-        spec[:type]      = schema_type(column).to_s
-        spec[:null]      = 'false' unless column.null
 
         if limit = schema_limit(column)
           spec[:limit] = limit
@@ -42,26 +40,38 @@ module ActiveRecord
         default = schema_default(column) if column.has_default?
         spec[:default]   = default unless default.nil?
 
+        spec[:null] = 'false' unless column.null
+
         if collation = schema_collation(column)
           spec[:collation] = collation
         end
 
+        spec[:comment] = column.comment.inspect if column.comment.present?
+
         spec
       end
 
       # Lists the valid migration options
       def migration_keys
-        [:name, :limit, :precision, :scale, :default, :null, :collation]
+        [:name, :limit, :precision, :scale, :default, :null, :collation, :comment]
       end
 
       private
 
+      def default_primary_key?(column)
+        schema_type(column) == :integer
+      end
+
       def schema_type(column)
-        column.type
+        if column.bigint?
+          :bigint
+        else
+          column.type
+        end
       end
 
       def schema_limit(column)
-        limit = column.limit
+        limit = column.limit unless column.bigint?
         limit.inspect if limit && limit != native_database_types[column.type][:limit]
       end
 

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -18,6 +18,11 @@ module ActiveRecord
         nil
       end
 
+      # Returns the table comment that's stored in database metadata.
+      def table_comment(table_name)
+        nil
+      end
+
       # Truncates a table alias according to the limits of the current adapter.
       def table_alias_for(table_name)
         table_name[0...table_alias_length].tr('.', '_')
@@ -254,8 +259,8 @@ module ActiveRecord
       #     SELECT * FROM orders INNER JOIN line_items ON order_id=orders.id
       #
       # See also TableDefinition#column for details on how to create columns.
-      def create_table(table_name, options = {})
-        td = create_table_definition table_name, options[:temporary], options[:options], options[:as]
+      def create_table(table_name, comment: nil, **options)
+        td = create_table_definition table_name, options[:temporary], options[:options], options[:as], comment: comment
 
         if options[:id] != false && !options[:as]
           pk = options.fetch(:primary_key) do
@@ -283,6 +288,14 @@ module ActiveRecord
           end
         end
 
+        if supports_comments? && !supports_comments_in_create?
+          change_table_comment(table_name, comment) if comment
+
+          td.columns.each do |column|
+            change_column_comment(table_name, column.name, column.comment) if column.comment
+          end
+        end
+
         result
       end
 
@@ -329,12 +342,13 @@ module ActiveRecord
 
         column_options = options.delete(:column_options) || {}
         column_options.reverse_merge!(null: false)
+        type = column_options.delete(:type) || :integer
 
         t1_column, t2_column = [table_1, table_2].map{ |t| t.to_s.singularize.foreign_key }
 
         create_table(join_table_name, options.merge!(id: false)) do |td|
-          td.integer t1_column, column_options
-          td.integer t2_column, column_options
+          td.send type, t1_column, column_options
+          td.send type, t2_column, column_options
           yield td if block_given?
         end
       end
@@ -776,7 +790,8 @@ module ActiveRecord
       # [<tt>:type</tt>]
       #   The reference column type. Defaults to +:integer+.
       # [<tt>:index</tt>]
-      #   Add an appropriate index. Defaults to false.
+      #   Add an appropriate index. Defaults to false.  
+      #   See #add_index for usage of this option.
       # [<tt>:foreign_key</tt>]
       #   Add an appropriate foreign key constraint. Defaults to false.
       # [<tt>:polymorphic</tt>]
@@ -796,6 +811,14 @@ module ActiveRecord
       #
       #   add_reference(:products, :supplier, polymorphic: true, index: true)
       #
+      # ====== Create a supplier_id column with a unique index
+      #
+      #   add_reference(:products, :supplier, index: { unique: true })
+      #
+      # ====== Create a supplier_id column with a named index
+      #
+      #   add_reference(:products, :supplier, index: { name: "my_supplier_index" })
+      #
       # ====== Create a supplier_id column and appropriate foreign key
       #
       #   add_reference(:products, :supplier, foreign_key: true)
@@ -854,7 +877,7 @@ module ActiveRecord
       #
       # generates:
       #
-      #   ALTER TABLE "articles" ADD CONSTRAINT articles_author_id_fk FOREIGN KEY ("author_id") REFERENCES "authors" ("id")
+      #   ALTER TABLE "articles" ADD CONSTRAINT fk_rails_e74ce85cbc FOREIGN KEY ("author_id") REFERENCES "authors" ("id")
       #
       # ====== Creating a foreign key on a specific column
       #
@@ -870,7 +893,7 @@ module ActiveRecord
       #
       # generates:
       #
-      #   ALTER TABLE "articles" ADD CONSTRAINT articles_author_id_fk FOREIGN KEY ("author_id") REFERENCES "authors" ("id") ON DELETE CASCADE
+      #   ALTER TABLE "articles" ADD CONSTRAINT fk_rails_e74ce85cbc FOREIGN KEY ("author_id") REFERENCES "authors" ("id") ON DELETE CASCADE
       #
       # The +options+ hash can include the following keys:
       # [<tt>:column</tt>]
@@ -962,11 +985,23 @@ module ActiveRecord
       end
 
       def dump_schema_information #:nodoc:
+        versions = ActiveRecord::SchemaMigration.order('version').pluck(:version)
+        insert_versions_sql(versions)
+      end
+
+      def insert_versions_sql(versions) # :nodoc:
         sm_table = ActiveRecord::Migrator.schema_migrations_table_name
 
-        sql = "INSERT INTO #{sm_table} (version) VALUES "
-        sql << ActiveRecord::SchemaMigration.order('version').pluck(:version).map {|v| "('#{v}')" }.join(', ')
-        sql << ";\n\n"
+        if supports_multi_insert?
+          sql = "INSERT INTO #{sm_table} (version) VALUES "
+          sql << versions.map {|v| "('#{v}')" }.join(', ')
+          sql << ";\n\n"
+          sql
+        else
+          versions.map { |version|
+            "INSERT INTO #{sm_table} (version) VALUES ('#{version}');"
+          }.join "\n\n"
+        end
       end
 
       # Should not be called normally, but this operation is non-destructive.
@@ -1003,7 +1038,7 @@ module ActiveRecord
           if (duplicate = inserting.detect {|v| inserting.count(v) > 1})
             raise "Duplicate migration #{duplicate}. Please renumber your migrations to resolve the conflict."
           end
-          execute "INSERT INTO #{sm_table} (version) VALUES #{inserting.map {|v| "('#{v}')"}.join(', ') }"
+          execute insert_versions_sql(inserting)
         end
       end
 
@@ -1051,9 +1086,9 @@ module ActiveRecord
       end
 
       # Adds timestamps (+created_at+ and +updated_at+) columns to +table_name+.
-      # Additional options (like <tt>null: false</tt>) are forwarded to #add_column.
+      # Additional options (like +:null+) are forwarded to #add_column.
       #
-      #   add_timestamps(:suppliers, null: false)
+      #   add_timestamps(:suppliers, null: true)
       #
       def add_timestamps(table_name, options = {})
         options[:null] = false if options[:null].nil?
@@ -1075,15 +1110,19 @@ module ActiveRecord
         Table.new(table_name, base)
       end
 
-      def add_index_options(table_name, column_name, options = {}) #:nodoc:
-        column_names = Array(column_name)
+      def add_index_options(table_name, column_name, comment: nil, **options) # :nodoc:
+        if column_name.is_a?(String) && /\W/ === column_name
+          column_names = column_name
+        else
+          column_names = Array(column_name)
+        end
 
         options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :using, :algorithm, :type)
 
         index_type = options[:type].to_s if options.key?(:type)
         index_type ||= options[:unique] ? "UNIQUE" : ""
         index_name = options[:name].to_s if options.key?(:name)
-        index_name ||= index_name(table_name, column: column_names)
+        index_name ||= index_name(table_name, index_name_options(column_names))
         max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
 
         if options.key?(:algorithm)
@@ -1106,13 +1145,23 @@ module ActiveRecord
         end
         index_columns = quoted_columns_for_index(column_names, options).join(", ")
 
-        [index_name, index_type, index_columns, index_options, algorithm, using]
+        [index_name, index_type, index_columns, index_options, algorithm, using, comment]
       end
 
       def options_include_default?(options)
         options.include?(:default) && !(options[:null] == false && options[:default].nil?)
       end
 
+      # Changes the comment for a table or removes it if +nil+.
+      def change_table_comment(table_name, comment)
+        raise NotImplementedError, "#{self.class} does not support changing table comments"
+      end
+
+      # Changes the comment for a column or removes it if +nil+.
+      def change_column_comment(table_name, column_name, comment) #:nodoc:
+        raise NotImplementedError, "#{self.class} does not support changing column comments"
+      end
+
       protected
         def add_index_sort_order(option_strings, column_names, options = {})
           if options.is_a?(Hash) && order = options[:order]
@@ -1129,6 +1178,8 @@ module ActiveRecord
 
         # Overridden by the MySQL adapter for supporting index lengths
         def quoted_columns_for_index(column_names, options = {})
+          return [column_names] if column_names.is_a?(String)
+
           option_strings = Hash[column_names.map {|name| [name, '']}]
 
           # add index sort order if supported
@@ -1140,6 +1191,8 @@ module ActiveRecord
         end
 
         def index_name_for_remove(table_name, options = {})
+          return options[:name] if can_remove_index_by_name?(options)
+
           # if the adapter doesn't support the indexes call the best we can do
           # is return the default index name for the options provided
           return index_name(table_name, options) unless respond_to?(:indexes)
@@ -1147,7 +1200,7 @@ module ActiveRecord
           checks = []
 
           if options.is_a?(Hash)
-            checks << lambda { |i| i.name == options[:name].to_s } if options.has_key?(:name)
+            checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
             column_names = Array(options[:column]).map(&:to_s)
           else
             column_names = Array(options).map(&:to_s)
@@ -1194,14 +1247,22 @@ module ActiveRecord
         end
 
       private
-      def create_table_definition(name, temporary = false, options = nil, as = nil)
-        TableDefinition.new(name, temporary, options, as)
+      def create_table_definition(*args)
+        TableDefinition.new(*args)
       end
 
       def create_alter_table(name)
         AlterTable.new create_table_definition(name)
       end
 
+      def index_name_options(column_names) # :nodoc:
+        if column_names.is_a?(String)
+          column_names = column_names.scan(/\w+/).join('_')
+        end
+
+        { column: column_names }
+      end
+
       def foreign_key_name(table_name, options) # :nodoc:
         identifier = "#{table_name}_#{options.fetch(:column)}_fk"
         hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
@@ -1223,6 +1284,10 @@ module ActiveRecord
           default_or_changes
         end
       end
+
+      def can_remove_index_by_name?(options)
+        options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
+      end
     end
   end
 end