activerecord 3.1.0 → 3.1.1.rc1

data/CHANGELOG

@@ -1,4 +1,39 @@
-*Rails 3.1.0 (unreleased)*
+*Rails 3.1.1 (unreleased)*
+
+* LRU cache in mysql and sqlite are now per-process caches.
+
+	* lib/active_record/connection_adapters/mysql_adapter.rb: LRU cache
+	  keys are per process id.
+	* lib/active_record/connection_adapters/sqlite_adapter.rb: ditto
+
+	[Aaron Patterson]
+
+* Database adapters use a statement pool for limiting the number of open
+  prepared statments on the database.  The limit defaults to 1000, but can
+  be adjusted in your database config by changing 'statement_limit'.
+
+* Fix clash between using 'preload', 'joins' or 'eager_load' in a default scope and including the
+  default scoped model in a nested through association. (GH #2834.) [Jon Leighton]
+
+* Ensure we are not comparing a string with a symbol in HasManyAssociation#inverse_updates_counter_cache?.
+  Fixes GH #2755, where a counter cache could be decremented twice as far as it was supposed to be.
+
+  [Jon Leighton]
+
+* Don't send any queries to the database when the foreign key of a belongs_to is nil. Fixes
+  GH #2828. [Georg Friedrich]
+
+* Fixed find_in_batches method to not include order from default_scope. See GH #2832 [Arun Agrawal]
+
+* Don't compute table name for abstract classes. Fixes problem with setting the primary key
+  in an abstract class. See GH #2791. [Akira Matsuda]
+
+* Psych errors with poor yaml formatting are proxied. Fixes GH #2645 and
+  GH #2731
+
+* Use the LIMIT word with the methods #last and #first. Fixes GH #2783 [Damien Mathieu]
+
+*Rails 3.1.0 (August 30, 2011)*
 
 * Add a proxy_association method to association proxies, which can be called by association
   extensions to access information about the association. This replaces proxy_owner etc with

data/lib/active_record.rb

@@ -21,13 +21,6 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-
-activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
-
-activemodel_path = File.expand_path('../../../activemodel/lib', __FILE__)
-$:.unshift(activemodel_path) if File.directory?(activemodel_path) && !$:.include?(activemodel_path)
-
 require 'active_support'
 require 'active_support/i18n'
 require 'active_model'

data/lib/active_record/associations/alias_tracker.rb

@@ -53,12 +53,18 @@ module ActiveRecord
           # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
           quoted_name = connection.quote_table_name(name).downcase
 
-          table_joins.map { |join|
-            # Table names + table aliases
-            join.left.downcase.scan(
-              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-            ).size
-          }.sum
+          counts = table_joins.map do |join|
+            if join.is_a?(Arel::Nodes::StringJoin)
+              # Table names + table aliases
+              join.left.downcase.scan(
+                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+              ).size
+            else
+              join.left.table_name == name ? 1 : 0
+            end
+          end
+
+          counts.sum
         end
 
         def truncate(name)

data/lib/active_record/associations/belongs_to_association.rb

@@ -20,6 +20,10 @@ module ActiveRecord
 
       private
 
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
         def update_counters(record)
           counter_cache_name = reflection.counter_cache_column
 

data/lib/active_record/associations/collection_association.rb

@@ -78,10 +78,14 @@ module ActiveRecord
       end
 
       def find(*args)
-        if options[:finder_sql]
-          find_by_scan(*args)
+        if block_given?
+          load_target.find(*args) { |*block_args| yield(*block_args) }
         else
-          scoped.find(*args)
+          if options[:finder_sql]
+            find_by_scan(*args)
+          else
+            scoped.find(*args)
+          end
         end
       end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -78,7 +78,7 @@ module ActiveRecord
       def method_missing(method, *args, &block)
         match = DynamicFinderMatch.match(method)
         if match && match.instantiator?
-          record = send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
+          send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
             proxy_association.send :set_owner_attributes, r
             proxy_association.send :add_to_target, r
             yield(r) if block_given?

data/lib/active_record/associations/through_association.rb

@@ -16,7 +16,7 @@ module ActiveRecord
           chain[1..-1].each do |reflection|
             scope = scope.merge(
               reflection.klass.scoped.with_default_scope.
-                except(:select, :create_with, :includes)
+                except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
           end
           scope

data/lib/active_record/base.rb

@@ -622,6 +622,8 @@ module ActiveRecord #:nodoc:
 
       # Computes the table name, (re)sets it internally, and returns it.
       def reset_table_name #:nodoc:
+        return if abstract_class?
+
         self.table_name = compute_table_name
       end
 

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

@@ -421,7 +421,7 @@ module ActiveRecord
       # can be used as an argument for establish_connection, for easily
       # re-establishing the connection.
       def remove_connection(klass)
-        pool = @connection_pools[klass.name]
+        pool = @connection_pools.delete(klass.name)
         return nil unless pool
 
         pool.automatic_reconnect = false

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

@@ -100,7 +100,7 @@ module ActiveRecord
       end
 
       def connection_pool
-        connection_handler.retrieve_connection_pool(self)
+        connection_handler.retrieve_connection_pool(self) or raise ConnectionNotEstablished
       end
 
       def retrieve_connection

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -2,6 +2,7 @@ require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 require 'set'
+require 'active_record/connection_adapters/statement_pool'
 
 gem 'mysql', '~> 2.8.1'
 require 'mysql'
@@ -184,11 +185,45 @@ module ActiveRecord
         :boolean     => { :name => "tinyint", :limit => 1 }
       }
 
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max = 1000)
+          super
+          @cache = Hash.new { |h,pid| h[pid] = {} }
+        end
+
+        def each(&block); cache.each(&block); end
+        def key?(key);    cache.key?(key); end
+        def [](key);      cache[key]; end
+        def length;       cache.length; end
+        def delete(key);  cache.delete(key); end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            cache.shift.last[:stmt].close
+          end
+          cache[sql] = key
+        end
+
+        def clear
+          cache.values.each do |hash|
+            hash[:stmt].close
+          end
+          cache.clear
+        end
+
+        private
+        def cache
+          @cache[$$]
+        end
+      end
+
       def initialize(connection, logger, connection_options, config)
         super(connection, logger)
         @connection_options, @config = connection_options, config
         @quoted_column_names, @quoted_table_names = {}, {}
         @statements = {}
+        @statements = StatementPool.new(@connection,
+                                        config.fetch(:statement_limit) { 1000 })
         @client_encoding = nil
         connect
       end
@@ -334,9 +369,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.values.each do |cache|
-          cache[:stmt].close
-        end
         @statements.clear
       end
 
@@ -755,7 +787,7 @@ module ActiveRecord
         def quoted_columns_for_index(column_names, options = {})
           length = options[:length] if options.is_a?(Hash)
 
-          quoted_column_names = case length
+          case length
           when Hash
             column_names.map {|name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
           when Fixnum

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,6 +1,7 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
+require 'active_record/connection_adapters/statement_pool'
 
 # Make sure we're using pg high enough for PGResult#values
 gem 'pg', '~> 0.11'
@@ -247,6 +248,47 @@ module ActiveRecord
         true
       end
 
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max)
+          super
+          @counter = 0
+          @cache   = Hash.new { |h,pid| h[pid] = {} }
+        end
+
+        def each(&block); cache.each(&block); end
+        def key?(key);    cache.key?(key); end
+        def [](key);      cache[key]; end
+        def length;       cache.length; end
+
+        def next_key
+          "a#{@counter + 1}"
+        end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            dealloc(cache.shift.last)
+          end
+          @counter += 1
+          cache[sql] = key
+        end
+
+        def clear
+          cache.each_value do |stmt_key|
+            dealloc stmt_key
+          end
+          cache.clear
+        end
+
+        private
+        def cache
+          @cache[$$]
+        end
+
+        def dealloc(key)
+          @connection.query "DEALLOCATE #{key}"
+        end
+      end
+
       # Initializes and connects a PostgreSQL adapter.
       def initialize(connection, logger, connection_parameters, config)
         super(connection, logger)
@@ -255,9 +297,10 @@ module ActiveRecord
         # @local_tz is initialized as nil to avoid warnings when connect tries to use it
         @local_tz = nil
         @table_alias_length = nil
-        @statements = {}
 
         connect
+        @statements = StatementPool.new @connection,
+                                        config.fetch(:statement_limit) { 1000 }
 
         if postgresql_version < 80200
           raise "Your version of PostgreSQL (#{postgresql_version}) is too old, please upgrade!"
@@ -272,9 +315,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.each_value do |value|
-          @connection.query "DEALLOCATE #{value}"
-        end
         @statements.clear
       end
 
@@ -672,6 +712,7 @@ module ActiveRecord
 
       def table_exists?(name)
         schema, table = extract_schema_and_table(name.to_s)
+        return false unless table # Abstract classes is having nil table name
 
         binds = [[nil, table.gsub(/(^"|"$)/,'')]]
         binds << [nil, schema] if schema
@@ -680,7 +721,7 @@ module ActiveRecord
             SELECT COUNT(*)
             FROM pg_tables
             WHERE tablename = $1
-            #{schema ? "AND schemaname = $2" : ''}
+           AND schemaname = #{schema ? "$2" : "ANY (current_schemas(false))"}
         SQL
       end
 
@@ -964,7 +1005,7 @@ module ActiveRecord
 
       def exec_cache(sql, binds)
         unless @statements.key? sql
-          nextkey = "a#{@statements.length + 1}"
+          nextkey = @statements.next_key
           @connection.prepare nextkey, sql
           @statements[sql] = nextkey
         end

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,5 +1,7 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
+require 'active_record/connection_adapters/statement_pool'
+require 'active_support/core_ext/string/encoding'
 
 module ActiveRecord
   module ConnectionAdapters #:nodoc:
@@ -48,9 +50,45 @@ module ActiveRecord
         end
       end
 
+      class StatementPool < ConnectionAdapters::StatementPool
+        def initialize(connection, max)
+          super
+          @cache = Hash.new { |h,pid| h[pid] = {} }
+        end
+
+        def each(&block); cache.each(&block); end
+        def key?(key);    cache.key?(key); end
+        def [](key);      cache[key]; end
+        def length;       cache.length; end
+
+        def []=(sql, key)
+          while @max <= cache.size
+            dealloc(cache.shift.last[:stmt])
+          end
+          cache[sql] = key
+        end
+
+        def clear
+          cache.values.each do |hash|
+            dealloc hash[:stmt]
+          end
+          cache.clear
+        end
+
+        private
+        def cache
+          @cache[$$]
+        end
+
+        def dealloc(stmt)
+          stmt.close unless stmt.closed?
+        end
+      end
+
       def initialize(connection, logger, config)
         super(connection, logger)
-        @statements = {}
+        @statements = StatementPool.new(@connection,
+                                        config.fetch(:statement_limit) { 1000 })
         @config = config
       end
 
@@ -107,7 +145,6 @@ module ActiveRecord
 
       # Clears the prepared statements cache.
       def clear_cache!
-        @statements.values.each { |hash| hash[:stmt].close }
         @statements.clear
       end
 
@@ -159,10 +196,25 @@ module ActiveRecord
         end
       end
 
-      def type_cast(value, column) # :nodoc:
-        return super unless BigDecimal === value
+      if "<3".encoding_aware?
+        def type_cast(value, column) # :nodoc:
+          return value.to_f if BigDecimal === value
+          return super unless String === value
+          return super unless column && value
 
-        value.to_f
+          value = super
+          if column.type == :string && value.encoding == Encoding::ASCII_8BIT
+            @logger.error "Binary data inserted for `string` type on column `#{column.name}`"
+            value.encode! 'utf-8'
+          end
+          value
+        end
+      else
+        def type_cast(value, column) # :nodoc:
+          return super unless BigDecimal === value
+
+          value.to_f
+        end
       end
 
       # DATABASE STATEMENTS ======================================

data/lib/active_record/connection_adapters/statement_pool.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class StatementPool
+      include Enumerable
+
+      def initialize(connection, max = 1000)
+        @connection = connection
+        @max        = max
+      end
+
+      def each
+        raise NotImplementedError
+      end
+
+      def key?(key)
+        raise NotImplementedError
+      end
+
+      def [](key)
+        raise NotImplementedError
+      end
+
+      def length
+        raise NotImplementedError
+      end
+
+      def []=(sql, key)
+        raise NotImplementedError
+      end
+
+      def clear
+        raise NotImplementedError
+      end
+
+      def delete(key)
+        raise NotImplementedError
+      end
+    end
+  end
+end