activerecord 2.3.5 → 2.3.6

data/lib/active_record/batches.rb

@@ -59,19 +59,23 @@ module ActiveRecord
         start = options.delete(:start).to_i
         batch_size = options.delete(:batch_size) || 1000
 
-        with_scope(:find => options.merge(:order => batch_order, :limit => batch_size)) do
-          records = find(:all, :conditions => [ "#{table_name}.#{primary_key} >= ?", start ])
+        proxy = scoped(options.merge(:order => batch_order, :limit => batch_size))
+        records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} >= ?", start ])
 
-          while records.any?
-            yield records
+        while records.any?
+          yield records
 
-            break if records.size < batch_size
-            records = find(:all, :conditions => [ "#{table_name}.#{primary_key} > ?", records.last.id ])
-          end
+          break if records.size < batch_size
+          
+          last_value = records.last.id
+          
+          raise "You must include the primary key if you define a select" unless last_value.present?
+          
+          records = proxy.find(:all, :conditions => [ "#{table_name}.#{primary_key} > ?", last_value ])
         end
       end
-      
-      
+
+
       private
         def batch_order
           "#{table_name}.#{primary_key} ASC"

data/lib/active_record/calculations.rb

@@ -294,12 +294,15 @@ module ActiveRecord
         end
 
         def type_cast_calculated_value(value, column, operation = nil)
-          operation = operation.to_s.downcase
-          case operation
+          if value.is_a?(String) || value.nil?
+            case operation.to_s.downcase
             when 'count' then value.to_i
             when 'sum'   then type_cast_using_column(value || '0', column)
-            when 'avg'   then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
+            when 'avg' then value.try(:to_d)
             else type_cast_using_column(value, column)
+            end
+          else
+            value
           end
         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
+    superclass_delegating_accessor :connection_handler
+    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/query_cache.rb

@@ -13,7 +13,7 @@ module ActiveRecord
 
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
-            base.class_eval <<-end_code, __FILE__, __LINE__
+            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)

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

@@ -11,12 +11,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)
@@ -28,7 +28,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
@@ -60,10 +60,6 @@ module ActiveRecord
       def quoted_date(value)
         value.to_s(:db)
       end
-
-      def quoted_string_prefix
-        ''
-      end
     end
   end
 end

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

@@ -256,7 +256,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

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

@@ -8,11 +8,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(/\./, '_')
@@ -101,7 +96,7 @@ module ActiveRecord
         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
 
-        yield table_definition
+        yield table_definition if block_given?
 
         if options[:force] && table_exists?(table_name)
           drop_table(table_name, options)
@@ -246,18 +241,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(column_name)
         index_name   = index_name(table_name, :column => column_names)
@@ -268,7 +277,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
 
@@ -283,7 +302,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 #{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:
@@ -300,6 +340,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
@@ -336,12 +385,12 @@ module ActiveRecord
         end
       end
 
-      def assume_migrated_upto_version(version)
+      def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
         version = version.to_i
         sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
         migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
-        versions = Dir['db/migrate/[0-9]*_*.rb'].map do |filename|
+        versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
           filename.split('/').last.split('_').first.to_i
         end
 
@@ -426,6 +475,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

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -11,6 +11,7 @@ require 'active_record/connection_adapters/abstract/quoting'
 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'
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -29,6 +30,7 @@ module ActiveRecord
     # notably, the instance methods provided by SchemaStatement are very useful.
     class AbstractAdapter
       include Quoting, DatabaseStatements, SchemaStatements
+      include DatabaseLimits
       include QueryCache
       include ActiveSupport::Callbacks
       define_callbacks :checkout, :checkin

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -454,10 +454,11 @@ module ActiveRecord
           if current_index != row[2]
             next if row[2] == "PRIMARY" # skip the primary key
             current_index = row[2]
-            indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [])
+            indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [], [])
           end
 
           indexes.last.columns << row[4]
+          indexes.last.lengths << row[7]
         end
         result.free
         indexes
@@ -480,6 +481,13 @@ module ActiveRecord
         execute "RENAME TABLE #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
       end
 
+      def add_column(table_name, column_name, type, options = {})
+        add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        add_column_options!(add_column_sql, options)
+        add_column_position!(add_column_sql, options)
+        execute(add_column_sql)
+      end
+
       def change_column_default(table_name, column_name, default) #:nodoc:
         column = column_for(table_name, column_name)
         change_column table_name, column_name, column.sql_type, :default => default
@@ -508,6 +516,7 @@ module ActiveRecord
 
         change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
         add_column_options!(change_column_sql, options)
+        add_column_position!(change_column_sql, options)
         execute(change_column_sql)
       end
 
@@ -539,6 +548,13 @@ module ActiveRecord
         end
       end
 
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+      end
 
       # SHOW VARIABLES LIKE 'name'
       def show_variable(name)
@@ -571,6 +587,20 @@ module ActiveRecord
         where_sql
       end
 
+      protected
+        def quoted_columns_for_index(column_names, options = {})
+          length = options[:length] if options.is_a?(Hash)
+
+          quoted_column_names = case length
+          when Hash
+            column_names.map {|name| length[name] ? "#{quote_column_name(name)}(#{length[name]})" : quote_column_name(name) }
+          when Fixnum
+            column_names.map {|name| "#{quote_column_name(name)}(#{length})"}
+          else
+            column_names.map {|name| quote_column_name(name) }
+          end
+        end
+
       private
         def connect
           encoding = @config[:encoding]

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -261,20 +261,12 @@ module ActiveRecord
         true
       end
 
-      # Does PostgreSQL support standard conforming strings?
-      def supports_standard_conforming_strings?
-        # Temporarily set the client message level above error to prevent unintentional
-        # error messages in the logs when working on a PostgreSQL database server that
-        # does not support standard conforming strings.
-        client_min_messages_old = client_min_messages
-        self.client_min_messages = 'panic'
-
-        # postgres-pr does not raise an exception when client_min_messages is set higher
-        # than error and "SHOW standard_conforming_strings" fails, but returns an empty
-        # PGresult instead.
-        has_support = query('SHOW standard_conforming_strings')[0][0] rescue false
-        self.client_min_messages = client_min_messages_old
-        has_support
+      # Enable standard-conforming strings if available.
+      def set_standard_conforming_strings
+        old, self.client_min_messages = client_min_messages, 'panic'
+        execute('SET standard_conforming_strings = on') rescue nil
+      ensure
+        self.client_min_messages = old
       end
 
       def supports_insert_with_returning?
@@ -298,7 +290,7 @@ module ActiveRecord
       # QUOTING ==================================================
 
       # Escapes binary strings for bytea input to the database.
-      def escape_bytea(value)
+      def escape_bytea(original_value)
         if @connection.respond_to?(:escape_bytea)
           self.class.instance_eval do
             define_method(:escape_bytea) do |value|
@@ -322,62 +314,40 @@ module ActiveRecord
             end
           end
         end
-        escape_bytea(value)
+        escape_bytea(original_value)
       end
 
       # Unescapes bytea output from a database to the binary string it represents.
       # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
       #       on escaped binary output from database drive.
-      def unescape_bytea(value)
+      def unescape_bytea(original_value)
         # In each case, check if the value actually is escaped PostgreSQL bytea output
         # or an unescaped Active Record attribute that was just written.
-        if PGconn.respond_to?(:unescape_bytea)
+        if @connection.respond_to?(:unescape_bytea)
           self.class.instance_eval do
             define_method(:unescape_bytea) do |value|
-              if value =~ /\\\d{3}/
-                PGconn.unescape_bytea(value)
-              else
-                value
-              end
+              @connection.unescape_bytea(value) if value
             end
           end
-        else
+        elsif PGconn.respond_to?(:unescape_bytea)
           self.class.instance_eval do
             define_method(:unescape_bytea) do |value|
-              if value =~ /\\\d{3}/
-                result = ''
-                i, max = 0, value.size
-                while i < max
-                  char = value[i]
-                  if char == ?\\
-                    if value[i+1] == ?\\
-                      char = ?\\
-                      i += 1
-                    else
-                      char = value[i+1..i+3].oct
-                      i += 3
-                    end
-                  end
-                  result << char
-                  i += 1
-                end
-                result
-              else
-                value
-              end
+              PGconn.unescape_bytea(value) if value
             end
           end
+        else
+          raise 'Your PostgreSQL connection does not support unescape_bytea. Try upgrading to pg 0.9.0 or later.'
         end
-        unescape_bytea(value)
+        unescape_bytea(original_value)
       end
 
       # Quotes PostgreSQL-specific data types for SQL input.
       def quote(value, column = nil) #:nodoc:
         if value.kind_of?(String) && column && column.type == :binary
-          "#{quoted_string_prefix}'#{escape_bytea(value)}'"
-        elsif value.kind_of?(String) && column && column.sql_type =~ /^xml$/
-          "xml E'#{quote_string(value)}'"
-        elsif value.kind_of?(Numeric) && column && column.sql_type =~ /^money$/
+          "'#{escape_bytea(value)}'"
+        elsif value.kind_of?(String) && column && column.sql_type == 'xml'
+          "xml '#{quote_string(value)}'"
+        elsif value.kind_of?(Numeric) && column && column.sql_type == 'money'
           # Not truly string input, so doesn't require (or allow) escape string syntax.
           "'#{value.to_s}'"
         elsif value.kind_of?(String) && column && column.sql_type =~ /^bit/
@@ -393,7 +363,7 @@ module ActiveRecord
       end
 
       # Quotes strings for use in SQL input in the postgres driver for better performance.
-      def quote_string(s) #:nodoc:
+      def quote_string(original_value) #:nodoc:
         if @connection.respond_to?(:escape)
           self.class.instance_eval do
             define_method(:quote_string) do |s|
@@ -413,7 +383,7 @@ module ActiveRecord
             remove_method(:quote_string)
           end
         end
-        quote_string(s)
+        quote_string(original_value)
       end
 
       # Checks the following cases:
@@ -889,9 +859,12 @@ module ActiveRecord
         execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
       end
 
-      # Drops an index from a table.
-      def remove_index(table_name, options = {})
-        execute "DROP INDEX #{quote_table_name(index_name(table_name, options))}"
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_table_name(index_name)}"
+      end
+
+      def index_name_length
+        63
       end
 
       # Maps logical Rails types to PostgreSQL-specific data types.
@@ -971,17 +944,6 @@ module ActiveRecord
           # Ignore async_exec and async_query when using postgres-pr.
           @async = @config[:allow_concurrency] && @connection.respond_to?(:async_exec)
 
-          # Use escape string syntax if available. We cannot do this lazily when encountering
-          # the first string, because that could then break any transactions in progress.
-          # See: http://www.postgresql.org/docs/current/static/runtime-config-compatible.html
-          # If PostgreSQL doesn't know the standard_conforming_strings parameter then it doesn't
-          # support escape string syntax. Don't override the inherited quoted_string_prefix.
-          if supports_standard_conforming_strings?
-            self.class.instance_eval do
-              define_method(:quoted_string_prefix) { 'E' }
-            end
-          end
-
           # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
           # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
           # should know about this but can't detect it there, so deal with it here.
@@ -1011,6 +973,9 @@ module ActiveRecord
           end
           self.client_min_messages = @config[:min_messages] if @config[:min_messages]
           self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
+
+          # Use standard-conforming strings if available so we don't have to do the E'...' dance.
+          set_standard_conforming_strings
         end
 
         # Returns the current ID of a table's sequence.