activerecord 4.1.0 → 4.2.0

data/lib/active_record/connection_adapters/column.rb

@@ -13,101 +13,36 @@ module ActiveRecord
         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, :default_function
-      attr_accessor :primary, :coder
+      attr_reader :name, :cast_type, :null, :sql_type, :default, :default_function
 
-      alias :encoded? :coder
+      delegate :type, :precision, :scale, :limit, :klass, :accessor,
+        :number?, :binary?, :changed?,
+        :type_cast_from_user, :type_cast_from_database, :type_cast_for_database,
+        :type_cast_for_schema,
+        to: :cast_type
 
       # 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>.
       # +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.
       # +null+ determines if this column allows +NULL+ values.
-      def initialize(name, default, sql_type = nil, null = true)
+      def initialize(name, default, cast_type, sql_type = nil, null = true)
         @name             = name
+        @cast_type        = cast_type
         @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)
+        @default          = default
         @default_function = nil
-        @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
       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
-
-      def binary?
-        type == :binary
-      end
-
-      # Casts a Ruby value to something appropriate for writing to the database.
-      def type_cast_for_write(value)
-        return value unless number?
-
-        case value
-        when FalseClass
-          0
-        when TrueClass
-          1
-        when String
-          value.presence
-        else
-          value
-        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.value_to_date(value)
-        when :binary               then klass.binary_to_string(value)
-        when :boolean              then klass.value_to_boolean(value)
-        else value
-        end
-      end
-
       # Returns the human name of the column name.
       #
       # ===== Examples
@@ -116,177 +51,31 @@ module ActiveRecord
         Base.human_attribute_name(@name)
       end
 
-      def extract_default(default)
-        type_cast(default)
-      end
-
-      class << self
-        # Used to convert from BLOBs to Strings
-        def binary_to_string(value)
-          value
-        end
-
-        def value_to_date(value)
-          if value.is_a?(String)
-            return nil if value.empty?
-            fast_string_to_date(value) || fallback_string_to_date(value)
-          elsif value.respond_to?(:to_date)
-            value.to_date
-          else
-            value
-          end
-        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.empty?
-            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
+      def with_type(type)
+        dup.tap do |clone|
+          clone.instance_variable_set('@cast_type', type)
         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, offset = nil)
-            # Treat 0000-00-00 00:00:00 as nil.
-            return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
-
-            if offset
-              time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
-              return nil unless time
-
-              time -= offset
-              Base.default_timezone == :utc ? time : time.getlocal
-            else
-              Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-            end
-          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
-
-          # 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
-
-          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)
+      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
+      end
+      alias :eql? :==
 
-            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
-          end
+      def hash
+        attributes_for_hash.hash
       end
 
       private
-        def extract_limit(sql_type)
-          $1.to_i if sql_type =~ /\((.*)\)/
-        end
 
-        def extract_precision(sql_type)
-          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
-        end
-
-        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
-        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
-          when /boolean/i
-            :boolean
-          end
-        end
+      def attributes_for_hash
+        [self.class, name, default, cast_type, sql_type, null, default_function]
+      end
     end
   end
   # :startdoc:

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -1,4 +1,5 @@
 require 'uri'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -32,8 +33,8 @@ module ActiveRecord
         #   }
         def initialize(url)
           raise "Database URL cannot be empty" if url.blank?
-          @uri     = URI.parse(url)
-          @adapter = @uri.scheme.gsub('-', '_')
+          @uri     = uri_parser.parse(url)
+          @adapter = @uri.scheme.tr('-', '_')
           @adapter = "postgresql" if @adapter == "postgres"
 
           if @uri.opaque
@@ -41,7 +42,6 @@ module ActiveRecord
           else
             @query = @uri.query
           end
-          @authority = url =~ %r{\A[^:]*://}
         end
 
         # Converts the given URL to a full connection hash.
@@ -63,8 +63,8 @@ module ActiveRecord
 
         # Converts the query parameters of the URI into a hash.
         #
-        #   "localhost?pool=5&reap_frequency=2"
-        #   # => { "pool" => "5", "reap_frequency" => "2" }
+        #   "localhost?pool=5&reaping_frequency=2"
+        #   # => { "pool" => "5", "reaping_frequency" => "2" }
         #
         # returns empty hash if no query present.
         #
@@ -86,26 +86,13 @@ module ActiveRecord
               "password" => uri.password,
               "port"     => uri.port,
               "database" => database_from_path,
-              "host"     => uri.host })
+              "host"     => uri.hostname })
           end
         end
 
         # Returns name of the database.
-        # Sqlite3's handling of a leading slash is in transition as of
-        # Rails 4.1.
         def database_from_path
-          if @authority && @adapter == 'sqlite3'
-            # 'sqlite3:///foo' is relative, for backwards compatibility.
-
-            database_name = uri.path.sub(%r{^/}, "")
-
-            msg = "Paths in SQLite3 database URLs of the form `sqlite3:///path` will be treated as absolute in Rails 4.2. " \
-              "Please switch to `sqlite3:#{database_name}`."
-            ActiveSupport::Deprecation.warn(msg)
-
-            database_name
-
-          elsif @adapter == 'sqlite3'
+          if @adapter == 'sqlite3'
             # 'sqlite3:/foo' is absolute, because that makes sense. The
             # corresponding relative version, 'sqlite3:foo', is handled
             # elsewhere, as an "opaque".
@@ -174,7 +161,7 @@ module ActiveRecord
         #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
         #   spec = Resolver.new(config).spec(:production)
         #   spec.adapter_method
-        #   # => "sqlite3"
+        #   # => "sqlite3_connection"
         #   spec.config
         #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
         #
@@ -235,15 +222,19 @@ module ActiveRecord
           # 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 "Passing a string to ActiveRecord::Base.establish_connection " \
-              "for a configuration lookup is deprecated, please pass a symbol (#{spec.to_sym.inspect}) instead"
+            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)
           end
         end
 
-        # Takes the environment such as `:production` or `:development`.
+        # Takes the environment such as +:production+ or +:development+.
         # This requires that the @configurations was initialized with a key that
         # matches.
         #
@@ -264,7 +255,7 @@ module ActiveRecord
         # 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_string_connection(spec.delete("url"))
+            connection_hash = resolve_url_connection(spec.delete("url"))
             spec.merge!(connection_hash)
           end
           spec

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -20,27 +20,20 @@ module ActiveRecord
       ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
     rescue Mysql2::Error => error
       if error.message.include?("Unknown database")
-        raise ActiveRecord::NoDatabaseError.new(error.message)
+        raise ActiveRecord::NoDatabaseError.new(error.message, error)
       else
-        raise error
+        raise
       end
     end
   end
 
   module ConnectionAdapters
     class Mysql2Adapter < AbstractMysqlAdapter
-
-      class Column < AbstractMysqlAdapter::Column # :nodoc:
-        def adapter
-          Mysql2Adapter
-        end
-      end
-
-      ADAPTER_NAME = 'Mysql2'
+      ADAPTER_NAME = 'Mysql2'.freeze
 
       def initialize(connection, logger, connection_options, config)
         super
-        @visitor = BindSubstitution.new self
+        @prepared_statements = false
         configure_connection
       end
 
@@ -69,21 +62,29 @@ module ActiveRecord
         end
       end
 
-      def new_column(field, default, type, null, collation, extra = "") # :nodoc:
-        Column.new(field, default, type, null, collation, strict_mode?, extra)
-      end
-
       def error_number(exception)
         exception.error_number if exception.respond_to?(:error_number)
       end
 
+      #--
       # QUOTING ==================================================
+      #++
 
       def quote_string(string)
         @connection.escape(string)
       end
 
+      def quoted_date(value)
+        if value.acts_like?(:time) && value.respond_to?(:usec)
+          "#{super}.#{sprintf("%06d", value.usec)}"
+        else
+          super
+        end
+      end
+
+      #--
       # CONNECTION MANAGEMENT ====================================
+      #++
 
       def active?
         return false unless @connection
@@ -107,7 +108,9 @@ module ActiveRecord
         end
       end
 
+      #--
       # DATABASE STATEMENTS ======================================
+      #++
 
       def explain(arel, binds = [])
         sql     = "EXPLAIN #{to_sql(arel, binds.dup)}"
@@ -235,11 +238,6 @@ module ActiveRecord
 
       alias exec_without_stmt exec_query
 
-      # Returns an ActiveRecord::Result instance.
-      def select(sql, name = nil, binds = [])
-        exec_query(sql, name)
-      end
-
       def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         super
         id_value || @connection.last_id
@@ -272,8 +270,8 @@ module ActiveRecord
         super
       end
 
-      def version
-        @version ||= @connection.info[:version].scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      def full_version
+        @full_version ||= @connection.info[:version]
       end
 
       def set_field_encoding field_name