activerecord 5.1.7 → 5.2.4.3

data/lib/active_record/connection_adapters/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
@@ -9,7 +11,7 @@ module ActiveRecord
 
       # Instantiates a new column in the table.
       #
-      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int</tt>.
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id bigint</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "uri"
 
 module ActiveRecord
@@ -181,13 +183,25 @@ module ActiveRecord
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
 
+          # Require the adapter itself and give useful feedback about
+          #   1. Missing adapter gems and
+          #   2. Adapter gems' missing dependencies.
           path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
           begin
             require path_to_adapter
-          rescue Gem::LoadError => e
-            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
           rescue LoadError => e
-            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
+            # We couldn't require the adapter itself. Raise an exception that
+            # points out config typos and missing gems.
+            if e.path == path_to_adapter
+              # We can assume that a non-builtin adapter was specified, so it's
+              # either misspelled or missing from Gemfile.
+              raise LoadError, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+            # Bubbled up from the adapter require. Prefix the exception message
+            # with some guidance about how to address it and reraise.
+            else
+              raise LoadError, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+            end
           end
 
           adapter_method = "#{spec[:adapter]}_connection"

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -1,15 +1,26 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module DetermineIfPreparableVisitor
-      attr_reader :preparable
+      attr_accessor :preparable
 
       def accept(*)
         @preparable = true
         super
       end
 
-      def visit_Arel_Nodes_In(*)
+      def visit_Arel_Nodes_In(o, collector)
         @preparable = false
+
+        if Array === o.right && !o.right.empty?
+          o.right.delete_if do |bind|
+            if Arel::Nodes::BindParam === bind && Relation::QueryAttribute === bind.value
+              !bind.value.boundable?
+            end
+          end
+        end
+
         super
       end
 

data/lib/active_record/connection_adapters/mysql/column.rb

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

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

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module DatabaseStatements
         # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], preparable: nil) # :nodoc:
+        def select_all(*) # :nodoc:
           result = if ExplainRegistry.collect? && prepared_statements
             unprepared_statement { super }
           else
             super
           end
-          @connection.next_result while @connection.more_results?
+          discard_remaining_results
           result
         end
 
@@ -48,11 +50,54 @@ module ActiveRecord
         alias :exec_update :exec_delete
 
         private
+          def default_insert_value(column)
+            Arel.sql("DEFAULT") unless column.auto_increment?
+          end
 
           def last_inserted_id(result)
             @connection.last_id
           end
 
+          def discard_remaining_results
+            @connection.next_result while @connection.more_results?
+          end
+
+          def supports_set_server_option?
+            @connection.respond_to?(:set_server_option)
+          end
+
+          def multi_statements_enabled?(flags)
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              (flags & Mysql2::Client::MULTI_STATEMENTS) != 0
+            end
+          end
+
+          def with_multi_statements
+            previous_flags = @config[:flags]
+
+            unless multi_statements_enabled?(previous_flags)
+              if supports_set_server_option?
+                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+              else
+                @config[:flags] = Mysql2::Client::MULTI_STATEMENTS
+                reconnect!
+              end
+            end
+
+            yield
+          ensure
+            unless multi_statements_enabled?(previous_flags)
+              if supports_set_server_option?
+                @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+              else
+                @config[:flags] = previous_flags
+                reconnect!
+              end
+            end
+          end
+
           def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
             # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
             # made since we established the connection

data/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb

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

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

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
-        QUOTED_TRUE, QUOTED_FALSE = "1".freeze, "0".freeze
-
         def quote_column_name(name)
           @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`".freeze
         end
@@ -12,18 +12,10 @@ module ActiveRecord
           @quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
         end
 
-        def quoted_true
-          QUOTED_TRUE
-        end
-
         def unquoted_true
           1
         end
 
-        def quoted_false
-          QUOTED_FALSE
-        end
-
         def unquoted_false
           0
         end
@@ -39,6 +31,13 @@ module ActiveRecord
         def quoted_binary(value)
           "x'#{value.hex}'"
         end
+
+        def _type_cast(value)
+          case value
+          when Date, Time then value
+          else super
+          end
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
@@ -16,7 +18,7 @@ module ActiveRecord
           end
 
           def visit_ChangeColumnDefinition(o)
-            change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+            change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}".dup
             add_column_position!(change_column_sql, column_options(o.column))
           end
 
@@ -28,7 +30,7 @@ module ActiveRecord
             # By default, TIMESTAMP columns are NOT NULL, cannot contain NULL values,
             # and assigning NULL assigns the current timestamp. To permit a TIMESTAMP
             # column to contain NULL, explicitly declare it with the NULL attribute.
-            # See http://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
+            # See https://dev.mysql.com/doc/refman/5.7/en/timestamp-initialization.html
             if /\Atimestamp\b/.match?(options[:column].sql_type) && !options[:primary_key]
               sql << " NULL" unless options[:null] == false || options_include_default?(options)
             end
@@ -63,7 +65,7 @@ module ActiveRecord
 
           def index_in_create(table_name, column_name, options)
             index_name, index_type, index_columns, _, _, index_using, comment = @conn.add_index_options(table_name, column_name, options)
-            add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})", comment)
+            add_sql_comment!("#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})".dup, comment)
           end
       end
     end

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

@@ -1,12 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module ColumnMethods
-        def primary_key(name, type = :primary_key, **options)
-          options[:auto_increment] = true if [:integer, :bigint].include?(type) && !options.key?(:default)
-          super
-        end
-
         def blob(*args, **options)
           args.each { |name| column(name, :blob, options) }
         end
@@ -35,10 +32,6 @@ module ActiveRecord
           args.each { |name| column(name, :longtext, options) }
         end
 
-        def json(*args, **options)
-          args.each { |name| column(name, :json, options) }
-        end
-
         def unsigned_integer(*args, **options)
           args.each { |name| column(name, :unsigned_integer, options) }
         end
@@ -66,7 +59,6 @@ module ActiveRecord
           when :primary_key
             type = :integer
             options[:limit] ||= 8
-            options[:auto_increment] = true
             options[:primary_key] = true
           when /\Aunsigned_(?<type>.+)\z/
             type = $~[:type].to_sym
@@ -80,6 +72,11 @@ module ActiveRecord
           def aliased_types(name, fallback)
             fallback
           end
+
+          def integer_like_primary_key_type(type, options)
+            options[:auto_increment] = true
+            type
+          end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table

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

@@ -1,32 +1,29 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      module ColumnDumper # :nodoc:
-        def prepare_column_options(column)
-          spec = super
-          spec[:unsigned] = "true" if column.unsigned?
-          spec[:auto_increment] = "true" if column.auto_increment?
-
-          if supports_virtual_columns? && column.virtual?
-            spec[:as] = extract_expression_for_virtual_column(column)
-            spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
-            spec = { type: schema_type(column).inspect }.merge!(spec)
-          end
-
-          spec
-        end
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        private
+          def prepare_column_options(column)
+            spec = super
+            spec[:unsigned] = "true" if column.unsigned?
+            spec[:auto_increment] = "true" if column.auto_increment?
 
-        def column_spec_for_primary_key(column)
-          spec = super
-          spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
-          spec
-        end
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec[:stored] = "true" if /\b(?:STORED|PERSISTENT)\b/.match?(column.extra)
+              spec = { type: schema_type(column).inspect }.merge!(spec)
+            end
 
-        def migration_keys
-          super + [:unsigned]
-        end
+            spec
+          end
 
-        private
+          def column_spec_for_primary_key(column)
+            spec = super
+            spec.delete(:auto_increment) if column.type == :integer && column.auto_increment?
+            spec
+          end
 
           def default_primary_key?(column)
             super && column.auto_increment? && !column.unsigned?
@@ -54,24 +51,27 @@ module ActiveRecord
           def schema_collation(column)
             if column.collation && table_name = column.table_name
               @table_collation_cache ||= {}
-              @table_collation_cache[table_name] ||= exec_query("SHOW TABLE STATUS LIKE #{quote(table_name)}", "SCHEMA").first["Collation"]
+              @table_collation_cache[table_name] ||=
+                @connection.exec_query("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}", "SCHEMA").first["Collation"]
               column.collation.inspect if column.collation != @table_collation_cache[table_name]
             end
           end
 
           def extract_expression_for_virtual_column(column)
-            if mariadb? && version < "10.2.5"
-              create_table_info = create_table_info(column.table_name)
-              if %r/#{quote_column_name(column.name)} #{Regexp.quote(column.sql_type)}(?: COLLATE \w+)? AS \((?<expression>.+?)\) #{column.extra}/ =~ create_table_info
+            if @connection.mariadb? && @connection.version < "10.2.5"
+              create_table_info = @connection.send(:create_table_info, column.table_name)
+              column_name = @connection.quote_column_name(column.name)
+              if %r/#{column_name} #{Regexp.quote(column.sql_type)}(?: COLLATE \w+)? AS \((?<expression>.+?)\) #{column.extra}/ =~ create_table_info
                 $~[:expression].inspect
               end
             else
-              scope = quoted_scope(column.table_name)
+              scope = @connection.send(:quoted_scope, column.table_name)
+              column_name = @connection.quote(column.name)
               sql = "SELECT generation_expression FROM information_schema.columns" \
                     " WHERE table_schema = #{scope[:schema]}" \
                     "   AND table_name = #{scope[:name]}" \
-                    "   AND column_name = #{quote(column.name)}"
-              query_value(sql, "SCHEMA").inspect
+                    "   AND column_name = #{column_name}"
+              @connection.query_value(sql, "SCHEMA").inspect
             end
           end
       end

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

@@ -1,7 +1,56 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module SchemaStatements # :nodoc:
+        # Returns an array of indexes for the given table.
+        def indexes(table_name)
+          indexes = []
+          current_index = nil
+          execute_and_free("SHOW KEYS FROM #{quote_table_name(table_name)}", "SCHEMA") do |result|
+            each_hash(result) do |row|
+              if current_index != row[:Key_name]
+                next if row[:Key_name] == "PRIMARY" # skip the primary key
+                current_index = row[:Key_name]
+
+                mysql_index_type = row[:Index_type].downcase.to_sym
+                case mysql_index_type
+                when :fulltext, :spatial
+                  index_type = mysql_index_type
+                when :btree, :hash
+                  index_using = mysql_index_type
+                end
+
+                indexes << [
+                  row[:Table],
+                  row[:Key_name],
+                  row[:Non_unique].to_i == 0,
+                  [],
+                  lengths: {},
+                  orders: {},
+                  type: index_type,
+                  using: index_using,
+                  comment: row[:Index_comment].presence
+                ]
+              end
+
+              indexes.last[-2] << row[:Column_name]
+              indexes.last[-1][:lengths].merge!(row[:Column_name] => row[:Sub_part].to_i) if row[:Sub_part]
+              indexes.last[-1][:orders].merge!(row[:Column_name] => :desc) if row[:Collation] == "D"
+            end
+          end
+
+          indexes.map { |index| IndexDefinition.new(*index) }
+        end
+
+        def remove_column(table_name, column_name, type = nil, options = {})
+          if foreign_key_exists?(table_name, column: column_name)
+            remove_foreign_key(table_name, column: column_name)
+          end
+          super
+        end
+
         def internal_string_options_for_primary_key
           super.tap do |options|
             if CHARSETS_OF_4BYTES_MAXLEN.include?(charset) && (mariadb? || version < "8.0.0")
@@ -10,13 +59,69 @@ module ActiveRecord
           end
         end
 
+        def update_table_definition(table_name, base)
+          MySQL::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          MySQL::SchemaDumper.create(self, options)
+        end
+
         private
           CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
 
+          def schema_creation
+            MySQL::SchemaCreation.new(self)
+          end
+
+          def create_table_definition(*args)
+            MySQL::TableDefinition.new(*args)
+          end
+
+          def new_column_from_field(table_name, field)
+            type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
+            if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(field[:Default])
+              default, default_function = nil, field[:Default]
+            else
+              default, default_function = field[:Default], nil
+            end
+
+            MySQL::Column.new(
+              field[:Field],
+              default,
+              type_metadata,
+              field[:Null] == "YES",
+              table_name,
+              default_function,
+              field[:Collation],
+              comment: field[:Comment].presence
+            )
+          end
+
+          def fetch_type_metadata(sql_type, extra = "")
+            MySQL::TypeMetadata.new(super(sql_type), extra: extra)
+          end
+
+          def extract_foreign_key_action(specifier)
+            super unless specifier == "RESTRICT"
+          end
+
+          def add_index_length(quoted_columns, **options)
+            lengths = options_for_index_columns(options[:length])
+            quoted_columns.each do |name, column|
+              column << "(#{lengths[name]})" if lengths[name].present?
+            end
+          end
+
+          def add_options_for_index_columns(quoted_columns, **options)
+            quoted_columns = add_index_length(quoted_columns, options)
+            super
+          end
+
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
 
-            sql = "SELECT table_name FROM information_schema.tables"
+            sql = "SELECT table_name FROM information_schema.tables".dup
             sql << " WHERE table_schema = #{scope[:schema]}"
             sql << " AND table_name = #{scope[:name]}" if scope[:name]
             sql << " AND table_type = #{scope[:type]}" if scope[:type]