activerecord 2.0.5 → 2.1.0

data/lib/active_record/calculations.rb

@@ -9,16 +9,16 @@ module ActiveRecord
       # Count operates using three different approaches.
       #
       # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-      # * Count using column : By passing a column name to count, it will return a count of all the rows for the model with supplied column present
+      # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
       # * Count using options will find the row count matched by the options used.
       #
       # The third approach, count using options, accepts an option hash as the only parameter. The options are:
       #
       # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro.
       # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
-      #   or named associations in the same form used for the :include option, which will perform an INNER JOIN on the associated table(s).
+      #   or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
       #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
-      #   Pass :readonly => false to override.
+      #   Pass <tt>:readonly => false</tt> to override.
       # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
       #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
       #   See eager loading under Associations.
@@ -41,45 +41,45 @@ module ActiveRecord
       #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
       #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
       #
-      # Note: Person.count(:all) will not work because it will use :all as the condition.  Use Person.count instead.
+      # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  Use Person.count instead.
       def count(*args)
         calculate(:count, *construct_count_options_from_args(*args))
       end
 
-      # Calculates the average value on a given column.  The value is returned as a float.  See #calculate for examples with options.
+      # Calculates the average value on a given column.  The value is returned as a float.  See +calculate+ for examples with options.
       #
       #   Person.average('age')
       def average(column_name, options = {})
         calculate(:avg, column_name, options)
       end
 
-      # Calculates the minimum value on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
+      # Calculates the minimum value on a given column.  The value is returned with the same data type of the column.  See +calculate+ for examples with options.
       #
       #   Person.minimum('age')
       def minimum(column_name, options = {})
         calculate(:min, column_name, options)
       end
 
-      # Calculates the maximum value on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
+      # Calculates the maximum value on a given column.  The value is returned with the same data type of the column.  See +calculate+ for examples with options.
       #
       #   Person.maximum('age')
       def maximum(column_name, options = {})
         calculate(:max, column_name, options)
       end
 
-      # Calculates the sum of values on a given column.  The value is returned with the same data type of the column.  See #calculate for examples with options.
+      # Calculates the sum of values on a given column.  The value is returned with the same data type of the column.  See +calculate+ for examples with options.
       #
       #   Person.sum('age')
       def sum(column_name, options = {})
-        calculate(:sum, column_name, options)
+        calculate(:sum, column_name, options) || 0
       end
 
       # This calculates aggregate values in the given column.  Methods for count, sum, average, minimum, and maximum have been added as shortcuts.
-      # Options such as :conditions, :order, :group, :having, and :joins can be passed to customize the query.
+      # Options such as <tt>:conditions</tt>, <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
       #
       # There are two basic forms of output:
       #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float for AVG, and the given column's type for everything else.
-      #   * Grouped values: This returns an ordered hash of the values and groups them by the :group option.  It takes either a column name, or the name
+      #   * Grouped values: This returns an ordered hash of the values and groups them by the <tt>:group</tt> option.  It takes either a column name, or the name
       #     of a belongs_to association.
       #
       #       values = Person.maximum(:age, :group => 'last_name')
@@ -111,6 +111,7 @@ module ActiveRecord
       #   Person.average(:age) # SELECT AVG(age) FROM people...
       #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
       #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
+      #   Person.sum("2 * age")
       def calculate(operation, column_name, options = {})
         validate_calculation_options(operation, options)
         column_name     = options[:select] if options[:select]
@@ -155,7 +156,7 @@ module ActiveRecord
           scope           = scope(:find)
           merged_includes = merge_includes(scope ? scope[:include] : [], options[:include])
           aggregate_alias = column_alias_for(operation, column_name)
-          column_name     = "#{connection.quote_table_name(table_name)}.#{column_name}" unless column_name == "*" || column_name.to_s.include?('.')
+          column_name     = "#{connection.quote_table_name(table_name)}.#{column_name}" if column_names.include?(column_name.to_s)
 
           if operation == 'count'
             if merged_includes.any?
@@ -168,13 +169,16 @@ module ActiveRecord
             end
           end
 
-          sql = "SELECT #{operation}(#{'DISTINCT ' if options[:distinct]}#{column_name}) AS #{aggregate_alias}"
+          if options[:distinct] && column_name.to_s !~ /\s*DISTINCT\s+/i
+            distinct = 'DISTINCT ' 
+          end
+          sql = "SELECT #{operation}(#{distinct}#{column_name}) AS #{aggregate_alias}"
 
           # A (slower) workaround if we're using a backend, like sqlite, that doesn't support COUNT DISTINCT.
           sql = "SELECT COUNT(*) AS #{aggregate_alias}" if use_workaround
 
           sql << ", #{options[:group_field]} AS #{options[:group_alias]}" if options[:group]
-          sql << " FROM (SELECT DISTINCT #{column_name}" if use_workaround
+          sql << " FROM (SELECT #{distinct}#{column_name}" if use_workaround
           sql << " FROM #{connection.quote_table_name(table_name)} "
           if merged_includes.any?
             join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(self, merged_includes, options[:joins])
@@ -231,7 +235,8 @@ module ActiveRecord
             key   = type_cast_calculated_value(row[group_alias], group_column)
             key   = key_records[key] if associated
             value = row[aggregate_alias]
-            all << [key, type_cast_calculated_value(value, column, operation)]
+            all[key] = type_cast_calculated_value(value, column, operation)
+            all
           end
         end
 
@@ -240,12 +245,14 @@ module ActiveRecord
           options.assert_valid_keys(CALCULATIONS_OPTIONS)
         end
 
-        # Converts a given key to the value that the database adapter returns as
-        # a usable column name.
-        #   users.id #=> users_id
-        #   sum(id) #=> sum_id
-        #   count(distinct users.id) #=> count_distinct_users_id
-        #   count(*) #=> count_all
+        # Converts the given keys to the value that the database adapter returns as
+        # a usable column name:
+        #
+        #   column_alias_for("users.id")                 # => "users_id"
+        #   column_alias_for("sum(id)")                  # => "sum_id"
+        #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
+        #   column_alias_for("count(*)")                 # => "count_all"
+        #   column_alias_for("count", "id")              # => "count_id"
         def column_alias_for(*keys)
           connection.table_alias_for(keys.join(' ').downcase.gsub(/\*/, 'all').gsub(/\W+/, ' ').strip.gsub(/ +/, '_'))
         end

data/lib/active_record/callbacks.rb

@@ -161,7 +161,7 @@ module ActiveRecord
   # == <tt>before_validation*</tt> returning statements
   #
   # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be aborted and <tt>Base#save</tt> will return +false+.
-  # If <tt>Base#save!</tt> is called it will raise a +RecordNotSaved+ exception.
+  # If Base#save! is called it will raise a RecordNotSaved exception.
   # Nothing will be appended to the errors object.
   #
   # == Canceling callbacks
@@ -183,14 +183,8 @@ module ActiveRecord
         base.send :alias_method_chain, method, :callbacks
       end
 
-      CALLBACKS.each do |method|
-        base.class_eval <<-"end_eval"
-          def self.#{method}(*callbacks, &block)
-            callbacks << block if block_given?
-            write_inheritable_array(#{method.to_sym.inspect}, callbacks)
-          end
-        end_eval
-      end
+      base.send :include, ActiveSupport::Callbacks
+      base.define_callbacks *CALLBACKS
     end
 
     # Is called when the object was instantiated by one of the finders, like <tt>Base.find</tt>.
@@ -235,9 +229,9 @@ module ActiveRecord
     # Is called _after_ <tt>Base.save</tt> on existing objects that have a record.
     def after_update() end
 
-    def update_with_callbacks #:nodoc:
+    def update_with_callbacks(*args) #:nodoc:
       return false if callback(:before_update) == false
-      result = update_without_callbacks
+      result = update_without_callbacks(*args)
       callback(:after_update)
       result
     end
@@ -301,38 +295,15 @@ module ActiveRecord
       def callback(method)
         notify(method)
 
-        callbacks_for(method).each do |callback|
-          result = case callback
-            when Symbol
-              self.send(callback)
-            when String
-              eval(callback, binding)
-            when Proc, Method
-              callback.call(self)
-            else
-              if callback.respond_to?(method)
-                callback.send(method, self)
-              else
-                raise ActiveRecordError, "Callbacks must be a symbol denoting the method to call, a string to be evaluated, a block to be invoked, or an object responding to the callback method."
-              end
-          end
-          return false if result == false
-        end
+        result = run_callbacks(method) { |result, object| result == false }
 
-        result = send(method) if respond_to_without_attributes?(method)
+        if result != false && respond_to_without_attributes?(method)
+          result = send(method)
+        end
 
         return result
       end
 
-      def callbacks_for(method)
-        self.class.read_inheritable_attribute(method.to_sym) or []
-      end
-
-      def invoke_and_notify(method)
-        notify(method)
-        send(method) if respond_to_without_attributes?(method)
-      end
-
       def notify(method) #:nodoc:
         self.class.changed
         self.class.notify_observers(method, self)

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

@@ -175,7 +175,7 @@ module ActiveRecord
     end
 
     # Establishes the connection to the database. Accepts a hash as input where
-    # the :adapter key must be specified with the name of a database adapter (in lower-case)
+    # 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):
     #
     #   ActiveRecord::Base.establish_connection(
@@ -193,7 +193,8 @@ module ActiveRecord
     #     :database  => "path/to/dbfile"
     #   )
     #
-    # Also accepts keys as strings (for parsing from yaml for example):
+    # Also accepts keys as strings (for parsing from YAML for example):
+    #
     #   ActiveRecord::Base.establish_connection(
     #     "adapter" => "sqlite",
     #     "database"  => "path/to/dbfile"

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

@@ -29,7 +29,7 @@ module ActiveRecord
       end
 
       # Returns an array of arrays containing the field values.
-      # Order is the same as that returned by #columns.
+      # Order is the same as that returned by +columns+.
       def select_rows(sql, name = nil)
         raise NotImplementedError, "select_rows is an abstract method"
       end
@@ -93,7 +93,7 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Alias for #add_limit_offset!.
+      # Alias for <tt>add_limit_offset!</tt>.
       def add_limit!(sql, options)
         add_limit_offset!(sql, options) if options
       end

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

@@ -44,6 +44,12 @@ module ActiveRecord
         @query_cache_enabled = old
       end
 
+      # Clears the query cache.
+      #
+      # One reason you may wish to call this method explicitly is between queries
+      # that ask the database to randomize results. Otherwise the cache would see
+      # the same SQL query and repeatedly return the same result each time, silently
+      # undermining the randomness you were expecting.
       def clear_query_cache
         @query_cache.clear if @query_cache
       end

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

@@ -16,13 +16,13 @@ module ActiveRecord
 
       # Instantiates a new column in the table.
       #
-      # +name+ is the column's name, as in <tt><b>supplier_id</b> int(11)</tt>.
-      # +default+ is the type-casted default value, such as <tt>sales_stage varchar(20) default <b>'new'</b></tt>.
-      # +sql_type+ is only used to extract the column's length, if necessary.  For example, <tt>company_name varchar(<b>60</b>)</tt>.
+      # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
+      # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
+      # +sql_type+ is only used to extract the column's length, if necessary. For example +60+ in <tt>company_name varchar(60)</tt>.
       # +null+ determines if this column allows +NULL+ values.
       def initialize(name, default, sql_type = nil, null = true)
         @name, @sql_type, @null = name, sql_type, null
-        @limit, @precision, @scale  = extract_limit(sql_type), extract_precision(sql_type), extract_scale(sql_type) 
+        @limit, @precision, @scale = extract_limit(sql_type), extract_precision(sql_type), extract_scale(sql_type)
         @type = simplified_type(sql_type)
         @default = extract_default(default)
 
@@ -92,7 +92,7 @@ module ActiveRecord
       # Returns the human name of the column name.
       #
       # ===== Examples
-      #  Column.new('sales_stage', ...).human_name #=> 'Sales stage'
+      #  Column.new('sales_stage', ...).human_name # => 'Sales stage'
       def human_name
         Base.human_attribute_name(@name)
       end
@@ -144,7 +144,10 @@ module ActiveRecord
 
         # convert something to a BigDecimal
         def value_to_decimal(value)
-          if value.is_a?(BigDecimal)
+          # Using .class is faster than .is_a? and
+          # subclasses of BigDecimal will be handled
+          # in the else clause
+          if value.class == BigDecimal
             value
           elsif value.respond_to?(:to_d)
             value.to_d
@@ -170,11 +173,7 @@ module ActiveRecord
             # Treat 0000-00-00 00:00:00 as nil.
             return nil if year.nil? || year == 0
 
-            Time.send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec)
-          # Over/underflow to DateTime
-          rescue ArgumentError, TypeError
-            zone_offset = Base.default_timezone == :local ? DateTime.local_offset : 0
-            DateTime.civil(year, mon, mday, hour, min, sec, zone_offset) rescue nil
+            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
           end
 
           def fast_string_to_date(string)
@@ -192,7 +191,7 @@ module ActiveRecord
           end
 
           def fallback_string_to_date(string)
-            new_date(*ParseDate.parsedate(string)[0..2])
+            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
           end
 
           def fallback_string_to_time(string)
@@ -251,11 +250,11 @@ module ActiveRecord
     end
 
     class ColumnDefinition < Struct.new(:base, :name, :type, :limit, :precision, :scale, :default, :null) #:nodoc:
-      
+
       def sql_type
         base.type_to_sql(type.to_sym, limit, precision, scale) rescue type
       end
-      
+
       def to_sql
         column_sql = "#{base.quote_column_name(name)} #{sql_type}"
         add_column_options!(column_sql, :null => null, :default => default) unless type.to_sym == :primary_key
@@ -271,7 +270,7 @@ module ActiveRecord
     end
 
     # Represents a SQL table in an abstract way.
-    # Columns are stored as a ColumnDefinition in the #columns attribute.
+    # Columns are stored as a ColumnDefinition in the +columns+ attribute.
     class TableDefinition
       attr_accessor :columns
 
@@ -310,39 +309,39 @@ module ActiveRecord
       # * <tt>:default</tt> -
       #   The column's default value. Use nil for NULL.
       # * <tt>:null</tt> -
-      #   Allows or disallows +NULL+ values in the column.  This option could
+      #   Allows or disallows +NULL+ values in the column. This option could
       #   have been named <tt>:null_allowed</tt>.
       # * <tt>:precision</tt> -
-      #   Specifies the precision for a <tt>:decimal</tt> column. 
+      #   Specifies the precision for a <tt>:decimal</tt> column.
       # * <tt>:scale</tt> -
-      #   Specifies the scale for a <tt>:decimal</tt> column. 
+      #   Specifies the scale for a <tt>:decimal</tt> column.
       #
       # Please be aware of different RDBMS implementations behavior with
       # <tt>:decimal</tt> columns:
       # * The SQL standard says the default scale should be 0, <tt>:scale</tt> <=
       #   <tt>:precision</tt>, and makes no comments about the requirements of
       #   <tt>:precision</tt>.
-      # * MySQL: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..30]. 
+      # * MySQL: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..30].
       #   Default is (10,0).
-      # * PostgreSQL: <tt>:precision</tt> [1..infinity], 
+      # * PostgreSQL: <tt>:precision</tt> [1..infinity],
       #   <tt>:scale</tt> [0..infinity]. No default.
-      # * SQLite2: Any <tt>:precision</tt> and <tt>:scale</tt> may be used. 
+      # * SQLite2: Any <tt>:precision</tt> and <tt>:scale</tt> may be used.
       #   Internal storage as strings. No default.
       # * SQLite3: No restrictions on <tt>:precision</tt> and <tt>:scale</tt>,
       #   but the maximum supported <tt>:precision</tt> is 16. No default.
-      # * Oracle: <tt>:precision</tt> [1..38], <tt>:scale</tt> [-84..127]. 
+      # * Oracle: <tt>:precision</tt> [1..38], <tt>:scale</tt> [-84..127].
       #   Default is (38,0).
-      # * DB2: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..62]. 
+      # * DB2: <tt>:precision</tt> [1..63], <tt>:scale</tt> [0..62].
       #   Default unknown.
-      # * Firebird: <tt>:precision</tt> [1..18], <tt>:scale</tt> [0..18]. 
+      # * Firebird: <tt>:precision</tt> [1..18], <tt>:scale</tt> [0..18].
       #   Default (9,0). Internal types NUMERIC and DECIMAL have different
       #   storage rules, decimal being better.
-      # * FrontBase?: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38]. 
+      # * FrontBase?: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38].
       #   Default (38,0). WARNING Max <tt>:precision</tt>/<tt>:scale</tt> for
       #   NUMERIC is 19, and DECIMAL is 38.
-      # * SqlServer?: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38]. 
+      # * SqlServer?: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38].
       #   Default (38,0).
-      # * Sybase: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38]. 
+      # * Sybase: <tt>:precision</tt> [1..38], <tt>:scale</tt> [0..38].
       #   Default (38,0).
       # * OpenBase?: Documentation unclear. Claims storage in <tt>double</tt>.
       #
@@ -351,28 +350,28 @@ module ActiveRecord
       # == Examples
       #  # Assuming td is an instance of TableDefinition
       #  td.column(:granted, :boolean)
-      #    #=> granted BOOLEAN
+      #  # granted BOOLEAN
       #
       #  td.column(:picture, :binary, :limit => 2.megabytes)
-      #    #=> picture BLOB(2097152)
+      #  # => picture BLOB(2097152)
       #
       #  td.column(:sales_stage, :string, :limit => 20, :default => 'new', :null => false)
-      #    #=> sales_stage VARCHAR(20) DEFAULT 'new' NOT NULL
+      #  # => sales_stage VARCHAR(20) DEFAULT 'new' NOT NULL
       #
-      #  def.column(:bill_gates_money, :decimal, :precision => 15, :scale => 2)
-      #    #=> bill_gates_money DECIMAL(15,2)
+      #  td.column(:bill_gates_money, :decimal, :precision => 15, :scale => 2)
+      #  # => bill_gates_money DECIMAL(15,2)
       #
-      #  def.column(:sensor_reading, :decimal, :precision => 30, :scale => 20)
-      #    #=> sensor_reading DECIMAL(30,20)
+      #  td.column(:sensor_reading, :decimal, :precision => 30, :scale => 20)
+      #  # => sensor_reading DECIMAL(30,20)
       #
       #  # While <tt>:scale</tt> defaults to zero on most databases, it
       #  # probably wouldn't hurt to include it.
-      #  def.column(:huge_integer, :decimal, :precision => 30)
-      #    #=> huge_integer DECIMAL(30)
+      #  td.column(:huge_integer, :decimal, :precision => 30)
+      #  # => huge_integer DECIMAL(30)
       #
       # == Short-hand examples
       #
-      # Instead of calling column directly, you can also work with the short-hand definitions for the default types.
+      # Instead of calling +column+ directly, you can also work with the short-hand definitions for the default types.
       # They use the type as the method name instead of as a parameter and allow for multiple columns to be defined
       # in a single statement.
       #
@@ -395,12 +394,12 @@ module ActiveRecord
       #     t.timestamps
       #   end
       #
-      # There's a short-hand method for each of the type values declared at the top. And then there's 
-      # TableDefinition#timestamps that'll add created_at and updated_at as datetimes.
+      # There's a short-hand method for each of the type values declared at the top. And then there's
+      # TableDefinition#timestamps that'll add created_at and +updated_at+ as datetimes.
       #
       # TableDefinition#references will add an appropriately-named _id column, plus a corresponding _type
-      # column if the :polymorphic option is supplied. If :polymorphic is a hash of options, these will be
-      # used when creating the _type column. So what can be written like this:
+      # column if the <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of options, these will be
+      # used when creating the <tt>_type</tt> column. So what can be written like this:
       #
       #   create_table :taggings do |t|
       #     t.integer :tag_id, :tagger_id, :taggable_id
@@ -435,13 +434,13 @@ module ActiveRecord
           def #{column_type}(*args)
             options = args.extract_options!
             column_names = args
-            
+
             column_names.each { |name| column(name, '#{column_type}', options) }
           end
         EOV
       end
-      
-      # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and 
+
+      # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
       # <tt>:updated_at</tt> to the table.
       def timestamps
         column(:created_at, :datetime)
@@ -459,7 +458,7 @@ module ActiveRecord
       alias :belongs_to :references
 
       # Returns a String whose contents are the column definitions
-      # concatenated together.  This string can then be prepended and appended to
+      # concatenated together. This string can then be prepended and appended to
       # to generate the final SQL to create the table.
       def to_sql
         @columns * ', '
@@ -470,5 +469,193 @@ module ActiveRecord
           @base.native_database_types
         end
     end
+
+    # Represents a SQL table in an abstract way for updating a table.
+    # Also see TableDefinition and SchemaStatements#create_table
+    #
+    # Available transformations are:
+    #
+    #   change_table :table do |t|
+    #     t.column
+    #     t.index
+    #     t.timestamps
+    #     t.change
+    #     t.change_default
+    #     t.rename
+    #     t.references
+    #     t.belongs_to
+    #     t.string
+    #     t.text
+    #     t.integer
+    #     t.float
+    #     t.decimal
+    #     t.datetime
+    #     t.timestamp
+    #     t.time
+    #     t.date
+    #     t.binary
+    #     t.boolean
+    #     t.remove
+    #     t.remove_references
+    #     t.remove_belongs_to
+    #     t.remove_index
+    #     t.remove_timestamps
+    #   end
+    #
+    class Table
+      def initialize(table_name, base)
+        @table_name = table_name
+        @base = base
+      end
+
+      # Adds a new column to the named table.
+      # See TableDefinition#column for details of the options you can use.
+      # ===== Example
+      # ====== Creating a simple column
+      #  t.column(:name, :string)
+      def column(column_name, type, options = {})
+        @base.add_column(@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
+      #
+      # ===== Examples
+      # ====== Creating a simple index
+      #  t.index(:name)
+      # ====== Creating a unique index
+      #  t.index([:branch_id, :party_id], :unique => true)
+      # ====== Creating a named index
+      #  t.index([:branch_id, :party_id], :unique => true, :name => 'by_branch_party')
+      def index(column_name, options = {})
+        @base.add_index(@table_name, column_name, options)
+      end
+
+      # Adds timestamps (created_at and updated_at) columns to the table. See SchemaStatements#add_timestamps
+      # ===== Example
+      #  t.timestamps
+      def timestamps
+        @base.add_timestamps(@table_name)
+      end
+
+      # Changes the column's definition according to the new options.
+      # See TableDefinition#column for details of the options you can use.
+      # ===== Examples
+      #  t.change(:name, :string, :limit => 80)
+      #  t.change(:description, :text)
+      def change(column_name, type, options = {})
+        @base.change_column(@table_name, column_name, type, options)
+      end
+
+      # Sets a new default value for a column. See SchemaStatements#change_column_default
+      # ===== Examples
+      #  t.change_default(:qualification, 'new')
+      #  t.change_default(:authorized, 1)
+      def change_default(column_name, default)
+        @base.change_column_default(@table_name, column_name, default)
+      end
+
+      # Removes the column(s) from the table definition.
+      # ===== Examples
+      #  t.remove(:qualification)
+      #  t.remove(:qualification, :experience)
+      def remove(*column_names)
+        @base.remove_column(@table_name, column_names)
+      end
+
+      # Removes the given index from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_name_index in the suppliers table
+      #   t.remove_index :name
+      # ====== Remove the index named accounts_branch_id_index in the accounts table
+      #   t.remove_index :column => :branch_id
+      # ====== Remove the index named accounts_branch_id_party_id_index in the accounts table
+      #   t.remove_index :column => [:branch_id, :party_id]
+      # ====== Remove the index named by_branch_party in the accounts table
+      #   t.remove_index :name => :by_branch_party
+      def remove_index(options = {})
+        @base.remove_index(@table_name, options)
+      end
+
+      # Removes the timestamp columns (created_at and updated_at) from the table.
+      # ===== Example
+      #  t.remove_timestamps
+      def remove_timestamps
+        @base.remove_timestamps(@table_name)
+      end
+
+      # Renames a column.
+      # ===== Example
+      #  t.rename(:description, :name)
+      def rename(column_name, new_column_name)
+        @base.rename_column(@table_name, column_name, new_column_name)
+      end
+
+      # Adds a reference. Optionally adds a +type+ column.
+      # <tt>references</tt> and <tt>belongs_to</tt> are acceptable.
+      # ===== Examples
+      #  t.references(:goat)
+      #  t.references(:goat, :polymorphic => true)
+      #  t.belongs_to(:goat)
+      def references(*args)
+        options = args.extract_options!
+        polymorphic = options.delete(:polymorphic)
+        args.each do |col|
+          @base.add_column(@table_name, "#{col}_id", :integer, options)
+          @base.add_column(@table_name, "#{col}_type", :string, polymorphic.is_a?(Hash) ? polymorphic : options) unless polymorphic.nil?
+        end
+      end
+      alias :belongs_to :references
+
+      # Removes a reference. Optionally removes a +type+ column.
+      # <tt>remove_references</tt> and <tt>remove_belongs_to</tt> are acceptable.
+      # ===== Examples
+      #  t.remove_references(:goat)
+      #  t.remove_references(:goat, :polymorphic => true)
+      #  t.remove_belongs_to(:goat)
+      def remove_references(*args)
+        options = args.extract_options!
+        polymorphic = options.delete(:polymorphic)
+        args.each do |col|
+          @base.remove_column(@table_name, "#{col}_id")
+          @base.remove_column(@table_name, "#{col}_type") unless polymorphic.nil?
+        end
+      end
+      alias :remove_belongs_to  :remove_references
+
+      # Adds a column or columns of a specified type
+      # ===== Examples
+      #  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
+          def #{column_type}(*args)
+            options = args.extract_options!
+            column_names = args
+
+            column_names.each do |name|
+              column = ColumnDefinition.new(@base, name, '#{column_type}')
+              if options[:limit]
+                column.limit = options[:limit]
+              elsif native['#{column_type}'.to_sym].is_a?(Hash)
+                column.limit = native['#{column_type}'.to_sym][:limit]
+              end
+              column.precision = options[:precision]
+              column.scale = options[:scale]
+              column.default = options[:default]
+              column.null = options[:null]
+              @base.add_column(@table_name, name, column.sql_type, options)
+            end
+          end
+        EOV
+      end
+
+      private
+        def native
+          @base.native_database_types
+        end
+    end
+
   end
 end