activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/connection_adapters/column.rb

@@ -1,107 +1,37 @@
-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, :table_name, :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, :default, :type, :limit, :null, :sql_type, :precision, :scale
-      attr_accessor :primary, :coder
-
-      alias :encoded? :coder
+      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>.
-      # +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, sql_type = nil, null = true)
-        @name      = name
-        @sql_type  = sql_type
-        @null      = null
-        @limit     = extract_limit(sql_type)
-        @precision = extract_precision(sql_type)
-        @scale     = extract_scale(sql_type)
-        @type      = simplified_type(sql_type)
-        @default   = extract_default(default)
-        @primary   = nil
-        @coder     = nil
-      end
-
-      # Returns +true+ if the column is either of type string or text.
-      def text?
-        type == :string || type == :text
-      end
-
-      # Returns +true+ if the column is either of type integer, float or decimal.
-      def number?
-        type == :integer || type == :float || type == :decimal
+      def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil, **)
+        @name = name.freeze
+        @table_name = table_name
+        @sql_type_metadata = sql_type_metadata
+        @null = null
+        @default = default
+        @default_function = default_function
+        @collation = collation
+        @comment = comment
       end
 
       def has_default?
-        !default.nil?
-      end
-
-      # Returns the Ruby class that corresponds to the abstract data type.
-      def klass
-        case type
-        when :integer                     then Fixnum
-        when :float                       then Float
-        when :decimal                     then BigDecimal
-        when :datetime, :timestamp, :time then Time
-        when :date                        then Date
-        when :text, :string, :binary      then String
-        when :boolean                     then Object
-        end
-      end
-
-      # Casts value (which is a String) to an appropriate instance.
-      def type_cast(value)
-        return nil if value.nil?
-        return coder.load(value) if encoded?
-
-        klass = self.class
-
-        case type
-        when :string, :text        then value
-        when :integer              then klass.value_to_integer(value)
-        when :float                then value.to_f
-        when :decimal              then klass.value_to_decimal(value)
-        when :datetime, :timestamp then klass.string_to_time(value)
-        when :time                 then klass.string_to_dummy_time(value)
-        when :date                 then klass.string_to_date(value)
-        when :binary               then klass.binary_to_string(value)
-        when :boolean              then klass.value_to_boolean(value)
-        else value
-        end
+        !default.nil? || default_function
       end
 
-      def type_cast_code(var_name)
-        klass = self.class.name
-
-        case type
-        when :string, :text        then var_name
-        when :integer              then "#{klass}.value_to_integer(#{var_name})"
-        when :float                then "#{var_name}.to_f"
-        when :decimal              then "#{klass}.value_to_decimal(#{var_name})"
-        when :datetime, :timestamp then "#{klass}.string_to_time(#{var_name})"
-        when :time                 then "#{klass}.string_to_dummy_time(#{var_name})"
-        when :date                 then "#{klass}.string_to_date(#{var_name})"
-        when :binary               then "#{klass}.binary_to_string(#{var_name})"
-        when :boolean              then "#{klass}.value_to_boolean(#{var_name})"
-        else var_name
-        end
+      def bigint?
+        /\Abigint\b/.match?(sql_type)
       end
 
       # Returns the human name of the column name.
@@ -112,184 +42,49 @@ module ActiveRecord
         Base.human_attribute_name(@name)
       end
 
-      def extract_default(default)
-        type_cast(default)
+      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"]
+        @default_function = coder["default_function"]
+        @collation = coder["collation"]
+        @comment = coder["comment"]
       end
 
-      # Used to convert from Strings to BLOBs
-      def string_to_binary(value)
-        self.class.string_to_binary(value)
+      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
+        coder["default_function"] = @default_function
+        coder["collation"] = @collation
+        coder["comment"] = @comment
       end
 
-      class << self
-        # Used to convert from Strings to BLOBs
-        def string_to_binary(value)
-          value
-        end
-
-        # Used to convert from BLOBs to Strings
-        def binary_to_string(value)
-          value
-        end
-
-        def string_to_date(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          fast_string_to_date(string) || fallback_string_to_date(string)
-        end
-
-        def string_to_time(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          fast_string_to_time(string) || fallback_string_to_time(string)
-        end
-
-        def string_to_dummy_time(string)
-          return string unless string.is_a?(String)
-          return nil if string.empty?
-
-          dummy_time_string = "2000-01-01 #{string}"
-
-          fast_string_to_time(dummy_time_string) || begin
-            time_hash = Date._parse(dummy_time_string)
-            return nil if time_hash[:hour].nil?
-            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
-          end
-        end
-
-        # convert something to a boolean
-        def value_to_boolean(value)
-          if value.is_a?(String) && value.blank?
-            nil
-          else
-            TRUE_VALUES.include?(value)
-          end
-        end
-
-        # Used to convert values to integer.
-        # handle the case when an integer column is used to store boolean values
-        def value_to_integer(value)
-          case value
-          when TrueClass, FalseClass
-            value ? 1 : 0
-          else
-            value.to_i rescue nil
-          end
-        end
-
-        # convert something to a BigDecimal
-        def value_to_decimal(value)
-          # Using .class is faster than .is_a? and
-          # subclasses of BigDecimal will be handled
-          # in the else clause
-          if value.class == BigDecimal
-            value
-          elsif value.respond_to?(:to_d)
-            value.to_d
-          else
-            value.to_s.to_d
-          end
-        end
-
-        protected
-          # '0.123456' -> 123456
-          # '1.123456' -> 123456
-          def microseconds(time)
-            time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
-          end
-
-          def new_date(year, mon, mday)
-            if year && year != 0
-              Date.new(year, mon, mday) rescue nil
-            end
-          end
-
-          def new_time(year, mon, mday, hour, min, sec, microsec)
-            # Treat 0000-00-00 00:00:00 as nil.
-            return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
-
-            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-          end
-
-          def fast_string_to_date(string)
-            if string =~ Format::ISO_DATE
-              new_date $1.to_i, $2.to_i, $3.to_i
-            end
-          end
-
-          if RUBY_VERSION >= '1.9'
-            # Doesn't handle time zones.
-            def fast_string_to_time(string)
-              if string =~ Format::ISO_DATETIME
-                microsec = ($7.to_r * 1_000_000).to_i
-                new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-              end
-            end
-          else
-            def fast_string_to_time(string)
-              if string =~ Format::ISO_DATETIME
-                microsec = ($7.to_f * 1_000_000).round.to_i
-                new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-              end
-            end
-          end
-
-          def fallback_string_to_date(string)
-            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
-          end
-
-          def fallback_string_to_time(string)
-            time_hash = Date._parse(string)
-            time_hash[:sec_fraction] = microseconds(time_hash)
-
-            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
-          end
+      def ==(other)
+        other.is_a?(Column) &&
+          attributes_for_hash == other.attributes_for_hash
       end
+      alias :eql? :==
 
-      private
-        def extract_limit(sql_type)
-          $1.to_i if sql_type =~ /\((.*)\)/
-        end
+      def hash
+        attributes_for_hash.hash
+      end
 
-        def extract_precision(sql_type)
-          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
-        end
+      protected
 
-        def extract_scale(sql_type)
-          case sql_type
-            when /^(numeric|decimal|number)\((\d+)\)/i then 0
-            when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
-          end
+        def attributes_for_hash
+          [self.class, name, default, sql_type_metadata, null, table_name, default_function, collation]
         end
+    end
 
-        def simplified_type(field_type)
-          case field_type
-          when /int/i
-            :integer
-          when /float|double/i
-            :float
-          when /decimal|numeric|number/i
-            extract_scale(field_type) == 0 ? :integer : :decimal
-          when /datetime/i
-            :datetime
-          when /timestamp/i
-            :timestamp
-          when /time/i
-            :time
-          when /date/i
-            :date
-          when /clob/i, /text/i
-            :text
-          when /blob/i, /binary/i
-            :binary
-          when /char/i, /string/i
-            :string
-          when /boolean/i
-            :boolean
-          end
-        end
+    class NullColumn < Column
+      def initialize(name)
+        super(name, nil)
+      end
     end
   end
   # :startdoc:

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionSpecification #:nodoc:
+      attr_reader :name, :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"
+        #   ConnectionUrlResolver.new(url).to_hash
+        #   # => {
+        #     "adapter"  => "postgresql",
+        #     "host"     => "localhost",
+        #     "port"     => 9000,
+        #     "database" => "foo_test",
+        #     "username" => "foo",
+        #     "password" => "bar",
+        #     "pool"     => "5",
+        #     "timeout"  => "3000"
+        #   }
+        def initialize(url)
+          raise "Database URL cannot be empty" if url.blank?
+          @uri     = uri_parser.parse(url)
+          @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
+          @adapter = "postgresql" if @adapter == "postgres"
+
+          if @uri.opaque
+            @uri.opaque, @query = @uri.opaque.split("?", 2)
+          else
+            @query = @uri.query
+          end
+        end
+
+        # 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
+        end
+
+        private
+
+          def uri
+            @uri
+          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
+
+          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
+
+          # 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.sub(%r{^/}, "")
+            end
+          end
+      end
+
+      ##
+      # Builds a ConnectionSpecification from user input.
+      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.
+        def initialize(configurations)
+          @configurations = configurations
+        end
+
+        # Returns a hash with database connection information.
+        #
+        # == Examples
+        #
+        # Full hash Configuration.
+        #
+        #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   Resolver.new(configurations).resolve(:production)
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
+        #
+        # Initialized with URL configuration strings.
+        #
+        #   configurations = { "production" => "postgresql://localhost/foo" }
+        #   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
+          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.
+        #
+        # == Example
+        #
+        #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+        #   spec = Resolver.new(config).spec(:production)
+        #   spec.adapter_method
+        #   # => "sqlite3_connection"
+        #   spec.config
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
+        #
+        def spec(config)
+          spec = resolve(config).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 LoadError => e
+            # 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"
+
+          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_url_connection spec
+            when Hash
+              resolve_hash_connection spec
+            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).merge("name" => spec.to_s)
+            else
+              raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+            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)
+            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
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module DetermineIfPreparableVisitor
+      attr_accessor :preparable
+
+      def accept(*)
+        @preparable = true
+        super
+      end
+
+      def visit_Arel_Nodes_In(o, collector)
+        @preparable = false
+
+        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
+
+        super
+      end
+
+      def visit_Arel_Nodes_SqlLiteral(*)
+        @preparable = false
+        super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      class Column < ConnectionAdapters::Column # :nodoc:
+        delegate :extra, to: :sql_type_metadata, allow_nil: true
+
+        def unsigned?
+          /\bunsigned(?: zerofill)?\z/.match?(sql_type)
+        end
+
+        def case_sensitive?
+          collation && !/_ci\z/.match?(collation)
+        end
+
+        def auto_increment?
+          extra == "auto_increment"
+        end
+
+        def virtual?
+          /\b(?:VIRTUAL|STORED|PERSISTENT)\b/.match?(extra)
+        end
+      end
+    end
+  end
+end