activerecord 4.1.0.beta2 → 4.1.0.rc1

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -43,7 +43,9 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column)
-        return value.id if value.respond_to?(:quoted_id)
+        if value.respond_to?(:quoted_id) && value.respond_to?(:id)
+          return value.id
+        end
 
         case value
         when String, ActiveSupport::Multibyte::Chars

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -120,9 +120,9 @@ module ActiveRecord
       #   The name of the primary key, if one is to be added automatically.
       #   Defaults to +id+. If <tt>:id</tt> is false this option is ignored.
       #
-      #   Also note that this just sets the primary key in the table. You additionally
-      #   need to configure the primary key in the model via +self.primary_key=+.
-      #   Models do NOT auto-detect the primary key from their table definition.
+      #   Note that Active Record models will automatically detect their
+      #   primary key. This can be avoided by using +self.primary_key=+ on the model
+      #   to define the key explicitly.
       #
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
@@ -714,7 +714,7 @@ module ActiveRecord
       # require the order columns appear in the SELECT.
       #
       #   columns_for_distinct("posts.id", ["posts.created_at desc"])
-      def columns_for_distinct(columns, orders) # :nodoc:
+      def columns_for_distinct(columns, orders) #:nodoc:
         columns
       end
 
@@ -736,6 +736,10 @@ module ActiveRecord
         remove_column table_name, :created_at
       end
 
+      def update_table_definition(table_name, base) #:nodoc:
+        Table.new(table_name, base)
+      end
+
       protected
         def add_index_sort_order(option_strings, column_names, options = {})
           if options.is_a?(Hash) && order = options[:order]
@@ -848,10 +852,6 @@ module ActiveRecord
       def create_alter_table(name)
         AlterTable.new create_table_definition(name, false, {})
       end
-
-      def update_table_definition(table_name, base)
-        Table.new(table_name, base)
-      end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -23,6 +23,10 @@ module ActiveRecord
         @parent = nil
       end
 
+      def finalized?
+        @state
+      end
+
       def committed?
         @state == :committed
       end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -262,6 +262,12 @@ module ActiveRecord
       def active?
       end
 
+      # Adapter should redefine this if it needs a threadsafe way to approximate
+      # if the connection is active
+      def active_threadsafe?
+        active?
+      end
+
       # Disconnects from the database if already connected, and establishes a
       # new connection with the database. Implementors should call super if they
       # override the default implementation.
@@ -349,6 +355,14 @@ module ActiveRecord
 
       protected
 
+      def translate_exception_class(e, sql)
+        message = "#{e.class.name}: #{e.message}: #{sql}"
+        @logger.error message if @logger
+        exception = translate_exception(e, message)
+        exception.set_backtrace e.backtrace
+        exception
+      end
+
       def log(sql, name = "SQL", binds = [], statement_name = nil)
         @instrumenter.instrument(
           "sql.active_record",
@@ -358,11 +372,7 @@ module ActiveRecord
           :statement_name => statement_name,
           :binds          => binds) { yield }
       rescue => e
-        message = "#{e.class.name}: #{e.message}: #{sql}"
-        @logger.error message if @logger
-        exception = translate_exception(e, message)
-        exception.set_backtrace e.backtrace
-        raise exception
+        raise translate_exception_class(e, sql)
       end
 
       def translate_exception(exception, message)

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -298,11 +298,7 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil)
-        if name == :skip_logging
-          @connection.query(sql)
-        else
-          log(sql, name) { @connection.query(sql) }
-        end
+        log(sql, name) { @connection.query(sql) }
       end
 
       # MysqlAdapter has to free a result after using it, so we use this method to write
@@ -775,7 +771,7 @@ module ActiveRecord
         end.compact.join(', ')
 
         # ...and send them all in one query
-        execute("SET #{encoding} #{variable_assignments}", :skip_logging)
+        @connection.query  "SET #{encoding} #{variable_assignments}"
       end
     end
   end

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -13,41 +13,146 @@ 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
+          @adapter = "postgresql" if @adapter == "postgres"
+          @query   = @uri.query || ''
+        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
+          query_hash.merge({
+            "adapter"  => @adapter,
+            "username" => uri.user,
+            "password" => uri.password,
+            "port"     => uri.port,
+            "database" => database,
+            "host"     => uri.host })
+        end
+
+        # Returns name of the database.
+        # Sqlite3 expects this to be a full path or `:memory:`.
+        def database
+          if @adapter == 'sqlite3'
+            if '/:memory:' == uri.path
+              ':memory:'
+            else
+              uri.path
+            end
+          else
+            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_env_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)
 
@@ -61,35 +166,87 @@ module ActiveRecord
           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
-
-          spec.map { |key,value| spec[key] = uri_parser.unescape(value) if value.is_a?(String) }
+        private
 
-          if config.query
-            options = Hash[config.query.split("&").map{ |pair| pair.split("=") }].symbolize_keys
+        # 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, String
+            resolve_env_connection spec
+          when Hash
+            resolve_hash_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_env_connection(:production)
+        #   # => {}
+        #
+        # Takes a connection URL.
+        #
+        #   Resolver.new({}).resolve_env_connection("postgresql://localhost/foo")
+        #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+        #
+        def resolve_env_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_string_connection and
+          # resolve_symbol_connection.
+          if config = configurations[spec.to_s]
+            if spec.is_a?(String)
+              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"
+            end
+            resolve_connection(config)
+          elsif spec.is_a?(String)
+            resolve_string_connection(spec)
+          else
+            raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available configuration: #{configurations.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 url = spec.delete("url")
+            connection_hash = resolve_string_connection(url)
+            spec.merge!(connection_hash)
+          end
           spec
         end
+
+        def resolve_string_connection(url)
+          ConnectionUrlResolver.new(url).to_hash
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -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
 
@@ -207,7 +213,7 @@ module ActiveRecord
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(sql, name = nil)
+      def select_rows(sql, name = nil, binds = [])
         execute(sql, name).to_a
       end
 

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
 
@@ -207,9 +213,9 @@ module ActiveRecord
 
       # DATABASE STATEMENTS ======================================
 
-      def select_rows(sql, name = nil)
+      def select_rows(sql, name = nil, binds = [])
         @connection.query_with_result = true
-        rows = exec_query(sql, name).rows
+        rows = exec_query(sql, name, binds).rows
         @connection.more_results && @connection.next_result    # invoking stored procedures with CLIENT_MULTI_RESULTS requires this to tidy up else connection will be dropped
         rows
       end