activerecord 4.2.8 → 6.0.0

data/lib/active_record/connection_adapters/column.rb

@@ -1,46 +1,36 @@
-require 'set'
+# frozen_string_literal: true
 
 module ActiveRecord
   # :stopdoc:
   module ConnectionAdapters
     # An abstract definition of a column in a table.
     class Column
-      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
-      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+      attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment
 
-      module Format
-        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
-        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      end
-
-      attr_reader :name, :cast_type, :null, :sql_type, :default, :default_function
-
-      delegate :type, :precision, :scale, :limit, :klass, :accessor,
-        :text?, :number?, :binary?, :changed?,
-        :type_cast_from_user, :type_cast_from_database, :type_cast_for_database,
-        :type_cast_for_schema,
-        to: :cast_type
+      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(11)</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>.
-      # +cast_type+ is the object used for type casting and type information.
-      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in
-      # <tt>company_name varchar(60)</tt>.
-      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +sql_type_metadata+ is various information about the type of the column
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, cast_type, sql_type = nil, null = true)
-        @name             = name.freeze
-        @cast_type        = cast_type
-        @sql_type         = sql_type
-        @null             = null
-        @default          = default
-        @default_function = nil
+      def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, **)
+        @name = name.freeze
+        @sql_type_metadata = sql_type_metadata
+        @null = null
+        @default = default
+        @default_function = default_function
+        @collation = collation
+        @comment = comment
       end
 
       def has_default?
-        !default.nil?
+        !default.nil? || default_function
+      end
+
+      def bigint?
+        /\Abigint\b/.match?(sql_type)
       end
 
       # Returns the human name of the column name.
@@ -51,30 +41,53 @@ module ActiveRecord
         Base.human_attribute_name(@name)
       end
 
-      def with_type(type)
-        dup.tap do |clone|
-          clone.instance_variable_set('@cast_type', type)
-        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.name == name &&
-          other.default == default &&
-          other.cast_type == cast_type &&
-          other.sql_type == sql_type &&
-          other.null == null &&
-          other.default_function == default_function
+        other.is_a?(Column) &&
+          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
+    end
 
-      private
-
-      def attributes_for_hash
-        [self.class, name, default, cast_type, sql_type, null, default_function]
+    class NullColumn < Column
+      def initialize(name)
+        super(name, nil)
       end
     end
   end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,22 +1,26 @@
-require 'uri'
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
+
+require "uri"
 
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionSpecification #:nodoc:
-      attr_reader :config, :adapter_method
+      attr_reader :name, :config, :adapter_method
 
-      def initialize(config, adapter_method)
-        @config, @adapter_method = config, adapter_method
+      def initialize(name, config, adapter_method)
+        @name, @config, @adapter_method = name, config, adapter_method
       end
 
       def initialize_dup(original)
         @config = original.config.dup
       end
 
+      def to_hash
+        @config.merge(name: @name)
+      end
+
       # Expands a connection string into a hash.
       class ConnectionUrlResolver # :nodoc:
-
         # == Example
         #
         #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
@@ -34,11 +38,11 @@ module ActiveRecord
         def initialize(url)
           raise "Database URL cannot be empty" if url.blank?
           @uri     = uri_parser.parse(url)
-          @adapter = @uri.scheme.tr('-', '_')
+          @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
           @adapter = "postgresql" if @adapter == "postgres"
 
           if @uri.opaque
-            @uri.opaque, @query = @uri.opaque.split('?', 2)
+            @uri.opaque, @query = @uri.opaque.split("?", 2)
           else
             @query = @uri.query
           end
@@ -46,65 +50,63 @@ module ActiveRecord
 
         # Converts the given URL to a full connection hash.
         def to_hash
-          config = raw_config.reject { |_,value| value.blank? }
-          config.map { |key,value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+          config = raw_config.reject { |_, value| value.blank? }
+          config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
           config
         end
 
         private
 
-        def uri
-          @uri
-        end
+          attr_reader :uri
 
-        def uri_parser
-          @uri_parser ||= URI::Parser.new
-        end
+          def uri_parser
+            @uri_parser ||= URI::Parser.new
+          end
 
-        # Converts the query parameters of the URI into a hash.
-        #
-        #   "localhost?pool=5&reaping_frequency=2"
-        #   # => { "pool" => "5", "reaping_frequency" => "2" }
-        #
-        # returns empty hash if no query present.
-        #
-        #   "localhost"
-        #   # => {}
-        def query_hash
-          Hash[(@query || '').split("&").map { |pair| pair.split("=") }]
-        end
+          # Converts the query parameters of the URI into a hash.
+          #
+          #   "localhost?pool=5&reaping_frequency=2"
+          #   # => { "pool" => "5", "reaping_frequency" => "2" }
+          #
+          # returns empty hash if no query present.
+          #
+          #   "localhost"
+          #   # => {}
+          def query_hash
+            Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
+          end
 
-        def raw_config
-          if uri.opaque
-            query_hash.merge({
-              "adapter"  => @adapter,
-              "database" => uri.opaque })
-          else
-            query_hash.merge({
-              "adapter"  => @adapter,
-              "username" => uri.user,
-              "password" => uri.password,
-              "port"     => uri.port,
-              "database" => database_from_path,
-              "host"     => uri.hostname })
+          def raw_config
+            if uri.opaque
+              query_hash.merge(
+                "adapter"  => @adapter,
+                "database" => uri.opaque)
+            else
+              query_hash.merge(
+                "adapter"  => @adapter,
+                "username" => uri.user,
+                "password" => uri.password,
+                "port"     => uri.port,
+                "database" => database_from_path,
+                "host"     => uri.hostname)
+            end
           end
-        end
 
-        # Returns name of the database.
-        def database_from_path
-          if @adapter == 'sqlite3'
-            # 'sqlite3:/foo' is absolute, because that makes sense. The
-            # corresponding relative version, 'sqlite3:foo', is handled
-            # elsewhere, as an "opaque".
+          # Returns name of the database.
+          def database_from_path
+            if @adapter == "sqlite3"
+              # 'sqlite3:/foo' is absolute, because that makes sense. The
+              # corresponding relative version, 'sqlite3:foo', is handled
+              # elsewhere, as an "opaque".
 
-            uri.path
-          else
-            # Only SQLite uses a filename as the "database" name; for
-            # anything else, a leading slash would be silly.
+              uri.path
+            else
+              # Only SQLite uses a filename as the "database" name; for
+              # anything else, a leading slash would be silly.
 
-            uri.path.sub(%r{^/}, "")
+              uri.path.sub(%r{^/}, "")
+            end
           end
-        end
       end
 
       ##
@@ -112,8 +114,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
@@ -134,25 +135,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
-          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.
         #
@@ -166,109 +156,141 @@ 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)
 
+          # Require the adapter itself and give useful feedback about
+          #   1. Missing adapter gems and
+          #   2. Adapter gems' missing dependencies.
           path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
           begin
             require path_to_adapter
-          rescue Gem::LoadError => e
-            raise Gem::LoadError, "Specified '#{spec[:adapter]}' for database adapter, but the gem is not loaded. Add `gem '#{e.name}'` to your Gemfile (and ensure its version is at the minimum required by ActiveRecord)."
           rescue LoadError => e
-            raise LoadError, "Could not load '#{path_to_adapter}'. Make sure that the adapter in config/database.yml is valid. If you use an adapter other than 'mysql', 'mysql2', 'postgresql' or 'sqlite3' add the necessary adapter gem to the Gemfile.", e.backtrace
+            # We couldn't require the adapter itself. Raise an exception that
+            # points out config typos and missing gems.
+            if e.path == path_to_adapter
+              # We can assume that a non-builtin adapter was specified, so it's
+              # either misspelled or missing from Gemfile.
+              raise LoadError, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+            # Bubbled up from the adapter require. Prefix the exception message
+            # with some guidance about how to address it and reraise.
+            else
+              raise LoadError, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+            end
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
-          ConnectionSpecification.new(spec, adapter_method)
+
+          unless ActiveRecord::Base.respond_to?(adapter_method)
+            raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[: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.
-        #
-        # == Examples
-        #
-        # Symbol representing current environment.
-        #
-        #   Resolver.new("production" => {}).resolve_connection(:production)
-        #   # => {}
-        #
-        # One layer deep hash of connection values.
-        #
-        #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
-        #   # => { "adapter" => "sqlite3" }
-        #
-        # Connection URL.
-        #
-        #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-        #
-        def resolve_connection(spec)
-          case spec
-          when Symbol
-            resolve_symbol_connection spec
-          when String
-            resolve_string_connection spec
-          when Hash
-            resolve_hash_connection spec
+          # Returns fully resolved connection, accepts hash, string or symbol.
+          # Always returns a hash.
+          #
+          # == Examples
+          #
+          # Symbol representing current environment.
+          #
+          #   Resolver.new("production" => {}).resolve_connection(:production)
+          #   # => {}
+          #
+          # One layer deep hash of connection values.
+          #
+          #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
+          #   # => { "adapter" => "sqlite3" }
+          #
+          # Connection URL.
+          #
+          #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
+          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+          #
+          def resolve_connection(config_or_env, pool_name = nil)
+            case config_or_env
+            when Symbol
+              resolve_symbol_connection config_or_env, pool_name
+            when String
+              resolve_url_connection config_or_env
+            when Hash
+              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
-        end
 
-        def resolve_string_connection(spec)
-          # Rails has historically accepted a string to mean either
-          # an environment key or a URL spec, so we have deprecated
-          # this ambiguous behaviour and in the future this function
-          # can be removed in favor of resolve_url_connection.
-          if configurations.key?(spec) || spec !~ /:/
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing a string to ActiveRecord::Base.establish_connection for a
-              configuration lookup is deprecated, please pass a symbol
-              (#{spec.to_sym.inspect}) instead.
-            MSG
-
-            resolve_symbol_connection(spec)
-          else
-            resolve_url_connection(spec)
+          # 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.
+          #
+          #   configurations = #<ActiveRecord::DatabaseConfigurations:0x00007fd9fdace3e0
+          #     @configurations=[
+          #       #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd9fdace250
+          #         @env_name="production", @spec_name="primary", @config={"database"=>"my_db"}>
+          #       ]>
+          #
+          #   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, <<~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
-        end
 
-        # Takes the environment such as +:production+ or +:development+.
-        # This requires that the @configurations was initialized with a key that
-        # matches.
-        #
-        #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
-        #   # => {}
-        #
-        def resolve_symbol_connection(spec)
-          if config = configurations[spec.to_s]
-            resolve_connection(config)
-          else
-            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+          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
-        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.
-        # Connection details inside of the "url" key win any merge conflicts
-        def resolve_hash_connection(spec)
-          if spec["url"] && spec["url"] !~ /^jdbc:/
-            connection_hash = resolve_url_connection(spec.delete("url"))
-            spec.merge!(connection_hash)
+          # 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.
+          # Connection details inside of the "url" key win any merge conflicts
+          def resolve_hash_connection(spec)
+            if spec["url"] && spec["url"] !~ /^jdbc:/
+              connection_hash = resolve_url_connection(spec.delete("url"))
+              spec.merge!(connection_hash)
+            end
+            spec
           end
-          spec
-        end
 
-        # Takes a connection URL.
-        #
-        #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
-        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
-        #
-        def resolve_url_connection(url)
-          ConnectionUrlResolver.new(url).to_hash
-        end
+          # Takes a connection URL.
+          #
+          #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
+          #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+          #
+          def resolve_url_connection(url)
+            ConnectionUrlResolver.new(url).to_hash
+          end
       end
     end
   end