activerecord 5.0.7.2 → 6.0.6.1

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

@@ -1,29 +1,39 @@
+# 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)
+        def select_all(*, **) # :nodoc:
           result = if ExplainRegistry.collect? && prepared_statements
             unprepared_statement { super }
           else
             super
           end
-          @connection.next_result while @connection.more_results?
+          @connection.abandon_results!
           result
         end
 
-        # 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 = [])
-          select_result(sql, name, binds) do |result|
-            @connection.next_result while @connection.more_results?
-            result.to_a
-          end
+        def query(sql, name = nil) # :nodoc:
+          execute(sql, name).to_a
+        end
+
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use
+        ) # :nodoc:
+        private_constant :READ_QUERY
+
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
         end
 
         # Executes the SQL statement in the context of this connection.
         def execute(sql, name = nil)
+          if preventing_writes? && write_query?(sql)
+            raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+          end
+
           # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
           # made since we established the connection
           @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
@@ -31,77 +41,155 @@ module ActiveRecord
           super
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
           if without_prepared_statement?(binds)
             execute_and_free(sql, name) do |result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
+              if result
+                ActiveRecord::Result.new(result.fields, result.to_a)
+              else
+                ActiveRecord::Result.new([], [])
+              end
             end
           else
             exec_stmt_and_free(sql, name, binds, cache_stmt: prepare) do |_, result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if result
+              if result
+                ActiveRecord::Result.new(result.fields, result.to_a)
+              else
+                ActiveRecord::Result.new([], [])
+              end
             end
           end
         end
 
-        def exec_delete(sql, name, binds)
+        def exec_delete(sql, name = nil, binds = [])
           if without_prepared_statement?(binds)
-            execute_and_free(sql, name) { @connection.affected_rows }
+            @lock.synchronize do
+              execute_and_free(sql, name) { @connection.affected_rows }
+            end
           else
             exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
           end
         end
         alias :exec_update :exec_delete
 
-        protected
+        private
+          def execute_batch(statements, name = nil)
+            combine_multi_statements(statements).each do |statement|
+              execute(statement, name)
+            end
+            @connection.abandon_results!
+          end
 
-        def last_inserted_id(result)
-          @connection.last_id
-        end
+          def default_insert_value(column)
+            super unless column.auto_increment?
+          end
 
-        private
+          def last_inserted_id(result)
+            @connection.last_id
+          end
 
-        def select_result(sql, name = nil, binds = [])
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name) { |result| yield result }
-          else
-            exec_stmt_and_free(sql, name, binds, cache_stmt: true) { |_, result| yield result }
+          def supports_set_server_option?
+            @connection.respond_to?(:set_server_option)
           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
-          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          def multi_statements_enabled?(flags)
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              (flags & Mysql2::Client::MULTI_STATEMENTS) != 0
+            end
+          end
 
-          type_casted_binds = type_casted_binds(binds)
+          def with_multi_statements
+            previous_flags = @config[:flags]
 
-          log(sql, name, binds, type_casted_binds) do
-            if cache_stmt
-              cache = @statements[sql] ||= {
-                stmt: @connection.prepare(sql)
-              }
-              stmt = cache[:stmt]
+            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 combine_multi_statements(total_sql)
+            total_sql.each_with_object([]) do |sql, total_sql_chunks|
+              previous_packet = total_sql_chunks.last
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
+              else
+                previous_packet << ";\n"
+                previous_packet << sql
+              end
+            end
+          end
+
+          def max_allowed_packet_reached?(current_packet, previous_packet)
+            if current_packet.bytesize > max_allowed_packet
+              raise ActiveRecordError,
+                "Fixtures set is too large #{current_packet.bytesize}. Consider increasing the max_allowed_packet variable."
+            elsif previous_packet.nil?
+              true
             else
-              stmt = @connection.prepare(sql)
+              (current_packet.bytesize + previous_packet.bytesize + 2) > max_allowed_packet
             end
+          end
+
+          def max_allowed_packet
+            @max_allowed_packet ||= show_variable("max_allowed_packet")
+          end
+
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
+            if preventing_writes? && write_query?(sql)
+              raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+            end
+
+            materialize_transactions
+
+            # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
+            # made since we established the connection
+            @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
 
-            begin
-              result = stmt.execute(*type_casted_binds)
-            rescue Mysql2::Error => e
+            type_casted_binds = type_casted_binds(binds)
+
+            log(sql, name, binds, type_casted_binds) do
               if cache_stmt
-                @statements.delete(sql)
+                stmt = @statements[sql] ||= @connection.prepare(sql)
               else
-                stmt.close
+                stmt = @connection.prepare(sql)
+              end
+
+              begin
+                result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                  stmt.execute(*type_casted_binds)
+                end
+              rescue Mysql2::Error => e
+                if cache_stmt
+                  @statements.delete(sql)
+                else
+                  stmt.close
+                end
+                raise e
               end
-              raise e
-            end
 
-            ret = yield stmt, result
-            result.free if result
-            stmt.close unless cache_stmt
-            ret
+              ret = yield stmt, result
+              result.free if result
+              stmt.close unless cache_stmt
+              ret
+            end
           end
-        end
       end
     end
   end

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
@@ -35,35 +37,34 @@ module ActiveRecord
         end
 
         private
-
-        def compute_column_widths(result)
-          [].tap do |widths|
-            result.columns.each_with_index do |column, i|
-              cells_in_column = [column] + result.rows.map {|r| r[i].nil? ? 'NULL' : r[i].to_s}
-              widths << cells_in_column.map(&:length).max
+          def compute_column_widths(result)
+            [].tap do |widths|
+              result.columns.each_with_index do |column, i|
+                cells_in_column = [column] + result.rows.map { |r| r[i].nil? ? "NULL" : r[i].to_s }
+                widths << cells_in_column.map(&:length).max
+              end
             end
           end
-        end
 
-        def build_separator(widths)
-          padding = 1
-          '+' + widths.map {|w| '-' * (w + (padding*2))}.join('+') + '+'
-        end
+          def build_separator(widths)
+            padding = 1
+            "+" + widths.map { |w| "-" * (w + (padding * 2)) }.join("+") + "+"
+          end
 
-        def build_cells(items, widths)
-          cells = []
-          items.each_with_index do |item, i|
-            item = 'NULL' if item.nil?
-            justifier = item.is_a?(Numeric) ? 'rjust' : 'ljust'
-            cells << item.to_s.send(justifier, widths[i])
+          def build_cells(items, widths)
+            cells = []
+            items.each_with_index do |item, i|
+              item = "NULL" if item.nil?
+              justifier = item.is_a?(Numeric) ? "rjust" : "ljust"
+              cells << item.to_s.send(justifier, widths[i])
+            end
+            "| " + cells.join(" | ") + " |"
           end
-          '| ' + cells.join(' | ') + ' |'
-        end
 
-        def build_footer(nrows, elapsed)
-          rows_label = nrows == 1 ? 'row' : 'rows'
-          "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
-        end
+          def build_footer(nrows, elapsed)
+            rows_label = nrows == 1 ? "row" : "rows"
+            "#{nrows} #{rows_label} in set (%.2f sec)" % elapsed
+          end
       end
     end
   end

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

@@ -1,29 +1,21 @@
+# 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('`', '``')}`"
+          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
         end
 
         def quote_table_name(name)
-          @quoted_table_names[name] ||= super.gsub('.', '`.`')
-        end
-
-        def quoted_true
-          QUOTED_TRUE
+          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
         end
 
         def unquoted_true
           1
         end
 
-        def quoted_false
-          QUOTED_FALSE
-        end
-
         def unquoted_false
           0
         end
@@ -32,19 +24,57 @@ module ActiveRecord
           if supports_datetime_with_precision?
             super
           else
-            super.sub(/\.\d{6}\z/, '')
+            super.sub(/\.\d{6}\z/, "")
           end
         end
 
-        private
+        def quoted_binary(value)
+          "x'#{value.hex}'"
+        end
 
-        def _quote(value)
-          if value.is_a?(Type::Binary::Data)
-            "x'#{value.hex}'"
-          else
-            super
-          end
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
         end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+AS\s+(?:\w+|`\w+`))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # `table_name`.`column_name` | function(one or no argument)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+            )
+            (?:\s+ASC|\s+DESC)?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
+        private
+          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,66 +1,70 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation
-        delegate :add_sql_comment!, to: :@conn
-        private :add_sql_comment!
+      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+        delegate :add_sql_comment!, :mariadb?, to: :@conn, private: true
 
         private
+          def visit_DropForeignKey(name)
+            "DROP FOREIGN KEY #{name}"
+          end
 
-        def visit_DropForeignKey(name)
-          "DROP FOREIGN KEY #{name}"
-        end
+          def visit_AddColumnDefinition(o)
+            add_column_position!(super, column_options(o.column))
+          end
 
-        def visit_ColumnDefinition(o)
-          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.unsigned)
-          super
-        end
+          def visit_ChangeColumnDefinition(o)
+            change_column_sql = +"CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
+            add_column_position!(change_column_sql, column_options(o.column))
+          end
 
-        def visit_AddColumnDefinition(o)
-          add_column_position!(super, column_options(o.column))
-        end
+          def add_table_options!(create_sql, options)
+            add_sql_comment!(super, options[:comment])
+          end
 
-        def visit_ChangeColumnDefinition(o)
-          change_column_sql = "CHANGE #{quote_column_name(o.name)} #{accept(o.column)}"
-          add_column_position!(change_column_sql, column_options(o.column))
-        end
+          def add_column_options!(sql, options)
+            # 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 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
 
-        def add_table_options!(create_sql, options)
-          add_sql_comment!(super, options[:comment])
-        end
+            if charset = options[:charset]
+              sql << " CHARACTER SET #{charset}"
+            end
 
-        def column_options(o)
-          column_options = super
-          column_options[:charset] = o.charset
-          column_options
-        end
+            if collation = options[:collation]
+              sql << " COLLATE #{collation}"
+            end
 
-        def add_column_options!(sql, options)
-          if charset = options[:charset]
-            sql << " CHARACTER SET #{charset}"
-          end
+            if as = options[:as]
+              sql << " AS (#{as})"
+              if options[:stored]
+                sql << (mariadb? ? " PERSISTENT" : " STORED")
+              end
+            end
 
-          if collation = options[:collation]
-            sql << " COLLATE #{collation}"
+            add_sql_comment!(super, options[:comment])
           end
 
-          add_sql_comment!(super, options[:comment])
-        end
+          def add_column_position!(sql, options)
+            if options[:first]
+              sql << " FIRST"
+            elsif options[:after]
+              sql << " AFTER #{quote_column_name(options[:after])}"
+            end
 
-        def add_column_position!(sql, options)
-          if options[:first]
-            sql << " FIRST"
-          elsif options[:after]
-            sql << " AFTER #{quote_column_name(options[:after])}"
+            sql
           end
 
-          sql
-        end
-
-        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)
-        end
+          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)
+          end
       end
     end
   end

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

@@ -1,88 +1,90 @@
+# 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 type == :bigint && !options.key?(:default)
-          super
-        end
+        extend ActiveSupport::Concern
 
-        def blob(*args, **options)
-          args.each { |name| column(name, :blob, options) }
-        end
+        ##
+        # :method: blob
+        # :call-seq: blob(*names, **options)
 
-        def tinyblob(*args, **options)
-          args.each { |name| column(name, :tinyblob, options) }
-        end
+        ##
+        # :method: tinyblob
+        # :call-seq: tinyblob(*names, **options)
 
-        def mediumblob(*args, **options)
-          args.each { |name| column(name, :mediumblob, options) }
-        end
+        ##
+        # :method: mediumblob
+        # :call-seq: mediumblob(*names, **options)
 
-        def longblob(*args, **options)
-          args.each { |name| column(name, :longblob, options) }
-        end
+        ##
+        # :method: longblob
+        # :call-seq: longblob(*names, **options)
 
-        def tinytext(*args, **options)
-          args.each { |name| column(name, :tinytext, options) }
-        end
+        ##
+        # :method: tinytext
+        # :call-seq: tinytext(*names, **options)
 
-        def mediumtext(*args, **options)
-          args.each { |name| column(name, :mediumtext, options) }
-        end
+        ##
+        # :method: mediumtext
+        # :call-seq: mediumtext(*names, **options)
 
-        def longtext(*args, **options)
-          args.each { |name| column(name, :longtext, options) }
-        end
+        ##
+        # :method: longtext
+        # :call-seq: longtext(*names, **options)
 
-        def json(*args, **options)
-          args.each { |name| column(name, :json, options) }
-        end
+        ##
+        # :method: unsigned_integer
+        # :call-seq: unsigned_integer(*names, **options)
 
-        def unsigned_integer(*args, **options)
-          args.each { |name| column(name, :unsigned_integer, options) }
-        end
+        ##
+        # :method: unsigned_bigint
+        # :call-seq: unsigned_bigint(*names, **options)
 
-        def unsigned_bigint(*args, **options)
-          args.each { |name| column(name, :unsigned_bigint, options) }
-        end
+        ##
+        # :method: unsigned_float
+        # :call-seq: unsigned_float(*names, **options)
 
-        def unsigned_float(*args, **options)
-          args.each { |name| column(name, :unsigned_float, options) }
-        end
+        ##
+        # :method: unsigned_decimal
+        # :call-seq: unsigned_decimal(*names, **options)
 
-        def unsigned_decimal(*args, **options)
-          args.each { |name| column(name, :unsigned_decimal, options) }
+        included do
+          define_column_methods :blob, :tinyblob, :mediumblob, :longblob,
+            :tinytext, :mediumtext, :longtext, :unsigned_integer, :unsigned_bigint,
+            :unsigned_float, :unsigned_decimal
         end
       end
 
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-        attr_accessor :charset, :unsigned
-      end
-
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
-        def new_column_definition(name, type, options) # :nodoc:
-          column = super
-          case column.type
+        def new_column_definition(name, type, **options) # :nodoc:
+          case type
+          when :virtual
+            type = options[:type]
           when :primary_key
-            column.type = :integer
-            column.auto_increment = true
+            type = :integer
+            options[:limit] ||= 8
+            options[:primary_key] = true
           when /\Aunsigned_(?<type>.+)\z/
-            column.type = $~[:type].to_sym
-            column.unsigned = true
+            type = $~[:type].to_sym
+            options[:unsigned] = true
           end
-          column.unsigned ||= options[:unsigned]
-          column.charset = options[:charset]
-          column
+
+          super
         end
 
         private
+          def aliased_types(name, fallback)
+            fallback
+          end
 
-        def create_column_definition(name, type)
-          MySQL::ColumnDefinition.new(name, type)
-        end
+          def integer_like_primary_key_type(type, options)
+            options[:auto_increment] = true
+            type
+          end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table