switchman 1.13.3 → 2.2.0

data/lib/switchman/active_record/finder_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module FinderMethods

data/lib/switchman/active_record/log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module LogSubscriber
@@ -18,18 +20,14 @@ module Switchman
         shard = "  [#{shard[:database_server_id]}:#{shard[:id]} #{shard[:env]}]" if shard
 
         unless (payload[:binds] || []).empty?
-          if ::Rails.version < '5.0.3'
-            binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
-          else
-            use_old_format = (::Rails.version < '5.1') ? (::Rails.version < '5.0.7') : (::Rails.version < '5.1.5')
-            args = use_old_format ?
-              [payload[:binds], payload[:type_casted_binds]] :
-              [payload[:type_casted_binds]]
-            casted_params = type_casted_binds(*args)
-            binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-              render_bind(attr, value)
-            }.inspect
-          end
+          use_old_format = (::Rails.version < '5.1.5')
+          args = use_old_format ?
+            [payload[:binds], payload[:type_casted_binds]] :
+            [payload[:type_casted_binds]]
+          casted_params = type_casted_binds(*args)
+          binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+            render_bind(attr, value)
+          }.inspect
         end
 
         name = colorize_payload_name(name, payload[:name])

data/lib/switchman/active_record/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module Migration
@@ -28,9 +30,53 @@ module Switchman
     end
 
     module Migrator
+      # significant change: just return MIGRATOR_SALT directly
+      # especially if you're going through pgbouncer, the database
+      # name you're accessing may not be consistent. it is NOT allowed
+      # to run migrations against multiple shards in the same database
+      # concurrently
       def generate_migrator_advisory_lock_id
-        shard_name_hash = Zlib.crc32(Shard.current.name)
-        ::ActiveRecord::Migrator::MIGRATOR_SALT * shard_name_hash
+        ::ActiveRecord::Migrator::MIGRATOR_SALT
+      end
+
+      if ::Rails.version >= '6.0'
+        # copy/paste from Rails 6.1
+        def with_advisory_lock
+          lock_id = generate_migrator_advisory_lock_id
+
+          with_advisory_lock_connection do |connection|
+            got_lock = connection.get_advisory_lock(lock_id)
+            raise ::ActiveRecord::ConcurrentMigrationError unless got_lock
+            load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
+            yield
+          ensure
+            if got_lock && !connection.release_advisory_lock(lock_id)
+              raise ::ActiveRecord::ConcurrentMigrationError.new(
+                ::ActiveRecord::ConcurrentMigrationError::RELEASE_LOCK_FAILED_MESSAGE
+              )
+            end
+          end
+        end
+
+        # significant change: strip out prefer_secondary from config
+        def with_advisory_lock_connection
+          pool = ::ActiveRecord::ConnectionAdapters::ConnectionHandler.new.establish_connection(
+            ::ActiveRecord::Base.connection_config.except(:prefer_secondary)
+          )
+
+          pool.with_connection { |connection| yield(connection) }
+        ensure
+          pool&.disconnect!
+        end
+      end
+    end
+
+    module MigrationContext
+      def migrations
+        return @migrations if instance_variable_defined?(:@migrations)
+        migrations_cache = Thread.current[:migrations_cache] ||= {}
+        key = Digest::MD5.hexdigest(migration_files.sort.join(','))
+        @migrations = migrations_cache[key] ||= super
       end
     end
   end

data/lib/switchman/active_record/model_schema.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module ModelSchema
       module ClassMethods
         def quoted_table_name
           @quoted_table_name ||= {}
-          @quoted_table_name[Shard.current.id] ||= connection.quote_table_name(table_name)
+          @quoted_table_name[Shard.current(shard_category).id] ||= connection.quote_table_name(table_name)
         end
       end
     end

data/lib/switchman/active_record/persistence.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module Persistence
       # touch reads the id attribute directly, so it's not relative to the current shard
-      def touch(*)
+      def touch(*, **)
         shard.activate(self.class.shard_category) { super }
       end
 
@@ -11,6 +13,15 @@ module Switchman
           shard.activate(self.class.shard_category) { super }
         end
       end
+
+      def delete
+        db = shard.database_server
+        if ::GuardRail.environment != db.guard_rail_environment
+          return db.unguard { super }
+        else
+          super
+        end
+      end
     end
   end
-end
+end

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module PostgreSQLAdapter
@@ -38,125 +40,163 @@ module Switchman
         select_values("SELECT * FROM unnest(current_schemas(false))")
       end
 
-      def use_qualified_names?
-        @config[:use_qualified_names]
+      def extract_schema_qualified_name(string)
+        name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(string.to_s)
+        if string && !name.schema
+          name.instance_variable_set(:@schema, shard.name)
+        end
+        [name.schema, name.identifier]
       end
 
-      def tables(name = nil)
-        schema = shard.name if use_qualified_names?
-
-        query(<<-SQL, 'SCHEMA').map { |row| row[0] }
-          SELECT tablename
-          FROM pg_tables
-          WHERE schemaname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
-        SQL
+      # significant change: use the shard name if no explicit schema
+      def quoted_scope(name = nil, type: nil)
+        schema, name = extract_schema_qualified_name(name)
+        type = \
+          case type
+          when "BASE TABLE"
+            "'r','p'"
+          when "VIEW"
+            "'v','m'"
+          when "FOREIGN TABLE"
+            "'f'"
+          end
+        scope = {}
+        scope[:schema] = quote(schema || shard.name)
+        scope[:name] = quote(name) if name
+        scope[:type] = type if type
+        scope
       end
 
-      if ::Rails.version >= '5.1'
-        def extract_schema_qualified_name(string)
-          name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(string.to_s)
-          if string && !name.schema && use_qualified_names?
-            name.instance_variable_set(:@schema, shard.name)
-          end
-          [name.schema, name.identifier]
+      if ::Rails.version < '6.0'
+        def tables(name = nil)
+          query(<<-SQL, 'SCHEMA').map { |row| row[0] }
+            SELECT tablename
+            FROM pg_tables
+            WHERE schemaname = '#{shard.name}'
+          SQL
         end
-      else
-        def data_source_exists?(name)
+
+        def view_exists?(name)
           name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
           return false unless name.identifier
-          if !name.schema && use_qualified_names?
+          if !name.schema
             name.instance_variable_set(:@schema, shard.name)
           end
 
-          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-            SELECT COUNT(*)
+          select_values(<<-SQL, 'SCHEMA').any?
+            SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
             AND c.relname = '#{name.identifier}'
-            AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+            AND n.nspname = '#{shard.name}'
           SQL
         end
-      end
 
-      def view_exists?(name)
-        name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-        return false unless name.identifier
-        if !name.schema && use_qualified_names?
-          name.instance_variable_set(:@schema, shard.name)
-        end
+        def indexes(table_name)
+          result = query(<<-SQL, 'SCHEMA')
+            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
+            FROM pg_class t
+            INNER JOIN pg_index d ON t.oid = d.indrelid
+            INNER JOIN pg_class i ON d.indexrelid = i.oid
+            WHERE i.relkind = 'i'
+              AND d.indisprimary = 'f'
+              AND t.relname = '#{table_name}'
+              AND t.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = '#{shard.name}' )
+            ORDER BY i.relname
+          SQL
 
-        select_values(<<-SQL, 'SCHEMA').any?
-          SELECT c.relname
-          FROM pg_class c
-          LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-          AND c.relname = '#{name.identifier}'
-          AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
-        SQL
-      end
 
-      def indexes(table_name)
-        schema = shard.name if use_qualified_names?
-
-        result = query(<<-SQL, 'SCHEMA')
-           SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
-           FROM pg_class t
-           INNER JOIN pg_index d ON t.oid = d.indrelid
-           INNER JOIN pg_class i ON d.indexrelid = i.oid
-           WHERE i.relkind = 'i'
-             AND d.indisprimary = 'f'
-             AND t.relname = '#{table_name}'
-             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'} )
-          ORDER BY i.relname
-        SQL
-
-
-        result.map do |row|
-          index_name = row[0]
-          unique = row[1] == true || row[1] == 't'
-          indkey = row[2].split(" ")
-          inddef = row[3]
-          oid = row[4]
-
-          columns = Hash[query(<<-SQL, "SCHEMA")]
-          SELECT a.attnum, a.attname
-          FROM pg_attribute a
-          WHERE a.attrelid = #{oid}
-          AND a.attnum IN (#{indkey.join(",")})
+          result.map do |row|
+            index_name = row[0]
+            unique = row[1] == true || row[1] == 't'
+            indkey = row[2].split(" ")
+            inddef = row[3]
+            oid = row[4]
+
+            columns = Hash[query(<<-SQL, "SCHEMA")]
+            SELECT a.attnum, a.attname
+            FROM pg_attribute a
+            WHERE a.attrelid = #{oid}
+            AND a.attnum IN (#{indkey.join(",")})
+            SQL
+
+            column_names = columns.stringify_keys.values_at(*indkey).compact
+
+            unless column_names.empty?
+              # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
+              desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
+              orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
+              where = inddef.scan(/WHERE (.+)$/).flatten[0]
+              using = inddef.scan(/USING (.+?) /).flatten[0].to_sym
+
+              if ::Rails.version >= "5.2"
+                ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, column_names, orders: orders, where: where, using: using)
+              else
+                ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, column_names, [], orders, where, nil, using)
+              end
+            end
+          end.compact
+        end
+
+        def index_name_exists?(table_name, index_name, _default = nil)
+          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
+              SELECT COUNT(*)
+              FROM pg_class t
+              INNER JOIN pg_index d ON t.oid = d.indrelid
+              INNER JOIN pg_class i ON d.indexrelid = i.oid
+              WHERE i.relkind = 'i'
+                AND i.relname = '#{index_name}'
+                AND t.relname = '#{table_name}'
+                AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = '#{shard.name}' )
           SQL
+        end
 
-          column_names = columns.stringify_keys.values_at(*indkey).compact
+        def foreign_keys(table_name)
+          # mostly copy-pasted from AR - only change is to the nspname condition for qualified names support
+          fk_info = select_all <<-SQL.strip_heredoc
+            SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
+            FROM pg_constraint c
+            JOIN pg_class t1 ON c.conrelid = t1.oid
+            JOIN pg_class t2 ON c.confrelid = t2.oid
+            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+            JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            WHERE c.contype = 'f'
+              AND t1.relname = #{quote(table_name)}
+              AND t3.nspname = '#{shard.name}'
+            ORDER BY c.conname
+          SQL
 
-          unless column_names.empty?
-            # add info on sort order for columns (only desc order is explicitly specified, asc is the default)
-            desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
-            orders = desc_order_columns.any? ? Hash[desc_order_columns.map {|order_column| [order_column, :desc]}] : {}
-            where = inddef.scan(/WHERE (.+)$/).flatten[0]
-            using = inddef.scan(/USING (.+?) /).flatten[0].to_sym
+          fk_info.map do |row|
+            options = {
+              column: row['column'],
+              name: row['name'],
+              primary_key: row['primary_key']
+            }
+
+            options[:on_delete] = extract_foreign_key_action(row['on_delete'])
+            options[:on_update] = extract_foreign_key_action(row['on_update'])
+
+            # strip the schema name from to_table if it matches
+            to_table = row['to_table']
+            to_table_qualified_name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(to_table)
+            if to_table_qualified_name.schema == shard.name
+              to_table = to_table_qualified_name.identifier
+            end
 
-            if ::Rails.version >= "5.2"
-              ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, column_names, orders: orders, where: where, using: using)
-            else
-              ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, index_name, unique, column_names, [], orders, where, nil, using)
+            ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, to_table, options)
+          end
+        end
+      else
+        def foreign_keys(table_name)
+          super.each do |fk|
+            to_table_qualified_name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(fk.to_table)
+            if to_table_qualified_name.schema == shard.name
+              fk.to_table = to_table_qualified_name.identifier
             end
           end
-        end.compact
-      end
-
-      def index_name_exists?(table_name, index_name, _default = nil)
-        schema = shard.name if use_qualified_names?
-
-        exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-            SELECT COUNT(*)
-            FROM pg_class t
-            INNER JOIN pg_index d ON t.oid = d.indrelid
-            INNER JOIN pg_class i ON d.indexrelid = i.oid
-            WHERE i.relkind = 'i'
-              AND i.relname = '#{index_name}'
-              AND t.relname = '#{table_name}'
-              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'} )
-        SQL
+        end
       end
 
       def quote_local_table_name(name)
@@ -169,59 +209,25 @@ module Switchman
       def quote_table_name(name)
         return quote_local_table_name(name) if @use_local_table_name
         name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-        if !name.schema && use_qualified_names?
+        if !name.schema
           name.instance_variable_set(:@schema, shard.name)
         end
         name.quoted
       end
 
-      def with_local_table_name
-        @use_local_table_name = true
-        yield
-      ensure
-        @use_local_table_name = false
+      def with_global_table_name(&block)
+        with_local_table_name(false, &block)
       end
 
-      def foreign_keys(table_name)
-        schema = shard.name if use_qualified_names?
-
-        # mostly copy-pasted from AR - only change is to the nspname condition for qualified names support
-        fk_info = select_all <<-SQL.strip_heredoc
-          SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
-          FROM pg_constraint c
-          JOIN pg_class t1 ON c.conrelid = t1.oid
-          JOIN pg_class t2 ON c.confrelid = t2.oid
-          JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
-          JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
-          JOIN pg_namespace t3 ON c.connamespace = t3.oid
-          WHERE c.contype = 'f'
-            AND t1.relname = #{quote(table_name)}
-            AND t3.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
-          ORDER BY c.conname
-        SQL
-
-        fk_info.map do |row|
-          options = {
-            column: row['column'],
-            name: row['name'],
-            primary_key: row['primary_key']
-          }
-
-          options[:on_delete] = extract_foreign_key_action(row['on_delete'])
-          options[:on_update] = extract_foreign_key_action(row['on_update'])
-
-          # strip the schema name from to_table if it matches
-          to_table = row['to_table']
-          to_table_qualified_name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(to_table)
-          if use_qualified_names? && to_table_qualified_name.schema == shard.name
-            to_table = to_table_qualified_name.identifier
-          end
-
-          ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, to_table, options)
-        end
+      def with_local_table_name(enable = true)
+        old_value = @use_local_table_name
+        @use_local_table_name = enable
+        yield
+      ensure
+        @use_local_table_name = old_value
       end
 
-      def add_index_options(_table_name, _column_name, _options = {})
+      def add_index_options(_table_name, _column_name, **)
         index_name, index_type, index_columns, index_options, algorithm, using = super
         algorithm = nil if DatabaseServer.creating_new_shard && algorithm == "CONCURRENTLY"
         [index_name, index_type, index_columns, index_options, algorithm, using]
@@ -248,6 +254,10 @@ module Switchman
 
         execute "ALTER INDEX #{quote_table_name(old_name)} RENAME TO #{quote_local_table_name(new_name)}"
       end
+
+      def columns(*)
+        with_local_table_name(false) { super }
+      end
     end
   end
 end

data/lib/switchman/active_record/predicate_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module PredicateBuilder
@@ -13,7 +15,7 @@ module Switchman
         def convert_to_id(value)
           case value
           when ::ActiveRecord::Base
-            value.send(primary_key)
+            value.id
           else
             super
           end

data/lib/switchman/active_record/query_cache.rb

@@ -1,122 +1,34 @@
+# frozen_string_literal: true
+
 module Switchman
   module ActiveRecord
     module QueryCache
-      if ::Rails.version < '5.0.1'
-        # thread local accessors to replace @query_cache_enabled
-        def query_cache
-          thread_cache = Thread.current[:query_cache] ||= {}
-          thread_cache[self.object_id] ||= Hash.new { |h,sql| h[sql] = {} }
-        end
-
-        def query_cache_enabled
-          Thread.current[:query_cache_enabled]
-        end
-
-        def query_cache_enabled=(value)
-          Thread.current[:query_cache_enabled] = value
-        end
-
-        # basically wholesale repeat of the methods from the original (see
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb),
-        # but with self.query_cache_enabled and self.query_cache_enabled= instead
-        # of @query_cache_enabled.
-
-        def enable_query_cache!
-          self.query_cache_enabled = true
-        end
-
-        def disable_query_cache!
-          self.query_cache_enabled = false
-        end
-
-        def cache
-          old, self.query_cache_enabled = query_cache_enabled, true
-          yield
-        ensure
-          self.query_cache_enabled = old
-          clear_query_cache unless self.query_cache_enabled
-        end
-
-        def uncached
-          old, self.query_cache_enabled = query_cache_enabled, false
-          yield
-        ensure
-          self.query_cache_enabled = old
-        end
-
-        def clear_query_cache
-          Thread.current[:query_cache]&.clear
-        end
-
-        def select_all(arel, name = nil, binds = [], preparable: nil)
-          if self.query_cache_enabled && !locked?(arel)
-            arel, binds = binds_from_relation(arel, binds)
-            sql = to_sql(arel, binds)
-            cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
-          else
-            super
-          end
-        end
-
-        # no reason to define these on the including class directly. the super
-        # works just as well from a method on the included module
-        [:insert, :update, :delete].each do |method_name|
-          class_eval <<-end_code, __FILE__, __LINE__ + 1
-            def #{method_name}(*args)
-              clear_query_cache if self.query_cache_enabled
-              super
-            end
-          end_code
-        end
-      end
 
       private
 
-      if ::Rails.version < '5.1'
-        def cache_sql(sql, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{self.shard.id}::#{sql}"
+      def cache_sql(sql, name, binds)
+        # have to include the shard id in the cache key because of switching dbs on the same connection
+        sql = "#{self.shard.id}::#{sql}"
+        @lock.synchronize do
           result =
               if query_cache[sql].key?(binds)
-                args = {:sql => sql, :binds => binds, :name => "CACHE", :connection_id => object_id}
-                args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.0.7'
-                ::ActiveSupport::Notifications.instrument("sql.active_record", args)
+                args = {
+                  sql: sql,
+                  binds: binds,
+                  name: name,
+                  connection_id: object_id,
+                  cached: true
+                }
+                args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.1.5'
+                ::ActiveSupport::Notifications.instrument(
+                    "sql.active_record",
+                    args
+                )
                 query_cache[sql][binds]
               else
                 query_cache[sql][binds] = yield
               end
-
-          if ::ActiveRecord::Result === result
-            result.dup
-          else
-            result.collect { |row| row.dup }
-          end
-        end
-      else
-        def cache_sql(sql, name, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{self.shard.id}::#{sql}"
-          @lock.synchronize do
-            result =
-                if query_cache[sql].key?(binds)
-                  args = {
-                    sql: sql,
-                    binds: binds,
-                    name: name,
-                    connection_id: object_id,
-                    cached: true
-                  }
-                  args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.1.5'
-                  ::ActiveSupport::Notifications.instrument(
-                      "sql.active_record",
-                      args
-                  )
-                  query_cache[sql][binds]
-                else
-                  query_cache[sql][binds] = yield
-                end
-            result.dup
-          end
+          result.dup
         end
       end
     end