activerecord 8.0.2 → 8.1.0.beta1

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

@@ -21,7 +21,7 @@ module ActiveRecord
                 index_using = mysql_index_type
               end
 
-              indexes << [
+              index = [
                 row["Table"],
                 row["Key_name"],
                 row["Non_unique"].to_i == 0,
@@ -30,8 +30,14 @@ module ActiveRecord
                 orders: {},
                 type: index_type,
                 using: index_using,
-                comment: row["Index_comment"].presence
+                comment: row["Index_comment"].presence,
               ]
+
+              if supports_disabling_indexes?
+                index[-1][:enabled] = mariadb? ? row["Ignored"] == "NO" : row["Visible"] == "YES"
+              end
+
+              indexes << index
             end
 
             if expression = row["Expression"]
@@ -63,8 +69,7 @@ module ActiveRecord
                 columns, order: orders, length: lengths
               ).values.join(", ")
             end
-
-            IndexDefinition.new(*index, **options)
+            MySQL::IndexDefinition.new(*index, **options)
           end
         rescue StatementInvalid => e
           if e.message.match?(/Table '.+' doesn't exist/)
@@ -74,6 +79,16 @@ module ActiveRecord
           end
         end
 
+        def create_index_definition(table_name, name, unique, columns, **options)
+          MySQL::IndexDefinition.new(table_name, name, unique, columns, **options)
+        end
+
+        def add_index_options(table_name, column_name, name: nil, if_not_exists: false, internal: false, **options) # :nodoc:
+          index, algorithm, if_not_exists = super
+          index.enabled = options[:enabled] unless options[:enabled].nil?
+          [index, algorithm, if_not_exists]
+        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)
@@ -209,6 +224,7 @@ module ActiveRecord
 
             MySQL::Column.new(
               field["Field"],
+              lookup_cast_type(type_metadata.sql_type),
               default,
               type_metadata,
               field["Null"] == "YES",
@@ -233,6 +249,12 @@ module ActiveRecord
             end
           end
 
+          def valid_index_options
+            index_options = super
+            index_options << :enabled if supports_disabling_indexes?
+            index_options
+          end
+
           def add_options_for_index_columns(quoted_columns, **options)
             quoted_columns = add_index_length(quoted_columns, **options)
             super

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

@@ -50,34 +50,40 @@ module ActiveRecord
 
             result = nil
             if binds.nil? || binds.empty?
-              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                result = raw_connection.query(sql)
-                # Ref: https://github.com/brianmario/mysql2/pull/1383
-                # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
-                # from that same connection was GCed while `#query` released the GVL.
-                # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
-                # of hitting the bug.
-                @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
-              end
+              result = raw_connection.query(sql)
+              # Ref: https://github.com/brianmario/mysql2/pull/1383
+              # As of mysql2 0.5.6 `#affected_rows` might raise Mysql2::Error if a prepared statement
+              # from that same connection was GCed while `#query` released the GVL.
+              # By avoiding to call `#affected_rows` when we have a result, we reduce the likeliness
+              # of hitting the bug.
+              @affected_rows_before_warnings = result&.size || raw_connection.affected_rows
             elsif prepare
-              stmt = @statements[sql] ||= raw_connection.prepare(sql)
+              retry_count = 1
               begin
-                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                  result = stmt.execute(*type_casted_binds)
-                  @affected_rows_before_warnings = stmt.affected_rows
-                end
-              rescue ::Mysql2::Error
+                stmt = @statements[sql] ||= raw_connection.prepare(sql)
+                result = stmt.execute(*type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
+              rescue ::Mysql2::Error => error
                 @statements.delete(sql)
+                # Sometimes for an unknown reason, we get that error.
+                # It suggest somehow that the prepared statement was deallocated
+                # but the client doesn't know it.
+                # But we know that this error is safe to retry, so we do so after
+                # getting rid of the originally cached statement.
+                if error.error_number == Mysql2Adapter::ER_UNKNOWN_STMT_HANDLER
+                  if retry_count.positive?
+                    retry_count -= 1
+                    retry
+                  end
+                end
                 raise
               end
             else
               stmt = raw_connection.prepare(sql)
 
               begin
-                ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                  result = stmt.execute(*type_casted_binds)
-                  @affected_rows_before_warnings = stmt.affected_rows
-                end
+                result = stmt.execute(*type_casted_binds)
+                @affected_rows_before_warnings = stmt.affected_rows
 
                 # Ref: https://github.com/brianmario/mysql2/pull/1383
                 # by eagerly closing uncached prepared statements, we also reduce the chances of
@@ -100,7 +106,6 @@ module ActiveRecord
             raw_connection.abandon_results!
 
             verified!
-            handle_warnings(sql)
             result
           ensure
             if reset_multi_statement && active?
@@ -109,12 +114,12 @@ module ActiveRecord
           end
 
           def cast_result(raw_result)
-            return ActiveRecord::Result.empty if raw_result.nil?
+            return ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings) if raw_result.nil?
 
             fields = raw_result.fields
 
             result = if fields.empty?
-              ActiveRecord::Result.empty
+              ActiveRecord::Result.empty(affected_rows: @affected_rows_before_warnings)
             else
               ActiveRecord::Result.new(fields, raw_result.to_a)
             end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -13,6 +13,7 @@ module ActiveRecord
       ER_BAD_DB_ERROR           = 1049
       ER_DBACCESS_DENIED_ERROR  = 1044
       ER_ACCESS_DENIED_ERROR    = 1045
+      ER_UNKNOWN_STMT_HANDLER   = 1243
       ER_CONN_HOST_ERROR        = 2003
       ER_UNKNOWN_HOST_ERROR     = 2005
 

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

@@ -11,8 +11,8 @@ module ActiveRecord
         end
 
         # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) # :nodoc:
-          result = internal_execute(sql, name)
+        def query(sql, name = nil, allow_retry: true, materialize_transactions: true) # :nodoc:
+          result = internal_execute(sql, name, allow_retry:, materialize_transactions:)
           result.map_types!(@type_map_for_results).values
         end
 
@@ -163,25 +163,27 @@ module ActiveRecord
             end
 
             verified!
-            handle_warnings(result)
-            notification_payload[:row_count] = result.count
+
+            notification_payload[:affected_rows] = result.cmd_tuples
+            notification_payload[:row_count] = result.ntuples
             result
           end
 
           def cast_result(result)
-            if result.fields.empty?
-              result.clear
-              return ActiveRecord::Result.empty
-            end
+            ar_result = if result.fields.empty?
+              ActiveRecord::Result.empty(affected_rows: result.cmd_tuples)
+            else
+              fields = result.fields
+              types = Array.new(fields.size)
+              fields.size.times do |index|
+                ftype = result.ftype(index)
+                fmod  = result.fmod(index)
+                types[index] = get_oid_type(ftype, fmod, fields[index])
+              end
 
-            types = {}
-            fields = result.fields
-            fields.each_with_index do |fname, i|
-              ftype = result.ftype i
-              fmod  = result.fmod i
-              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
+              ActiveRecord::Result.new(fields, result.values, types.freeze, affected_rows: result.cmd_tuples)
             end
-            ar_result = ActiveRecord::Result.new(fields, result.values, types.freeze)
+
             result.clear
             ar_result
           end
@@ -213,7 +215,7 @@ module ActiveRecord
             pk unless pk.is_a?(Array)
           end
 
-          def handle_warnings(sql)
+          def handle_warnings(result, sql)
             @notice_receiver_sql_warnings.each do |warning|
               next if warning_ignored?(warning)
 

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -16,8 +16,8 @@ module ActiveRecord
             @subtype = subtype
             @delimiter = delimiter
 
-            @pg_encoder = PG::TextEncoder::Array.new name: "#{type}[]", delimiter: delimiter
-            @pg_decoder = PG::TextDecoder::Array.new name: "#{type}[]", delimiter: delimiter
+            @pg_encoder = PG::TextEncoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
+            @pg_decoder = PG::TextDecoder::Array.new(name: "#{type}[]".freeze, delimiter: delimiter).freeze
           end
 
           def deserialize(value)

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -68,7 +68,7 @@ module ActiveRecord
 
             def register_array_type(row)
               register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
-                OID::Array.new(subtype, row["typdelim"])
+                OID::Array.new(subtype, row["typdelim"].freeze)
               end
             end
 

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

@@ -153,14 +153,15 @@ module ActiveRecord
           "'#{escape_bytea(value.to_s)}'"
         end
 
+        # `column` may be either an instance of Column or ColumnDefinition.
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
           elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
-            type = lookup_cast_type_from_column(column)
-            quote(type.serialize(value))
+            # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+            quote(column.fetch_cast_type(self).serialize(value))
           else
             super
           end
@@ -186,16 +187,12 @@ module ActiveRecord
           end
         end
 
-        def lookup_cast_type_from_column(column) # :nodoc:
-          verify! if type_map.nil?
-          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        # TODO: Make this method private after we release 8.1.
+        def lookup_cast_type(sql_type) # :nodoc:
+          super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)
         end
 
         private
-          def lookup_cast_type(sql_type)
-            super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)
-          end
-
           def encode_array(array_data)
             encoder = array_data.encoder
             values = type_cast_array(array_data.values)
@@ -208,7 +205,17 @@ module ActiveRecord
           end
 
           def encode_range(range)
-            "[#{type_cast_range_value(range.begin)},#{type_cast_range_value(range.end)}#{range.exclude_end? ? ')' : ']'}"
+            lower_bound = type_cast_range_value(range.begin)
+            upper_bound = if date_or_time_range?(range)
+              # Postgres will convert `[today,]` to `[today,)`, making it exclusive.
+              # We can use the special timestamp value `infinity` to force inclusion.
+              # https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-INFINITE
+              range.end.nil? ? "infinity" : type_cast(range.end)
+            else
+              type_cast_range_value(range.end)
+            end
+
+            "[#{lower_bound},#{upper_bound}#{range.exclude_end? ? ')' : ']'}"
           end
 
           def determine_encoding_of_strings_in_array(value)
@@ -232,6 +239,10 @@ module ActiveRecord
           def infinity?(value)
             value.respond_to?(:infinite?) && value.infinite?
           end
+
+          def date_or_time_range?(range)
+            [range.begin.class, range.end.class].intersect?([Date, DateTime, Time])
+          end
       end
     end
   end

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

@@ -99,7 +99,7 @@ module ActiveRecord
               if options[:default].nil?
                 change_column_sql << ", ALTER COLUMN #{quoted_column_name} DROP DEFAULT"
               else
-                quoted_default = quote_default_expression(options[:default], column)
+                quoted_default = quote_default_expression_for_column_definition(options[:default], column)
                 change_column_sql << ", ALTER COLUMN #{quoted_column_name} SET DEFAULT #{quoted_default}"
               end
             end

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

@@ -5,6 +5,7 @@ module ActiveRecord
     module PostgreSQL
       module ColumnMethods
         extend ActiveSupport::Concern
+        extend ConnectionAdapters::ColumnMethods::ClassMethods
 
         # Defines the primary key field.
         # Use of the native PostgreSQL UUID type is supported, and can be used
@@ -15,22 +16,10 @@ module ActiveRecord
         #     t.timestamps
         #   end
         #
-        # By default, this will use the <tt>gen_random_uuid()</tt> function from the
-        # +pgcrypto+ extension. As that extension is only available in
-        # PostgreSQL 9.4+, for earlier versions an explicit default can be set
-        # to use <tt>uuid_generate_v4()</tt> from the +uuid-ossp+ extension instead:
+        # By default, this will use the <tt>gen_random_uuid()</tt> function.
         #
-        #   create_table :stuffs, id: false do |t|
-        #     t.primary_key :id, :uuid, default: "uuid_generate_v4()"
-        #     t.uuid :foo_id
-        #     t.timestamps
-        #   end
-        #
-        # To enable the appropriate extension, which is a requirement, use
-        # the +enable_extension+ method in your migrations.
-        #
-        # To use a UUID primary key without any of the extensions, set the
-        # +:default+ option to +nil+:
+        # To use a UUID primary key without any defaults, set the +:default+
+        # option to +nil+:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: nil
@@ -181,12 +170,10 @@ module ActiveRecord
         # :method: enum
         # :call-seq: enum(*names, **options)
 
-        included do
-          define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
-            :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
-            :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
-            :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml, :timestamptz, :enum
-        end
+        define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
+          :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
+          :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
+          :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml, :timestamptz, :enum
       end
 
       ExclusionConstraintDefinition = Struct.new(:table_name, :expression, :options) do

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

@@ -5,6 +5,23 @@ module ActiveRecord
     module PostgreSQL
       class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         private
+          attr_accessor :schema_name
+
+          def initialize(connection, options = {})
+            super
+
+            @dump_schemas =
+              case ActiveRecord.dump_schemas
+              when :schema_search_path
+                connection.current_schemas
+              when String
+                schema_names = ActiveRecord.dump_schemas.split(",").map(&:strip)
+                schema_names & connection.schema_names
+              else
+                connection.schema_names
+              end
+          end
+
           def extensions(stream)
             extensions = @connection.extensions
             if extensions.any?
@@ -17,19 +34,20 @@ module ActiveRecord
           end
 
           def types(stream)
-            types = @connection.enum_types
-            if types.any?
-              stream.puts "  # Custom types defined in this database."
-              stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
-              types.sort.each do |name, values|
-                stream.puts "  create_enum #{name.inspect}, #{values.inspect}"
+            within_each_schema do
+              types = @connection.enum_types
+              if types.any?
+                stream.puts "  # Custom types defined in this database."
+                stream.puts "  # Note that some types may not work with other database engines. Be careful if changing database."
+                types.sort.each do |name, values|
+                  stream.puts "  create_enum #{relation_name(name).inspect}, #{values.inspect}"
+                end
               end
-              stream.puts
             end
           end
 
           def schemas(stream)
-            schema_names = @connection.schema_names - ["public"]
+            schema_names = @dump_schemas - ["public"]
 
             if schema_names.any?
               schema_names.sort.each do |name|
@@ -39,46 +57,43 @@ module ActiveRecord
             end
           end
 
+          def tables(stream)
+            previous_schema_had_tables = false
+            within_each_schema do
+              stream.puts if previous_schema_had_tables
+              super
+              previous_schema_had_tables = @connection.tables.any?
+            end
+          end
+
           def exclusion_constraints_in_create(table, stream)
             if (exclusion_constraints = @connection.exclusion_constraints(table)).any?
-              add_exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
-                parts = [
-                  "t.exclusion_constraint #{exclusion_constraint.expression.inspect}"
-                ]
-
+              exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
+                parts = [ exclusion_constraint.expression.inspect ]
                 parts << "where: #{exclusion_constraint.where.inspect}" if exclusion_constraint.where
                 parts << "using: #{exclusion_constraint.using.inspect}" if exclusion_constraint.using
                 parts << "deferrable: #{exclusion_constraint.deferrable.inspect}" if exclusion_constraint.deferrable
+                parts << "name: #{exclusion_constraint.name.inspect}" if exclusion_constraint.export_name_on_schema_dump?
 
-                if exclusion_constraint.export_name_on_schema_dump?
-                  parts << "name: #{exclusion_constraint.name.inspect}"
-                end
-
-                "    #{parts.join(', ')}"
+                "    t.exclusion_constraint #{parts.join(', ')}"
               end
 
-              stream.puts add_exclusion_constraint_statements.sort.join("\n")
+              stream.puts exclusion_constraint_statements.sort.join("\n")
             end
           end
 
           def unique_constraints_in_create(table, stream)
             if (unique_constraints = @connection.unique_constraints(table)).any?
-              add_unique_constraint_statements = unique_constraints.map do |unique_constraint|
-                parts = [
-                  "t.unique_constraint #{unique_constraint.column.inspect}"
-                ]
-
+              unique_constraint_statements = unique_constraints.map do |unique_constraint|
+                parts = [ unique_constraint.column.inspect ]
                 parts << "nulls_not_distinct: #{unique_constraint.nulls_not_distinct.inspect}" if unique_constraint.nulls_not_distinct
                 parts << "deferrable: #{unique_constraint.deferrable.inspect}" if unique_constraint.deferrable
+                parts << "name: #{unique_constraint.name.inspect}" if unique_constraint.export_name_on_schema_dump?
 
-                if unique_constraint.export_name_on_schema_dump?
-                  parts << "name: #{unique_constraint.name.inspect}"
-                end
-
-                "    #{parts.join(', ')}"
+                "    t.unique_constraint #{parts.join(', ')}"
               end
 
-              stream.puts add_unique_constraint_statements.sort.join("\n")
+              stream.puts unique_constraint_statements.sort.join("\n")
             end
           end
 
@@ -122,6 +137,26 @@ module ActiveRecord
           def extract_expression_for_virtual_column(column)
             column.default_function.inspect
           end
+
+          def within_each_schema
+            @dump_schemas.each do |schema_name|
+              old_search_path = @connection.schema_search_path
+              @connection.schema_search_path = schema_name
+              self.schema_name = schema_name
+              yield
+            ensure
+              self.schema_name = nil
+              @connection.schema_search_path = old_search_path
+            end
+          end
+
+          def relation_name(name)
+            if @dump_schemas.size == 1
+              name
+            else
+              "#{schema_name}.#{name}"
+            end
+          end
       end
     end
   end