activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/connection_adapters/column.rb

@@ -1,21 +1,24 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      attr_reader :name, :default, :sql_type_metadata, :null, :table_name, :default_function, :collation, :comment
+      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
 
       # Instantiates a new column in the table.
       #
-      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int</tt>.
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id bigint</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
       # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil, **)
+      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **)
         @name = name.freeze
-        @table_name = table_name
         @sql_type_metadata = sql_type_metadata
         @null = null
         @default = default
@@ -29,7 +32,7 @@ module ActiveRecord
       end
 
       def bigint?
-        /\Abigint\b/ === sql_type
+        /\Abigint\b/.match?(sql_type)
       end
 
       # Returns the human name of the column name.
@@ -40,25 +43,64 @@ module ActiveRecord
         Base.human_attribute_name(@name)
       end
 
+      def init_with(coder)
+        @name = coder["name"]
+        @sql_type_metadata = coder["sql_type_metadata"]
+        @null = coder["null"]
+        @default = coder["default"]
+        @default_function = coder["default_function"]
+        @collation = coder["collation"]
+        @comment = coder["comment"]
+      end
+
+      def encode_with(coder)
+        coder["name"] = @name
+        coder["sql_type_metadata"] = @sql_type_metadata
+        coder["null"] = @null
+        coder["default"] = @default
+        coder["default_function"] = @default_function
+        coder["collation"] = @collation
+        coder["comment"] = @comment
+      end
+
       def ==(other)
         other.is_a?(Column) &&
-          attributes_for_hash == other.attributes_for_hash
+          name == other.name &&
+          default == other.default &&
+          sql_type_metadata == other.sql_type_metadata &&
+          null == other.null &&
+          default_function == other.default_function &&
+          collation == other.collation &&
+          comment == other.comment
       end
       alias :eql? :==
 
       def hash
-        attributes_for_hash.hash
+        Column.hash ^
+          name.hash ^
+          name.encoding.hash ^
+          default.hash ^
+          sql_type_metadata.hash ^
+          null.hash ^
+          default_function.hash ^
+          collation.hash ^
+          comment.hash
       end
 
-      protected
-
-      def attributes_for_hash
-        [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
-      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/legacy_pool_manager.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class LegacyPoolManager # :nodoc:
+      def initialize
+        @name_to_pool_config = {}
+      end
+
+      def shard_names
+        @name_to_pool_config.keys
+      end
+
+      def pool_configs(_ = nil)
+        @name_to_pool_config.values
+      end
+
+      def remove_pool_config(_, shard)
+        @name_to_pool_config.delete(shard)
+      end
+
+      def get_pool_config(_, shard)
+        @name_to_pool_config[shard]
+      end
+
+      def set_pool_config(_, shard, pool_config)
+        @name_to_pool_config[shard] = pool_config
+      end
+    end
+  end
+end

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

@@ -1,48 +1,25 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module MySQL
       class Column < ConnectionAdapters::Column # :nodoc:
-        delegate :strict, :extra, to: :sql_type_metadata, allow_nil: true
-
-        def initialize(*)
-          super
-          assert_valid_default
-          extract_default
-        end
-
-        def has_default?
-          return false if blob_or_text_column? # MySQL forbids defaults on blob and text columns
-          super
-        end
-
-        def blob_or_text_column?
-          /\A(?:tiny|medium|long)?blob\b/ === sql_type || type == :text
-        end
+        delegate :extra, to: :sql_type_metadata, allow_nil: true
 
         def unsigned?
-          /\A(?:enum|set)\b/ !~ sql_type && /\bunsigned\b/ === sql_type
+          /\bunsigned(?: zerofill)?\z/.match?(sql_type)
         end
 
         def case_sensitive?
-          collation && collation !~ /_ci\z/
+          collation && !collation.end_with?("_ci")
         end
 
         def auto_increment?
-          extra == 'auto_increment'
-        end
-
-        private
-
-        def extract_default
-          if blob_or_text_column?
-            @default = null || strict ? nil : ''
-          end
+          extra == "auto_increment"
         end
 
-        def assert_valid_default
-          if blob_or_text_column? && default.present?
-            raise ArgumentError, "#{type} columns cannot have a default value: #{default.inspect}"
-          end
+        def virtual?
+          /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)
         end
       end
     end

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

@@ -1,29 +1,48 @@
+# 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
+
+        def explain(arel, binds = [])
+          sql     = "EXPLAIN #{to_sql(arel, binds)}"
+          start   = Concurrent.monotonic_time
+          result  = exec_query(sql, "EXPLAIN", binds)
+          elapsed = Concurrent.monotonic_time - start
+
+          MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
         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 +50,144 @@ 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
+                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) do |_, result|
-              ActiveRecord::Result.new(result.fields, result.to_a) if 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, 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 multi_statements_enabled?
+            flags = @config[:flags]
+
+            if flags.is_a?(Array)
+              flags.include?("MULTI_STATEMENTS")
+            else
+              flags.anybits?(Mysql2::Client::MULTI_STATEMENTS)
+            end
           end
-        end
 
-        def exec_stmt_and_free(sql, name, binds, cache_stmt: false)
-          # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
-          # made since we established the connection
-          @connection.query_options[:database_timezone] = ActiveRecord::Base.default_timezone
+          def with_multi_statements
+            multi_statements_was = multi_statements_enabled?
 
-          type_casted_binds = type_casted_binds(binds)
+            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
+              if max_allowed_packet_reached?(sql, previous_packet)
+                total_sql_chunks << +sql
+              else
+                previous_packet << ";\n"
+                previous_packet << sql
+              end
+            end
+          end
 
-          log(sql, name, binds, type_casted_binds) do
-            if cache_stmt
-              cache = @statements[sql] ||= {
-                stmt: @connection.prepare(sql)
-              }
-              stmt = cache[:stmt]
+          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
+            mark_transaction_written_if_write(sql)
+
+            # 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