activerecord 7.0.0 → 7.1.2

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

@@ -4,138 +4,57 @@ 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(
-          :desc, :describe, :set, :show, :use
+        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)").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
 
-        def explain(arel, binds = [])
-          sql     = "EXPLAIN #{to_sql(arel, binds)}"
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def explain(arel, binds = [], options = [])
+          sql     = build_explain_clause(options) + " " + to_sql(arel, binds)
           start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          result  = exec_query(sql, "EXPLAIN", binds)
+          result  = internal_exec_query(sql, "EXPLAIN", binds)
           elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
           MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
         end
 
-        # Executes the SQL statement in the context of this connection.
-        def execute(sql, name = nil, async: false)
-          sql = transform_query(sql)
-          check_if_write_query(sql)
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
 
-          raw_execute(sql, name, async: async)
-        end
+          explain_clause = "EXPLAIN #{options.join(" ").upcase}"
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
-          if without_prepared_statement?(binds)
-            execute_and_free(sql, name, async: async) do |result|
-              if result
-                build_result(columns: result.fields, rows: result.to_a)
-              else
-                build_result(columns: [], rows: [])
-              end
-            end
-          else
-            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare, async: async) do |_, result|
-              if result
-                build_result(columns: result.fields, rows: result.to_a)
-              else
-                build_result(columns: [], rows: [])
-              end
-            end
-          end
-        end
-
-        def exec_delete(sql, name = nil, binds = []) # :nodoc:
-          if without_prepared_statement?(binds)
-            @lock.synchronize do
-              execute_and_free(sql, name) { @connection.affected_rows }
-            end
+          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
-
-        # 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)").freeze # :nodoc:
-        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
-
-        def high_precision_current_timestamp
-          HIGH_PRECISION_CURRENT_TIMESTAMP
-        end
 
         private
-          def raw_execute(sql, name, async: false)
-            # make sure we carry over any changes to ActiveRecord.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord.default_timezone
-
-            super
-          end
-
-          def execute_batch(statements, name = nil)
-            statements = statements.map { |sql| transform_query(sql) }
-            combine_multi_statements(statements).each do |statement|
-              raw_execute(statement, name)
-            end
-            @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 multi_statements_enabled?
-            flags = @config[:flags]
-
-            if flags.is_a?(Array)
-              flags.include?("MULTI_STATEMENTS")
-            else
-              flags.anybits?(Mysql2::Client::MULTI_STATEMENTS)
-            end
-          end
-
-          def with_multi_statements
-            multi_statements_was = multi_statements_enabled?
-
-            unless multi_statements_was
-              @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
-            end
-
-            yield
-          ensure
-            unless multi_statements_was
-              @connection.set_server_option(Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
-            end
-          end
-
           def combine_multi_statements(total_sql)
             total_sql.each_with_object([]) do |sql, total_sql_chunks|
               previous_packet = total_sql_chunks.last
@@ -162,46 +81,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, async: false)
-            sql = transform_query(sql)
-            check_if_write_query(sql)
-
-            materialize_transactions
-            mark_transaction_written_if_write(sql)
-
-            # make sure we carry over any changes to ActiveRecord.default_timezone that have been
-            # made since we established the connection
-            @connection.query_options[:database_timezone] = ActiveRecord.default_timezone
-
-            type_casted_binds = type_casted_binds(binds)
-
-            log(sql, name, binds, type_casted_binds, async: async) 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/quoting.rb

@@ -6,27 +6,35 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       module Quoting # :nodoc:
-        def quote_bound_value(value)
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        def cast_bound_value(value)
           case value
+          when Rational
+            value.to_f.to_s
           when Numeric
-            quote(value.to_s)
+            value.to_s
           when BigDecimal
-            quote(value.to_s("F"))
+            value.to_s("F")
           when true
-            "'1'"
+            "1"
           when false
-            "'0'"
+            "0"
+          when ActiveSupport::Duration
+            warn_quote_duration_deprecated
+            value.to_s
           else
-            quote(value)
+            value
           end
         end
 
         def quote_column_name(name)
-          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
+          QUOTED_COLUMN_NAMES[name] ||= "`#{super.gsub('`', '``')}`"
         end
 
         def quote_table_name(name)
-          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+          QUOTED_TABLE_NAMES[name] ||= super.gsub(".", "`.`").freeze
         end
 
         def unquoted_true
@@ -49,15 +57,23 @@ module ActiveRecord
           "x'#{value.hex}'"
         end
 
+        def unquote_identifier(identifier)
+          if identifier && identifier.start_with?("`")
+            identifier[1..-2]
+          else
+            identifier
+          end
+        end
+
         # Override +type_cast+ we pass to mysql2 Date and Time objects instead
-        # of Strings since mysql2 is able to handle those classes more efficiently.
+        # 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 ActiveRecord.default_timezone == :utc
+            if default_timezone == :utc
               value.getutc
             else
               value.getlocal
@@ -82,7 +98,7 @@ module ActiveRecord
           (
             (?:
               # `table_name`.`column_name` | function(one or no argument)
-              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
             )
             (?:(?:\s+AS)?\s+(?:\w+|`\w+`))?
           )
@@ -95,8 +111,9 @@ module ActiveRecord
           (
             (?:
               # `table_name`.`column_name` | function(one or no argument)
-              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`)) | \w+\((?:|\g<2>)\)
+              ((?:\w+\.|`\w+`\.)?(?:\w+|`\w+`) | \w+\((?:|\g<2>)\))
             )
+            (?:\s+COLLATE\s+(?:\w+|"\w+"))?
             (?:\s+ASC|\s+DESC)?
           )
           (?:\s*,\s*\g<1>)*

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

@@ -24,6 +24,15 @@ module ActiveRecord
             add_column_position!(change_column_sql, column_options(o.column))
           end
 
+          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

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

@@ -57,6 +57,7 @@ module ActiveRecord
         end
       end
 
+      # = Active Record MySQL Adapter \Table Definition
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
@@ -85,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

@@ -53,14 +53,20 @@ module ActiveRecord
           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

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

@@ -36,7 +36,7 @@ module ActiveRecord
               end
 
               if row[:Expression]
-                expression = row[:Expression]
+                expression = row[:Expression].gsub("\\'", "'")
                 expression = +"(#{expression})" unless expression.start_with?("(")
                 indexes.last[-2] << expression
                 indexes.last[-1][:expressions] ||= {}
@@ -57,9 +57,9 @@ module ActiveRecord
               orders = options.delete(:orders)
               lengths = options.delete(:lengths)
 
-              columns = index[-1].map { |name|
+              columns = index[-1].to_h { |name|
                 [ name.to_sym, expressions[name] || +quote_column_name(name) ]
-              }.to_h
+              }
 
               index[-1] = add_options_for_index_columns(
                 columns, order: orders, length: lengths
@@ -125,6 +125,10 @@ module ActiveRecord
           256 # https://dev.mysql.com/doc/refman/en/identifiers.html
         end
 
+        def schema_creation # :nodoc:
+          MySQL::SchemaCreation.new(self)
+        end
+
         private
           CHARSETS_OF_4BYTES_MAXLEN = ["utf8mb4", "utf16", "utf16le", "utf32"]
 
@@ -150,26 +154,45 @@ module ActiveRecord
             @default_row_format
           end
 
-          def schema_creation
-            MySQL::SchemaCreation.new(self)
+          def valid_primary_key_options
+            super + [:unsigned]
           end
 
           def create_table_definition(name, **options)
             MySQL::TableDefinition.new(self, name, **options)
           end
 
-          def new_column_from_field(table_name, field)
+          def default_type(table_name, field_name)
+            match = create_table_info(table_name)&.match(/`#{field_name}` (.+) DEFAULT ('|\d+|[A-z]+)/)
+            default_pre = match[2] if match
+
+            if default_pre == "'"
+              :string
+            elsif default_pre&.match?(/^\d+$/)
+              :integer
+            elsif default_pre&.match?(/^[A-z]+$/)
+              :function
+            end
+          end
+
+          def new_column_from_field(table_name, field, _definitions)
+            field_name = field.fetch(:Field)
             type_metadata = fetch_type_metadata(field[:Type], field[:Extra])
             default, default_function = field[:Default], nil
 
             if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field[:Extra])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")
               default, default_function = nil, default
-            elsif type_metadata.type == :text && default
+            elsif type_metadata.type == :text && default&.start_with?("'")
               # strip and unescape quotes
               default = default[1...-1].gsub("\\'", "'")
+            elsif default&.match?(/\A\d/)
+              # Its a number so we can skip the query to check if it is a function
+            elsif default && default_type(table_name, field_name) == :function
+              default, default_function = nil, default
             end
 
             MySQL::Column.new(
@@ -206,14 +229,15 @@ module ActiveRecord
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
 
-            sql = +"SELECT table_name FROM (SELECT table_name, table_type FROM information_schema.tables "
-            sql << " WHERE table_schema = #{scope[:schema]}) _subquery"
-            if scope[:type] || scope[:name]
-              conditions = []
-              conditions << "_subquery.table_type = #{scope[:type]}" if scope[:type]
-              conditions << "_subquery.table_name = #{scope[:name]}" if scope[:name]
-              sql << " WHERE #{conditions.join(" AND ")}"
+            sql = +"SELECT table_name FROM information_schema.tables"
+            sql << " WHERE table_schema = #{scope[:schema]}"
+
+            if scope[:name]
+              sql << " AND table_name = #{scope[:name]}"
+              sql << " AND table_name IN (SELECT table_name FROM information_schema.tables WHERE table_schema = #{scope[:schema]})"
             end
+
+            sql << " AND table_type = #{scope[:type]}" if scope[:type]
             sql
           end
 

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Mysql2
+      module DatabaseStatements
+        # Returns an ActiveRecord::Result instance.
+        def select_all(*, **) # :nodoc:
+          result = nil
+          with_raw_connection do |conn|
+            result = if ExplainRegistry.collect? && prepared_statements
+              unprepared_statement { super }
+            else
+              super
+            end
+            conn.abandon_results!
+          end
+          result
+        end
+
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+          if without_prepared_statement?(binds)
+            execute_and_free(sql, name, async: async) do |result|
+              if result
+                build_result(columns: result.fields, rows: result.to_a)
+              else
+                build_result(columns: [], rows: [])
+              end
+            end
+          else
+            exec_stmt_and_free(sql, name, binds, cache_stmt: prepare, async: async) do |_, result|
+              if result
+                build_result(columns: result.fields, rows: result.to_a)
+              else
+                build_result(columns: [], rows: [])
+              end
+            end
+          end
+        end
+
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          if without_prepared_statement?(binds)
+            with_raw_connection do |conn|
+              @affected_rows_before_warnings = nil
+              execute_and_free(sql, name) { @affected_rows_before_warnings || conn.affected_rows }
+            end
+          else
+            exec_stmt_and_free(sql, name, binds) { |stmt| stmt.affected_rows }
+          end
+        end
+        alias :exec_update :exec_delete
+
+        private
+          def sync_timezone_changes(raw_connection)
+            raw_connection.query_options[:database_timezone] = default_timezone
+          end
+
+          def execute_batch(statements, name = nil)
+            statements = statements.map { |sql| transform_query(sql) }
+            combine_multi_statements(statements).each do |statement|
+              with_raw_connection do |conn|
+                raw_execute(statement, name)
+                conn.abandon_results!
+              end
+            end
+          end
+
+          def last_inserted_id(result)
+            @raw_connection&.last_id
+          end
+
+          def multi_statements_enabled?
+            flags = @config[:flags]
+
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              flags.anybits?(::Mysql2::Client::MULTI_STATEMENTS)
+            end
+          end
+
+          def with_multi_statements
+            if multi_statements_enabled?
+              return yield
+            end
+
+            with_raw_connection do |conn|
+              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_ON)
+
+              yield
+            ensure
+              conn.set_server_option(::Mysql2::Client::OPTION_MULTI_STATEMENTS_OFF)
+            end
+          end
+
+          def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+            log(sql, name, async: async) do
+              with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+                sync_timezone_changes(conn)
+                result = conn.query(sql)
+                verified!
+                handle_warnings(sql)
+                result
+              end
+            end
+          end
+
+          def exec_stmt_and_free(sql, name, binds, cache_stmt: false, async: false)
+            sql = transform_query(sql)
+            check_if_write_query(sql)
+
+            mark_transaction_written_if_write(sql)
+
+            type_casted_binds = type_casted_binds(binds)
+
+            log(sql, name, binds, type_casted_binds, async: async) do
+              with_raw_connection do |conn|
+                sync_timezone_changes(conn)
+
+                if cache_stmt
+                  stmt = @statements[sql] ||= conn.prepare(sql)
+                else
+                  stmt = conn.prepare(sql)
+                end
+
+                begin
+                  result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                    stmt.execute(*type_casted_binds)
+                  end
+                  verified!
+                  result
+                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
+  end
+end