activerecord 5.2.4.4 → 6.0.3.4

data/lib/active_record/connection_adapters/column.rb

@@ -5,7 +5,7 @@ module ActiveRecord
   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
+      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
 
@@ -15,9 +15,8 @@ module ActiveRecord
       # +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
@@ -44,7 +43,6 @@ module ActiveRecord
 
       def init_with(coder)
         @name = coder["name"]
-        @table_name = coder["table_name"]
         @sql_type_metadata = coder["sql_type_metadata"]
         @null = coder["null"]
         @default = coder["default"]
@@ -55,7 +53,6 @@ module ActiveRecord
 
       def encode_with(coder)
         coder["name"] = @name
-        coder["table_name"] = @table_name
         coder["sql_type_metadata"] = @sql_type_metadata
         coder["null"] = @null
         coder["default"] = @default
@@ -66,19 +63,26 @@ module ActiveRecord
 
       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 ^
+          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
     end
 
     class NullColumn < Column

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -56,10 +56,7 @@ module ActiveRecord
         end
 
         private
-
-          def uri
-            @uri
-          end
+          attr_reader :uri
 
           def uri_parser
             @uri_parser ||= URI::Parser.new
@@ -75,7 +72,7 @@ module ActiveRecord
           #   "localhost"
           #   # => {}
           def query_hash
-            Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
+            Hash[(@query || "").split("&").map { |pair| pair.split("=", 2) }]
           end
 
           def raw_config
@@ -116,8 +113,7 @@ module ActiveRecord
       class Resolver # :nodoc:
         attr_reader :configurations
 
-        # Accepts a hash two layers deep, keys on the first layer represent
-        # environments such as "production". Keys must be strings.
+        # Accepts a list of db config objects.
         def initialize(configurations)
           @configurations = configurations
         end
@@ -138,34 +134,14 @@ module ActiveRecord
         #   Resolver.new(configurations).resolve(:production)
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
         #
-        def resolve(config)
-          if config
-            resolve_connection config
-          elsif env = ActiveRecord::ConnectionHandling::RAILS_ENV.call
-            resolve_symbol_connection env.to_sym
+        def resolve(config_or_env, pool_name = nil)
+          if config_or_env
+            resolve_connection config_or_env, pool_name
           else
             raise AdapterNotSpecified
           end
         end
 
-        # Expands each key in @configurations hash into fully resolved hash
-        def resolve_all
-          config = configurations.dup
-
-          if env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-            env_config = config[env] if config[env].is_a?(Hash) && !(config[env].key?("adapter") || config[env].key?("url"))
-          end
-
-          config.reject! { |k, v| v.is_a?(Hash) && !(v.key?("adapter") || v.key?("url")) }
-          config.merge! env_config if env_config
-
-          config.each do |key, value|
-            config[key] = resolve(value) if value
-          end
-
-          config
-        end
-
         # Returns an instance of ConnectionSpecification for a given adapter.
         # Accepts a hash one layer deep that contains all connection information.
         #
@@ -179,7 +155,9 @@ module ActiveRecord
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
         #
         def spec(config)
-          spec = resolve(config).symbolize_keys
+          pool_name = config if config.is_a?(Symbol)
+
+          spec = resolve(config, pool_name).symbolize_keys
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
 
@@ -207,14 +185,13 @@ module ActiveRecord
           adapter_method = "#{spec[:adapter]}_connection"
 
           unless ActiveRecord::Base.respond_to?(adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+            raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter"
           end
 
           ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
         end
 
         private
-
           # Returns fully resolved connection, accepts hash, string or symbol.
           # Always returns a hash.
           #
@@ -235,32 +212,64 @@ module ActiveRecord
           #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
           #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
           #
-          def resolve_connection(spec)
-            case spec
+          def resolve_connection(config_or_env, pool_name = nil)
+            case config_or_env
             when Symbol
-              resolve_symbol_connection spec
+              resolve_symbol_connection config_or_env, pool_name
             when String
-              resolve_url_connection spec
+              resolve_url_connection config_or_env
             when Hash
-              resolve_hash_connection spec
+              resolve_hash_connection config_or_env
+            else
+              raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config_or_env.inspect}"
             end
           end
 
-          # Takes the environment such as +:production+ or +:development+.
+          # Takes the environment such as +:production+ or +:development+ and a
+          # pool name the corresponds to the name given by the connection pool
+          # to the connection. That pool name is merged into the hash with the
+          # name key.
+          #
           # This requires that the @configurations was initialized with a key that
           # matches.
           #
-          #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-          #   # => {}
+          #   configurations = #<ActiveRecord::DatabaseConfigurations:0x00007fd9fdace3e0
+          #     @configurations=[
+          #       #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd9fdace250
+          #         @env_name="production", @spec_name="primary", @config={"database"=>"my_db"}>
+          #       ]>
           #
-          def resolve_symbol_connection(spec)
-            if config = configurations[spec.to_s]
-              resolve_connection(config).merge("name" => spec.to_s)
+          #   Resolver.new(configurations).resolve_symbol_connection(:production, "primary")
+          #   # => { "database" => "my_db" }
+          def resolve_symbol_connection(env_name, pool_name)
+            db_config = configurations.find_db_config(env_name)
+
+            if db_config
+              resolve_connection(db_config.config).merge("name" => pool_name.to_s)
             else
-              raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+              raise AdapterNotSpecified, <<~MSG
+                The `#{env_name}` database is not configured for the `#{ActiveRecord::ConnectionHandling::DEFAULT_ENV.call}` environment.
+
+                Available databases configurations are:
+
+                #{build_configuration_sentence}
+              MSG
             end
           end
 
+          def build_configuration_sentence # :nodoc:
+            configs = configurations.configs_for(include_replicas: true)
+
+            configs.group_by(&:env_name).map do |env, config|
+              namespaces = config.map(&:spec_name)
+              if namespaces.size > 1
+                "#{env}: #{namespaces.join(", ")}"
+              else
+                env
+              end
+            end.join("\n")
+          end
+
           # Accepts a hash. Expands the "url" key that contains a
           # URL database connection to a full connection
           # hash and merges with the rest of the hash.

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -5,26 +5,22 @@ module ActiveRecord
     module DetermineIfPreparableVisitor
       attr_accessor :preparable
 
-      def accept(*)
+      def accept(object, collector)
         @preparable = true
         super
       end
 
       def visit_Arel_Nodes_In(o, collector)
         @preparable = false
+        super
+      end
 
-        if Array === o.right && !o.right.empty?
-          o.right.delete_if do |bind|
-            if Arel::Nodes::BindParam === bind && Relation::QueryAttribute === bind.value
-              !bind.value.boundable?
-            end
-          end
-        end
-
+      def visit_Arel_Nodes_NotIn(o, collector)
+        @preparable = false
         super
       end
 
-      def visit_Arel_Nodes_SqlLiteral(*)
+      def visit_Arel_Nodes_SqlLiteral(o, collector)
         @preparable = false
         super
       end

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

@@ -11,7 +11,7 @@ module ActiveRecord
         end
 
         def case_sensitive?
-          collation && !/_ci\z/.match?(collation)
+          collation && !collation.end_with?("_ci")
         end
 
         def auto_increment?

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

@@ -5,13 +5,13 @@ module ActiveRecord
     module MySQL
       module DatabaseStatements
         # Returns an ActiveRecord::Result instance.
-        def select_all(*) # :nodoc:
+        def select_all(*, **) # :nodoc:
           result = if ExplainRegistry.collect? && prepared_statements
             unprepared_statement { super }
           else
             super
           end
-          discard_remaining_results
+          @connection.abandon_results!
           result
         end
 
@@ -19,8 +19,21 @@ module ActiveRecord
           execute(sql, name).to_a
         end
 
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc, :with
+        ) # :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,18 +44,28 @@ module ActiveRecord
         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 = 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
@@ -50,18 +73,21 @@ module ActiveRecord
         alias :exec_update :exec_delete
 
         private
+          def execute_batch(statements, name = nil)
+            combine_multi_statements(statements).each do |statement|
+              execute(statement, name)
+            end
+            @connection.abandon_results!
+          end
+
           def default_insert_value(column)
-            Arel.sql("DEFAULT") unless column.auto_increment?
+            super unless column.auto_increment?
           end
 
           def last_inserted_id(result)
             @connection.last_id
           end
 
-          def discard_remaining_results
-            @connection.next_result while @connection.more_results?
-          end
-
           def supports_set_server_option?
             @connection.respond_to?(:set_server_option)
           end
@@ -98,7 +124,40 @@ module ActiveRecord
             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
+              (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
@@ -107,10 +166,7 @@ module ActiveRecord
 
             log(sql, name, binds, type_casted_binds) do
               if cache_stmt
-                cache = @statements[sql] ||= {
-                  stmt: @connection.prepare(sql)
-                }
-                stmt = cache[:stmt]
+                stmt = @statements[sql] ||= @connection.prepare(sql)
               else
                 stmt = @connection.prepare(sql)
               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|

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

@@ -5,11 +5,11 @@ module ActiveRecord
     module MySQL
       module Quoting # :nodoc:
         def quote_column_name(name)
-          @quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`".freeze
+          self.class.quoted_column_names[name] ||= "`#{super.gsub('`', '``')}`"
         end
 
         def quote_table_name(name)
-          @quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
+          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
         end
 
         def unquoted_true
@@ -32,12 +32,49 @@ module ActiveRecord
           "x'#{value.hex}'"
         end
 
-        def _type_cast(value)
-          case value
-          when Date, Time then value
-          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