activerecord 4.0.4 → 4.1.16

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -13,41 +13,173 @@ module ActiveRecord
         @config = original.config.dup
       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.parse(url)
+          @adapter = @uri.scheme.gsub('-', '_')
+          @adapter = "postgresql" if @adapter == "postgres"
+
+          if @uri.opaque
+            @uri.opaque, @query = @uri.opaque.split('?', 2)
+          else
+            @query = @uri.query
+          end
+          @authority = url =~ %r{\A[^:]*://}
+        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&reap_frequency=2"
+        #   # => { "pool" => "5", "reap_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.
+        # 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'
+            # '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
+      # Builds a ConnectionSpecification from user input.
       class Resolver # :nodoc:
-        attr_reader :config, :klass, :configurations
+        attr_reader :configurations
 
-        def initialize(config, configurations)
-          @config         = config
+        # 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
 
-        def spec
-          case config
-          when nil
-            raise AdapterNotSpecified unless defined?(Rails.env)
-            resolve_string_connection Rails.env
-          when Symbol, String
-            resolve_string_connection config.to_s
-          when Hash
-            resolve_hash_connection config
+        # 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
 
-        private
-        def resolve_string_connection(spec) # :nodoc:
-          hash = configurations.fetch(spec) do |k|
-            connection_url_to_hash(k)
+        # 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
-
-          raise(AdapterNotSpecified, "#{spec} database is not configured") unless hash
-
-          resolve_hash_connection hash
+          config
         end
 
-        def resolve_hash_connection(spec) # :nodoc:
-          spec = spec.symbolize_keys
+        # 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"
+        #   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)
 
@@ -55,41 +187,97 @@ module ActiveRecord
           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."
+            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
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
-
           ConnectionSpecification.new(spec, adapter_method)
         end
 
-        def connection_url_to_hash(url) # :nodoc:
-          config = URI.parse url
-          adapter = config.scheme
-          adapter = "postgresql" if adapter == "postgres"
-          spec = { :adapter  => adapter,
-                   :username => config.user,
-                   :password => config.password,
-                   :port     => config.port,
-                   :database => config.path.sub(%r{^/},""),
-                   :host     => config.host }
-
-          spec.reject!{ |_,value| value.blank? }
-
-          uri_parser = URI::Parser.new
+        private
 
-          spec.map { |key,value| spec[key] = uri_parser.unescape(value) if value.is_a?(String) }
+        # 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
+          end
+        end
 
-          if config.query
-            options = Hash[config.query.split("&").map{ |pair| pair.split("=") }].symbolize_keys
+        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 "Passing a string to ActiveRecord::Base.establish_connection " \
+              "for a configuration lookup is deprecated, please pass a symbol (#{spec.to_sym.inspect}) instead"
+            resolve_symbol_connection(spec)
+          else
+            resolve_url_connection(spec)
+          end
+        end
 
-            spec.merge!(options)
+        # 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}")
           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_string_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

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,6 +1,6 @@
 require 'active_record/connection_adapters/abstract_mysql_adapter'
 
-gem 'mysql2', '~> 0.3.10'
+gem 'mysql2', '~> 0.3.13'
 require 'mysql2'
 
 module ActiveRecord
@@ -18,6 +18,12 @@ module ActiveRecord
       client = Mysql2::Client.new(config)
       options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
       ConnectionAdapters::Mysql2Adapter.new(client, logger, options, config)
+    rescue Mysql2::Error => error
+      if error.message.include?("Unknown database")
+        raise ActiveRecord::NoDatabaseError.new(error.message)
+      else
+        raise error
+      end
     end
   end
 
@@ -229,8 +235,7 @@ module ActiveRecord
 
       alias exec_without_stmt exec_query
 
-      # Returns an array of record hashes with the column names as keys and
-      # column values as values.
+      # Returns an ActiveRecord::Result instance.
       def select(sql, name = nil, binds = [])
         exec_query(sql, name)
       end
@@ -267,8 +272,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.server_info[:version]
       end
 
       def set_field_encoding field_name

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -34,6 +34,12 @@ module ActiveRecord
       default_flags |= Mysql::CLIENT_FOUND_ROWS if Mysql.const_defined?(:CLIENT_FOUND_ROWS)
       options = [host, username, password, database, port, socket, default_flags]
       ConnectionAdapters::MysqlAdapter.new(mysql, logger, options, config)
+    rescue Mysql::Error => error
+      if error.message.include?("Unknown database")
+        raise ActiveRecord::NoDatabaseError.new(error.message)
+      else
+        raise error
+      end
     end
   end
 
@@ -51,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/server-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/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.
@@ -160,12 +166,6 @@ module ActiveRecord
 
       # QUOTING ==================================================
 
-      def type_cast(value, column)
-        return super unless value == true || value == false
-
-        value ? 1 : 0
-      end
-
       def quote_string(string) #:nodoc:
         @connection.quote(string)
       end
@@ -425,14 +425,19 @@ module ActiveRecord
 
           if result
             types = {}
+            fields = []
             result.fetch_fields.each { |field|
+              field_name = field.name
+              fields << field_name
+
               if field.decimals > 0
-                types[field.name] = Fields::Decimal.new
+                types[field_name] = Fields::Decimal.new
               else
-                types[field.name] = Fields.find_type field
+                types[field_name] = Fields.find_type field
               end
             }
-            result_set = ActiveRecord::Result.new(types.keys, result.to_a, types)
+
+            result_set = ActiveRecord::Result.new(fields, result.to_a, types)
             result.free
           else
             result_set = ActiveRecord::Result.new([], [])
@@ -468,15 +473,17 @@ module ActiveRecord
 
       def begin_db_transaction #:nodoc:
         exec_query "BEGIN"
-      rescue Mysql::Error
-        # Transactions aren't supported
       end
 
       private
 
       def exec_stmt(sql, name, binds)
         cache = {}
-        log(sql, name, binds) do
+        type_casted_binds = binds.map { |col, val|
+          [col, type_cast(val, col)]
+        }
+
+        log(sql, name, type_casted_binds) do
           if binds.empty?
             stmt = @connection.prepare(sql)
           else
@@ -487,7 +494,7 @@ module ActiveRecord
           end
 
           begin
-            stmt.execute(*binds.map { |col, val| type_cast(val, col) })
+            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
@@ -551,9 +558,9 @@ module ActiveRecord
         rows
       end
 
-      # Returns the version of the connected MySQL server.
-      def version
-        @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
+      # Returns the full version of the connected MySQL server.
+      def full_version
+        @full_version ||= @connection.server_info
       end
 
       def set_field_encoding field_name

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

@@ -2,6 +2,13 @@ module ActiveRecord
   module ConnectionAdapters
     class PostgreSQLColumn < Column
       module ArrayParser
+
+        DOUBLE_QUOTE = '"'
+        BACKSLASH = "\\"
+        COMMA = ','
+        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
@@ -12,18 +19,18 @@ module ActiveRecord
             include PgArrayParser
           rescue LoadError
             def parse_pg_array(string)
-              parse_data(string, 0)
+              parse_data(string)
             end
           end
 
-          def parse_data(string, index)
-            local_index = index
+          def parse_data(string)
+            local_index = 0
             array = []
             while(local_index < string.length)
               case string[local_index]
-              when '{'
+              when BRACKET_OPEN
                 local_index,array = parse_array_contents(array, string, local_index + 1)
-              when '}'
+              when BRACKET_CLOSE
                 return array
               end
               local_index += 1
@@ -33,9 +40,9 @@ module ActiveRecord
           end
 
           def parse_array_contents(array, string, index)
-            is_escaping = false
-            is_quoted = false
-            was_quoted = false
+            is_escaping  = false
+            is_quoted    = false
+            was_quoted   = false
             current_item = ''
 
             local_index = index
@@ -47,29 +54,29 @@ module ActiveRecord
               else
                 if is_quoted
                   case token
-                  when '"'
+                  when DOUBLE_QUOTE
                     is_quoted = false
                     was_quoted = true
-                  when "\\"
+                  when BACKSLASH
                     is_escaping = true
                   else
                     current_item << token
                   end
                 else
                   case token
-                  when "\\"
+                  when BACKSLASH
                     is_escaping = true
-                  when ','
+                  when COMMA
                     add_item_to_array(array, current_item, was_quoted)
                     current_item = ''
                     was_quoted = false
-                  when '"'
+                  when DOUBLE_QUOTE
                     is_quoted = true
-                  when '{'
+                  when BRACKET_OPEN
                     internal_items = []
                     local_index,internal_items = parse_array_contents(internal_items, string, local_index + 1)
                     array.push(internal_items)
-                  when '}'
+                  when BRACKET_CLOSE
                     add_item_to_array(array, current_item, was_quoted)
                     return local_index,array
                   else

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

@@ -17,8 +17,8 @@ module ActiveRecord
           return string unless String === string
 
           case string
-          when 'infinity'; 1.0 / 0.0
-          when '-infinity'; -1.0 / 0.0
+          when 'infinity'; Float::INFINITY
+          when '-infinity'; -Float::INFINITY
           when / BC$/
             super("-" + string.sub(/ BC$/, ""))
           else
@@ -67,7 +67,7 @@ module ActiveRecord
           end
         end
 
-        def array_to_string(value, column, adapter, should_be_quoted = false)
+        def array_to_string(value, column, adapter)
           casted_values = value.map do |val|
             if String === val
               if val == "NULL"
@@ -119,7 +119,7 @@ module ActiveRecord
         end
 
         def string_to_array(string, oid)
-          parse_pg_array(string).map{|val| oid.type_cast val}
+          parse_pg_array(string).map {|val| type_cast_array(oid, val)}
         end
 
         private
@@ -154,6 +154,14 @@ module ActiveRecord
               "\"#{value}\""
             end
           end
+
+          def type_cast_array(oid, value)
+            if ::Array === value
+              value.map {|item| type_cast_array(oid, item)}
+            else
+              oid.type_cast value
+            end
+          end
       end
     end
   end

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

@@ -134,35 +134,28 @@ module ActiveRecord
         end
 
         def exec_query(sql, name = 'SQL', binds = [])
-          log(sql, name, binds) do
-            result = without_prepared_statement?(binds) ? exec_no_cache(sql, binds) :
-                                                          exec_cache(sql, binds)
-
-            types = {}
-            fields = result.fields
-            fields.each_with_index do |fname, i|
-              ftype = result.ftype i
-              fmod  = result.fmod i
-              types[fname] = OID::TYPE_MAP.fetch(ftype, fmod) { |oid, mod|
-                warn "unknown OID: #{fname}(#{oid}) (#{sql})"
-                OID::Identity.new
-              }
-            end
-
-            ret = ActiveRecord::Result.new(fields, result.values, types)
-            result.clear
-            return ret
+          result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
+                                                        exec_cache(sql, name, binds)
+
+          types = {}
+          fields = result.fields
+          fields.each_with_index do |fname, i|
+            ftype = result.ftype i
+            fmod  = result.fmod i
+            types[fname] = get_oid_type(ftype, fmod, fname)
           end
+
+          ret = ActiveRecord::Result.new(fields, result.values, types)
+          result.clear
+          return ret
         end
 
         def exec_delete(sql, name = 'SQL', binds = [])
-          log(sql, name, binds) do
-            result = without_prepared_statement?(binds) ? exec_no_cache(sql, binds) :
-                                                          exec_cache(sql, binds)
-            affected = result.cmd_tuples
-            result.clear
-            affected
-          end
+          result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
+                                                        exec_cache(sql, name, binds)
+          affected = result.cmd_tuples
+          result.clear
+          affected
         end
         alias :exec_update :exec_delete
 
@@ -218,25 +211,6 @@ module ActiveRecord
         def rollback_db_transaction
           execute "ROLLBACK"
         end
-
-        def outside_transaction?
-          message = "#outside_transaction? is deprecated. This method was only really used " \
-                    "internally, but you can use #transaction_open? instead."
-          ActiveSupport::Deprecation.warn message
-          @connection.transaction_status == PGconn::PQTRANS_IDLE
-        end
-
-        def create_savepoint
-          execute("SAVEPOINT #{current_savepoint_name}")
-        end
-
-        def rollback_to_savepoint
-          execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-        end
-
-        def release_savepoint
-          execute("RELEASE SAVEPOINT #{current_savepoint_name}")
-        end
       end
     end
   end