activerecord 3.0.0.beta4 → 3.0.0.rc

data/lib/active_record/callbacks.rb

@@ -1,6 +1,8 @@
 require 'active_support/core_ext/array/wrap'
 
 module ActiveRecord
+  # = Active Record Callbacks
+  # 
   # Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic
   # before or after an alteration of the object state. This can be used to make sure that associated and
   # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
@@ -234,8 +236,7 @@ module ActiveRecord
 
     included do
       extend ActiveModel::Callbacks
-
-      define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+      include ActiveModel::Validations::Callbacks
 
       define_model_callbacks :initialize, :find, :only => :after
       define_model_callbacks :save, :create, :update, :destroy
@@ -249,29 +250,6 @@ module ActiveRecord
           send(meth.to_sym, meth.to_sym)
         end
       end
-
-      def before_validation(*args, &block)
-        options = args.last
-        if options.is_a?(Hash) && options[:on]
-          options[:if] = Array.wrap(options[:if])
-          options[:if] << "@_on_validate == :#{options[:on]}"
-        end
-        set_callback(:validation, :before, *args, &block)
-      end
-
-      def after_validation(*args, &block)
-        options = args.extract_options!
-        options[:prepend] = true
-        options[:if] = Array.wrap(options[:if])
-        options[:if] << "!halted && value != false"
-        options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
-        set_callback(:validation, :after, *(args << options), &block)
-      end
-    end
-
-    def valid?(*) #:nodoc:
-      @_on_validate = new_record? ? :create : :update
-      _run_validation_callbacks { super }
     end
 
     def destroy #:nodoc:
@@ -286,6 +264,7 @@ module ActiveRecord
     end
 
   private
+
     def create_or_update #:nodoc:
       _run_save_callbacks { super }
     end

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

@@ -9,7 +9,7 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
-    # Connection pool base class for managing ActiveRecord database
+    # Connection pool base class for managing Active Record database
     # connections.
     #
     # == Introduction
@@ -30,12 +30,12 @@ module ActiveRecord
     # Connections can be obtained and used from a connection pool in several
     # ways:
     #
-    # 1. Simply use ActiveRecord::Base.connection as with ActiveRecord 2.1 and
+    # 1. Simply use ActiveRecord::Base.connection as with Active Record 2.1 and
     #    earlier (pre-connection-pooling). Eventually, when you're done with
     #    the connection(s) and wish it to be returned to the pool, you call
     #    ActiveRecord::Base.clear_active_connections!. This will be the
-    #    default behavior for ActiveRecord when used in conjunction with
-    #    ActionPack's request handling cycle.
+    #    default behavior for Active Record when used in conjunction with
+    #    Action Pack's request handling cycle.
     # 2. Manually check out a connection from the pool with
     #    ActiveRecord::Base.connection_pool.checkout. You are responsible for
     #    returning this connection to the pool when finished by calling
@@ -144,7 +144,9 @@ module ActiveRecord
         @connections.each do |conn|
           conn.disconnect! if conn.requires_reloading?
         end
-        @connections = []
+        @connections.delete_if do |conn|
+          conn.requires_reloading?
+        end
       end
 
       # Verify active connections and remove and disconnect connections
@@ -159,8 +161,13 @@ module ActiveRecord
       # Return any checked-out connections back to the pool by threads that
       # are no longer alive.
       def clear_stale_cached_connections!
-        remove_stale_cached_threads!(@reserved_connections) do |name, conn|
-          checkin conn
+        keys = @reserved_connections.keys - Thread.list.find_all { |t|
+          t.alive?
+        }.map { |thread| thread.object_id }
+
+        keys.each do |key|
+          checkin @reserved_connections[key]
+          @reserved_connections.delete(key)
         end
       end
 
@@ -230,20 +237,6 @@ module ActiveRecord
         Thread.current.object_id
       end
 
-      # Remove stale threads from the cache.
-      def remove_stale_cached_threads!(cache, &block)
-        keys = Set.new(cache.keys)
-
-        Thread.list.each do |thread|
-          keys.delete(thread.object_id) if thread.alive?
-        end
-        keys.each do |key|
-          next unless cache.has_key?(key)
-          block.call(key, cache[key])
-          cache.delete(key)
-        end
-      end
-
       def checkout_new_connection
         c = new_connection
         @connections << c
@@ -265,7 +258,7 @@ module ActiveRecord
     end
 
     # ConnectionHandler is a collection of ConnectionPool objects. It is used
-    # for keeping separate connection pools for ActiveRecord models that connect
+    # for keeping separate connection pools for Active Record models that connect
     # to different databases.
     #
     # For example, suppose that you have 5 models, with the following hierarchy:
@@ -285,17 +278,15 @@ module ActiveRecord
     # is not the same as the one used by Book/ScaryBook/GoodBook.
     #
     # Normally there is only a single ConnectionHandler instance, accessible via
-    # ActiveRecord::Base.connection_handler. ActiveRecord models use this to
+    # ActiveRecord::Base.connection_handler. Active Record models use this to
     # determine that connection pool that they should use.
     class ConnectionHandler
+      attr_reader :connection_pools
+
       def initialize(pools = {})
         @connection_pools = pools
       end
 
-      def connection_pools
-        @connection_pools ||= {}
-      end
-
       def establish_connection(name, spec)
         @connection_pools[name] = ConnectionAdapters::ConnectionPool.new(spec)
       end
@@ -343,9 +334,11 @@ module ActiveRecord
       # re-establishing the connection.
       def remove_connection(klass)
         pool = @connection_pools[klass.name]
+        return nil unless pool
+
         @connection_pools.delete_if { |key, value| value == pool }
-        pool.disconnect! if pool
-        pool.spec.config if pool
+        pool.disconnect!
+        pool.spec.config
       end
 
       def retrieve_connection_pool(klass)

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

@@ -66,15 +66,9 @@ module ActiveRecord
           unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
 
           begin
-            require 'rubygems'
-            gem "activerecord-#{spec[:adapter]}-adapter"
             require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
           rescue LoadError
-            begin
-              require "active_record/connection_adapters/#{spec[:adapter]}_adapter"
-            rescue LoadError
-              raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{$!})"
-            end
+            raise "Please install the #{spec[:adapter]} adapter: `gem install activerecord-#{spec[:adapter]}-adapter` (#{$!})"
           end
 
           adapter_method = "#{spec[:adapter]}_connection"
@@ -103,7 +97,7 @@ module ActiveRecord
         connection_handler.retrieve_connection(self)
       end
 
-      # Returns true if +ActiveRecord+ is connected.
+      # Returns true if Active Record is connected.
       def connected?
         connection_handler.connected?(self)
       end

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

@@ -304,7 +304,7 @@ module ActiveRecord
               begin
                 record.rolledback!(rollback)
               rescue Exception => e
-                record.logger.error(e) if record.respond_to?(:logger)
+                record.logger.error(e) if record.respond_to?(:logger) && record.logger
               end
             end
           end
@@ -319,7 +319,7 @@ module ActiveRecord
               begin
                 record.committed!
               rescue Exception => e
-                record.logger.error(e) if record.respond_to?(:logger)
+                record.logger.error(e) if record.respond_to?(:logger) && record.logger
               end
             end
           end

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

@@ -582,6 +582,11 @@ module ActiveRecord
         @base.add_column(@table_name, column_name, type, options)
       end
 
+      # Checks to see if a column exists. See SchemaStatements#column_exists?
+      def column_exists?(column_name, type = nil, options = nil)
+        @base.column_exists?(@table_name, column_name, type, options)
+      end
+
       # Adds a new index to the table. +column_name+ can be a single Symbol, or
       # an Array of Symbols. See SchemaStatements#add_index
       #
@@ -596,6 +601,11 @@ module ActiveRecord
         @base.add_index(@table_name, column_name, options)
       end
 
+      # Checks to see if an index exists. See SchemaStatements#index_exists?
+      def index_exists?(column_name, options = {})
+        @base.index_exists?(@table_name, column_name, options)
+      end
+
       # Adds timestamps (created_at and updated_at) columns to the table. See SchemaStatements#add_timestamps
       # ===== Example
       #  t.timestamps

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

@@ -24,10 +24,53 @@ module ActiveRecord
       # Returns an array of indexes for the given table.
       # def indexes(table_name, name = nil) end
 
+      # Checks to see if an index exists on a table for a given index definition
+      #
+      # === Examples
+      #  # Check an index exists
+      #  index_exists?(:suppliers, :company_id)
+      #
+      #  # Check an index on multiple columns exists
+      #  index_exists?(:suppliers, [:company_id, :company_type])
+      #
+      #  # Check a unique index exists
+      #  index_exists?(:suppliers, :company_id, :unique => true)
+      #
+      #  # Check an index with a custom name exists
+      #  index_exists?(:suppliers, :company_id, :name => "idx_company_id"
+      def index_exists?(table_name, column_name, options = {})
+        column_names = Array.wrap(column_name)
+        index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
+        if options[:unique]
+          indexes(table_name).any?{ |i| i.unique && i.name == index_name }
+        else
+          indexes(table_name).any?{ |i| i.name == index_name }
+        end
+      end
+
       # Returns an array of Column objects for the table specified by +table_name+.
       # See the concrete implementation for details on the expected parameter values.
       def columns(table_name, name = nil) end
 
+      # Checks to see if a column exists in a given table.
+      #
+      # === Examples
+      #  # Check a column exists
+      #  column_exists?(:suppliers, :name)
+      #
+      #  # Check a column exists of a particular type
+      #  column_exists?(:suppliers, :name, :string)
+      #
+      #  # Check a column exists with a specific definition
+      #  column_exists?(:suppliers, :name, :string, :limit => 100)
+      def column_exists?(table_name, column_name, type = nil, options = {})
+        columns(table_name).any?{ |c| c.name == column_name.to_s &&
+                                      (!type                 || c.type == type) &&
+                                      (!options[:limit]      || c.limit == options[:limit]) &&
+                                      (!options[:precision]  || c.precision == options[:precision]) &&
+                                      (!options[:scale]      || c.scale == options[:scale]) }
+      end
+
       # Creates a new table with the name +table_name+. +table_name+ may either
       # be a String or a Symbol.
       #
@@ -60,10 +103,15 @@ module ActiveRecord
       # The +options+ hash can include the following keys:
       # [<tt>:id</tt>]
       #   Whether to automatically add a primary key column. Defaults to true.
-      #   Join tables for +has_and_belongs_to_many+ should set <tt>:id => false</tt>.
+      #   Join tables for +has_and_belongs_to_many+ should set it to false.
       # [<tt>:primary_key</tt>]
       #   The name of the primary key, if one is to be added automatically.
-      #   Defaults to +id+.
+      #   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 the +set_primary_key+ macro.
+      #   Models do NOT auto-detect the primary key from their table definition. 
+      #   
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
       # [<tt>:temporary</tt>]
@@ -205,6 +253,7 @@ module ActiveRecord
       #  remove_column(:suppliers, :qualification)
       #  remove_columns(:suppliers, :qualification, :experience)
       def remove_column(table_name, *column_names)
+        raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
         column_names.flatten.each do |column_name|
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
         end
@@ -292,7 +341,7 @@ module ActiveRecord
           @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.")
           return
         end
-        if index_exists?(table_name, index_name, false)
+        if index_name_exists?(table_name, index_name, false)
           @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
           return
         end
@@ -313,7 +362,7 @@ module ActiveRecord
       #   remove_index :accounts, :name => :by_branch_party
       def remove_index(table_name, options = {})
         index_name = index_name(table_name, options)
-        unless index_exists?(table_name, index_name, true)
+        unless index_name_exists?(table_name, index_name, true)
           @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
           return
         end
@@ -321,7 +370,7 @@ module ActiveRecord
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name)} ON #{table_name}"
+        execute "DROP INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
       end
 
       # Rename an index.
@@ -350,11 +399,11 @@ module ActiveRecord
         end
       end
 
-      # Verify the existence of an index.
+      # Verify the existence of an index with a given name.
       #
       # The default argument is returned if the underlying implementation does not define the indexes method,
       # as there's no way to determine the correct answer in that case.
-      def index_exists?(table_name, index_name, default)
+      def index_name_exists?(table_name, index_name, default)
         return default unless respond_to?(:indexes)
         indexes(table_name).detect { |i| i.name == index_name }
       end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -15,7 +15,7 @@ require 'active_record/connection_adapters/abstract/database_limits'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    # ActiveRecord supports multiple database systems. AbstractAdapter and
+    # Active Record supports multiple database systems. AbstractAdapter and
     # related classes form the abstraction layer which makes this possible.
     # An AbstractAdapter represents a connection to a database, and provides an
     # abstract interface for database-specific functionality such as establishing
@@ -36,14 +36,12 @@ module ActiveRecord
 
       define_callbacks :checkout, :checkin
 
-      @@row_even = true
-
       def initialize(connection, logger = nil) #:nodoc:
         @active = nil
         @connection, @logger = connection, logger
-        @runtime = 0
         @query_cache_enabled = false
         @query_cache = {}
+        @instrumenter = ActiveSupport::Notifications.instrumenter
       end
 
       # Returns the human-readable name of the adapter.  Use mixed case - one
@@ -59,7 +57,7 @@ module ActiveRecord
       end
 
       # Can this adapter determine the primary key for tables not attached
-      # to an ActiveRecord class, such as join tables?  Backend specific, as
+      # to an Active Record class, such as join tables?  Backend specific, as
       # the abstract adapter always returns +false+.
       def supports_primary_key?
         false
@@ -92,11 +90,6 @@ module ActiveRecord
         false
       end
 
-      def reset_runtime #:nodoc:
-        rt, @runtime = @runtime, 0
-        rt
-      end
-
       # QUOTING ==================================================
 
       # Override to return the quoted table name. Defaults to column quoting.
@@ -107,7 +100,7 @@ module ActiveRecord
       # REFERENTIAL INTEGRITY ====================================
 
       # Override to turn off referential integrity while executing <tt>&block</tt>.
-      def disable_referential_integrity(&block)
+      def disable_referential_integrity
         yield
       end
 
@@ -142,9 +135,10 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
-      # Returns true if its safe to reload the connection between requests for development mode.
+      # Returns true if its required to reload the connection between requests for development mode.
+      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
       def requires_reloading?
-        true
+        false
       end
 
       # Checks whether the connection to the database is still active (i.e. not stale).
@@ -198,12 +192,10 @@ module ActiveRecord
 
         def log(sql, name)
           name ||= "SQL"
-          result = nil
-          ActiveSupport::Notifications.instrument("sql.active_record",
-            :sql => sql, :name => name, :connection_id => self.object_id) do
-            @runtime += Benchmark.ms { result = yield }
+          @instrumenter.instrument("sql.active_record",
+            :sql => sql, :name => name, :connection_id => object_id) do
+            yield
           end
-          result
         rescue Exception => e
           message = "#{e.class.name}: #{e.message}: #{sql}"
           @logger.debug message if @logger

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -125,7 +125,7 @@ module ActiveRecord
       # By default, the MysqlAdapter will consider all columns of type <tt>tinyint(1)</tt>
       # as boolean. If you wish to disable this emulation (which was the default
       # behavior in versions 0.13.1 and earlier) you can add the following line
-      # to your environment.rb file:
+      # to your application.rb file:
       #
       #   ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans = false
       cattr_accessor :emulate_booleans
@@ -219,7 +219,7 @@ module ActiveRecord
 
       # REFERENTIAL INTEGRITY ====================================
 
-      def disable_referential_integrity(&block) #:nodoc:
+      def disable_referential_integrity #:nodoc:
         old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
 
         begin