activerecord 3.2.6 → 6.0.0

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

@@ -1,124 +1,196 @@
+# frozen_string_literal: true
+
 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)
-          visitor.accept(arel.ast) do
-            quote(*binds.shift.reverse)
+      def to_sql(arel_or_sql_string, binds = [])
+        sql, _ = to_sql_and_binds(arel_or_sql_string, binds)
+        sql
+      end
+
+      def to_sql_and_binds(arel_or_sql_string, binds = []) # :nodoc:
+        if arel_or_sql_string.respond_to?(:ast)
+          unless binds.empty?
+            raise "Passing bind parameters with an arel AST is forbidden. " \
+              "The values must be stored on the AST directly"
+          end
+
+          if prepared_statements
+            sql, binds = visitor.compile(arel_or_sql_string.ast, collector)
+
+            if binds.length > bind_params_length
+              unprepared_statement do
+                sql, binds = to_sql_and_binds(arel_or_sql_string)
+                visitor.preparable = false
+              end
+            end
+          else
+            sql = visitor.compile(arel_or_sql_string.ast, collector)
           end
+          [sql.freeze, binds]
+        else
+          visitor.preparable = false if prepared_statements
+          [arel_or_sql_string.dup.freeze, binds]
+        end
+      end
+      private :to_sql_and_binds
+
+      # This is used in the StatementCache object. It returns an object that
+      # can be used to query the database repeatedly.
+      def cacheable_query(klass, arel) # :nodoc:
+        if prepared_statements
+          sql, binds = visitor.compile(arel.ast, collector)
+          query = klass.query(sql)
         else
-          arel
+          collector = klass.partial_query_collector
+          parts, binds = visitor.compile(arel.ast, collector)
+          query = klass.partial_query(parts)
         end
+        [query, binds]
       end
 
-      # Returns an array of record hashes with the column names as keys and
-      # column values as values.
-      def select_all(arel, name = nil, binds = [])
-        select(to_sql(arel, binds), name, binds)
+      # Returns an ActiveRecord::Result instance.
+      def select_all(arel, name = nil, binds = [], preparable: nil)
+        arel = arel_from_relation(arel)
+        sql, binds = to_sql_and_binds(arel, binds)
+
+        if preparable.nil?
+          preparable = prepared_statements ? visitor.preparable : false
+        end
+
+        if prepared_statements && preparable
+          select_prepared(sql, name, binds)
+        else
+          select(sql, name, binds)
+        end
       end
 
       # Returns a record hash with the column names as keys and column values
       # as values.
-      def select_one(arel, name = nil)
-        result = select_all(arel, name)
-        result.first if result
+      def select_one(arel, name = nil, binds = [])
+        select_all(arel, name, binds).first
       end
 
       # Returns a single value from a record
-      def select_value(arel, name = nil)
-        if result = select_one(arel, name)
-          result.values.first
-        end
+      def select_value(arel, name = nil, binds = [])
+        single_value_from_rows(select_rows(arel, name, binds))
       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(arel, name = nil)
-        result = select_rows(to_sql(arel, []), name)
-        result.map { |v| v[0] }
+      def select_values(arel, name = nil, binds = [])
+        select_rows(arel, name, binds).map(&:first)
       end
 
       # Returns an array of arrays containing the field values.
       # Order is the same as that returned by +columns+.
-      def select_rows(sql, name = nil)
+      def select_rows(arel, name = nil, binds = [])
+        select_all(arel, name, binds).rows
+      end
+
+      def query_value(sql, name = nil) # :nodoc:
+        single_value_from_rows(query(sql, name))
+      end
+
+      def query_values(sql, name = nil) # :nodoc:
+        query(sql, name).map(&:first)
       end
-      undef_method :select_rows
 
-      # Executes the SQL statement in the context of this connection.
+      def query(sql, name = nil) # :nodoc:
+        exec_query(sql, name).rows
+      end
+
+      # Determines whether the SQL statement is a write query.
+      def write_query?(sql)
+        raise NotImplementedError
+      end
+
+      # Executes the SQL statement in the context of this connection and returns
+      # the raw result from the connection adapter.
+      # Note: depending on your database connector, the result returned by this
+      # method may be manually memory managed. Consider using the exec_query
+      # wrapper instead.
       def execute(sql, name = nil)
+        raise NotImplementedError
       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 = [])
+      def exec_query(sql, name = "SQL", binds = [], prepare: false)
+        raise NotImplementedError
       end
 
       # Executes insert +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_insert(sql, name, binds)
+      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+        sql, binds = sql_for_insert(sql, pk, binds)
         exec_query(sql, name, binds)
       end
 
       # Executes delete +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes. +name+ is the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_delete(sql, name, binds)
+      def exec_delete(sql, name = nil, 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 the logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_update(sql, name, binds)
+      def exec_update(sql, name = nil, binds = [])
         exec_query(sql, name, binds)
       end
 
-      # Returns the last auto-generated ID from the affected table.
+      # Executes an INSERT query and returns the new record's ID
       #
-      # +id_value+ will be returned unless the value is nil, in
+      # +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)
+        sql, binds = to_sql_and_binds(arel, binds)
+        value = exec_insert(sql, name, binds, pk, sequence_name)
         id_value || last_inserted_id(value)
       end
+      alias create insert
 
       # Executes the update statement and returns the number of rows affected.
       def update(arel, name = nil, binds = [])
-        exec_update(to_sql(arel, binds), name, binds)
+        sql, binds = to_sql_and_binds(arel, binds)
+        exec_update(sql, name, binds)
       end
 
       # Executes the delete statement and returns the number of rows affected.
       def delete(arel, name = nil, binds = [])
-        exec_delete(to_sql(arel, binds), name, binds)
+        sql, binds = to_sql_and_binds(arel, binds)
+        exec_delete(sql, 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
+      # Executes the truncate statement.
+      def truncate(table_name, name = nil)
+        execute(build_truncate_statements(table_name), name)
       end
 
-      # Returns +true+ when the connection adapter supports prepared statement
-      # caching, otherwise returns +false+
-      def supports_statement_cache?
-        false
+      def truncate_tables(*table_names) # :nodoc:
+        return if table_names.empty?
+
+        with_multi_statements do
+          disable_referential_integrity do
+            Array(build_truncate_statements(*table_names)).each do |sql|
+              execute_batch(sql, "Truncate Tables")
+            end
+          end
+        end
       end
 
       # Runs the given block in a database transaction, and returns the result
@@ -132,8 +204,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/savepoint.html
-      # Savepoints are supported by MySQL and PostgreSQL, but not SQLite3.
+      # https://dev.mysql.com/doc/refman/5.7/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
@@ -158,101 +231,112 @@ 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
-      def transaction(options = {})
-        options.assert_valid_keys :requires_new, :joinable
-
-        last_transaction_joinable = defined?(@transaction_joinable) ? @transaction_joinable : nil
-        if options.has_key?(:joinable)
-          @transaction_joinable = options[:joinable]
-        else
-          @transaction_joinable = true
-        end
-        requires_new = options[:requires_new] || !last_transaction_joinable
-
-        transaction_open = false
-        @_current_transaction_records ||= []
-
-        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
-      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
+      #
+      # == 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:
+      #
+      # * https://www.postgresql.org/docs/current/static/transaction-iso.html
+      # * https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html
+      #
+      # An ActiveRecord::TransactionIsolationError 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 mysql2 and postgresql adapters support setting the transaction
+      # isolation level.
+      def transaction(requires_new: nil, isolation: nil, joinable: true)
+        if !requires_new && current_transaction.joinable?
+          if isolation
+            raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
+          yield
+        else
+          transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable) { yield }
         end
+      rescue ActiveRecord::Rollback
+        # rollbacks are silently swallowed
+      end
+
+      attr_reader :transaction_manager #:nodoc:
+
+      delegate :within_new_transaction, :open_transactions, :current_transaction, :begin_transaction,
+               :commit_transaction, :rollback_transaction, :materialize_transactions,
+               :disable_lazy_transactions!, :enable_lazy_transactions!, to: :transaction_manager
+
+      def transaction_open?
+        current_transaction.open?
+      end
+
+      def reset_transaction #:nodoc:
+        @transaction_manager = ConnectionAdapters::TransactionManager.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
+        current_transaction.add_record(record)
+      end
+
+      def transaction_state
+        current_transaction.state
       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
 
       # Rolls back the transaction (and turns on auto-committing). Must be
       # done if the transaction block raises an exception or returns false.
-      def rollback_db_transaction() end
+      def rollback_db_transaction
+        exec_rollback_db_transaction
+      end
+
+      def exec_rollback_db_transaction() end #:nodoc:
+
+      def rollback_to_savepoint(name = nil)
+        exec_rollback_to_savepoint(name)
+      end
 
       def default_sequence_name(table, column)
         nil
@@ -265,126 +349,164 @@ module ActiveRecord
 
       # Inserts the given fixture into the table. Overridden in adapters that require
       # something beyond a simple insert (eg. Oracle).
+      # Most of adapters should implement `insert_fixtures_set` that leverages bulk SQL insert.
+      # We keep this method to provide fallback
+      # for databases like sqlite that do not support bulk inserts.
       def insert_fixture(fixture, table_name)
-        columns = Hash[columns(table_name).map { |c| [c.name, c] }]
-
-        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'
+        execute(build_fixture_sql(Array.wrap(fixture), table_name), "Fixture Insert")
       end
 
-      def empty_insert_statement_value
-        "VALUES(DEFAULT)"
-      end
+      def insert_fixtures_set(fixture_set, tables_to_delete = [])
+        fixture_inserts = build_fixture_statements(fixture_set)
+        table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
+        total_sql = Array(combine_multi_statements(table_deletes + fixture_inserts))
 
-      def case_sensitive_equality_operator
-        "="
+        with_multi_statements do
+          disable_referential_integrity do
+            transaction(requires_new: true) do
+              total_sql.each do |sql|
+                execute_batch(sql, "Fixtures Load")
+              end
+            end
+          end
+        end
       end
 
-      def limited_update_conditions(where_sql, quoted_table_name, quoted_primary_key)
-        "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{quoted_table_name} #{where_sql})"
+      def empty_insert_statement_value(primary_key = nil)
+        "DEFAULT VALUES"
       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.
+      # should look like an integer, 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:
-        subselect = select.clone
-        subselect.projections = [update.key]
-
-        update.where update.key.in(subselect)
-      end
-
-      protected
-        # Returns an array of record hashes with the column names as keys and
-        # column values as values.
-        def select(sql, name = nil, binds = [])
+      # Fixture value is quoted by Arel, however scalar values
+      # are not quotable. In this case we want to convert
+      # the column value to YAML.
+      def with_yaml_fallback(value) # :nodoc:
+        if value.is_a?(Hash) || value.is_a?(Array)
+          YAML.dump(value)
+        else
+          value
         end
-        undef_method :select
+      end
 
-        # Returns the last auto-generated ID from the affected table.
-        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      private
+        def execute_batch(sql, name = nil)
           execute(sql, name)
-          id_value
         end
 
-        # Executes the update statement and returns the number of rows affected.
-        def update_sql(sql, name = nil)
-          execute(sql, name)
-        end
+        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+        private_constant :DEFAULT_INSERT_VALUE
 
-        # Executes the delete statement and returns the number of rows affected.
-        def delete_sql(sql, name = nil)
-          update_sql(sql, name)
+        def default_insert_value(column)
+          DEFAULT_INSERT_VALUE
         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)
-          if rollback
-            records = @_current_transaction_records.flatten
-            @_current_transaction_records.clear
-          else
-            records = @_current_transaction_records.pop
-          end
+        def build_fixture_sql(fixtures, table_name)
+          columns = schema_cache.columns_hash(table_name)
 
-          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
+          values_list = fixtures.map do |fixture|
+            fixture = fixture.stringify_keys
+
+            unknown_columns = fixture.keys - columns.keys
+            if unknown_columns.any?
+              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+            end
+
+            columns.map do |name, column|
+              if fixture.key?(name)
+                type = lookup_cast_type_from_column(column)
+                with_yaml_fallback(type.serialize(fixture[name]))
+              else
+                default_insert_value(column)
               end
             end
           end
-        end
 
-        # Send a commit message to all records after they have been committed.
-        def commit_transaction_records
-          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
+          table = Arel::Table.new(table_name)
+          manager = Arel::InsertManager.new
+          manager.into(table)
+
+          if values_list.size == 1
+            values = values_list.shift
+            new_values = []
+            columns.each_key.with_index { |column, i|
+              unless values[i].equal?(DEFAULT_INSERT_VALUE)
+                new_values << values[i]
+                manager.columns << table[column]
               end
-            end
+            }
+            values_list << new_values
+          else
+            columns.each_key { |column| manager.columns << table[column] }
           end
+
+          manager.values = manager.create_values_list(values_list)
+          manager.to_sql
         end
 
-      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-        [sql, binds]
-      end
+        def build_fixture_statements(fixture_set)
+          fixture_set.map do |table_name, fixtures|
+            next if fixtures.empty?
+            build_fixture_sql(fixtures, table_name)
+          end.compact
+        end
 
-      def last_inserted_id(result)
-        row = result.rows.first
-        row && row.first
-      end
+        def build_truncate_statements(*table_names)
+          truncate_tables = table_names.map do |table_name|
+            "TRUNCATE TABLE #{quote_table_name(table_name)}"
+          end
+          combine_multi_statements(truncate_tables)
+        end
+
+        def with_multi_statements
+          yield
+        end
+
+        def combine_multi_statements(total_sql)
+          total_sql.join(";\n")
+        end
+
+        # Returns an ActiveRecord::Result instance.
+        def select(sql, name = nil, binds = [])
+          exec_query(sql, name, binds, prepare: false)
+        end
+
+        def select_prepared(sql, name = nil, binds = [])
+          exec_query(sql, name, binds, prepare: true)
+        end
+
+        def sql_for_insert(sql, pk, binds)
+          [sql, binds]
+        end
+
+        def last_inserted_id(result)
+          single_value_from_rows(result.rows)
+        end
+
+        def single_value_from_rows(rows)
+          row = rows.first
+          row && row.first
+        end
+
+        def arel_from_relation(relation)
+          if relation.is_a?(Relation)
+            relation.arel
+          else
+            relation
+          end
+        end
     end
   end
 end