activerecord 3.0.20 → 3.1.0.beta1

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

@@ -12,11 +12,15 @@ module ActiveRecord
 
       # 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(/\./, '_')
+        table_name[0...table_alias_length].gsub(/\./, '_')
       end
 
       # def tables(name = nil) end
 
+      # Checks to see if the table +table_name+ exists on the database.
+      #
+      # === Example
+      #   table_exists?(:developers)
       def table_exists?(table_name)
         tables.include?(table_name.to_s)
       end
@@ -24,7 +28,7 @@ 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
+      # Checks to see if an index exists on a table for a given index definition.
       #
       # === Examples
       #  # Check an index exists
@@ -151,10 +155,10 @@ module ActiveRecord
       #
       # See also TableDefinition#column for details on how to create columns.
       def create_table(table_name, options = {})
-        table_definition = TableDefinition.new(self)
-        table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
+        td = table_definition
+        td.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
 
-        yield table_definition if block_given?
+        yield td if block_given?
 
         if options[:force] && table_exists?(table_name)
           drop_table(table_name, options)
@@ -162,7 +166,7 @@ module ActiveRecord
 
         create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
         create_sql << "#{quote_table_name(table_name)} ("
-        create_sql << table_definition.to_sql
+        create_sql << td.to_sql
         create_sql << ") #{options[:options]}"
         execute create_sql
       end
@@ -176,6 +180,13 @@ module ActiveRecord
       #    # Other column alterations here
       #  end
       #
+      # The +options+ hash can include the following keys:
+      # [<tt>:bulk</tt>]
+      #   Set this to true to make this a bulk alter query, such as
+      #   ALTER TABLE `users` ADD COLUMN age INT(11), ADD COLUMN birthdate DATETIME ...
+      #
+      #   Defaults to false.
+      #
       # ===== Examples
       # ====== Add a column
       #  change_table(:suppliers) do |t|
@@ -224,8 +235,14 @@ module ActiveRecord
       #
       # See also Table for details on
       # all of the various column transformation
-      def change_table(table_name)
-        yield Table.new(table_name, self)
+      def change_table(table_name, options = {})
+        if supports_bulk_alter? && options[:bulk]
+          recorder = ActiveRecord::Migration::CommandRecorder.new(self)
+          yield Table.new(table_name, recorder)
+          bulk_change_table(table_name, recorder.commands)
+        else
+          yield Table.new(table_name, self)
+        end
       end
 
       # Renames a table.
@@ -253,10 +270,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
+        columns_for_remove(table_name, *column_names).each {|column_name| execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{column_name}" }
       end
       alias :remove_columns :remove_column
 
@@ -269,12 +283,11 @@ module ActiveRecord
         raise NotImplementedError, "change_column is not implemented"
       end
 
-      # Sets a new default value for a column.  If you want to set the default
-      # value to +NULL+, you are out of luck.  You need to
-      # DatabaseStatements#execute the appropriate SQL statement yourself.
+      # Sets a new default value for a column.
       # ===== Examples
       #  change_column_default(:suppliers, :qualification, 'new')
       #  change_column_default(:accounts, :authorized, 1)
+      #  change_column_default(:users, :email, nil)
       def change_column_default(table_name, column_name, default)
         raise NotImplementedError, "change_column_default is not implemented"
       end
@@ -327,25 +340,8 @@ module ActiveRecord
       #
       # 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)
-
-        if Hash === options # legacy support, since this param was a string
-          index_type = options[:unique] ? "UNIQUE" : ""
-          index_name = options[:name].to_s if options.key?(:name)
-        else
-          index_type = options
-        end
-
-        if index_name.length > index_name_length
-          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
-        end
-        if index_name_exists?(table_name, index_name, false)
-          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
-        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})"
+        index_name, index_type, index_columns = add_index_options(table_name, column_name, options)
+        execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns})"
       end
 
       # Remove the given index from the table.
@@ -359,11 +355,7 @@ 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 = {})
-        index_name = index_name(table_name, options)
-        unless index_name_exists?(table_name, index_name, true)
-          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
-        end
-        remove_index!(table_name, index_name)
+        remove_index!(table_name, index_name_for_remove(table_name, options))
       end
 
       def remove_index!(table_name, index_name) #:nodoc:
@@ -442,12 +434,14 @@ module ActiveRecord
         end
       end
 
-      def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
+      def assume_migrated_upto_version(version, migrations_paths = ActiveRecord::Migrator.migrations_paths)
+        migrations_paths = Array.wrap(migrations_paths)
         version = version.to_i
         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
         migrated = select_values("SELECT version FROM #{sm_table}").map { |v| v.to_i }
-        versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
+        paths = migrations_paths.map {|p| "#{p}/[0-9]*_*.rb" }
+        versions = Dir[*paths].map do |filename|
           filename.split('/').last.split('_').first.to_i
         end
 
@@ -467,7 +461,7 @@ module ActiveRecord
       end
 
       def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-        if native = native_database_types[type]
+        if native = native_database_types[type.to_sym]
           column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
 
           if type == :decimal # ignore limit, use precision and scale
@@ -534,6 +528,50 @@ module ActiveRecord
         def options_include_default?(options)
           options.include?(:default) && !(options[:null] == false && options[:default].nil?)
         end
+
+        def add_index_options(table_name, column_name, options = {})
+          column_names = Array.wrap(column_name)
+          index_name   = index_name(table_name, :column => column_names)
+
+          if Hash === options # legacy support, since this param was a string
+            index_type = options[:unique] ? "UNIQUE" : ""
+            index_name = options[:name].to_s if options.key?(:name)
+          else
+            index_type = options
+          end
+
+          if index_name.length > index_name_length
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
+          end
+          if index_name_exists?(table_name, index_name, false)
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+          end
+          index_columns = quoted_columns_for_index(column_names, options).join(", ")
+
+          [index_name, index_type, index_columns]
+        end
+
+        def index_name_for_remove(table_name, options = {})
+          index_name = index_name(table_name, options)
+
+          unless index_name_exists?(table_name, index_name, true)
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
+          end
+
+          index_name
+        end
+
+        def columns_for_remove(table_name, *column_names)
+          column_names = column_names.flatten
+
+          raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.blank?
+          column_names.map {|column_name| quote_column_name(column_name) }
+        end
+
+      private
+      def table_definition
+        TableDefinition.new(self)
+      end
     end
   end
 end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -4,6 +4,7 @@ require 'bigdecimal/util'
 require 'active_support/core_ext/benchmark'
 
 # TODO: Autoload these files
+require 'active_record/connection_adapters/column'
 require 'active_record/connection_adapters/abstract/schema_definitions'
 require 'active_record/connection_adapters/abstract/schema_statements'
 require 'active_record/connection_adapters/abstract/database_statements'
@@ -12,6 +13,7 @@ require 'active_record/connection_adapters/abstract/connection_pool'
 require 'active_record/connection_adapters/abstract/connection_specification'
 require 'active_record/connection_adapters/abstract/query_cache'
 require 'active_record/connection_adapters/abstract/database_limits'
+require 'active_record/result'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -40,61 +42,60 @@ module ActiveRecord
         @active = nil
         @connection, @logger = connection, logger
         @query_cache_enabled = false
-        @query_cache = {}
+        @query_cache = Hash.new { |h,sql| h[sql] = {} }
         @instrumenter = ActiveSupport::Notifications.instrumenter
       end
 
-      # Returns the human-readable name of the adapter.  Use mixed case - one
+      # Returns the human-readable name of the adapter. Use mixed case - one
       # can always use downcase if needed.
       def adapter_name
         'Abstract'
       end
 
-      # Does this adapter support migrations?  Backend specific, as the
+      # Does this adapter support migrations? Backend specific, as the
       # abstract adapter always returns +false+.
       def supports_migrations?
         false
       end
 
       # Can this adapter determine the primary key for tables not attached
-      # to an Active Record 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
       end
 
-      # Does this adapter support using DISTINCT within COUNT?  This is +true+
+      # Does this adapter support using DISTINCT within COUNT? This is +true+
       # for all adapters except sqlite.
       def supports_count_distinct?
         true
       end
 
-      # Does this adapter support DDL rollbacks in transactions?  That is, would
-      # CREATE TABLE or ALTER TABLE get rolled back by a transaction?  PostgreSQL,
-      # SQL Server, and others support this.  MySQL and others do not.
+      # Does this adapter support DDL rollbacks in transactions? That is, would
+      # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
+      # SQL Server, and others support this. MySQL and others do not.
       def supports_ddl_transactions?
         false
       end
 
-      # Does this adapter support savepoints? PostgreSQL and MySQL do, SQLite
-      # does not.
+      def supports_bulk_alter?
+        false
+      end
+
+      # Does this adapter support savepoints? PostgreSQL and MySQL do,
+      # SQLite < 3.6.8 does not.
       def supports_savepoints?
         false
       end
 
       # Should primary key values be selected from their corresponding
-      # sequence before the insert statement?  If true, next_sequence_value
+      # sequence before the insert statement? If true, next_sequence_value
       # is called before each insert to set the record's primary key.
       # This is false for all adapters but Firebird.
       def prefetch_primary_key?(table_name = nil)
         false
       end
 
-      # Does this adapter restrict the number of ids you can use in a list. Oracle has a limit of 1000.
-      def ids_in_list_limit
-        nil
-      end
-
       # QUOTING ==================================================
 
       # Override to return the quoted table name. Defaults to column quoting.
@@ -102,6 +103,12 @@ module ActiveRecord
         quote_column_name(name)
       end
 
+      # Returns a bind substitution value given a +column+ and list of current
+      # +binds+
+      def substitute_at(column, index)
+        Arel.sql '?'
+      end
+
       # REFERENTIAL INTEGRITY ====================================
 
       # Override to turn off referential integrity while executing <tt>&block</tt>.
@@ -140,6 +147,13 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
+      ###
+      # Clear any caching the database adapter may be doing, for example
+      # clearing the prepared statement cache. This is database specific.
+      def clear_cache!
+        # this should be overridden by concrete adapters
+      end
+
       # 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?
@@ -189,24 +203,29 @@ module ActiveRecord
       def release_savepoint
       end
 
+      def case_sensitive_modifier(node)
+        node
+      end
+
       def current_savepoint_name
         "active_record_#{open_transactions}"
       end
 
       protected
 
-        def log(sql, name)
-          name ||= "SQL"
-          @instrumenter.instrument("sql.active_record",
-            :sql => sql, :name => name, :connection_id => object_id) do
-            yield
-          end
+        def log(sql, name = "SQL", binds = [])
+          @instrumenter.instrument(
+            "sql.active_record",
+            :sql           => sql,
+            :name          => name,
+            :connection_id => object_id,
+            :binds         => binds) { yield }
         rescue Exception => e
           message = "#{e.class.name}: #{e.message}: #{sql}"
           @logger.debug message if @logger
-          ex = translate_exception(e, message)
-          ex.set_backtrace e.backtrace
-          raise ex
+          exception = translate_exception(e, message)
+          exception.set_backtrace e.backtrace
+          raise exception
         end
 
         def translate_exception(e, message)

data/lib/active_record/connection_adapters/column.rb

@@ -0,0 +1,268 @@
+module ActiveRecord
+  # :stopdoc:
+  module ConnectionAdapters
+    # An abstract definition of a column in a table.
+    class Column
+      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].to_set
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE'].to_set
+
+      module Format
+        ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+        ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
+      end
+
+      attr_reader :name, :default, :type, :limit, :null, :sql_type, :precision, :scale
+      attr_accessor :primary, :coder
+
+      alias :encoded? :coder
+
+      # Instantiates a new column in the table.
+      #
+      # +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 used to extract the column's length, if necessary. For example +60+ in
+      # <tt>company_name varchar(60)</tt>.
+      # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
+      # +null+ determines if this column allows +NULL+ values.
+      def initialize(name, default, sql_type = nil, null = true)
+        @name      = name
+        @sql_type  = sql_type
+        @null      = null
+        @limit     = extract_limit(sql_type)
+        @precision = extract_precision(sql_type)
+        @scale     = extract_scale(sql_type)
+        @type      = simplified_type(sql_type)
+        @default   = extract_default(default)
+        @primary   = nil
+        @coder     = nil
+      end
+
+      # Returns +true+ if the column is either of type string or text.
+      def text?
+        type == :string || type == :text
+      end
+
+      # Returns +true+ if the column is either of type integer, float or decimal.
+      def number?
+        type == :integer || type == :float || type == :decimal
+      end
+
+      def has_default?
+        !default.nil?
+      end
+
+      # Returns the Ruby class that corresponds to the abstract data type.
+      def klass
+        case type
+        when :integer                     then Fixnum
+        when :float                       then Float
+        when :decimal                     then BigDecimal
+        when :datetime, :timestamp, :time then Time
+        when :date                        then Date
+        when :text, :string, :binary      then String
+        when :boolean                     then Object
+        end
+      end
+
+      # Casts value (which is a String) to an appropriate instance.
+      def type_cast(value)
+        return nil if value.nil?
+        return coder.load(value) if encoded?
+
+        klass = self.class
+
+        case type
+        when :string, :text        then value
+        when :integer              then value.to_i rescue value ? 1 : 0
+        when :float                then value.to_f
+        when :decimal              then klass.value_to_decimal(value)
+        when :datetime, :timestamp then klass.string_to_time(value)
+        when :time                 then klass.string_to_dummy_time(value)
+        when :date                 then klass.string_to_date(value)
+        when :binary               then klass.binary_to_string(value)
+        when :boolean              then klass.value_to_boolean(value)
+        else value
+        end
+      end
+
+      def type_cast_code(var_name)
+        klass = self.class.name
+
+        case type
+        when :string, :text        then var_name
+        when :integer              then "(#{var_name}.to_i rescue #{var_name} ? 1 : 0)"
+        when :float                then "#{var_name}.to_f"
+        when :decimal              then "#{klass}.value_to_decimal(#{var_name})"
+        when :datetime, :timestamp then "#{klass}.string_to_time(#{var_name})"
+        when :time                 then "#{klass}.string_to_dummy_time(#{var_name})"
+        when :date                 then "#{klass}.string_to_date(#{var_name})"
+        when :binary               then "#{klass}.binary_to_string(#{var_name})"
+        when :boolean              then "#{klass}.value_to_boolean(#{var_name})"
+        else var_name
+        end
+      end
+
+      # Returns the human name of the column name.
+      #
+      # ===== Examples
+      #  Column.new('sales_stage', ...).human_name # => 'Sales stage'
+      def human_name
+        Base.human_attribute_name(@name)
+      end
+
+      def extract_default(default)
+        type_cast(default)
+      end
+
+      # Used to convert from Strings to BLOBs
+      def string_to_binary(value)
+        self.class.string_to_binary(value)
+      end
+
+      class << self
+        # Used to convert from Strings to BLOBs
+        def string_to_binary(value)
+          value
+        end
+
+        # Used to convert from BLOBs to Strings
+        def binary_to_string(value)
+          value
+        end
+
+        def string_to_date(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_date(string) || fallback_string_to_date(string)
+        end
+
+        def string_to_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          fast_string_to_time(string) || fallback_string_to_time(string)
+        end
+
+        def string_to_dummy_time(string)
+          return string unless string.is_a?(String)
+          return nil if string.empty?
+
+          string_to_time "2000-01-01 #{string}"
+        end
+
+        # convert something to a boolean
+        def value_to_boolean(value)
+          if value.is_a?(String) && value.blank?
+            nil
+          else
+            TRUE_VALUES.include?(value)
+          end
+        end
+
+        # convert something to a BigDecimal
+        def value_to_decimal(value)
+          # 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
+          else
+            value.to_s.to_d
+          end
+        end
+
+        protected
+          # '0.123456' -> 123456
+          # '1.123456' -> 123456
+          def microseconds(time)
+            ((time[:sec_fraction].to_f % 1) * 1_000_000).to_i
+          end
+
+          def new_date(year, mon, mday)
+            if year && year != 0
+              Date.new(year, mon, mday) rescue nil
+            end
+          end
+
+          def new_time(year, mon, mday, hour, min, sec, microsec)
+            # Treat 0000-00-00 00:00:00 as nil.
+            return nil if year.nil? || year == 0
+
+            Time.time_with_datetime_fallback(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+          end
+
+          def fast_string_to_date(string)
+            if string =~ Format::ISO_DATE
+              new_date $1.to_i, $2.to_i, $3.to_i
+            end
+          end
+
+          # Doesn't handle time zones.
+          def fast_string_to_time(string)
+            if string =~ Format::ISO_DATETIME
+              microsec = ($7.to_f * 1_000_000).to_i
+              new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+            end
+          end
+
+          def fallback_string_to_date(string)
+            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+          end
+
+          def fallback_string_to_time(string)
+            time_hash = Date._parse(string)
+            time_hash[:sec_fraction] = microseconds(time_hash)
+
+            new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+          end
+      end
+
+      private
+        def extract_limit(sql_type)
+          $1.to_i if sql_type =~ /\((.*)\)/
+        end
+
+        def extract_precision(sql_type)
+          $2.to_i if sql_type =~ /^(numeric|decimal|number)\((\d+)(,\d+)?\)/i
+        end
+
+        def extract_scale(sql_type)
+          case sql_type
+            when /^(numeric|decimal|number)\((\d+)\)/i then 0
+            when /^(numeric|decimal|number)\((\d+)(,(\d+))\)/i then $4.to_i
+          end
+        end
+
+        def simplified_type(field_type)
+          case field_type
+          when /int/i
+            :integer
+          when /float|double/i
+            :float
+          when /decimal|numeric|number/i
+            extract_scale(field_type) == 0 ? :integer : :decimal
+          when /datetime/i
+            :datetime
+          when /timestamp/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /clob/i, /text/i
+            :text
+          when /blob/i, /binary/i
+            :binary
+          when /char/i, /string/i
+            :string
+          when /boolean/i
+            :boolean
+          end
+        end
+    end
+  end
+  # :startdoc:
+end