activerecord 1.10.1 → 1.11.0

data/lib/active_record/callbacks.rb

@@ -153,7 +153,7 @@ module ActiveRecord
   #
   # == The after_find and after_initialize exceptions
   #
-  # Because after_find and after_initialize is called for each object instantiated found by a finder, such as Base.find_all, we've had
+  # Because after_find and after_initialize is called for each object instantiated found by a finder, such as Base.find(:all), we've had
   # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, after_find and
   # after_initialize will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
   # callback types will be called.
@@ -213,17 +213,13 @@ module ActiveRecord
     module ClassMethods #:nodoc:
       def instantiate_with_callbacks(record)
         object = instantiate_without_callbacks(record)
-        
-        if object.send(:respond_to_without_attributes?, :after_find)
+
+        if object.respond_to_without_attributes?(:after_find)
           object.send(:callback, :after_find)
-        else
-          object.send(:invoke_and_notify, :after_find)
         end
 
-        if object.send(:respond_to_without_attributes?, :after_initialize)
+        if object.respond_to_without_attributes?(:after_initialize)
           object.send(:callback, :after_initialize)
-        else
-          object.send(:invoke_and_notify, :after_initialize)
         end
 
         object
@@ -231,14 +227,15 @@ module ActiveRecord
     end
 
     # Is called when the object was instantiated by one of the finders, like Base.find.
-    # def after_find() end
+    #def after_find() end
 
     # Is called after the object has been instantiated by a call to Base.new.
-    # def after_initialize() end
+    #def after_initialize() end
+
     def initialize_with_callbacks(attributes = nil) #:nodoc:
       initialize_without_callbacks(attributes)
       result = yield self if block_given?
-      respond_to_without_attributes?(:after_initialize) ? callback(:after_initialize) : invoke_and_notify(:after_initialize)
+      callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
       result
     end
 
@@ -328,6 +325,8 @@ module ActiveRecord
 
     private
       def callback(method)
+        notify(method)
+
         callbacks_for(method).each do |callback|
           result = case callback
             when Symbol
@@ -346,8 +345,9 @@ module ActiveRecord
           return false if result == false
         end
 
-        invoke_and_notify(method)
-        true
+        send(method) if respond_to_without_attributes?(method)
+
+        return true
       end
 
       def callbacks_for(method)
@@ -355,8 +355,8 @@ module ActiveRecord
       end
 
       def invoke_and_notify(method)
-        send(method) if respond_to_without_attributes?(method)
         notify(method)
+        send(method) if respond_to_without_attributes?(method)
       end
 
       def notify(method) #:nodoc:

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -16,7 +16,7 @@ def require_library_or_gem(library_name)
       raise cannot_require
     end
     # 2. Rubygems is installed and loaded. Try to load the library again
-    begin 
+    begin
       require library_name
     rescue LoadError => gem_not_installed
       raise cannot_require
@@ -32,7 +32,7 @@ module ActiveRecord
         @config, @adapter_method = config, adapter_method
       end
     end
-    
+
     # The class -> [adapter_method, config] map
     @@defined_connections = {}
 
@@ -92,32 +92,32 @@ module ActiveRecord
     # for (not necessarily the current class).
     def self.retrieve_connection #:nodoc:
       klass = self
-      until klass == ActiveRecord::Base.superclass
-        Thread.current['active_connections'] ||= {}
-        if Thread.current['active_connections'][klass]
-          return Thread.current['active_connections'][klass]
-        elsif @@defined_connections[klass]
-          klass.connection = @@defined_connections[klass]
+      ar_super = ActiveRecord::Base.superclass
+      until klass == ar_super
+        if conn = (Thread.current['active_connections'] ||= {})[klass]
+          return conn
+        elsif conn = @@defined_connections[klass]
+          klass.connection = conn
           return self.connection
         end
         klass = klass.superclass
       end
       raise ConnectionNotEstablished
     end
-    
+
     # Returns true if a connection that's accessible to this class have already been opened.
     def self.connected?
       klass = self
       until klass == ActiveRecord::Base.superclass
         if Thread.current['active_connections'].is_a?(Hash) && Thread.current['active_connections'][klass]
-          return true 
+          return true
         else
           klass = klass.superclass
         end
       end
       return false
     end
-    
+
     # Remove the connection for this class. This will close the active
     # connection and the defined connection (if they exist). The result
     # can be used as argument for establish_connection, for easy
@@ -129,7 +129,7 @@ module ActiveRecord
       Thread.current['active_connections'][klass] = nil
       conn.config if conn
     end
-    
+
     # Set the connection for the class.
     def self.connection=(spec)
       raise ConnectionNotEstablished unless spec
@@ -152,14 +152,10 @@ module ActiveRecord
       # The type parameter should either contain :integer, :float, :datetime, :date, :text, or :string
       # The sql_type is just used for extracting the limit, such as 10 in "varchar(10)"
       def initialize(name, default, sql_type = nil)
-        @name, @default, @type = name, default, simplified_type(sql_type)
+        @name, @default, @type = name, type_cast(default), simplified_type(sql_type)
         @limit = extract_limit(sql_type) unless sql_type.nil?
       end
 
-      def default
-        type_cast(@default)
-      end
-
       def klass
         case type
           when :integer       then Fixnum
@@ -173,7 +169,7 @@ module ActiveRecord
           when :boolean       then Object
         end
       end
-      
+
       def type_cast(value)
         if value.nil? then return nil end
         case type
@@ -190,18 +186,18 @@ module ActiveRecord
           else value
         end
       end
-      
+
       def human_name
         Base.human_attribute_name(@name)
       end
-      
+
       def string_to_binary(value)
         value
-      end     
+      end
 
       def binary_to_string(value)
         value
-      end     
+      end
 
       private
         def string_to_date(string)
@@ -210,7 +206,7 @@ module ActiveRecord
           # treat 0000-00-00 as nil
           Date.new(date_array[0], date_array[1], date_array[2]) rescue nil
         end
-        
+
         def string_to_time(string)
           return string unless string.is_a?(String)
           time_array = ParseDate.parsedate(string.to_s).compact
@@ -224,12 +220,12 @@ module ActiveRecord
           # pad the resulting array with dummy date information
           time_array[0] = 2000; time_array[1] = 1; time_array[2] = 1;
           Time.send(Base.default_timezone, *time_array) rescue nil
-        end 
-        
+        end
+
         def extract_limit(sql_type)
           $1.to_i if sql_type =~ /\((.*)\)/
         end
-        
+
         def simplified_type(field_type)
           case field_type
             when /int/i
@@ -262,8 +258,6 @@ module ActiveRecord
     class AbstractAdapter
       @@row_even = true
 
-      include Benchmark
-
       def initialize(connection, logger = nil) # :nodoc:
         @connection, @logger = connection, logger
         @runtime = 0
@@ -271,7 +265,7 @@ module ActiveRecord
 
       # Returns an array of record hashes with the column names as a keys and fields as values.
       def select_all(sql, name = nil) end
-      
+
       # Returns a record hash with the column names as a keys and fields as values.
       def select_one(sql, name = nil) end
 
@@ -310,8 +304,8 @@ module ActiveRecord
 
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
-      
-      # Commits the transaction (and turns on auto-committing). 
+
+      # Commits the transaction (and turns on auto-committing).
       def commit_db_transaction()   end
 
       # Rolls back the transaction (and turns on auto-committing). Must be done if the transaction block
@@ -320,7 +314,7 @@ module ActiveRecord
 
       def quote(value, column = nil)
         case value
-          when String                
+          when String
             if column && column.type == :binary
               "'#{quote_string(column.string_to_binary(value))}'" # ' (for ruby-mode)
             else
@@ -330,7 +324,7 @@ module ActiveRecord
           when TrueClass             then (column && column.type == :boolean ? "'t'" : "1")
           when FalseClass            then (column && column.type == :boolean ? "'f'" : "0")
           when Float, Fixnum, Bignum then value.to_s
-          when Date                  then "'#{value.to_s}'" 
+          when Date                  then "'#{value.to_s}'"
           when Time, DateTime        then "'#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
           else                            "'#{quote_string(value.to_yaml)}'"
         end
@@ -352,36 +346,37 @@ module ActiveRecord
       # Returns a string of the CREATE TABLE SQL statements for recreating the entire structure of the database.
       def structure_dump() end
 
-      def add_limit!(sql, limit)
-        if limit.is_a? Array
-          limit, offset = *limit
-          add_limit_with_offset!(sql, limit.to_i, offset.to_i)
-        else
-          add_limit_without_offset!(sql, limit)
-        end
-      end
-        
-      def add_limit_with_offset!(sql, limit, offset)
-        sql << " LIMIT #{limit} OFFSET #{offset}"
+      def add_limit!(sql, options)
+        return unless options
+        add_limit_offset!(sql, options)
       end
-      
-      def add_limit_without_offset!(sql, limit)
-        sql << " LIMIT #{limit}"
+
+      def add_limit_offset!(sql, options)
+        return if options[:limit].nil?
+        sql << " LIMIT #{options[:limit]}"
+        sql << " OFFSET #{options[:offset]}" if options.has_key?(:offset) and !options[:offset].nil?
       end
 
+
       def initialize_schema_information
         begin
-          execute "CREATE TABLE schema_info (version #{native_database_types[:integer][:name]}#{native_database_types[:integer][:limit]})"
+          execute "CREATE TABLE schema_info (version #{type_to_sql(:integer)})"
           insert "INSERT INTO schema_info (version) VALUES(0)"
         rescue ActiveRecord::StatementInvalid
           # Schema has been intialized
         end
       end
-
-      def create_table(name, options = "")
-        execute "CREATE TABLE #{name} (id #{native_database_types[:primary_key]}) #{options}"
-        table_definition = yield TableDefinition.new
-        table_definition.columns.each { |column_name, type, options| add_column(name, column_name, type, options) }
+      
+      def create_table(name, options = {})
+        table_definition = TableDefinition.new(self)
+        table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+
+        yield table_definition
+        create_sql = "CREATE TABLE #{name} ("
+        create_sql << table_definition.to_sql
+        create_sql << ") #{options[:options]}"
+                
+        execute create_sql
       end
 
       def drop_table(name)
@@ -390,29 +385,68 @@ module ActiveRecord
 
       def add_column(table_name, column_name, type, options = {})
         native_type = native_database_types[type]
-        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{native_type[:name]}"
-        add_column_sql << "(#{options[:limit] || native_type[:limit]})" if options[:limit] || native_type[:limit]
-        add_column_sql << " DEFAULT '#{options[:default]}'" if options[:default]
+        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}"
+        add_column_options!(add_column_sql, options)
         execute(add_column_sql)
       end
-
+      
       def remove_column(table_name, column_name)
         execute "ALTER TABLE #{table_name} DROP #{column_name}"
+      end      
+
+      def change_column(table_name, column_name, type, options = {})
+        raise NotImplementedError, "change_column is not implemented"
+      end
+      
+      def change_column_default(table_name, column_name, default)
+        raise NotImplementedError, "change_column_default is not implemented"
+      end
+      
+      def supports_migrations?
+        false
+      end      
+
+      def rename_column(table_name, column_name, new_column_name)
+        raise NotImplementedError, "rename_column is not implemented"
       end
 
+      def add_index(table_name, column_name, index_type = '')
+        execute "CREATE #{index_type} INDEX #{table_name}_#{column_name.to_a.first}_index ON #{table_name} (#{column_name.to_a.join(", ")})"
+      end
 
-      protected
-        def log(sql, name, connection = nil)
-          connection ||= @connection
+      def remove_index(table_name, column_name)
+        execute "DROP INDEX #{table_name}_#{column_name}_index ON #{table_name}"
+      end
+      
+      def supports_migrations?
+        false
+      end           
+
+      def native_database_types
+        {}
+      end       
+
+      def type_to_sql(type, limit = nil)
+        native = native_database_types[type]
+        limit ||= native[:limit]
+        column_type_sql = native[:name]
+        column_type_sql << "(#{limit})" if limit
+        column_type_sql
+      end            
+
+      protected  
+        def log(sql, name)
           begin
-            if @logger.nil? || @logger.level > Logger::INFO
-              yield connection
-            elsif block_given?
-              result = nil
-              bm = measure { result = yield connection }
-              @runtime += bm.real
-              log_info(sql, name, bm.real)
-              result
+            if block_given?
+              if @logger and @logger.level <= Logger::INFO
+                result = nil
+                seconds = Benchmark.realtime { result = yield }
+                @runtime += seconds
+                log_info(sql, name, seconds)
+                result
+              else
+                yield
+              end
             else
               log_info(sql, name, 0)
               nil
@@ -424,11 +458,11 @@ module ActiveRecord
         end
 
         def log_info(sql, name, runtime)
-          if @logger.nil? then return end
+          return unless @logger
 
-          @logger.info(
+          @logger.debug(
             format_log_entry(
-              "#{name.nil? ? "SQL" : name} (#{sprintf("%f", runtime)})", 
+              "#{name.nil? ? "SQL" : name} (#{sprintf("%f", runtime)})",
               sql.gsub(/ +/, " ")
             )
           )
@@ -441,7 +475,7 @@ module ActiveRecord
             else
               @@row_even = true; caller_color = "1;36"; message_color = "4;35"; dump_color = "0;37"
             end
-          
+
             log_entry = "  \e[#{message_color}m#{message}\e[m"
             log_entry << "   \e[#{dump_color}m%s\e[m" % dump if dump.kind_of?(String) && !dump.nil?
             log_entry << "   \e[#{dump_color}m%p\e[m" % dump if !dump.kind_of?(String) && !dump.nil?
@@ -450,19 +484,47 @@ module ActiveRecord
             "%s  %s" % [message, dump]
           end
         end
+      
+        def add_column_options!(sql, options)
+          sql << " DEFAULT '#{options[:default]}'" unless options[:default].nil?
+        end
     end
 
     class TableDefinition
       attr_accessor :columns
-      
-      def initialize
+
+      def initialize(base)
         @columns = []
+        @base = base
+      end
+
+      def primary_key(name)
+        @columns << "#{name} #{native[:primary_key]}"
+        self
       end
 
       def column(name, type, options = {})
-        @columns << [ name, type, options ]
+        limit = options[:limit] || native[type.to_sym][:limit]
+        
+        column_sql = "#{name} #{type_to_sql(type.to_sym, options[:limit])}"
+        column_sql << " DEFAULT '#{options[:default]}'" if options[:default]
+        @columns << column_sql
         self
       end
+      
+      def to_sql
+        @columns.join(", ")
+      end
+      
+      private
+      
+      def type_to_sql(name, limit)
+        @base.type_to_sql(name, limit)
+      end
+      
+      def native
+        @base.native_database_types
+      end
     end
   end
 end