activerecord 3.0.0.beta3 → 3.0.0.beta4

data/lib/active_record/callbacks.rb

@@ -17,8 +17,13 @@ module ActiveRecord
   # * (-) <tt>create</tt>
   # * (5) <tt>after_create</tt>
   # * (6) <tt>after_save</tt>
+  # * (7) <tt>after_commit</tt>
   #
-  # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the
+  # Also, an <tt>after_rollback</tt> callback can be configured to be triggered whenever a rollback is issued.
+  # Check out <tt>ActiveRecord::Transactions</tt> for more details about <tt>after_commit</tt> and
+  # <tt>after_rollback</tt>.
+  #
+  # That's a total of ten callbacks, which gives you immense power to react and prepare for each state in the
   # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, except that each
   # <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
   #
@@ -26,7 +31,7 @@ module ActiveRecord
   #   class CreditCard < ActiveRecord::Base
   #     # Strip everything but digits, so the user can specify "555 234 34" or
   #     # "5552-3434" or both will mean "55523434"
-  #     def before_validation_on_create
+  #     before_validation(:on => :create) do
   #       self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
   #     end
   #   end
@@ -228,10 +233,6 @@ module ActiveRecord
     ]
 
     included do
-      [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
-        alias_method_chain method, :callbacks
-      end
-
       extend ActiveModel::Callbacks
 
       define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
@@ -268,45 +269,33 @@ module ActiveRecord
       end
     end
 
-    def create_or_update_with_callbacks #:nodoc:
-      _run_save_callbacks do
-        create_or_update_without_callbacks
-      end
+    def valid?(*) #:nodoc:
+      @_on_validate = new_record? ? :create : :update
+      _run_validation_callbacks { super }
     end
-    private :create_or_update_with_callbacks
 
-    def create_with_callbacks #:nodoc:
-      _run_create_callbacks do
-        create_without_callbacks
-      end
+    def destroy #:nodoc:
+      _run_destroy_callbacks { super }
     end
-    private :create_with_callbacks
 
-    def update_with_callbacks(*args) #:nodoc:
-      _run_update_callbacks do
-        update_without_callbacks(*args)
+    def deprecated_callback_method(symbol) #:nodoc:
+      if respond_to?(symbol, true)
+        ActiveSupport::Deprecation.warn("Overwriting #{symbol} in your models has been deprecated, please use Base##{symbol} :method_name instead")
+        send(symbol)
       end
     end
-    private :update_with_callbacks
 
-    def valid_with_callbacks? #:nodoc:
-      @_on_validate = new_record? ? :create : :update
-      _run_validation_callbacks do
-        valid_without_callbacks?
-      end
+  private
+    def create_or_update #:nodoc:
+      _run_save_callbacks { super }
     end
 
-    def destroy_with_callbacks #:nodoc:
-      _run_destroy_callbacks do
-        destroy_without_callbacks
-      end
+    def create #:nodoc:
+      _run_create_callbacks { super }
     end
 
-    def deprecated_callback_method(symbol) #:nodoc:
-      if respond_to?(symbol, true)
-        ActiveSupport::Deprecation.warn("Overwriting #{symbol} in your models has been deprecated, please use Base##{symbol} :method_name instead")
-        send(symbol)
-      end
+    def update(*) #:nodoc:
+      _run_update_callbacks { super }
     end
   end
 end

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

@@ -211,7 +211,7 @@ module ActiveRecord
       # calling +checkout+ on this pool.
       def checkin(conn)
         @connection_mutex.synchronize do
-          conn.run_callbacks :checkin do
+          conn.send(:_run_checkin_callbacks) do
             @checked_out.delete conn
             @queue.signal
           end

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

@@ -10,8 +10,8 @@ module ActiveRecord
     ##
     # :singleton-method:
     # The connection handler
-    cattr_accessor :connection_handler, :instance_writer => false
-    @@connection_handler = ConnectionAdapters::ConnectionHandler.new
+    class_attribute :connection_handler, :instance_writer => false
+    self.connection_handler = ConnectionAdapters::ConnectionHandler.new
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work that isn't
@@ -54,7 +54,7 @@ module ActiveRecord
           raise AdapterNotSpecified unless defined?(Rails.env)
           establish_connection(Rails.env)
         when ConnectionSpecification
-          @@connection_handler.establish_connection(name, spec)
+          self.connection_handler.establish_connection(name, spec)
         when Symbol, String
           if configuration = configurations[spec.to_s]
             establish_connection(configuration)

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

@@ -0,0 +1,57 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module DatabaseLimits
+
+      # the maximum length of a table alias
+      def table_alias_length
+        255
+      end
+
+      # the maximum length of a column name
+      def column_name_length
+        64
+      end
+
+      # the maximum length of a table name
+      def table_name_length
+        64
+      end
+
+      # the maximum length of an index name
+      def index_name_length
+        64
+      end
+
+      # the maximum number of columns per table
+      def columns_per_table
+        1024
+      end
+
+      # the maximum number of indexes per table
+      def indexes_per_table
+        16
+      end
+
+      # the maximum number of columns in a multicolumn index
+      def columns_per_multicolumn_index
+        16
+      end
+
+      # the maximum number of elements in an IN (x,y,z) clause
+      def in_clause_length
+        65535
+      end
+
+      # the maximum length of a SQL query
+      def sql_query_length
+        1048575
+      end
+
+      # maximum number of joins in a single query
+      def joins_per_query
+        256
+      end
+
+    end
+  end
+end

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

@@ -122,6 +122,8 @@ module ActiveRecord
         requires_new = options[:requires_new] || !last_transaction_joinable
 
         transaction_open = false
+        @_current_transaction_records ||= []
+
         begin
           if block_given?
             if requires_new || open_transactions == 0
@@ -132,6 +134,7 @@ module ActiveRecord
               end
               increment_open_transactions
               transaction_open = true
+              @_current_transaction_records.push([])
             end
             yield
           end
@@ -141,8 +144,10 @@ module ActiveRecord
             decrement_open_transactions
             if open_transactions == 0
               rollback_db_transaction
+              rollback_transaction_records(true)
             else
               rollback_to_savepoint
+              rollback_transaction_records(false)
             end
           end
           raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
@@ -157,20 +162,35 @@ module ActiveRecord
           begin
             if open_transactions == 0
               commit_db_transaction
+              commit_transaction_records
             else
               release_savepoint
+              save_point_records = @_current_transaction_records.pop
+              unless save_point_records.blank?
+                @_current_transaction_records.push([]) if @_current_transaction_records.empty?
+                @_current_transaction_records.last.concat(save_point_records)
+              end
             end
           rescue Exception => database_transaction_rollback
             if open_transactions == 0
               rollback_db_transaction
+              rollback_transaction_records(true)
             else
               rollback_to_savepoint
+              rollback_transaction_records(false)
             end
             raise
           end
         end
       end
 
+      # Register a record with the current transaction so that its after_commit and after_rollback callbacks
+      # can be called.
+      def add_transaction_record(record)
+        last_batch = @_current_transaction_records.last
+        last_batch << record if last_batch
+      end
+
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
@@ -268,6 +288,42 @@ module ActiveRecord
             limit.to_i
           end
         end
+
+        # Send a rollback message to all records after they have been rolled back. If rollback
+        # is false, only rollback records since the last save point.
+        def rollback_transaction_records(rollback) #:nodoc
+          if rollback
+            records = @_current_transaction_records.flatten
+            @_current_transaction_records.clear
+          else
+            records = @_current_transaction_records.pop
+          end
+
+          unless records.blank?
+            records.uniq.each do |record|
+              begin
+                record.rolledback!(rollback)
+              rescue Exception => e
+                record.logger.error(e) if record.respond_to?(:logger)
+              end
+            end
+          end
+        end
+
+        # Send a commit message to all records after they have been committed.
+        def commit_transaction_records #:nodoc
+          records = @_current_transaction_records.flatten
+          @_current_transaction_records.clear
+          unless records.blank?
+            records.uniq.each do |record|
+              begin
+                record.committed!
+              rescue Exception => e
+                record.logger.error(e) if record.respond_to?(:logger)
+              end
+            end
+          end
+        end
     end
   end
 end

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

@@ -5,23 +5,16 @@ module ActiveRecord
     module QueryCache
       class << self
         def included(base)
-          base.class_eval do
-            alias_method_chain :columns, :query_cache
-            alias_method_chain :select_all, :query_cache
-          end
-
           dirties_query_cache base, :insert, :update, :delete
         end
 
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
-              def #{method_name}_with_query_dirty(*args)        # def update_with_query_dirty(*args)
-                clear_query_cache if @query_cache_enabled       #   clear_query_cache if @query_cache_enabled
-                #{method_name}_without_query_dirty(*args)       #   update_without_query_dirty(*args)
-              end                                               # end
-                                                                #
-              alias_method_chain :#{method_name}, :query_dirty  # alias_method_chain :update, :query_dirty
+              def #{method_name}(*)                         # def update_with_query_dirty(*args)
+                clear_query_cache if @query_cache_enabled   #   clear_query_cache if @query_cache_enabled
+                super                                       #   update_without_query_dirty(*args)
+              end                                           # end
             end_code
           end
         end
@@ -56,19 +49,19 @@ module ActiveRecord
         @query_cache.clear
       end
 
-      def select_all_with_query_cache(*args)
+      def select_all(*args)
         if @query_cache_enabled
-          cache_sql(args.first) { select_all_without_query_cache(*args) }
+          cache_sql(args.first) { super }
         else
-          select_all_without_query_cache(*args)
+          super
         end
       end
 
-      def columns_with_query_cache(*args)
+      def columns(*)
         if @query_cache_enabled
-          @query_cache["SHOW FIELDS FROM #{args.first}"] ||= columns_without_query_cache(*args)
+          @query_cache["SHOW FIELDS FROM #{args.first}"] ||= super
         else
-          columns_without_query_cache(*args)
+          super
         end
       end
 
@@ -76,7 +69,7 @@ module ActiveRecord
         def cache_sql(sql)
           result =
             if @query_cache.has_key?(sql)
-              ActiveSupport::Notifications.instrument("active_record.sql", 
+              ActiveSupport::Notifications.instrument("sql.active_record",
                 :sql => sql, :name => "CACHE", :connection_id => self.object_id)
               @query_cache[sql]
             else

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

@@ -13,12 +13,12 @@ module ActiveRecord
           when String, ActiveSupport::Multibyte::Chars
             value = value.to_s
             if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-              "#{quoted_string_prefix}'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
             elsif column && [:integer, :float].include?(column.type)
               value = column.type == :integer ? value.to_i : value.to_f
               value.to_s
             else
-              "#{quoted_string_prefix}'#{quote_string(value)}'" # ' (for ruby-mode)
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
             end
           when NilClass                 then "NULL"
           when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
@@ -30,7 +30,7 @@ module ActiveRecord
             if value.acts_like?(:date) || value.acts_like?(:time)
               "'#{quoted_date(value)}'"
             else
-              "#{quoted_string_prefix}'#{quote_string(value.to_yaml)}'"
+              "'#{quote_string(value.to_yaml)}'"
             end
         end
       end
@@ -67,10 +67,6 @@ module ActiveRecord
           value
         end.to_s(:db)
       end
-
-      def quoted_string_prefix
-        ''
-      end
     end
   end
 end

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

@@ -258,7 +258,7 @@ module ActiveRecord
         end
     end
 
-    class IndexDefinition < Struct.new(:table, :name, :unique, :columns) #:nodoc:
+    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
     end
 
     # Abstract representation of a column definition. Instances of this type
@@ -494,7 +494,7 @@ module ActiveRecord
       end
 
       %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
-        class_eval <<-EOV
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{column_type}(*args)                                               # def string(*args)
             options = args.extract_options!                                       #   options = args.extract_options!
             column_names = args                                                   #   column_names = args
@@ -694,7 +694,7 @@ module ActiveRecord
       #  t.string(:goat)
       #  t.string(:goat, :sheep)
       %w( string text integer float decimal datetime timestamp time date binary boolean ).each do |column_type|
-        class_eval <<-EOV
+        class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{column_type}(*args)                                          # def string(*args)
             options = args.extract_options!                                  #   options = args.extract_options!
             column_names = args                                              #   column_names = args

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

@@ -10,11 +10,6 @@ module ActiveRecord
         {}
       end
 
-      # This is the maximum length a table alias can be
-      def table_alias_length
-        255
-      end
-
       # Truncates a table alias according to the limits of the current adapter.
       def table_alias_for(table_name)
         table_name[0..table_alias_length-1].gsub(/\./, '_')
@@ -256,18 +251,32 @@ module ActiveRecord
       # name.
       #
       # ===== Examples
+      #
       # ====== Creating a simple index
       #  add_index(:suppliers, :name)
       # generates
       #  CREATE INDEX suppliers_name_index ON suppliers(name)
+      #
       # ====== Creating a unique index
       #  add_index(:accounts, [:branch_id, :party_id], :unique => true)
       # generates
       #  CREATE UNIQUE INDEX accounts_branch_id_party_id_index ON accounts(branch_id, party_id)
+      #
       # ====== Creating a named index
       #  add_index(:accounts, [:branch_id, :party_id], :unique => true, :name => 'by_branch_party')
       # generates
       #  CREATE UNIQUE INDEX by_branch_party ON accounts(branch_id, party_id)
+      #
+      # ====== Creating an index with specific key length
+      #  add_index(:accounts, :name, :name => 'by_name', :length => 10)
+      # generates
+      #  CREATE INDEX by_name ON accounts(name(10))
+      #
+      #  add_index(:accounts, [:name, :surname], :name => 'by_name_surname', :length => {:name => 10, :surname => 15})
+      # generates
+      #  CREATE INDEX by_name_surname ON accounts(name(10), surname(15))
+      #
+      # Note: SQLite doesn't support index length
       def add_index(table_name, column_name, options = {})
         column_names = Array.wrap(column_name)
         index_name   = index_name(table_name, :column => column_names)
@@ -278,7 +287,17 @@ module ActiveRecord
         else
           index_type = options
         end
-        quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+
+        if index_name.length > index_name_length
+          @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)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
+          return
+        end
+        quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")
+
         execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
       end
 
@@ -293,7 +312,28 @@ module ActiveRecord
       # Remove the index named by_branch_party in the accounts table.
       #   remove_index :accounts, :name => :by_branch_party
       def remove_index(table_name, options = {})
-        execute "DROP INDEX #{quote_column_name(index_name(table_name, options))} ON #{quote_table_name(table_name)}"
+        index_name = index_name(table_name, options)
+        unless index_exists?(table_name, index_name, true)
+          @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
+          return
+        end
+        remove_index!(table_name, index_name)
+      end
+
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name)} ON #{table_name}"
+      end
+
+      # Rename an index.
+      #
+      # Rename the index_people_on_last_name index to index_users_on_last_name
+      #   rename_index :people, 'index_people_on_last_name', 'index_users_on_last_name'
+      def rename_index(table_name, old_name, new_name)
+        # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
+        old_index_def = indexes(table_name).detect { |i| i.name == old_name }
+        return unless old_index_def
+        remove_index(table_name, :name => old_name)
+        add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
       end
 
       def index_name(table_name, options) #:nodoc:
@@ -310,6 +350,15 @@ module ActiveRecord
         end
       end
 
+      # Verify the existence of an index.
+      #
+      # 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)
+        return default unless respond_to?(:indexes)
+        indexes(table_name).detect { |i| i.name == index_name }
+      end
+
       # Returns a string of <tt>CREATE TABLE</tt> SQL statement(s) for recreating the
       # entire structure of the database.
       def structure_dump
@@ -430,6 +479,11 @@ module ActiveRecord
       end
 
       protected
+        # Overridden by the mysql adapter for supporting index lengths
+        def quoted_columns_for_index(column_names, options = {})
+          column_names.map {|name| quote_column_name(name) }
+        end
+
         def options_include_default?(options)
           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
         end