activerecord 6.0.0 → 7.2.3

data/lib/active_record/connection_adapters/column.rb

@@ -5,6 +5,8 @@ module ActiveRecord
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
+      include Deduplicable
+
       attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
@@ -61,6 +63,15 @@ module ActiveRecord
         coder["comment"] = @comment
       end
 
+      # whether the column is auto-populated by the database using a sequence
+      def auto_incremented_by_db?
+        false
+      end
+
+      def auto_populated?
+        auto_incremented_by_db? || default_function
+      end
+
       def ==(other)
         other.is_a?(Column) &&
           name == other.name &&
@@ -76,6 +87,7 @@ module ActiveRecord
       def hash
         Column.hash ^
           name.hash ^
+          name.encoding.hash ^
           default.hash ^
           sql_type_metadata.hash ^
           null.hash ^
@@ -83,10 +95,25 @@ module ActiveRecord
           collation.hash ^
           comment.hash
       end
+
+      def virtual?
+        false
+      end
+
+      private
+        def deduplicated
+          @name = -name
+          @sql_type_metadata = sql_type_metadata.deduplicate if sql_type_metadata
+          @default = -default if default
+          @default_function = -default_function if default_function
+          @collation = -collation if collation
+          @comment = -comment if comment
+          super
+        end
     end
 
     class NullColumn < Column
-      def initialize(name)
+      def initialize(name, **)
         super(name, nil)
       end
     end

data/lib/active_record/connection_adapters/deduplicable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Deduplicable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def registry
+          @registry ||= {}
+        end
+
+        def new(*, **)
+          super.deduplicate
+        end
+      end
+
+      def deduplicate
+        self.class.registry[self] ||= deduplicated
+      end
+      alias :-@ :deduplicate
+
+      private
+        def deduplicated
+          freeze
+        end
+    end
+  end
+end

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

@@ -11,12 +11,13 @@ module ActiveRecord
         end
 
         def case_sensitive?
-          collation && !/_ci\z/.match?(collation)
+          collation && !collation.end_with?("_ci")
         end
 
         def auto_increment?
           extra == "auto_increment"
         end
+        alias_method :auto_incremented_by_db?, :auto_increment?
 
         def virtual?
           /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)

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

@@ -4,130 +4,65 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module DatabaseStatements
-        # Returns an ActiveRecord::Result instance.
-        def select_all(*) # :nodoc:
-          result = if ExplainRegistry.collect? && prepared_statements
-            unprepared_statement { super }
-          else
-            super
-          end
-          @connection.abandon_results!
-          result
-        end
-
-        def query(sql, name = nil) # :nodoc:
-          execute(sql, name).to_a
-        end
-
-        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(:begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback) # :nodoc:
+        READ_QUERY = AbstractAdapter.build_read_query_regexp(
+          :desc, :describe, :set, :show, :use, :kill
+        ) # :nodoc:
         private_constant :READ_QUERY
 
+        # https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_current-timestamp
+        # https://dev.mysql.com/doc/refman/5.7/en/date-and-time-type-syntax.html
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP(6)", retryable: true).freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         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
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        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
+        def explain(arel, binds = [], options = [])
+          sql     = build_explain_clause(options) + " " + to_sql(arel, binds)
+          start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result  = internal_exec_query(sql, "EXPLAIN", binds)
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
-          super
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name) do |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|
-              if result
-                ActiveRecord::Result.new(result.fields, result.to_a)
-              else
-                ActiveRecord::Result.new([], [])
-              end
-            end
-          end
-        end
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
 
-        def exec_delete(sql, name = nil, binds = [])
-          if without_prepared_statement?(binds)
-            @lock.synchronize do
-              execute_and_free(sql, name) { @connection.affected_rows }
-            end
+          explain_clause = "EXPLAIN #{options.join(" ").upcase}"
+
+          if analyze_without_explain? && explain_clause.include?("ANALYZE")
+            explain_clause.sub("EXPLAIN ", "")
           else
-            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+            explain_clause
           end
         end
-        alias :exec_update :exec_delete
 
         private
-          def execute_batch(sql, name = nil)
-            super
-            @connection.abandon_results!
+          # https://mariadb.com/kb/en/analyze-statement/
+          def analyze_without_explain?
+            mariadb? && database_version >= "10.1.0"
           end
 
           def default_insert_value(column)
             super unless column.auto_increment?
           end
 
-          def last_inserted_id(result)
-            @connection.last_id
-          end
-
-          def supports_set_server_option?
-            @connection.respond_to?(:set_server_option)
-          end
-
-          def build_truncate_statements(*table_names)
-            if table_names.size == 1
-              super.first
+          def returning_column_values(result)
+            if supports_insert_returning?
+              result.rows.first
             else
               super
             end
           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 combine_multi_statements(total_sql)
             total_sql.each_with_object([]) do |sql, total_sql_chunks|
               previous_packet = total_sql_chunks.last
@@ -154,46 +89,6 @@ module ActiveRecord
           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
-
-            type_casted_binds = type_casted_binds(binds)
-
-            log(sql, name, binds, type_casted_binds) do
-              if cache_stmt
-                stmt = @statements[sql] ||= @connection.prepare(sql)
-              else
-                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
-
-              ret = yield stmt, result
-              result.free if result
-              stmt.close unless cache_stmt
-              ret
-            end
-          end
       end
     end
   end

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

@@ -37,7 +37,6 @@ module ActiveRecord
         end
 
         private
-
           def compute_column_widths(result)
             [].tap do |widths|
               result.columns.each_with_index do |column, i|
@@ -57,7 +56,7 @@ module ActiveRecord
             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])
+              cells << item.to_s.public_send(justifier, widths[i])
             end
             "| " + cells.join(" | ") + " |"
           end

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

@@ -1,15 +1,72 @@
 # frozen_string_literal: true
 
+require "active_support/time_with_zone"
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
-        def quote_column_name(name)
-          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \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
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # `table_name`.`column_name` | function(one or no argument)
+                  ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
+                )
+                (?:\s+COLLATE\s+(?:\w+|"\w+"))?
+                (?:\s+ASC|\s+DESC)?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= "`#{name.to_s.gsub('`', '``')}`".freeze
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= "`#{name.to_s.gsub('`', '``').gsub(".", "`.`")}`".freeze
+          end
         end
 
-        def quote_table_name(name)
-          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+        def cast_bound_value(value)
+          case value
+          when Rational
+            value.to_f.to_s
+          when Numeric
+            value.to_s
+          when BigDecimal
+            value.to_s("F")
+          when true
+            "1"
+          when false
+            "0"
+          else
+            value
+          end
         end
 
         def unquoted_true
@@ -32,49 +89,39 @@ module ActiveRecord
           "x'#{value.hex}'"
         end
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
+        def unquote_identifier(identifier)
+          if identifier && identifier.start_with?("`")
+            identifier[1..-2]
+          else
+            identifier
+          end
         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
+        # Override +type_cast+ we pass to mysql2 Date and Time objects instead
+        # of Strings since MySQL adapters are able to handle those classes more efficiently.
+        def type_cast(value) # :nodoc:
+          case value
+          when ActiveSupport::TimeWithZone
+            # We need to check explicitly for ActiveSupport::TimeWithZone because
+            # we need to transform it to Time objects but we don't want to
+            # transform Time objects to themselves.
+            if default_timezone == :utc
+              value.getutc
+            else
+              value.getlocal
+            end
+          when Time
+            if default_timezone == :utc
+              value.utc? ? value : value.getutc
+            else
+              value.utc? ? value.getlocal : value
             end
+          when Date
+            value
+          else
+            super
           end
+        end
       end
     end
   end

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

@@ -3,15 +3,18 @@
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+      class SchemaCreation < SchemaCreation # :nodoc:
         delegate :add_sql_comment!, :mariadb?, to: :@conn, private: true
 
         private
-
           def visit_DropForeignKey(name)
             "DROP FOREIGN KEY #{name}"
           end
 
+          def visit_DropCheckConstraint(name)
+            "DROP #{mariadb? ? 'CONSTRAINT' : 'CHECK'} #{name}"
+          end
+
           def visit_AddColumnDefinition(o)
             add_column_position!(super, column_options(o.column))
           end
@@ -21,15 +24,46 @@ module ActiveRecord
             add_column_position!(change_column_sql, column_options(o.column))
           end
 
-          def add_table_options!(create_sql, options)
-            add_sql_comment!(super, options[:comment])
+          def visit_ChangeColumnDefaultDefinition(o)
+            sql = +"ALTER COLUMN #{quote_column_name(o.column.name)} "
+            if o.default.nil? && !o.column.null
+              sql << "DROP DEFAULT"
+            else
+              sql << "SET DEFAULT #{quote_default_expression(o.default, o.column)}"
+            end
+          end
+
+          def visit_CreateIndexDefinition(o)
+            sql = visit_IndexDefinition(o.index, true)
+            sql << " #{o.algorithm}" if o.algorithm
+            sql
+          end
+
+          def visit_IndexDefinition(o, create = false)
+            index_type = o.type&.to_s&.upcase || o.unique && "UNIQUE"
+
+            sql = create ? ["CREATE"] : []
+            sql << index_type if index_type
+            sql << "INDEX"
+            sql << quote_column_name(o.name)
+            sql << "USING #{o.using}" if o.using
+            sql << "ON #{quote_table_name(o.table)}" if create
+            sql << "(#{quoted_columns(o)})"
+
+            add_sql_comment!(sql.join(" "), o.comment)
+          end
+
+          def add_table_options!(create_sql, o)
+            create_sql << " DEFAULT CHARSET=#{o.charset}" if o.charset
+            create_sql << " COLLATE=#{o.collation}" if o.collation
+            add_sql_comment!(super, o.comment)
           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
+            # See https://dev.mysql.com/doc/refman/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,8 +97,8 @@ module ActiveRecord
           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)
+            index, _ = @conn.add_index_options(table_name, column_name, **options)
+            accept(index)
           end
       end
     end

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

@@ -57,9 +57,18 @@ module ActiveRecord
         end
       end
 
+      # = Active Record MySQL Adapter \Table Definition
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        attr_reader :charset, :collation
+
+        def initialize(conn, name, charset: nil, collation: nil, **)
+          super
+          @charset = charset
+          @collation = collation
+        end
+
         def new_column_definition(name, type, **options) # :nodoc:
           case type
           when :virtual
@@ -77,16 +86,24 @@ module ActiveRecord
         end
 
         private
+          def valid_column_definition_options
+            super + [:auto_increment, :charset, :as, :size, :unsigned, :first, :after, :type, :stored]
+          end
+
           def aliased_types(name, fallback)
             fallback
           end
 
           def integer_like_primary_key_type(type, options)
-            options[:auto_increment] = true
+            unless options[:auto_increment] == false
+              options[:auto_increment] = true
+            end
+
             type
           end
       end
 
+      # = Active Record MySQL Adapter \Table
       class Table < ActiveRecord::ConnectionAdapters::Table
         include ColumnMethods
       end

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

@@ -49,18 +49,24 @@ module ActiveRecord
           end
 
           def schema_limit(column)
-            super unless /\A(?:enum|set|(?:tiny|medium|long)?(?:text|blob))\b/.match?(column.sql_type)
+            super unless /\A(?:tiny|medium|long)?(?:text|blob)\b/.match?(column.sql_type)
           end
 
           def schema_precision(column)
-            super unless /\A(?:date)?time(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+            if /\Atime(?:stamp)?\b/.match?(column.sql_type) && column.precision == 0
+              nil
+            elsif column.type == :datetime
+              column.precision == 0 ? "nil" : super
+            else
+              super
+            end
           end
 
           def schema_collation(column)
             if column.collation
               @table_collation_cache ||= {}
               @table_collation_cache[table_name] ||=
-                @connection.exec_query("SHOW TABLE STATUS LIKE #{@connection.quote(table_name)}", "SCHEMA").first["Collation"]
+                @connection.internal_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
@@ -79,7 +85,10 @@ module ActiveRecord
                     " WHERE table_schema = #{scope[:schema]}" \
                     "   AND table_name = #{scope[:name]}" \
                     "   AND column_name = #{column_name}"
-              @connection.query_value(sql, "SCHEMA").inspect
+              # Calling .inspect leads into issues with the query result
+              # which already returns escaped quotes.
+              # We remove the escape sequence from the result in order to deal with double escaping issues.
+              @connection.query_value(sql, "SCHEMA").gsub("\\'", "'").inspect
             end
           end
       end