activerecord 7.1.4.1 → 7.2.2.1

data/lib/active_record/tasks/database_tasks.rb

@@ -125,11 +125,11 @@ module ActiveRecord
       end
 
       def create_all
-        each_local_configuration do |db_config|
-          with_temporary_connection(db_config) do
-            create(db_config)
-          end
-        end
+        db_config = migration_connection.pool.db_config
+
+        each_local_configuration { |db_config| create(db_config) }
+
+        migration_class.establish_connection(db_config)
       end
 
       def setup_initial_database_yaml # :nodoc:
@@ -175,11 +175,12 @@ module ActiveRecord
 
       def prepare_all
         seed = false
+        dump_db_configs = []
 
         each_current_configuration(env) do |db_config|
           with_temporary_pool(db_config) do
             begin
-              database_initialized = migration_connection.schema_migration.table_exists?
+              database_initialized = migration_connection_pool.schema_migration.table_exists?
             rescue ActiveRecord::NoDatabaseError
               create(db_config)
               retry
@@ -197,15 +198,25 @@ module ActiveRecord
 
         each_current_environment(env) do |environment|
           db_configs_with_versions(environment).sort.each do |version, db_configs|
+            dump_db_configs |= db_configs
+
             db_configs.each do |db_config|
               with_temporary_pool(db_config) do
                 migrate(version)
-                dump_schema(db_config) if ActiveRecord.dump_schema_after_migration
               end
             end
           end
         end
 
+        # Dump schema for databases that were migrated.
+        if ActiveRecord.dump_schema_after_migration
+          dump_db_configs.each do |db_config|
+            with_temporary_pool(db_config) do
+              dump_schema(db_config)
+            end
+          end
+        end
+
         load_seed if seed
       end
 
@@ -248,7 +259,7 @@ module ActiveRecord
 
         check_target_version
 
-        migration_connection.migration_context.migrate(target_version) do |migration|
+        migration_connection_pool.migration_context.migrate(target_version) do |migration|
           if version.blank?
             scope.blank? || scope == migration.scope
           else
@@ -258,7 +269,7 @@ module ActiveRecord
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
-        migration_connection.schema_cache.clear!
+        migration_connection_pool.schema_cache.clear!
       ensure
         Migration.verbose = verbose_was
       end
@@ -266,9 +277,9 @@ module ActiveRecord
       def db_configs_with_versions(environment = env) # :nodoc:
         db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
 
-        with_temporary_connection_for_each(env: environment) do |conn|
-          db_config = conn.pool.db_config
-          versions_to_run = conn.migration_context.pending_migration_versions
+        with_temporary_pool_for_each(env: environment) do |pool|
+          db_config = pool.db_config
+          versions_to_run = pool.migration_context.pending_migration_versions
           target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
 
           versions_to_run.each do |version|
@@ -281,15 +292,15 @@ module ActiveRecord
       end
 
       def migrate_status
-        unless migration_connection.schema_migration.table_exists?
+        unless migration_connection_pool.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
         end
 
         # output
-        puts "\ndatabase: #{migration_connection.pool.db_config.database}\n\n"
+        puts "\ndatabase: #{migration_connection_pool.db_config.database}\n\n"
         puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
         puts "-" * 50
-        migration_connection.migration_context.migrations_status.each do |status, version, name|
+        migration_connection_pool.migration_context.migrations_status.each do |status, version, name|
           puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
         end
         puts
@@ -370,7 +381,7 @@ module ActiveRecord
           raise ArgumentError, "unknown format #{format.inspect}"
         end
 
-        migration_connection.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
+        migration_connection_pool.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
       ensure
         Migration.verbose = verbose_was
       end
@@ -382,11 +393,12 @@ module ActiveRecord
 
         return true unless file && File.exist?(file)
 
-        with_temporary_connection(db_config) do |connection|
-          return false unless connection.internal_metadata.enabled?
-          return false unless connection.internal_metadata.table_exists?
+        with_temporary_pool(db_config) do |pool|
+          internal_metadata = pool.internal_metadata
+          return false unless internal_metadata.enabled?
+          return false unless internal_metadata.table_exists?
 
-          connection.internal_metadata[:schema_sha1] == schema_sha1(file)
+          internal_metadata[:schema_sha1] == schema_sha1(file)
         end
       end
 
@@ -397,7 +409,7 @@ module ActiveRecord
 
         with_temporary_pool(db_config, clobber: true) do
           if schema_up_to_date?(db_config, format, file)
-            truncate_tables(db_config)
+            truncate_tables(db_config) unless ENV["SKIP_TEST_DATABASE_TRUNCATE"]
           else
             purge(db_config)
             load_schema(db_config, format, file)
@@ -419,11 +431,11 @@ module ActiveRecord
         case format
         when :ruby
           File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(migration_connection, file)
+            ActiveRecord::SchemaDumper.dump(migration_connection_pool, file)
           end
         when :sql
           structure_dump(db_config, filename)
-          if migration_connection.schema_migration.table_exists?
+          if migration_connection_pool.schema_migration.table_exists?
             File.open(filename, "a") do |f|
               f.puts migration_connection.dump_schema_information
               f.print "\n"
@@ -445,14 +457,26 @@ module ActiveRecord
         end
       end
 
-      def cache_dump_filename(db_config_name, schema_cache_path: nil)
-        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
-          "schema_cache.yml"
+      def cache_dump_filename(db_config_or_name, schema_cache_path: nil)
+        if db_config_or_name.is_a?(DatabaseConfigurations::DatabaseConfig)
+          schema_cache_path ||
+            db_config_or_name.schema_cache_path ||
+            schema_cache_env ||
+            db_config_or_name.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
         else
-          "#{db_config_name}_schema_cache.yml"
-        end
+          ActiveRecord.deprecator.warn(<<~MSG.squish)
+            Passing a database name to `cache_dump_filename` is deprecated and will be removed in Rails 8.0. Pass a
+            `ActiveRecord::DatabaseConfigurations::DatabaseConfig` object instead.
+          MSG
 
-        schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+          filename = if ActiveRecord::Base.configurations.primary?(db_config_or_name)
+            "schema_cache.yml"
+          else
+            "#{db_config_or_name}_schema_cache.yml"
+          end
+
+          schema_cache_path || schema_cache_env || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+        end
       end
 
       def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
@@ -484,29 +508,29 @@ module ActiveRecord
       # Dumps the schema cache in YAML format for the connection into the file
       #
       # ==== Examples
-      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
-      def dump_schema_cache(conn, filename)
-        conn.schema_cache.dump_to(filename)
+      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.lease_connection, "tmp/schema_dump.yaml")
+      def dump_schema_cache(conn_or_pool, filename)
+        conn_or_pool.schema_cache.dump_to(filename)
       end
 
       def clear_schema_cache(filename)
         FileUtils.rm_f filename, verbose: false
       end
 
-      def with_temporary_connection_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
+      def with_temporary_pool_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
         if name
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
-          with_temporary_connection(db_config, clobber: clobber, &block)
+          with_temporary_pool(db_config, clobber: clobber, &block)
         else
           ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
-            with_temporary_connection(db_config, clobber: clobber, &block)
+            with_temporary_pool(db_config, clobber: clobber, &block)
           end
         end
       end
 
-      def with_temporary_connection(db_config, clobber: false) # :nodoc:
+      def with_temporary_connection(db_config, clobber: false, &block) # :nodoc:
         with_temporary_pool(db_config, clobber: clobber) do |pool|
-          yield pool.connection
+          pool.with_connection(&block)
         end
       end
 
@@ -515,10 +539,25 @@ module ActiveRecord
       end
 
       def migration_connection # :nodoc:
-        migration_class.connection
+        migration_class.lease_connection
+      end
+
+      def migration_connection_pool # :nodoc:
+        migration_class.connection_pool
       end
 
       private
+        def schema_cache_env
+          if ENV["SCHEMA_CACHE"]
+            ActiveRecord.deprecator.warn(<<~MSG.squish)
+              Setting `ENV["SCHEMA_CACHE"]` is deprecated and will be removed in Rails 8.0.
+              Configure the `:schema_cache_path` in the database configuration instead.
+            MSG
+
+            nil
+          end
+        end
+
         def with_temporary_pool(db_config, clobber: false)
           original_db_config = migration_class.connection_db_config
           pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)
@@ -614,11 +653,11 @@ module ActiveRecord
 
         def check_current_protected_environment!(db_config)
           with_temporary_pool(db_config) do |pool|
-            connection = pool.connection
-            current = connection.migration_context.current_environment
-            stored  = connection.migration_context.last_stored_environment
+            migration_context = pool.migration_context
+            current = migration_context.current_environment
+            stored  = migration_context.last_stored_environment
 
-            if connection.migration_context.protected_environment?
+            if migration_context.protected_environment?
               raise ActiveRecord::ProtectedEnvironmentError.new(stored)
             end
 

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -71,7 +71,7 @@ module ActiveRecord
         attr_reader :db_config, :configuration_hash
 
         def connection
-          ActiveRecord::Base.connection
+          ActiveRecord::Base.lease_connection
         end
 
         def establish_connection(config = db_config)

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -88,7 +88,7 @@ module ActiveRecord
         attr_reader :db_config, :configuration_hash
 
         def connection
-          ActiveRecord::Base.connection
+          ActiveRecord::Base.lease_connection
         end
 
         def establish_connection(config = db_config)

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -66,11 +66,12 @@ module ActiveRecord
         attr_reader :db_config, :root
 
         def connection
-          ActiveRecord::Base.connection
+          ActiveRecord::Base.lease_connection
         end
 
         def establish_connection(config = db_config)
           ActiveRecord::Base.establish_connection(config)
+          connection.connect!
         end
 
         def run_cmd(cmd, args, out)

data/lib/active_record/test_fixtures.rb

@@ -53,20 +53,6 @@ module ActiveRecord
         self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
       end
 
-      def fixture_path # :nodoc:
-        ActiveRecord.deprecator.warn(<<~WARNING)
-          TestFixtures.fixture_path is deprecated and will be removed in Rails 7.2. Use .fixture_paths instead.
-          If multiple fixture paths have been configured with .fixture_paths, then .fixture_path will just return
-          the first path.
-        WARNING
-        fixture_paths.first
-      end
-
-      def fixture_path=(path) # :nodoc:
-        ActiveRecord.deprecator.warn("TestFixtures.fixture_path= is deprecated and will be removed in Rails 7.2. Use .fixture_paths= instead.")
-        self.fixture_paths = Array(path)
-      end
-
       def fixtures(*fixture_set_names)
         if fixture_set_names.first == :all
           raise StandardError, "No fixture path found. Please set `#{self}.fixture_paths`." if fixture_paths.blank?
@@ -79,7 +65,7 @@ module ActiveRecord
           fixture_set_names = fixture_set_names.flatten.map(&:to_s)
         end
 
-        self.fixture_table_names |= fixture_set_names
+        self.fixture_table_names = (fixture_table_names | fixture_set_names).sort
         setup_fixture_accessors(fixture_set_names)
       end
 
@@ -110,45 +96,76 @@ module ActiveRecord
       end
     end
 
-    def fixture_path # :nodoc:
-      ActiveRecord.deprecator.warn(<<~WARNING)
-        TestFixtures#fixture_path is deprecated and will be removed in Rails 7.2. Use #fixture_paths instead.
-        If multiple fixture paths have been configured with #fixture_paths, then #fixture_path will just return
-        the first path.
-      WARNING
-      fixture_paths.first
+    # Generic fixture accessor for fixture names that may conflict with other methods.
+    #
+    #   assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    #   assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    def fixture(fixture_set_name, *fixture_names)
+      active_record_fixture(fixture_set_name, *fixture_names)
     end
 
-    def run_in_transaction?
-      use_transactional_tests &&
-        !self.class.uses_transaction?(name)
-    end
-
-    def setup_fixtures(config = ActiveRecord::Base)
-      if pre_loaded_fixtures && !use_transactional_tests
-        raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+    private
+      def run_in_transaction?
+        use_transactional_tests &&
+          !self.class.uses_transaction?(name)
       end
 
-      @fixture_cache = {}
-      @fixture_connections = []
-      @@already_loaded_fixtures ||= {}
-      @connection_subscriber = nil
-      @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+      def setup_fixtures(config = ActiveRecord::Base)
+        if pre_loaded_fixtures && !use_transactional_tests
+          raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+        end
+
+        @fixture_cache = {}
+        @fixture_cache_key = [self.class.fixture_table_names.dup, self.class.fixture_paths.dup, self.class.fixture_class_names.dup]
+        @fixture_connection_pools = []
+        @@already_loaded_fixtures ||= {}
+        @connection_subscriber = nil
+        @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+
+        if run_in_transaction?
+          # Load fixtures once and begin transaction.
+          @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key]
+          unless @loaded_fixtures
+            @@already_loaded_fixtures.clear
+            @loaded_fixtures = @@already_loaded_fixtures[@fixture_cache_key] = load_fixtures(config)
+          end
 
-      # Load fixtures once and begin transaction.
-      if run_in_transaction?
-        if @@already_loaded_fixtures[self.class]
-          @loaded_fixtures = @@already_loaded_fixtures[self.class]
+          setup_transactional_fixtures
         else
+          # Load fixtures for every test.
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
           @loaded_fixtures = load_fixtures(config)
-          @@already_loaded_fixtures[self.class] = @loaded_fixtures
         end
 
+        # Instantiate fixtures for every test if requested.
+        instantiate_fixtures if use_instantiated_fixtures
+      end
+
+      def teardown_fixtures
+        # Rollback changes if a transaction is active.
+        if run_in_transaction?
+          teardown_transactional_fixtures
+        else
+          ActiveRecord::FixtureSet.reset_cache
+          invalidate_already_loaded_fixtures
+        end
+
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+      end
+
+      def invalidate_already_loaded_fixtures
+        @@already_loaded_fixtures.clear
+      end
+
+      def setup_transactional_fixtures
+        setup_shared_connection_pool
+
         # Begin transactions for connections already established
-        @fixture_connections = enlist_fixture_connections
-        @fixture_connections.each do |connection|
-          connection.begin_transaction joinable: false, _lazy: false
-          connection.pool.lock_thread = true if lock_threads
+        @fixture_connection_pools = ActiveRecord::Base.connection_handler.connection_pool_list(:writing)
+        @fixture_connection_pools.each do |pool|
+          pool.pin_connection!(lock_threads)
+          pool.lease_connection
         end
 
         # When connections are established in the future, begin a transaction too
@@ -157,59 +174,31 @@ module ActiveRecord
           shard = payload[:shard] if payload.key?(:shard)
 
           if connection_name
-            begin
-              connection = ActiveRecord::Base.connection_handler.retrieve_connection(connection_name, shard: shard)
-            rescue ConnectionNotEstablished
-              connection = nil
-            end
-
-            if connection
+            pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard: shard)
+            if pool
               setup_shared_connection_pool
 
-              if !@fixture_connections.include?(connection)
-                connection.begin_transaction joinable: false, _lazy: false
-                connection.pool.lock_thread = true if lock_threads
-                @fixture_connections << connection
+              unless @fixture_connection_pools.include?(pool)
+                pool.pin_connection!(lock_threads)
+                pool.lease_connection
+                @fixture_connection_pools << pool
               end
             end
           end
         end
-
-      # Load fixtures for every test.
-      else
-        ActiveRecord::FixtureSet.reset_cache
-        @@already_loaded_fixtures[self.class] = nil
-        @loaded_fixtures = load_fixtures(config)
       end
 
-      # Instantiate fixtures for every test if requested.
-      instantiate_fixtures if use_instantiated_fixtures
-    end
-
-    def teardown_fixtures
-      # Rollback changes if a transaction is active.
-      if run_in_transaction?
+      def teardown_transactional_fixtures
         ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
-        @fixture_connections.each do |connection|
-          connection.rollback_transaction if connection.transaction_open?
-          connection.pool.lock_thread = false
+        unless @fixture_connection_pools.map(&:unpin_connection!).all?
+          # Something caused the transaction to be committed or rolled back
+          # We can no longer trust the database is in a clean state.
+          @@already_loaded_fixtures.clear
         end
-        @fixture_connections.clear
+        @fixture_connection_pools.clear
         teardown_shared_connection_pool
-      else
-        ActiveRecord::FixtureSet.reset_cache
       end
 
-      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
-    end
-
-    def enlist_fixture_connections
-      setup_shared_connection_pool
-
-      ActiveRecord::Base.connection_handler.connection_pool_list(:writing).map(&:connection)
-    end
-
-    private
       # Shares the writing connection pool with connections on
       # other handlers.
       #
@@ -272,22 +261,30 @@ module ActiveRecord
         use_instantiated_fixtures != :no_instances
       end
 
-      def method_missing(name, *args, **kwargs, &block)
-        if fs_name = fixture_sets[name.to_s]
-          access_fixture(fs_name, *args, **kwargs, &block)
+      def method_missing(method, ...)
+        if fixture_sets.key?(method.name)
+          active_record_fixture(method, ...)
         else
           super
         end
       end
 
-      def respond_to_missing?(name, include_private = false)
-        if include_private && fixture_sets.key?(name.to_s)
+      def respond_to_missing?(method, include_private = false)
+        if include_private && fixture_sets.key?(method.name)
           true
         else
           super
         end
       end
 
+      def active_record_fixture(fixture_set_name, *fixture_names)
+        if fs_name = fixture_sets[fixture_set_name.name]
+          access_fixture(fs_name, *fixture_names)
+        else
+          raise StandardError, "No fixture set named '#{fixture_set_name.inspect}'"
+        end
+      end
+
       def access_fixture(fs_name, *fixture_names)
         force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
         return_single_record = fixture_names.size == 1

data/lib/active_record/testing/query_assertions.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Assertions
+    module QueryAssertions
+      # Asserts that the number of SQL queries executed in the given block matches the expected count.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_count(1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_count { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_queries_count(1, include_schema: true) { Post.columns }
+      #
+      def assert_queries_count(count = nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_count", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          if count
+            assert_equal count, queries.size, "#{queries.size} instead of #{count} queries were executed. Queries: #{queries.join("\n\n")}"
+          else
+            assert_operator queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+          result
+        end
+      end
+
+      # Asserts that no SQL queries are executed in the given block.
+      #
+      #   assert_no_queries { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related) are counted.
+      #
+      #   assert_no_queries(include_schema: true) { Post.columns }
+      #
+      def assert_no_queries(include_schema: false, &block)
+        assert_queries_count(0, include_schema: include_schema, &block)
+      end
+
+      # Asserts that the SQL queries executed in the given block match expected pattern.
+      #
+      #   # Check for exact number of queries
+      #   assert_queries_match(/LIMIT \?/, count: 1) { Post.first }
+      #
+      #   # Check for any number of queries
+      #   assert_queries_match(/LIMIT \?/) { Post.first }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are considered.
+      #
+      #   assert_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_queries_match(match, count: nil, include_schema: false, &block)
+        ActiveRecord::Base.lease_connection.materialize_transactions
+
+        counter = SQLCounter.new
+        ActiveSupport::Notifications.subscribed(counter, "sql.active_record") do
+          result = _assert_nothing_raised_or_warn("assert_queries_match", &block)
+          queries = include_schema ? counter.log_all : counter.log
+          matched_queries = queries.select { |query| match === query }
+
+          if count
+            assert_equal count, matched_queries.size, "#{matched_queries.size} instead of #{count} queries were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          else
+            assert_operator matched_queries.size, :>=, 1, "1 or more queries expected, but none were executed.#{queries.empty? ? '' : "\nQueries:\n#{queries.join("\n")}"}"
+          end
+
+          result
+        end
+      end
+
+      # Asserts that no SQL queries matching the pattern are executed in the given block.
+      #
+      #   assert_no_queries_match(/SELECT/i) { post.comments }
+      #
+      # If the +:include_schema+ option is provided, any queries (including schema related)
+      # that match the matcher are counted.
+      #
+      #   assert_no_queries_match(/FROM pg_attribute/i, include_schema: true) { Post.columns }
+      #
+      def assert_no_queries_match(match, include_schema: false, &block)
+        assert_queries_match(match, count: 0, include_schema: include_schema, &block)
+      end
+
+      class SQLCounter # :nodoc:
+        attr_reader :log_full, :log_all
+
+        def initialize
+          @log_full = []
+          @log_all = []
+        end
+
+        def log
+          @log_full.map(&:first)
+        end
+
+        def call(*, payload)
+          return if payload[:cached]
+
+          sql = payload[:sql]
+          @log_all << sql
+
+          unless payload[:name] == "SCHEMA"
+            bound_values = (payload[:binds] || []).map do |value|
+              value = value.value_for_database if value.respond_to?(:value_for_database)
+              value
+            end
+
+            @log_full << [sql, bound_values]
+          end
+        end
+      end
+    end
+  end
+end