activerecord 4.2.0 → 5.2.8.1

data/lib/active_record/connection_adapters/statement_pool.rb

@@ -1,40 +1,61 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
-    class StatementPool
+    class StatementPool # :nodoc:
       include Enumerable
 
-      def initialize(connection, max = 1000)
-        @connection = connection
-        @max        = max
+      DEFAULT_STATEMENT_LIMIT = 1000
+
+      def initialize(statement_limit = nil)
+        @cache = Hash.new { |h, pid| h[pid] = {} }
+        @statement_limit = statement_limit || DEFAULT_STATEMENT_LIMIT
       end
 
-      def each
-        raise NotImplementedError
+      def each(&block)
+        cache.each(&block)
       end
 
       def key?(key)
-        raise NotImplementedError
+        cache.key?(key)
       end
 
       def [](key)
-        raise NotImplementedError
+        cache[key]
       end
 
       def length
-        raise NotImplementedError
+        cache.length
       end
 
-      def []=(sql, key)
-        raise NotImplementedError
+      def []=(sql, stmt)
+        while @statement_limit <= cache.size
+          dealloc(cache.shift.last)
+        end
+        cache[sql] = stmt
       end
 
       def clear
-        raise NotImplementedError
+        cache.each_value do |stmt|
+          dealloc stmt
+        end
+        cache.clear
       end
 
       def delete(key)
-        raise NotImplementedError
+        dealloc cache[key]
+        cache.delete(key)
       end
+
+      private
+
+        def cache
+          @cache[Process.pid]
+        end
+
+        def dealloc(stmt)
+          raise NotImplementedError
+        end
     end
   end
 end

data/lib/active_record/connection_handling.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionHandling
-    RAILS_ENV   = -> { (Rails.env if defined?(Rails)) || ENV["RAILS_ENV"] || ENV["RACK_ENV"] }
+    RAILS_ENV   = -> { (Rails.env if defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
     DEFAULT_ENV = -> { RAILS_ENV.call || "default_env" }
 
     # Establishes the connection to the database. Accepts a hash as input where
     # the <tt>:adapter</tt> key must be specified with the name of a database adapter (in lower-case)
-    # example for regular databases (MySQL, Postgresql, etc):
+    # example for regular databases (MySQL, PostgreSQL, etc):
     #
     #   ActiveRecord::Base.establish_connection(
-    #     adapter:  "mysql",
+    #     adapter:  "mysql2",
     #     host:     "localhost",
     #     username: "myuser",
     #     password: "mypass",
@@ -35,26 +37,27 @@ module ActiveRecord
     #     "postgres://myuser:mypass@localhost/somedatabase"
     #   )
     #
-    # In case <tt>ActiveRecord::Base.configurations</tt> is set (Rails
-    # automatically loads the contents of config/database.yml into it),
+    # In case {ActiveRecord::Base.configurations}[rdoc-ref:Core.configurations]
+    # is set (Rails automatically loads the contents of config/database.yml into it),
     # a symbol can also be given as argument, representing a key in the
     # configuration hash:
     #
     #   ActiveRecord::Base.establish_connection(:production)
     #
-    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
+    # The exceptions AdapterNotSpecified, AdapterNotFound and +ArgumentError+
     # may be returned on an error.
-    def establish_connection(spec = nil)
-      spec     ||= DEFAULT_ENV.call.to_sym
-      resolver =   ConnectionAdapters::ConnectionSpecification::Resolver.new configurations
-      spec     =   resolver.spec(spec)
+    def establish_connection(config = nil)
+      raise "Anonymous class is not allowed." unless name
 
-      unless respond_to?(spec.adapter_method)
-        raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
-      end
+      config ||= DEFAULT_ENV.call.to_sym
+      spec_name = self == Base ? "primary" : name
+      self.connection_specification_name = spec_name
 
-      remove_connection
-      connection_handler.establish_connection self, spec
+      resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(Base.configurations)
+      spec = resolver.resolve(config).symbolize_keys
+      spec[:name] = spec_name
+
+      connection_handler.establish_connection(spec)
     end
 
     class MergeAndResolveDefaultUrlConfig # :nodoc:
@@ -72,7 +75,7 @@ module ActiveRecord
       private
         def config
           @raw_config.dup.tap do |cfg|
-            if url = ENV['DATABASE_URL']
+            if url = ENV["DATABASE_URL"]
               cfg[@env] ||= {}
               cfg[@env]["url"] ||= url
             end
@@ -87,12 +90,14 @@ module ActiveRecord
       retrieve_connection
     end
 
-    def connection_id
-      ActiveRecord::RuntimeRegistry.connection_id
-    end
+    attr_writer :connection_specification_name
 
-    def connection_id=(connection_id)
-      ActiveRecord::RuntimeRegistry.connection_id = connection_id
+    # Return the specification name from the current class or its parent.
+    def connection_specification_name
+      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
+        return self == Base ? "primary" : superclass.connection_specification_name
+      end
+      @connection_specification_name
     end
 
     # Returns the configuration of the associated connection as a hash:
@@ -106,20 +111,28 @@ module ActiveRecord
     end
 
     def connection_pool
-      connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
+      connection_handler.retrieve_connection_pool(connection_specification_name) || raise(ConnectionNotEstablished)
     end
 
     def retrieve_connection
-      connection_handler.retrieve_connection(self)
+      connection_handler.retrieve_connection(connection_specification_name)
     end
 
     # Returns +true+ if Active Record is connected.
     def connected?
-      connection_handler.connected?(self)
+      connection_handler.connected?(connection_specification_name)
     end
 
-    def remove_connection(klass = self)
-      connection_handler.remove_connection(klass)
+    def remove_connection(name = nil)
+      name ||= @connection_specification_name if defined?(@connection_specification_name)
+      # if removing a connection that has a pool, we reset the
+      # connection_specification_name so it will use the parent
+      # pool.
+      if connection_handler.retrieve_connection_pool(name)
+        self.connection_specification_name = nil
+      end
+
+      connection_handler.remove_connection(name)
     end
 
     def clear_cache! # :nodoc:
@@ -127,6 +140,6 @@ module ActiveRecord
     end
 
     delegate :clear_active_connections!, :clear_reloadable_connections!,
-      :clear_all_connections!, :to => :connection_handler
+      :clear_all_connections!, :flush_idle_connections!, to: :connection_handler
   end
 end