activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -32,7 +32,7 @@ module ActiveRecord
         #   }
         def initialize(url)
           raise "Database URL cannot be empty" if url.blank?
-          @uri     = URI.parse(url)
+          @uri     = uri_parser.parse(url)
           @adapter = @uri.scheme.gsub('-', '_')
           @adapter = "postgresql" if @adapter == "postgres"
 
@@ -41,7 +41,6 @@ module ActiveRecord
           else
             @query = @uri.query
           end
-          @authority = url =~ %r{\A[^:]*://}
         end
 
         # Converts the given URL to a full connection hash.
@@ -63,8 +62,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.
         #
@@ -91,21 +90,8 @@ module ActiveRecord
         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 +160,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" }
         #
@@ -264,7 +250,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'
 
       def initialize(connection, logger, connection_options, config)
         super
-        @visitor = BindSubstitution.new self
+        @prepared_statements = false
         configure_connection
       end
 
@@ -69,10 +62,6 @@ 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
@@ -83,6 +72,14 @@ module ActiveRecord
         @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?
@@ -273,7 +270,7 @@ module ActiveRecord
       end
 
       def full_version
-        @full_version ||= @connection.server_info[:version]
+        @full_version ||= @connection.info[:version]
       end
 
       def set_field_encoding field_name

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -36,9 +36,9 @@ module ActiveRecord
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
     rescue Mysql::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
@@ -57,7 +57,7 @@ module ActiveRecord
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
     # * <tt>:encoding</tt> - (Optional) Sets the client encoding by executing "SET NAMES <encoding>" after connection.
     # * <tt>:reconnect</tt> - Defaults to false (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/auto-reconnect.html).
-    # * <tt>:strict</tt> - Defaults to true. Enable STRICT_ALL_TABLES. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/sql-mode.html)
+    # * <tt>:strict</tt> - Defaults to true. Enable STRICT_ALL_TABLES. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/server-sql-mode.html)
     # * <tt>:variables</tt> - (Optional) A hash session variables to send as `SET @@SESSION.key = value` on each database connection. Use the value `:default` to set a variable to its DEFAULT value. (See MySQL documentation: http://dev.mysql.com/doc/refman/5.0/en/set-statement.html).
     # * <tt>:sslca</tt> - Necessary to use MySQL with an SSL connection.
     # * <tt>:sslkey</tt> - Necessary to use MySQL with an SSL connection.
@@ -66,35 +66,6 @@ module ActiveRecord
     # * <tt>:sslcipher</tt> - Necessary to use MySQL with an SSL connection.
     #
     class MysqlAdapter < AbstractMysqlAdapter
-
-      class Column < AbstractMysqlAdapter::Column #:nodoc:
-        def self.string_to_time(value)
-          return super unless Mysql::Time === value
-          new_time(
-            value.year,
-            value.month,
-            value.day,
-            value.hour,
-            value.minute,
-            value.second,
-            value.second_part)
-        end
-
-        def self.string_to_dummy_time(v)
-          return super unless Mysql::Time === v
-          new_time(2000, 01, 01, v.hour, v.minute, v.second, v.second_part)
-        end
-
-        def self.string_to_date(v)
-          return super unless Mysql::Time === v
-          new_date(v.year, v.month, v.day)
-        end
-
-        def adapter
-          MysqlAdapter
-        end
-      end
-
       ADAPTER_NAME = 'MySQL'
 
       class StatementPool < ConnectionAdapters::StatementPool
@@ -156,10 +127,6 @@ 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) # :nodoc:
         exception.errno if exception.respond_to?(:errno)
       end
@@ -222,6 +189,7 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
+        super
         @statements.clear
       end
 
@@ -294,126 +262,70 @@ module ActiveRecord
         @connection.insert_id
       end
 
-      module Fields
-        class Type
-          def type; end
-
-          def type_cast_for_write(value)
-            value
-          end
-        end
-
-        class Identity < Type
-          def type_cast(value); value; end
-        end
-
-        class Integer < Type
-          def type_cast(value)
-            return if value.nil?
-
-            value.to_i rescue value ? 1 : 0
-          end
-        end
-
-        class Date < Type
-          def type; :date; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.value_to_date value
-          end
-        end
-
-        class DateTime < Type
-          def type; :datetime; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.string_to_time value
-          end
-        end
-
-        class Time < Type
-          def type; :time; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            # FIXME: probably we can improve this since we know it is mysql
-            # specific
-            ConnectionAdapters::Column.string_to_dummy_time value
-          end
-        end
-
-        class Float < Type
-          def type; :float; end
-
-          def type_cast(value)
-            return if value.nil?
-
-            value.to_f
+      module Fields # :nodoc:
+        class DateTime < Type::DateTime # :nodoc:
+          def cast_value(value)
+            if Mysql::Time === value
+              new_time(
+                value.year,
+                value.month,
+                value.day,
+                value.hour,
+                value.minute,
+                value.second,
+                value.second_part)
+            else
+              super
+            end
           end
         end
 
-        class Decimal < Type
-          def type_cast(value)
-            return if value.nil?
-
-            ConnectionAdapters::Column.value_to_decimal value
+        class Time < Type::Time # :nodoc:
+          def cast_value(value)
+            if Mysql::Time === value
+              new_time(
+                2000,
+                01,
+                01,
+                value.hour,
+                value.minute,
+                value.second,
+                value.second_part)
+            else
+              super
+            end
           end
         end
 
-        class Boolean < Type
-          def type_cast(value)
-            return if value.nil?
+        class << self
+          TYPES = Type::HashLookupTypeMap.new # :nodoc:
 
-            ConnectionAdapters::Column.value_to_boolean value
-          end
-        end
-
-        TYPES = {}
-
-        # Register an MySQL +type_id+ with a typecasting object in
-        # +type+.
-        def self.register_type(type_id, type)
-          TYPES[type_id] = type
-        end
+          delegate :register_type, :alias_type, to: :TYPES
 
-        def self.alias_type(new, old)
-          TYPES[new] = TYPES[old]
-        end
-
-        def self.find_type(field)
-          if field.type == Mysql::Field::TYPE_TINY && field.length > 1
-            TYPES[Mysql::Field::TYPE_LONG]
-          else
-            TYPES.fetch(field.type) { Fields::Identity.new }
+          def find_type(field)
+            if field.type == Mysql::Field::TYPE_TINY && field.length > 1
+              TYPES.lookup(Mysql::Field::TYPE_LONG)
+            else
+              TYPES.lookup(field.type)
+            end
           end
         end
 
-        register_type Mysql::Field::TYPE_TINY,    Fields::Boolean.new
-        register_type Mysql::Field::TYPE_LONG,    Fields::Integer.new
+        register_type Mysql::Field::TYPE_TINY,    Type::Boolean.new
+        register_type Mysql::Field::TYPE_LONG,    Type::Integer.new
         alias_type Mysql::Field::TYPE_LONGLONG,   Mysql::Field::TYPE_LONG
         alias_type Mysql::Field::TYPE_NEWDECIMAL, Mysql::Field::TYPE_LONG
 
-        register_type Mysql::Field::TYPE_VAR_STRING, Fields::Identity.new
-        register_type Mysql::Field::TYPE_BLOB, Fields::Identity.new
-        register_type Mysql::Field::TYPE_DATE, Fields::Date.new
+        register_type Mysql::Field::TYPE_DATE, Type::Date.new
         register_type Mysql::Field::TYPE_DATETIME, Fields::DateTime.new
         register_type Mysql::Field::TYPE_TIME, Fields::Time.new
-        register_type Mysql::Field::TYPE_FLOAT, Fields::Float.new
+        register_type Mysql::Field::TYPE_FLOAT, Type::Float.new
+      end
 
-        Mysql::Field.constants.grep(/TYPE/).map { |class_name|
-          Mysql::Field.const_get class_name
-        }.reject { |const| TYPES.key? const }.each do |const|
-          register_type const, Fields::Identity.new
-        end
+      def initialize_type_map(m) # :nodoc:
+        super
+        m.register_type %r(datetime)i, Fields::DateTime.new
+        m.register_type %r(time)i,     Fields::Time.new
       end
 
       def exec_without_stmt(sql, name = 'SQL') # :nodoc:
@@ -431,7 +343,7 @@ module ActiveRecord
               fields << field_name
 
               if field.decimals > 0
-                types[field_name] = Fields::Decimal.new
+                types[field_name] = Type::Decimal.new
               else
                 types[field_name] = Fields.find_type field
               end
@@ -447,7 +359,7 @@ module ActiveRecord
         end
       end
 
-      def execute_and_free(sql, name = nil)
+      def execute_and_free(sql, name = nil) # :nodoc:
         result = execute(sql, name)
         ret = yield result
         result.free
@@ -460,7 +372,7 @@ module ActiveRecord
       end
       alias :create :insert_sql
 
-      def exec_delete(sql, name, binds)
+      def exec_delete(sql, name, binds) # :nodoc:
         affected_rows = 0
 
         exec_query(sql, name, binds) do |n|
@@ -497,7 +409,7 @@ module ActiveRecord
             stmt.execute(*type_casted_binds.map { |_, val| val })
           rescue Mysql::Error => e
             # Older versions of MySQL leave the prepared statement in a bad
-            # place when an error occurs. To support older mysql versions, we
+            # place when an error occurs. To support older MySQL versions, we
             # need to close the statement and delete the statement from the
             # cache.
             stmt.close

data/lib/active_record/connection_adapters/postgresql/array_parser.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
-    class PostgreSQLColumn < Column
-      module ArrayParser
+    module PostgreSQL
+      module ArrayParser # :nodoc:
 
         DOUBLE_QUOTE = '"'
         BACKSLASH = "\\"
@@ -9,35 +9,23 @@ module ActiveRecord
         BRACKET_OPEN = '{'
         BRACKET_CLOSE = '}'
 
-        private
-          # Loads pg_array_parser if available. String parsing can be
-          # performed quicker by a native extension, which will not create
-          # a large amount of Ruby objects that will need to be garbage
-          # collected. pg_array_parser has a C and Java extension
-          begin
-            require 'pg_array_parser'
-            include PgArrayParser
-          rescue LoadError
-            def parse_pg_array(string)
-              parse_data(string)
+        def parse_pg_array(string) # :nodoc:
+          local_index = 0
+          array = []
+          while(local_index < string.length)
+            case string[local_index]
+            when BRACKET_OPEN
+              local_index,array = parse_array_contents(array, string, local_index + 1)
+            when BRACKET_CLOSE
+              return array
             end
+            local_index += 1
           end
 
-          def parse_data(string)
-            local_index = 0
-            array = []
-            while(local_index < string.length)
-              case string[local_index]
-              when BRACKET_OPEN
-                local_index,array = parse_array_contents(array, string, local_index + 1)
-              when BRACKET_CLOSE
-                return array
-              end
-              local_index += 1
-            end
+          array
+        end
 
-            array
-          end
+        private
 
           def parse_array_contents(array, string, index)
             is_escaping  = false