activerecord 5.1.7 → 5.2.6

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

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
@@ -28,17 +32,17 @@ module ActiveRecord
         end
 
         def enable_query_cache!
-          @query_cache_enabled[connection_cache_key(Thread.current)] = true
+          @query_cache_enabled[connection_cache_key(current_thread)] = true
           connection.enable_query_cache! if active_connection?
         end
 
         def disable_query_cache!
-          @query_cache_enabled.delete connection_cache_key(Thread.current)
+          @query_cache_enabled.delete connection_cache_key(current_thread)
           connection.disable_query_cache! if active_connection?
         end
 
         def query_cache_enabled
-          @query_cache_enabled[connection_cache_key(Thread.current)]
+          @query_cache_enabled[connection_cache_key(current_thread)]
         end
       end
 
@@ -90,8 +94,13 @@ module ActiveRecord
 
       def select_all(arel, name = nil, binds = [], preparable: nil)
         if @query_cache_enabled && !locked?(arel)
-          arel, binds = binds_from_relation arel, binds
-          sql = to_sql(arel, binds)
+          arel = arel_from_relation(arel)
+          sql, binds = to_sql_and_binds(arel, binds)
+
+          if preparable.nil?
+            preparable = prepared_statements ? visitor.preparable : false
+          end
+
           cache_sql(sql, name, binds) { super(sql, name, binds, preparable: preparable) }
         else
           super
@@ -124,6 +133,7 @@ module ActiveRecord
         # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
         # queries should not be cached.
         def locked?(arel)
+          arel = arel.arel if arel.is_a?(Relation)
           arel.respond_to?(:locked) && arel.locked
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/big_decimal/conversions"
 require "active_support/multibyte/chars"
 
@@ -5,21 +7,12 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module Quoting
       # Quotes the column value to help prevent
-      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      # {SQL injection attacks}[https://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
         value = id_value_for_database(value) if value.is_a?(Base)
 
-        if value.respond_to?(:quoted_id)
-          at = value.method(:quoted_id).source_location
-          at &&= " at %s:%d" % at
-
-          owner = value.method(:quoted_id).owner.to_s
-          klass = value.class.to_s
-          klass += "(#{owner})" unless owner == klass
-
-          ActiveSupport::Deprecation.warn \
-            "Defining #quoted_id is deprecated and will be ignored in Rails 5.2. (defined on #{klass}#{at})"
-          return value.quoted_id
+        if value.respond_to?(:value_for_database)
+          value = value.value_for_database
         end
 
         _quote(value)
@@ -31,10 +24,6 @@ module ActiveRecord
       def type_cast(value, column = nil)
         value = id_value_for_database(value) if value.is_a?(Base)
 
-        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
-          return value.id
-        end
-
         if column
           value = type_cast_from_column(column, value)
         end
@@ -68,17 +57,6 @@ module ActiveRecord
         lookup_cast_type(column.sql_type)
       end
 
-      def fetch_type_metadata(sql_type)
-        cast_type = lookup_cast_type(sql_type)
-        SqlTypeMetadata.new(
-          sql_type: sql_type,
-          type: cast_type.type,
-          limit: cast_type.limit,
-          precision: cast_type.precision,
-          scale: cast_type.scale,
-        )
-      end
-
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
@@ -117,19 +95,19 @@ module ActiveRecord
       end
 
       def quoted_true
-        "'t'".freeze
+        "TRUE".freeze
       end
 
       def unquoted_true
-        "t".freeze
+        true
       end
 
       def quoted_false
-        "'f'".freeze
+        "FALSE".freeze
       end
 
       def unquoted_false
-        "f".freeze
+        false
       end
 
       # Quote date/time values for use in SQL input. Includes microseconds
@@ -169,6 +147,10 @@ module ActiveRecord
       end
 
       private
+        def lookup_cast_type(sql_type)
+          type_map.lookup(sql_type)
+        end
+
         def id_value_for_database(value)
           if primary_key = value.class.primary_key
             value.instance_variable_get(:@attributes)[primary_key].value_for_database

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Savepoints

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/strip"
 
 module ActiveRecord
@@ -22,7 +24,7 @@ module ActiveRecord
         private
 
           def visit_AlterTable(o)
-            sql = "ALTER TABLE #{quote_table_name(o.name)} "
+            sql = "ALTER TABLE #{quote_table_name(o.name)} ".dup
             sql << o.adds.map { |col| accept col }.join(" ")
             sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
             sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
@@ -30,17 +32,17 @@ module ActiveRecord
 
           def visit_ColumnDefinition(o)
             o.sql_type = type_to_sql(o.type, o.options)
-            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}"
+            column_sql = "#{quote_column_name(o.name)} #{o.sql_type}".dup
             add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
             column_sql
           end
 
           def visit_AddColumnDefinition(o)
-            "ADD #{accept(o.column)}"
+            "ADD #{accept(o.column)}".dup
           end
 
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+            create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
 
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
@@ -55,7 +57,7 @@ module ActiveRecord
 
             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 << " AS #{to_sql(o.as)}" if o.as
             create_sql
           end
 
@@ -93,6 +95,7 @@ module ActiveRecord
             if options_sql = options[:options]
               create_sql << " #{options_sql}"
             end
+            create_sql
           end
 
           def column_options(o)
@@ -114,6 +117,11 @@ module ActiveRecord
             sql
           end
 
+          def to_sql(sql)
+            sql = sql.to_sql if sql.respond_to?(:to_sql)
+            sql
+          end
+
           def foreign_key_in_create(from_table, to_table, options)
             options = foreign_key_options(from_table, to_table, options)
             accept ForeignKeyDefinition.new(from_table, to_table, options)
@@ -133,5 +141,6 @@ module ActiveRecord
           end
       end
     end
+    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end

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

@@ -1,9 +1,47 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
     # 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
-    IndexDefinition = Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using, :comment) #:nodoc:
+    # adapters. e.g. ActiveRecord::ConnectionAdapters::MySQL::SchemaStatements#indexes
+    class IndexDefinition # :nodoc:
+      attr_reader :table, :name, :unique, :columns, :lengths, :orders, :opclasses, :where, :type, :using, :comment
+
+      def initialize(
+        table, name,
+        unique = false,
+        columns = [],
+        lengths: {},
+        orders: {},
+        opclasses: {},
+        where: nil,
+        type: nil,
+        using: nil,
+        comment: nil
+      )
+        @table = table
+        @name = name
+        @unique = unique
+        @columns = columns
+        @lengths = concise_options(lengths)
+        @orders = concise_options(orders)
+        @opclasses = concise_options(opclasses)
+        @where = where
+        @type = type
+        @using = using
+        @comment = comment
+      end
+
+      private
+        def concise_options(options)
+          if columns.size == options.size && options.values.uniq.size == 1
+            options.values.first
+          else
+            options
+          end
+        end
+    end
 
     # Abstract representation of a column definition. Instances of this type
     # are typically created by methods in TableDefinition, and added to the
@@ -58,6 +96,11 @@ module ActiveRecord
         options[:primary_key] != default_primary_key
       end
 
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
       def defined_for?(to_table_ord = nil, to_table: nil, **options)
         if to_table_ord
           self.to_table == to_table_ord.to_s
@@ -177,6 +220,7 @@ module ActiveRecord
         :decimal,
         :float,
         :integer,
+        :json,
         :string,
         :text,
         :time,
@@ -369,6 +413,9 @@ module ActiveRecord
       alias :belongs_to :references
 
       def new_column_definition(name, type, **options) # :nodoc:
+        if integer_like_primary_key?(type, options)
+          type = integer_like_primary_key_type(type, options)
+        end
         type = aliased_types(type.to_s, type)
         options[:primary_key] ||= type == :primary_key
         options[:null] = false if options[:primary_key]
@@ -383,6 +430,14 @@ module ActiveRecord
         def aliased_types(name, fallback)
           "timestamp" == name ? :datetime : fallback
         end
+
+        def integer_like_primary_key?(type, options)
+          options[:primary_key] && [:integer, :bigint].include?(type) && !options.key?(:default)
+        end
+
+        def integer_like_primary_key_type(type, options)
+          type
+        end
     end
 
     class AlterTable # :nodoc:
@@ -443,6 +498,9 @@ module ActiveRecord
     #     t.date
     #     t.binary
     #     t.boolean
+    #     t.foreign_key
+    #     t.json
+    #     t.virtual
     #     t.remove
     #     t.remove_references
     #     t.remove_belongs_to
@@ -607,19 +665,19 @@ module ActiveRecord
 
       # Adds a foreign key.
       #
-      # t.foreign_key(:authors)
+      #  t.foreign_key(:authors)
       #
       # See {connection.add_foreign_key}[rdoc-ref:SchemaStatements#add_foreign_key]
-      def foreign_key(*args) # :nodoc:
+      def foreign_key(*args)
         @base.add_foreign_key(name, *args)
       end
 
       # Checks to see if a foreign key exists.
       #
-      # t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
+      #  t.foreign_key(:authors) unless t.foreign_key_exists?(:authors)
       #
       # See {connection.foreign_key_exists?}[rdoc-ref:SchemaStatements#foreign_key_exists?]
-      def foreign_key_exists?(*args) # :nodoc:
+      def foreign_key_exists?(*args)
         @base.foreign_key_exists?(name, *args)
       end
     end

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

@@ -1,63 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/compact"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    # The goal of this module is to move Adapter specific column
-    # definitions to the Adapter instead of having it in the schema
-    # dumper itself. This code represents the normal case.
-    # We can then redefine how certain data types may be handled in the schema dumper on the
-    # Adapter level by over-writing this code inside the database specific adapters
-    module ColumnDumper
-      def column_spec(column)
-        [schema_type_with_virtual(column), prepare_column_options(column)]
+    class SchemaDumper < SchemaDumper # :nodoc:
+      def self.create(connection, options)
+        new(connection, options)
       end
 
-      def column_spec_for_primary_key(column)
-        return {} if default_primary_key?(column)
-        spec = { id: schema_type(column).inspect }
-        spec.merge!(prepare_column_options(column).except!(:null))
-        spec[:default] ||= "nil" if explicit_primary_key_default?(column)
-        spec
-      end
-
-      # This can be overridden on an Adapter level basis to support other
-      # extended datatypes (Example: Adding an array option in the
-      # PostgreSQL::ColumnDumper)
-      def prepare_column_options(column)
-        spec = {}
-
-        if limit = schema_limit(column)
-          spec[:limit] = limit
+      private
+        def column_spec(column)
+          [schema_type_with_virtual(column), prepare_column_options(column)]
         end
 
-        if precision = schema_precision(column)
-          spec[:precision] = precision
+        def column_spec_for_primary_key(column)
+          return {} if default_primary_key?(column)
+          spec = { id: schema_type(column).inspect }
+          spec.merge!(prepare_column_options(column).except!(:null))
+          spec[:default] ||= "nil" if explicit_primary_key_default?(column)
+          spec
         end
 
-        if scale = schema_scale(column)
-          spec[:scale] = scale
+        def prepare_column_options(column)
+          spec = {}
+          spec[:limit] = schema_limit(column)
+          spec[:precision] = schema_precision(column)
+          spec[:scale] = schema_scale(column)
+          spec[:default] = schema_default(column)
+          spec[:null] = "false" unless column.null
+          spec[:collation] = schema_collation(column)
+          spec[:comment] = column.comment.inspect if column.comment.present?
+          spec.compact!
+          spec
         end
 
-        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 # :nodoc:
-        column_options_keys
-      end
-      deprecate :migration_keys
-
-      private
-
         def default_primary_key?(column)
           schema_type(column) == :bigint
         end
@@ -67,7 +44,7 @@ module ActiveRecord
         end
 
         def schema_type_with_virtual(column)
-          if supports_virtual_columns? && column.virtual?
+          if @connection.supports_virtual_columns? && column.virtual?
             :virtual
           else
             schema_type(column)
@@ -84,7 +61,7 @@ module ActiveRecord
 
         def schema_limit(column)
           limit = column.limit unless column.bigint?
-          limit.inspect if limit && limit != native_database_types[column.type][:limit]
+          limit.inspect if limit && limit != @connection.native_database_types[column.type][:limit]
         end
 
         def schema_precision(column)
@@ -96,7 +73,8 @@ module ActiveRecord
         end
 
         def schema_default(column)
-          type = lookup_cast_type_from_column(column)
+          return unless column.has_default?
+          type = @connection.lookup_cast_type_from_column(column)
           default = type.deserialize(column.default)
           if default.nil?
             schema_expression(column)