activerecord 3.0.0 → 4.0.0

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

@@ -2,52 +2,62 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseLimits
 
-      # the maximum length of a table alias
+      # Returns the maximum length of a table alias.
       def table_alias_length
         255
       end
 
-      # the maximum length of a column name
+      # Returns the maximum length of a column name.
       def column_name_length
         64
       end
 
-      # the maximum length of a table name
+      # Returns the maximum length of a table name.
       def table_name_length
         64
       end
 
-      # the maximum length of an index name
+      # Returns the maximum allowed length for an index name. This
+      # limit is enforced by rails and Is less than or equal to
+      # <tt>index_name_length</tt>. The gap between
+      # <tt>index_name_length</tt> is to allow internal rails
+      # operations to use prefixes in temporary operations.
+      def allowed_index_name_length
+        index_name_length
+      end
+
+      # Returns the maximum length of an index name.
       def index_name_length
         64
       end
 
-      # the maximum number of columns per table
+      # Returns the maximum number of columns per table.
       def columns_per_table
         1024
       end
 
-      # the maximum number of indexes per table
+      # Returns the maximum number of indexes per table.
       def indexes_per_table
         16
       end
 
-      # the maximum number of columns in a multicolumn index
+      # Returns 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
+      # Returns the maximum number of elements in an IN (x,y,z) clause.
+      # nil means no limit.
       def in_clause_length
-        65535
+        nil
       end
 
-      # the maximum length of an SQL query
+      # Returns the maximum length of an SQL query.
       def sql_query_length
         1048575
       end
 
-      # maximum number of joins in a single query
+      # Returns maximum number of joins in a single query.
       def joins_per_query
         256
       end

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

@@ -1,30 +1,47 @@
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module DatabaseStatements
+      def initialize
+        super
+        reset_transaction
+      end
+
+      # Converts an arel AST to SQL
+      def to_sql(arel, binds = [])
+        if arel.respond_to?(:ast)
+          binds = binds.dup
+          visitor.accept(arel.ast) do
+            quote(*binds.shift.reverse)
+          end
+        else
+          arel
+        end
+      end
+
       # Returns an array of record hashes with the column names as keys and
       # column values as values.
-      def select_all(sql, name = nil)
-        select(sql, name)
+      def select_all(arel, name = nil, binds = [])
+        select(to_sql(arel, binds), name, binds)
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(sql, name = nil)
-        result = select_all(sql, name)
+      def select_one(arel, name = nil, binds = [])
+        result = select_all(arel, name, binds)
         result.first if result
       end
 
       # Returns a single value from a record
-      def select_value(sql, name = nil)
-        if result = select_one(sql, name)
+      def select_value(arel, name = nil, binds = [])
+        if result = select_one(arel, name, binds)
           result.values.first
         end
       end
 
       # Returns an array of the values of the first column in a select:
       #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
-      def select_values(sql, name = nil)
-        result = select_rows(sql, name)
+      def select_values(arel, name = nil)
+        result = select_rows(to_sql(arel, []), name)
         result.map { |v| v[0] }
       end
 
@@ -35,37 +52,65 @@ module ActiveRecord
       undef_method :select_rows
 
       # Executes the SQL statement in the context of this connection.
-      def execute(sql, name = nil, skip_logging = false)
+      def execute(sql, name = nil)
       end
       undef_method :execute
 
+      # Executes +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_query(sql, name = 'SQL', binds = [])
+      end
+
+      # Executes insert +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes delete +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_delete(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
+      # Executes update +sql+ statement in the context of this connection using
+      # +binds+ as the bind substitutes. +name+ is logged along with
+      # the executed +sql+ statement.
+      def exec_update(sql, name, binds)
+        exec_query(sql, name, binds)
+      end
+
       # Returns the last auto-generated ID from the affected table.
-      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        insert_sql(sql, name, pk, id_value, sequence_name)
+      #
+      # +id_value+ will be returned unless the value is nil, in
+      # which case the database will attempt to calculate the last inserted
+      # id and return that value.
+      #
+      # If the next id was calculated in advance (as in Oracle), it should be
+      # passed in as +id_value+.
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds)
+        value      = exec_insert(sql, name, binds, pk, sequence_name)
+        id_value || last_inserted_id(value)
       end
 
       # Executes the update statement and returns the number of rows affected.
-      def update(sql, name = nil)
-        update_sql(sql, name)
+      def update(arel, name = nil, binds = [])
+        exec_update(to_sql(arel, binds), name, binds)
       end
 
       # Executes the delete statement and returns the number of rows affected.
-      def delete(sql, name = nil)
-        delete_sql(sql, name)
+      def delete(arel, name = nil, binds = [])
+        exec_delete(to_sql(arel, binds), name, binds)
       end
 
-      # Checks whether there is currently no transaction active. This is done
-      # by querying the database driver, and does not use the transaction
-      # house-keeping information recorded by #increment_open_transactions and
-      # friends.
-      #
-      # Returns true if there is no transaction active, false if there is a
-      # transaction active, and nil if this information is unknown.
-      #
-      # Not all adapters supports transaction state introspection. Currently,
-      # only the PostgreSQL adapter supports this.
-      def outside_transaction?
-        nil
+      # Returns +true+ when the connection adapter supports prepared statement
+      # caching, otherwise returns +false+
+      def supports_statement_cache?
+        false
       end
 
       # Runs the given block in a database transaction, and returns the result
@@ -79,8 +124,9 @@ module ActiveRecord
       #
       # In order to get around this problem, #transaction will emulate the effect
       # of nested transactions, by using savepoints:
-      # http://dev.mysql.com/doc/refman/5.0/en/savepoints.html
-      # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
+      # http://dev.mysql.com/doc/refman/5.0/en/savepoint.html
+      # Savepoints are supported by MySQL and PostgreSQL. SQLite3 version >= '3.6.8'
+      # supports savepoints.
       #
       # It is safe to call this method if a database transaction is already open,
       # i.e. if #transaction is called within another #transaction block. In case
@@ -105,95 +151,124 @@ module ActiveRecord
       # already-automatically-released savepoints:
       #
       #   Model.connection.transaction do  # BEGIN
-      #     Model.connection.transaction(:requires_new => true) do  # CREATE SAVEPOINT active_record_1
+      #     Model.connection.transaction(requires_new: true) do  # CREATE SAVEPOINT active_record_1
       #       Model.connection.create_table(...)
       #       # active_record_1 now automatically released
       #     end  # RELEASE SAVEPOINT active_record_1  <--- BOOM! database error!
       #   end
+      #
+      # == Transaction isolation
+      #
+      # If your database supports setting the isolation level for a transaction, you can set
+      # it like so:
+      #
+      #   Post.transaction(isolation: :serializable) do
+      #     # ...
+      #   end
+      #
+      # Valid isolation levels are:
+      #
+      # * <tt>:read_uncommitted</tt>
+      # * <tt>:read_committed</tt>
+      # * <tt>:repeatable_read</tt>
+      # * <tt>:serializable</tt>
+      #
+      # You should consult the documentation for your database to understand the
+      # semantics of these different levels:
+      #
+      # * http://www.postgresql.org/docs/9.1/static/transaction-iso.html
+      # * https://dev.mysql.com/doc/refman/5.0/en/set-transaction.html
+      #
+      # An <tt>ActiveRecord::TransactionIsolationError</tt> will be raised if:
+      #
+      # * The adapter does not support setting the isolation level
+      # * You are joining an existing open transaction
+      # * You are creating a nested (savepoint) transaction
+      #
+      # The mysql, mysql2 and postgresql adapters support setting the transaction
+      # isolation level. However, support is disabled for mysql versions below 5,
+      # because they are affected by a bug[http://bugs.mysql.com/bug.php?id=39170]
+      # which means the isolation level gets persisted outside the transaction.
       def transaction(options = {})
-        options.assert_valid_keys :requires_new, :joinable
+        options.assert_valid_keys :requires_new, :joinable, :isolation
+
+        if !options[:requires_new] && current_transaction.joinable?
+          if options[:isolation]
+            raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
+          end
 
-        last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
-        if options.has_key?(:joinable)
-          @transaction_joinable = options[:joinable]
+          yield
         else
-          @transaction_joinable = true
+          within_new_transaction(options) { yield }
         end
-        requires_new = options[:requires_new] || !last_transaction_joinable
-
-        transaction_open = false
-        @_current_transaction_records ||= []
+      rescue ActiveRecord::Rollback
+        # rollbacks are silently swallowed
+      end
 
-        begin
-          if block_given?
-            if requires_new || open_transactions == 0
-              if open_transactions == 0
-                begin_db_transaction
-              elsif requires_new
-                create_savepoint
-              end
-              increment_open_transactions
-              transaction_open = true
-              @_current_transaction_records.push([])
-            end
-            yield
-          end
-        rescue Exception => database_transaction_rollback
-          if transaction_open && !outside_transaction?
-            transaction_open = false
-            decrement_open_transactions
-            if open_transactions == 0
-              rollback_db_transaction
-              rollback_transaction_records(true)
-            else
-              rollback_to_savepoint
-              rollback_transaction_records(false)
-            end
-          end
-          raise unless database_transaction_rollback.is_a?(ActiveRecord::Rollback)
-        end
+      def within_new_transaction(options = {}) #:nodoc:
+        transaction = begin_transaction(options)
+        yield
+      rescue Exception => error
+        rollback_transaction if transaction
+        raise
       ensure
-        @transaction_joinable = last_transaction_joinable
-
-        if outside_transaction?
-          @open_transactions = 0
-        elsif transaction_open
-          decrement_open_transactions
-          begin
-            if open_transactions == 0
-              commit_db_transaction
-              commit_transaction_records
-            else
-              release_savepoint
-              save_point_records = @_current_transaction_records.pop
-              unless save_point_records.blank?
-                @_current_transaction_records.push([]) if @_current_transaction_records.empty?
-                @_current_transaction_records.last.concat(save_point_records)
-              end
-            end
-          rescue Exception => database_transaction_rollback
-            if open_transactions == 0
-              rollback_db_transaction
-              rollback_transaction_records(true)
-            else
-              rollback_to_savepoint
-              rollback_transaction_records(false)
-            end
-            raise
-          end
+        begin
+          commit_transaction unless error
+        rescue Exception
+          rollback_transaction
+          raise
         end
       end
 
+      def current_transaction #:nodoc:
+        @transaction
+      end
+
+      def transaction_open?
+        @transaction.open?
+      end
+
+      def begin_transaction(options = {}) #:nodoc:
+        @transaction = @transaction.begin(options)
+      end
+
+      def commit_transaction #:nodoc:
+        @transaction = @transaction.commit
+      end
+
+      def rollback_transaction #:nodoc:
+        @transaction = @transaction.rollback
+      end
+
+      def reset_transaction #:nodoc:
+        @transaction = ClosedTransaction.new(self)
+      end
+
       # Register a record with the current transaction so that its after_commit and after_rollback callbacks
       # can be called.
       def add_transaction_record(record)
-        last_batch = @_current_transaction_records.last
-        last_batch << record if last_batch
+        @transaction.add_record(record)
       end
 
       # Begins the transaction (and turns off auto-committing).
       def begin_db_transaction()    end
 
+      def transaction_isolation_levels
+        {
+          read_uncommitted: "READ UNCOMMITTED",
+          read_committed:   "READ COMMITTED",
+          repeatable_read:  "REPEATABLE READ",
+          serializable:     "SERIALIZABLE"
+        }
+      end
+
+      # Begins the transaction with the isolation level set. Raises an error by
+      # default; adapters that support setting the isolation level should implement
+      # this method.
+      def begin_isolated_db_transaction(isolation)
+        raise ActiveRecord::TransactionIsolationError, "adapter does not support setting transaction isolation"
+      end
+
       # Commits the transaction (and turns on auto-committing).
       def commit_db_transaction()   end
 
@@ -201,46 +276,31 @@ module ActiveRecord
       # done if the transaction block raises an exception or returns false.
       def rollback_db_transaction() end
 
-      # Appends +LIMIT+ and +OFFSET+ options to an SQL statement, or some SQL
-      # fragment that has the same semantics as LIMIT and OFFSET.
-      #
-      # +options+ must be a Hash which contains a +:limit+ option
-      # and an +:offset+ option.
-      #
-      # This method *modifies* the +sql+ parameter.
-      #
-      # ===== Examples
-      #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
-      # generates
-      #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
-
-      def add_limit_offset!(sql, options)
-        if limit = options[:limit]
-          sql << " LIMIT #{sanitize_limit(limit)}"
-        end
-        if offset = options[:offset]
-          sql << " OFFSET #{offset.to_i}"
-        end
-        sql
-      end
-
       def default_sequence_name(table, column)
         nil
       end
 
       # Set the sequence to the max value of the table's column.
       def reset_sequence!(table, column, sequence = nil)
-        # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
+        # Do nothing by default. Implement for PostgreSQL, Oracle, ...
       end
 
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
       def insert_fixture(fixture, table_name)
-        execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
+        columns = schema_cache.columns_hash(table_name)
+
+        key_list   = []
+        value_list = fixture.map do |name, value|
+          key_list << quote_column_name(name)
+          quote(value, columns[name])
+        end
+
+        execute "INSERT INTO #{quote_table_name(table_name)} (#{key_list.join(', ')}) VALUES (#{value_list.join(', ')})", 'Fixture Insert'
       end
 
       def empty_insert_statement_value
-        "VALUES(DEFAULT)"
+        "DEFAULT VALUES"
       end
 
       def case_sensitive_equality_operator
@@ -251,10 +311,53 @@ module ActiveRecord
         "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
       end
 
+      # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
+      #
+      # The +limit+ may be anything that can evaluate to a string via #to_s. It
+      # should look like an integer, or a comma-delimited list of integers, or
+      # an Arel SQL literal.
+      #
+      # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
+      # Returns the sanitized limit parameter, either as an integer, or as a
+      # string which contains a comma-delimited list of integers.
+      def sanitize_limit(limit)
+        if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
+          limit
+        elsif limit.to_s =~ /,/
+          Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
+        else
+          Integer(limit)
+        end
+      end
+
+      # The default strategy for an UPDATE with joins is to use a subquery. This doesn't work
+      # on mysql (even when aliasing the tables), but mysql allows using JOIN directly in
+      # an UPDATE statement, so in the mysql adapters we redefine this to do that.
+      def join_to_update(update, select) #:nodoc:
+        key = update.key
+        subselect = subquery_for(key, select)
+
+        update.where key.in(subselect)
+      end
+
+      def join_to_delete(delete, select, key) #:nodoc:
+        subselect = subquery_for(key, select)
+
+        delete.where key.in(subselect)
+      end
+
       protected
+
+        # Return a subquery for the given key using the join information.
+        def subquery_for(key, select)
+          subselect = select.clone
+          subselect.projections = [key]
+          subselect
+        end
+
         # Returns an array of record hashes with the column names as keys and
         # column values as values.
-        def select(sql, name = nil)
+        def select(sql, name = nil, binds = [])
         end
         undef_method :select
 
@@ -274,56 +377,14 @@ module ActiveRecord
           update_sql(sql, name)
         end
 
-        # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-        #
-        # +limit+ may be anything that can evaluate to a string via #to_s. It
-        # should look like an integer, or a comma-delimited list of integers.
-        #
-        # Returns the sanitized limit parameter, either as an integer, or as a
-        # string which contains a comma-delimited list of integers.
-        def sanitize_limit(limit)
-          if limit.to_s =~ /,/
-            limit.to_s.split(',').map{ |i| i.to_i }.join(',')
-          else
-            limit.to_i
-          end
-        end
-
-        # Send a rollback message to all records after they have been rolled back. If rollback
-        # is false, only rollback records since the last save point.
-        def rollback_transaction_records(rollback) #:nodoc
-          if rollback
-            records = @_current_transaction_records.flatten
-            @_current_transaction_records.clear
-          else
-            records = @_current_transaction_records.pop
-          end
-
-          unless records.blank?
-            records.uniq.each do |record|
-              begin
-                record.rolledback!(rollback)
-              rescue Exception => e
-                record.logger.error(e) if record.respond_to?(:logger) && record.logger
-              end
-            end
-          end
-        end
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        [sql, binds]
+      end
 
-        # Send a commit message to all records after they have been committed.
-        def commit_transaction_records #:nodoc
-          records = @_current_transaction_records.flatten
-          @_current_transaction_records.clear
-          unless records.blank?
-            records.uniq.each do |record|
-              begin
-                record.committed!
-              rescue Exception => e
-                record.logger.error(e) if record.respond_to?(:logger) && record.logger
-              end
-            end
-          end
-        end
+      def last_inserted_id(result)
+        row = result.rows.first
+        row && row.first
+      end
     end
   end
 end

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

@@ -1,19 +1,17 @@
-require 'active_support/core_ext/object/duplicable'
-
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module QueryCache
       class << self
-        def included(base)
+        def included(base) #:nodoc:
           dirties_query_cache base, :insert, :update, :delete
         end
 
         def dirties_query_cache(base, *method_names)
           method_names.each do |method_name|
             base.class_eval <<-end_code, __FILE__, __LINE__ + 1
-              def #{method_name}(*)                         # def update_with_query_dirty(*args)
+              def #{method_name}(*)                         # def update_with_query_dirty(*)
                 clear_query_cache if @query_cache_enabled   #   clear_query_cache if @query_cache_enabled
-                super                                       #   update_without_query_dirty(*args)
+                super                                       #   super
               end                                           # end
             end_code
           end
@@ -31,6 +29,14 @@ module ActiveRecord
         @query_cache_enabled = old
       end
 
+      def enable_query_cache!
+        @query_cache_enabled = true
+      end
+
+      def disable_query_cache!
+        @query_cache_enabled = false
+      end
+
       # Disable the query cache within the block.
       def uncached
         old, @query_cache_enabled = @query_cache_enabled, false
@@ -49,33 +55,41 @@ module ActiveRecord
         @query_cache.clear
       end
 
-      def select_all(*args)
-        if @query_cache_enabled
-          cache_sql(args.first) { super }
+      def select_all(arel, name = nil, binds = [])
+        if @query_cache_enabled && !locked?(arel)
+          sql = to_sql(arel, binds)
+          cache_sql(sql, binds) { super(sql, name, binds) }
         else
           super
         end
       end
 
       private
-        def cache_sql(sql)
-          result =
-            if @query_cache.has_key?(sql)
-              ActiveSupport::Notifications.instrument("sql.active_record",
-                :sql => sql, :name => "CACHE", :connection_id => self.object_id)
-              @query_cache[sql]
-            else
-              @query_cache[sql] = yield
-            end
 
-          if Array === result
-            result.collect { |row| row.dup }
+      def cache_sql(sql, binds)
+        result =
+          if @query_cache[sql].key?(binds)
+            ActiveSupport::Notifications.instrument("sql.active_record",
+              :sql => sql, :binds => binds, :name => "CACHE", :connection_id => object_id)
+            @query_cache[sql][binds]
           else
-            result.duplicable? ? result.dup : result
+            @query_cache[sql][binds] = yield
           end
-        rescue TypeError
-          result
+
+        # FIXME: we should guarantee that all cached items are Result
+        # objects.  Then we can avoid this conditional
+        if ActiveRecord::Result === result
+          result.dup
+        else
+          result.collect { |row| row.dup }
         end
+      end
+
+      # If arel is locked this is a SELECT ... FOR UPDATE or somesuch. Such
+      # queries should not be cached.
+      def locked?(arel)
+        arel.respond_to?(:locked) && arel.locked
+      end
     end
   end
 end