activerecord 3.0.0.beta3 → 3.0.0.beta4

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
 
@@ -197,7 +199,7 @@ module ActiveRecord
         def log(sql, name)
           name ||= "SQL"
           result = nil
-          ActiveSupport::Notifications.instrument("active_record.sql",
+          ActiveSupport::Notifications.instrument("sql.active_record",
             :sql => sql, :name => name, :connection_id => self.object_id) do
             @runtime += Benchmark.ms { result = yield }
           end

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -3,48 +3,6 @@ require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 require 'set'
 
-module MysqlCompat #:nodoc:
-  # add all_hashes method to standard mysql-c bindings or pure ruby version
-  def self.define_all_hashes_method!
-    raise 'Mysql not loaded' unless defined?(::Mysql)
-
-    target = defined?(Mysql::Result) ? Mysql::Result : MysqlRes
-    return if target.instance_methods.include?('all_hashes') ||
-              target.instance_methods.include?(:all_hashes)
-
-    # Ruby driver has a version string and returns null values in each_hash
-    # C driver >= 2.7 returns null values in each_hash
-    if Mysql.const_defined?(:VERSION) && (Mysql::VERSION.is_a?(String) || Mysql::VERSION >= 20700)
-      target.class_eval <<-'end_eval'
-      def all_hashes                     # def all_hashes
-        rows = []                        #   rows = []
-        each_hash { |row| rows << row }  #   each_hash { |row| rows << row }
-        rows                             #   rows
-      end                                # end
-      end_eval
-
-    # adapters before 2.7 don't have a version constant
-    # and don't return null values in each_hash
-    else
-      target.class_eval <<-'end_eval'
-      def all_hashes                                            # def all_hashes
-        rows = []                                               #   rows = []
-        all_fields = fetch_fields.inject({}) { |fields, f|      #   all_fields = fetch_fields.inject({}) { |fields, f|
-          fields[f.name] = nil; fields                          #     fields[f.name] = nil; fields
-        }                                                       #   }
-        each_hash { |row| rows << all_fields.dup.update(row) }  #   each_hash { |row| rows << all_fields.dup.update(row) }
-        rows                                                    #   rows
-      end                                                       # end
-      end_eval
-    end
-
-    unless target.instance_methods.include?('all_hashes') ||
-           target.instance_methods.include?(:all_hashes)
-      raise "Failed to defined #{target.name}#all_hashes method. Mysql::VERSION = #{Mysql::VERSION.inspect}"
-    end
-  end
-end
-
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects.
@@ -57,17 +15,17 @@ module ActiveRecord
       password = config[:password].to_s
       database = config[:database]
 
-      # Require the MySQL driver and define Mysql::Result.all_hashes
       unless defined? Mysql
         begin
-          require_library_or_gem('mysql')
+          require 'mysql'
         rescue LoadError
-          $stderr.puts '!!! Please install the mysql gem and try again: gem install mysql.'
-          raise
+          raise "!!! Missing the mysql gem. Add it to your Gemfile: gem 'mysql', '2.8.1'"
         end
-      end
 
-      MysqlCompat.define_all_hashes_method!
+        unless defined?(Mysql::Result) && Mysql::Result.method_defined?(:each_hash)
+          raise "!!! Outdated mysql gem. Upgrade to 2.8.1 or later. In your Gemfile: gem 'mysql', '2.8.1'"
+        end
+      end
 
       mysql = Mysql.init
       mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslca] || config[:sslkey]
@@ -461,10 +419,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
@@ -594,6 +553,18 @@ module ActiveRecord
       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
 
         def translate_exception(exception, message)
           return super unless exception.respond_to?(:errno)
@@ -643,7 +614,8 @@ module ActiveRecord
         def select(sql, name = nil)
           @connection.query_with_result = true
           result = execute(sql, name)
-          rows = result.all_hashes
+          rows = []
+          result.each_hash { |row| rows << row }
           result.free
           rows
         end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -2,26 +2,12 @@ require 'active_record/connection_adapters/abstract_adapter'
 require 'active_support/core_ext/kernel/requires'
 require 'active_support/core_ext/object/blank'
 
-begin
-  require_library_or_gem 'pg'
-rescue LoadError => e
-  begin
-    require_library_or_gem 'postgres'
-    class PGresult
-      alias_method :nfields, :num_fields unless self.method_defined?(:nfields)
-      alias_method :ntuples, :num_tuples unless self.method_defined?(:ntuples)
-      alias_method :ftype, :type unless self.method_defined?(:ftype)
-      alias_method :cmd_tuples, :cmdtuples unless self.method_defined?(:cmd_tuples)
-    end
-  rescue LoadError
-    raise e
-  end
-end
-
 module ActiveRecord
   class Base
     # Establishes a connection to the database that's used by all Active Record objects
     def self.postgresql_connection(config) # :nodoc:
+      require 'pg'
+
       config = config.symbolize_keys
       host     = config[:host]
       port     = config[:port] || 5432
@@ -277,20 +263,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?
@@ -314,85 +292,23 @@ module ActiveRecord
       # QUOTING ==================================================
 
       # Escapes binary strings for bytea input to the database.
-      def escape_bytea(original_value)
-        if @connection.respond_to?(:escape_bytea)
-          self.class.instance_eval do
-            define_method(:escape_bytea) do |value|
-              @connection.escape_bytea(value) if value
-            end
-          end
-        elsif PGconn.respond_to?(:escape_bytea)
-          self.class.instance_eval do
-            define_method(:escape_bytea) do |value|
-              PGconn.escape_bytea(value) if value
-            end
-          end
-        else
-          self.class.instance_eval do
-            define_method(:escape_bytea) do |value|
-              if value
-                result = ''
-                value.each_byte { |c| result << sprintf('\\\\%03o', c) }
-                result
-              end
-            end
-          end
-        end
-        escape_bytea(original_value)
+      def escape_bytea(value)
+        @connection.escape_bytea(value) if 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(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)
-          self.class.instance_eval do
-            define_method(:unescape_bytea) do |value|
-              if value =~ /\\\d{3}/
-                PGconn.unescape_bytea(value)
-              else
-                value
-              end
-            end
-          end
-        else
-          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
-            end
-          end
-        end
-        unescape_bytea(original_value)
+      def unescape_bytea(value)
+        @connection.unescape_bytea(value) if 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)}'"
+          "'#{escape_bytea(value)}'"
         elsif value.kind_of?(String) && column && column.sql_type == 'xml'
-          "xml E'#{quote_string(value)}'"
+          "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}'"
@@ -408,28 +324,9 @@ module ActiveRecord
         end
       end
 
-      # Quotes strings for use in SQL input in the postgres driver for better performance.
-      def quote_string(original_value) #:nodoc:
-        if @connection.respond_to?(:escape)
-          self.class.instance_eval do
-            define_method(:quote_string) do |s|
-              @connection.escape(s)
-            end
-          end
-        elsif PGconn.respond_to?(:escape)
-          self.class.instance_eval do
-            define_method(:quote_string) do |s|
-              PGconn.escape(s)
-            end
-          end
-        else
-          # There are some incorrectly compiled postgres drivers out there
-          # that don't define PGconn.escape.
-          self.class.instance_eval do
-            remove_method(:quote_string)
-          end
-        end
-        quote_string(original_value)
+      # Quotes strings for use in SQL input.
+      def quote_string(s) #:nodoc:
+        @connection.escape(s)
       end
 
       # Checks the following cases:
@@ -593,12 +490,8 @@ module ActiveRecord
         execute "ROLLBACK"
       end
 
-      if defined?(PGconn::PQTRANS_IDLE)
-        # The ruby-pg driver supports inspecting the transaction status,
-        # while the ruby-postgres driver does not.
-        def outside_transaction?
-          @connection.transaction_status == PGconn::PQTRANS_IDLE
-        end
+      def outside_transaction?
+        @connection.transaction_status == PGconn::PQTRANS_IDLE
       end
 
       def create_savepoint
@@ -926,9 +819,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.
@@ -1005,22 +901,11 @@ 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.
-          PostgreSQLColumn.money_precision =
-            (postgresql_version >= 80300) ? 19 : 10
+          PostgreSQLColumn.money_precision = (postgresql_version >= 80300) ? 19 : 10
+
           configure_connection
         end
 
@@ -1036,7 +921,10 @@ 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
+
           # If using ActiveRecord's time zone support configure the connection to return
           # TIMESTAMP WITH ZONE types in UTC.
           execute("SET time zone 'UTC'") if ActiveRecord::Base.default_timezone == :utc

data/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -34,6 +34,10 @@ module ActiveRecord
         end
 
         def binary_to_string(value)
+          if value.respond_to?(:force_encoding) && value.encoding != Encoding::ASCII_8BIT
+            value = value.force_encoding(Encoding::ASCII_8BIT)
+          end
+
           value.gsub(/%00|%25/n) do |b|
             case b
               when "%00" then "\0"
@@ -217,8 +221,8 @@ module ActiveRecord
         column ? column['name'] : nil
       end
 
-      def remove_index(table_name, options={}) #:nodoc:
-        execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+      def remove_index!(table_name, index_name) #:nodoc:
+        execute "DROP INDEX #{quote_column_name(index_name)}"
       end
 
       def rename_table(name, new_name)

data/lib/active_record/counter_cache.rb

@@ -0,0 +1,105 @@
+module ActiveRecord
+  module CounterCache
+    # Resets one or more counter caches to their correct value using an SQL
+    # count query.  This is useful when adding new counter caches, or if the
+    # counter has been corrupted or modified directly by SQL.
+    #
+    # ==== Parameters
+    #
+    # * +id+ - The id of the object you wish to reset a counter on.
+    # * +counters+ - One or more counter names to reset
+    #
+    # ==== Examples
+    #
+    #   # For Post with id #1 records reset the comments_count
+    #   Post.reset_counters(1, :comments)
+    def reset_counters(id, *counters)
+      object = find(id)
+      counters.each do |association|
+        child_class = reflect_on_association(association.to_sym).klass
+        belongs_name = self.name.demodulize.underscore.to_sym
+        counter_name = child_class.reflect_on_association(belongs_name).counter_cache_column
+
+        self.unscoped.where(arel_table[self.primary_key].eq(object.id)).arel.update({
+          arel_table[counter_name] => object.send(association).count
+        })
+      end
+      return true
+    end
+
+    # A generic "counter updater" implementation, intended primarily to be
+    # used by increment_counter and decrement_counter, but which may also
+    # be useful on its own. It simply does a direct SQL update for the record
+    # with the given ID, altering the given hash of counters by the amount
+    # given by the corresponding value:
+    #
+    # ==== Parameters
+    #
+    # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
+    # * +counters+ - An Array of Hashes containing the names of the fields
+    #   to update as keys and the amount to update the field by as values.
+    #
+    # ==== Examples
+    #
+    #   # For the Post with id of 5, decrement the comment_count by 1, and
+    #   # increment the action_count by 1
+    #   Post.update_counters 5, :comment_count => -1, :action_count => 1
+    #   # Executes the following SQL:
+    #   # UPDATE posts
+    #   #    SET comment_count = comment_count - 1,
+    #   #        action_count = action_count + 1
+    #   #  WHERE id = 5
+    #
+    #   # For the Posts with id of 10 and 15, increment the comment_count by 1
+    #   Post.update_counters [10, 15], :comment_count => 1
+    #   # Executes the following SQL:
+    #   # UPDATE posts
+    #   #    SET comment_count = comment_count + 1,
+    #   #  WHERE id IN (10, 15)
+    def update_counters(id, counters)
+      updates = counters.map do |counter_name, value|
+        operator = value < 0 ? '-' : '+'
+        quoted_column = connection.quote_column_name(counter_name)
+        "#{quoted_column} = COALESCE(#{quoted_column}, 0) #{operator} #{value.abs}"
+      end
+
+      update_all(updates.join(', '), primary_key => id )
+    end
+
+    # Increment a number field by one, usually representing a count.
+    #
+    # This is used for caching aggregate values, so that they don't need to be computed every time.
+    # For example, a DiscussionBoard may cache post_count and comment_count otherwise every time the board is
+    # shown it would have to run an SQL query to find how many posts and comments there are.
+    #
+    # ==== Parameters
+    #
+    # * +counter_name+ - The name of the field that should be incremented.
+    # * +id+ - The id of the object that should be incremented.
+    #
+    # ==== Examples
+    #
+    #   # Increment the post_count column for the record with an id of 5
+    #   DiscussionBoard.increment_counter(:post_count, 5)
+    def increment_counter(counter_name, id)
+      update_counters(id, counter_name => 1)
+    end
+
+    # Decrement a number field by one, usually representing a count.
+    #
+    # This works the same as increment_counter but reduces the column value by 1 instead of increasing it.
+    #
+    # ==== Parameters
+    #
+    # * +counter_name+ - The name of the field that should be decremented.
+    # * +id+ - The id of the object that should be decremented.
+    #
+    # ==== Examples
+    #
+    #   # Decrement the post_count column for the record with an id of 5
+    #   DiscussionBoard.decrement_counter(:post_count, 5)
+    def decrement_counter(counter_name, id)
+      update_counters(id, counter_name => -1)
+    end
+  end
+end