rubocop-isucon 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c235faec7d2edaadc48681992ad139ffc81d0745e010d923132a509f8012daa3
-  data.tar.gz: eecb16448d52f4a48860171045e9fc6b6108ce68db7d5aa4601a6fcc865828b0
+  metadata.gz: 645e1a353538a4c8d8c8914ac76ac7fbb6f1338dbea8d10c16394a6711be725a
+  data.tar.gz: 450b780a05d2e4f5632bd2ffe35453390bfa1e1c4a240662e440b5cbb2e5390c
 SHA512:
-  metadata.gz: 2a82eca957548836926ef797d18ed5e014ab26c03407b1bdfd82a659b082479f1d5ede81c05baacd0c172b5856b38b839262fb9ba238618b03597f524f2ddeda
-  data.tar.gz: 3571157d23e59636c0af87617111d0146c00dedfe3da74f4b64fd4e4e108886ef32d1fa56f65f531578be251eca6f0c8182a263cec18c098c497cd9fcc8be6a3
+  metadata.gz: 5c900d876a05963ec323cb6e9a4aec8b6b3b9f35c9bc76910e43c758cf0b6b5203b1d53ee2cf050a7ccfe5f304b4158f6d43a85b72441c42726270e0518b6f83
+  data.tar.gz: 0cea7082761dd2bdc38792b0cd60fbccafa886bded25475fa848fb6c2cbab58ea3a370d5fcbb793ca02402c95aab495bfee8e63b3617f3e5b9420fde4d18070e

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
-[full changelog](http://github.com/sue445/rubocop-isucon/compare/v0.1.0...main)
+[full changelog](http://github.com/sue445/rubocop-isucon/compare/v0.2.0...main)
+
+* Add `Isucon/Sqlite3/SelectAsterisk`
+  * https://github.com/sue445/rubocop-isucon/pull/202
+* Add `Isucon/Sqlite3/WhereWithoutIndex`
+  * https://github.com/sue445/rubocop-isucon/pull/207
+* Add `Isucon/Sqlite3/JoinWithoutIndex`
+  * https://github.com/sue445/rubocop-isucon/pull/208
+* Add `Isucon/Sqlite3/ManyJoinTable`
+  * https://github.com/sue445/rubocop-isucon/pull/209
+* Add `Isucon/Sqlite3/NPlusOneQuery`
+  * https://github.com/sue445/rubocop-isucon/pull/210
+
+## [0.1.0] - 2022-07-31
+[full changelog](http://github.com/sue445/rubocop-isucon/compare/v0.1.0...v0.2.0)
 
 ## [0.1.0] - 2022-07-23
 

data/README.md

@@ -1,6 +1,7 @@
 # RuboCop ISUCON
 RuboCop plugin for ruby reference implementation of [ISUCON](https://github.com/isucon)
 
+[![Gem Version](https://badge.fury.io/rb/rubocop-isucon.svg)](https://badge.fury.io/rb/rubocop-isucon)
 [![Build Status](https://github.com/sue445/rubocop-isucon/workflows/test/badge.svg?branch=main)](https://github.com/sue445/rubocop-isucon/actions?query=workflow%3Atest)
 
 ## Installation
@@ -72,16 +73,25 @@ Isucon/Mysql2:
     password: isucon
     encoding: utf8
     port: 3306
+
+Isucon/Sqlite3:
+  Database:
+    adapter: sqlite3
+    database: # TODO: Fix this
 ```
 
 `Database` isn't configured in `.rubocop.yml`, some cops doesn't work
 
-| cop                               | offense detection          | auto-correct               |
-|-----------------------------------|----------------------------|----------------------------|
-| `Isucon/Mysql2/JoinWithoutIndex`  | `Database` is **required** | Not supported              |
-| `Isucon/Mysql2/NPlusOneQuery`     | `Database` is optional     | `Database` is **required** |
-| `Isucon/Mysql2/SelectAsterisk`    | `Database` is optional     | `Database` is **required** |
-| `Isucon/Mysql2/WhereWithoutIndex` | `Database` is **required** | Not supported              |
+| cop                                | offense detection          | auto-correct               |
+|------------------------------------|----------------------------|----------------------------|
+| `Isucon/Mysql2/JoinWithoutIndex`   | `Database` is **required** | Not supported              |
+| `Isucon/Mysql2/NPlusOneQuery`      | `Database` is optional     | `Database` is **required** |
+| `Isucon/Mysql2/SelectAsterisk`     | `Database` is optional     | `Database` is **required** |
+| `Isucon/Mysql2/WhereWithoutIndex`  | `Database` is **required** | Not supported              |
+| `Isucon/Sqlite3/JoinWithoutIndex`  | `Database` is **required** | Not supported              |
+| `Isucon/Sqlite3/NPlusOneQuery`     | `Database` is optional     | `Database` is **required** |
+| `Isucon/Sqlite3/SelectAsterisk`    | `Database` is optional     | `Database` is **required** |
+| `Isucon/Sqlite3/WhereWithoutIndex` | `Database` is **required** | Not supported              |
 
 ## Documentation
 See. https://sue445.github.io/rubocop-isucon/
@@ -89,6 +99,7 @@ See. https://sue445.github.io/rubocop-isucon/
 * `Isucon/Mysql2` department docs : https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Mysql2.html
 * `Isucon/Shell` department docs : https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Shell.html
 * `Isucon/Sinatra` department docs : https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Sinatra.html
+* `Isucon/Sqlite3` department docs : https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Sqlite3.html
 
 ## Benchmark
 See [benchmark/](benchmark/)

data/config/default.yml

@@ -81,3 +81,39 @@ Isucon/Sinatra/ServeStaticFile:
   Enabled: true
   VersionAdded: '0.1.0'
   StyleGuide: ServeStaticFile.html
+
+Isucon/Sqlite3:
+  StyleGuideBaseURL: https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Sqlite3/
+  Database:
+
+Isucon/Sqlite3/JoinWithoutIndex:
+  Description: 'Check for `JOIN` without index'
+  Enabled: true
+  VersionAdded: '0.2.0'
+  StyleGuide: JoinWithoutIndex.html
+
+Isucon/Sqlite3/ManyJoinTable:
+  Description: 'Check if SQL contains many JOINs'
+  Enabled: true
+  VersionAdded: '0.2.0'
+  StyleGuide: ManyJoinTable.html
+  CountTables: 3
+
+Isucon/Sqlite3/NPlusOneQuery:
+  Description: 'Checks that N+1 query is not used'
+  Enabled: true
+  VersionAdded: '0.2.0'
+  SafeAutoCorrect: false
+  StyleGuide: NPlusOneQuery.html
+
+Isucon/Sqlite3/SelectAsterisk:
+  Description: 'Avoid `SELECT *` in `db.execute`'
+  Enabled: true
+  VersionAdded: '0.2.0'
+  StyleGuide: SelectAsterisk.html
+
+Isucon/Sqlite3/WhereWithoutIndex:
+  Description: 'Check for `WHERE` without index'
+  Enabled: true
+  VersionAdded: '0.2.0'
+  StyleGuide: WhereWithoutIndex.html

data/lib/rubocop/cop/isucon/correctors/{mysql2_n_plus_one_query_corrector → n_plus_one_query_corrector}/correctable_methods.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Isucon
       module Correctors
-        class Mysql2NPlusOneQueryCorrector
+        class NPlusOneQueryCorrector
           # Check whether can correct
           module CorrectableMethods
             # @return [Boolean]

data/lib/rubocop/cop/isucon/correctors/{mysql2_n_plus_one_query_corrector → n_plus_one_query_corrector}/replace_methods.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Isucon
       module Correctors
-        class Mysql2NPlusOneQueryCorrector
+        class NPlusOneQueryCorrector
           # replace ast
           module ReplaceMethods
             def replace

data/lib/rubocop/cop/isucon/correctors/{mysql2_n_plus_one_query_corrector.rb → n_plus_one_query_corrector.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "mysql2_n_plus_one_query_corrector/correctable_methods"
-require_relative "mysql2_n_plus_one_query_corrector/replace_methods"
+require_relative "n_plus_one_query_corrector/correctable_methods"
+require_relative "n_plus_one_query_corrector/replace_methods"
 
 module RuboCop
   module Cop
@@ -21,7 +21,7 @@ module RuboCop
         #     @users_by_id ||= db.xquery('SELECT * FROM `users` WHERE `id` IN (?)', courses.map { |course| course[:teacher_id] }).each_with_object({}) { |v, hash| hash[v[:id]] = v }
         #     teacher = @users_by_id[course[:teacher_id]]
         #   end
-        class Mysql2NPlusOneQueryCorrector
+        class NPlusOneQueryCorrector
           # rubocop:enable Layout/LineLength
 
           include Mixin::Mysql2XqueryMethods
@@ -46,19 +46,24 @@ module RuboCop
           # @return [RuboCop::Isucon::DatabaseConnection]
           attr_reader :connection
 
+          # @return [Boolean]
+          attr_reader :is_array_arg
+
           # @param corrector [RuboCop::Cop::Corrector]
           # @param current_node [RuboCop::AST::Node]
           # @param parent_node [RuboCop::AST::Node]
           # @param type [Symbol] Node type. one of `:str`, `:dstr`
           # @param gda [RuboCop::Isucon::GDA::Client]
           # @param connection [RuboCop::Isucon::DatabaseConnection]
-          def initialize(corrector:, current_node:, parent_node:, type:, gda:, connection:) # rubocop:disable Metrics/ParameterLists
+          # @param is_array_arg [Boolean]
+          def initialize(corrector:, current_node:, parent_node:, type:, gda:, connection:, is_array_arg:) # rubocop:disable Metrics/ParameterLists
             @corrector = corrector
             @current_node = current_node
             @parent_node = parent_node
             @type = type
             @gda = gda
             @connection = connection
+            @is_array_arg = is_array_arg
           end
 
           def correct
@@ -67,6 +72,10 @@ module RuboCop
 
           private
 
+          def array_arg?
+            is_array_arg
+          end
+
           # @return [RuboCop::AST::Node,nil]
           def parent_receiver
             parent_node.child_nodes&.first&.receiver
@@ -88,6 +97,8 @@ module RuboCop
 
           # @return [RuboCop::AST::Node]
           def xquery_arg
+            return current_node.child_nodes[2].child_nodes[0] if array_arg? && current_node.child_nodes[2]&.array_type?
+
             current_node.child_nodes[2]
           end
 

data/lib/rubocop/cop/isucon/mixin/join_without_index_methods.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::JoinWithoutIndex}
+        # and {RuboCop::Cop::Isucon::Sqlite3::JoinWithoutIndex}
+        module JoinWithoutIndexMethods
+          include Mixin::DatabaseMethods
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_error_handling(node) do
+              return unless enabled_database?
+
+              with_db_query(node) do |type, root_gda|
+                check_and_register_offence(type: type, root_gda: root_gda, node: node)
+              end
+            end
+          end
+
+          private
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param node [RuboCop::AST::Node]
+          def check_and_register_offence(type:, root_gda:, node:)
+            return unless root_gda
+
+            root_gda.visit_all do |gda|
+              gda.join_conditions.each do |join_condition|
+                join_operand = join_operand_without_index(join_condition)
+                next unless join_operand
+
+                register_offense(type: type, node: node, join_operand: join_operand)
+              end
+            end
+          end
+
+          # @param join_condition [RuboCop::Isucon::GDA::JoinCondition]
+          # @return [RuboCop::Isucon::GDA::JoinOperand,nil]
+          def join_operand_without_index(join_condition)
+            join_condition.operands.each do |join_operand|
+              next unless join_operand.table_name
+
+              unless indexed_column?(table_name: join_operand.table_name, column_name: join_operand.column_name)
+                return join_operand
+              end
+            end
+
+            nil
+          end
+
+          # @param table_name [String]
+          # @param column_name [String]
+          # @return [Boolean]
+          def indexed_column?(table_name:, column_name:)
+            primary_keys = connection.primary_keys(table_name)
+
+            return true if primary_keys&.first == column_name
+
+            indexes = connection.indexes(table_name)
+            index_first_columns = indexes.map { |index| index.columns[0] }
+            index_first_columns.include?(column_name)
+          end
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param node [RuboCop::AST::Node]
+          # @param join_operand [RuboCop::Isucon::GDA::JoinOperand]
+          def register_offense(type:, node:, join_operand:)
+            loc = offense_location(type: type, node: node, gda_location: join_operand.node.location)
+            return unless loc
+
+            message = offense_message(join_operand)
+            add_offense(loc, message: message)
+          end
+
+          # @param join_operand [RuboCop::Isucon::GDA::JoinOperand]
+          def offense_message(join_operand)
+            generate_offense_message(table_name: join_operand.table_name, column_name: join_operand.column_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/many_join_table_methods.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::ManyJoinTable}
+        # and {RuboCop::Cop::Isucon::Sqlite3::ManyJoinTable}
+        module ManyJoinTableMethods
+          MSG = "Avoid SQL with lots of JOINs"
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_db_query(node) do |_, root_gda|
+              check_and_register_offence(root_gda: root_gda, node: node)
+            end
+          end
+
+          private
+
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param node [RuboCop::AST::Node]
+          def check_and_register_offence(root_gda:, node:)
+            return unless root_gda
+
+            root_gda.visit_all do |gda|
+              add_offense(node) if gda.table_names.count > count_tables
+            end
+          end
+
+          # @return [Integer]
+          def count_tables
+            cop_config["CountTables"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/mysql2_xquery_methods.rb

@@ -8,6 +8,8 @@ module RuboCop
         module Mysql2XqueryMethods
           extend NodePattern::Macros
 
+          include OffenceLocationMethods
+
           # @!method find_xquery(node)
           #   @param node [RuboCop::AST::Node]
           def_node_search :find_xquery, <<~PATTERN
@@ -22,7 +24,7 @@ module RuboCop
           # @yieldparam root_gda [RuboCop::Isucon::GDA::Client,nil]
           #
           # @note If arguments of `db.xquery` isn't string, `root_gda` is `nil`
-          def with_xquery(node)
+          def with_db_query(node)
             find_xquery(node) do |type, params|
               sql = xquery_param(type: type, params: params)
 
@@ -36,22 +38,13 @@ module RuboCop
             end
           end
 
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param node [RuboCop::AST::Node]
-          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
-          # @return [Parser::Source::Range,nil]
-          def offense_location(type:, node:, gda_location:)
-            return nil unless gda_location
-
-            begin_pos = begin_position_from_gda_location(type: type, node: node, gda_location: gda_location)
-            return nil unless begin_pos
+          private
 
-            end_pos = begin_pos + gda_location.length
-            Parser::Source::Range.new(node.loc.expression.source_buffer, begin_pos, end_pos)
+          # @return [Array<Symbol>]
+          def db_query_methods
+            %i[xquery query]
           end
 
-          private
-
           # @param type [Symbol] Node type. one of `:str`, `:dstr`
           # @param params [Array<RuboCop::AST::Node>]
           # @return [String,nil]
@@ -67,108 +60,6 @@ module RuboCop
             end
             nil
           end
-
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param node [RuboCop::AST::Node]
-          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
-          # @return [Integer,nil]
-          def begin_position_from_gda_location(type:, node:, gda_location:)
-            case type
-            when :str
-              return begin_position_from_gda_location_for_str(node: node, gda_location: gda_location)
-            when :dstr
-              return begin_position_from_gda_location_for_dstr(node: node, gda_location: gda_location)
-            end
-
-            nil
-          end
-
-          # @param node [RuboCop::AST::Node]
-          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
-          # @return [Integer,nil]
-          def begin_position_from_gda_location_for_str(node:, gda_location:)
-            str_node = node.child_nodes[1]
-            return nil unless str_node&.str_type?
-
-            str_node.loc.begin.end_pos + gda_location.begin_pos
-          end
-
-          # @param node [RuboCop::AST::Node]
-          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
-          # @return [Integer,nil]
-          def begin_position_from_gda_location_for_dstr(node:, gda_location:)
-            dstr_node = node.child_nodes[1]
-            return nil unless dstr_node&.dstr_type?
-
-            str_node = find_str_node_from_gda_location(dstr_node: dstr_node, gda_location: gda_location)
-            index = str_node.value.index(gda_location.body)
-            return nil unless index
-
-            str_node_begin_pos(str_node) + index + heredoc_indent_level(node)
-          end
-
-          # @param str_node [RuboCop::AST::StrNode]
-          # @return [Integer]
-          def str_node_begin_pos(str_node)
-            begin_pos = str_node.loc.expression.begin_pos
-
-            # e.g.
-            #   db.xquery(
-            #     "SELECT * " \
-            #     "FROM users " \
-            #     "LIMIT 10"
-            #   )
-            return begin_pos + 1 if str_node.loc.expression.source_buffer.source[begin_pos] == '"'
-
-            begin_pos
-          end
-
-          # @param dstr_node [RuboCop::AST::DstrNode]
-          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
-          # @return [RuboCop::AST::StrNode,nil]
-          def find_str_node_from_gda_location(dstr_node:, gda_location:)
-            return nil unless dstr_node
-
-            begin_pos = 0
-            dstr_node.child_nodes.each do |str_node|
-              return str_node if begin_pos <= gda_location.begin_pos && gda_location.begin_pos < begin_pos + str_node.value.length
-
-              begin_pos += str_node.value.length
-            end
-            nil
-          end
-
-          # @param node [RuboCop::AST::Node]
-          # @return [Integer]
-          def heredoc_indent_level(node)
-            dstr_node = node.child_nodes[1]
-            return 0 unless dstr_node&.dstr_type?
-
-            heredoc_indent_type = heredoc_indent_type(node)
-            return 0 unless heredoc_indent_type == "~"
-
-            heredoc_body = dstr_node.loc.heredoc_body.source
-            indent_level(heredoc_body)
-          end
-
-          # @param str [String]
-          # @return [Integer]
-          # @see https://github.com/rubocop/rubocop/blob/v1.21.0/lib/rubocop/cop/mixin/heredoc.rb#L23-L28
-          def indent_level(str)
-            indentations = str.lines.
-                           map { |line| line[/^\s*/] }.
-                           reject { |line| line.end_with?("\n") }
-            indentations.empty? ? 0 : indentations.min_by(&:size).size
-          end
-
-          # Returns '~', '-' or nil
-          #
-          # @param node [RuboCop::AST::Node]
-          # @return [String,nil] '~', '-' or `nil`
-          # @see https://github.com/rubocop/rubocop/blob/v1.21.0/lib/rubocop/cop/layout/heredoc_indentation.rb#L146-L149
-          def heredoc_indent_type(node)
-            node.source[/<<([~-])/, 1]
-          end
         end
       end
     end

data/lib/rubocop/cop/isucon/mixin/n_plus_one_query_methods.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::NPlusOneQuery}
+        # and {RuboCop::Cop::Isucon::Sqlite3::NPlusOneQuery}
+        module NPlusOneQueryMethods
+          include Mixin::DatabaseMethods
+
+          extend NodePattern::Macros
+
+          MSG = "This looks like N+1 query."
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L38
+          POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L39
+          LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L41
+          ENUMERABLE_METHOD_NAMES = (Enumerable.instance_methods + [:each]).to_set.freeze
+
+          def_node_matcher :csv_loop?, <<~PATTERN
+            (block
+              (send (const nil? :CSV) :parse ...)
+              ...)
+          PATTERN
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L68
+          def_node_matcher :kernel_loop?, <<~PATTERN
+            (block
+              (send {nil? (const nil? :Kernel)} :loop)
+              ...)
+          PATTERN
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L74
+          def_node_matcher :enumerable_loop?, <<~PATTERN
+            (block
+              (send $_ #enumerable_method? ...)
+              ...)
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_error_handling(node) do
+              with_db_query(node) do |type, root_gda|
+                check_and_register_offence(node: node, type: type, root_gda: root_gda, is_array_arg: array_arg?)
+              end
+            end
+          end
+
+          private
+
+          # @param node [RuboCop::AST::Node]
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param is_array_arg [Boolean]
+          def check_and_register_offence(node:, type:, root_gda:, is_array_arg:) # rubocop:disable Metrics/MethodLength
+            return unless db_query_node?(node)
+
+            receiver, = *node.children
+
+            parent = parent_loop_node(receiver)
+            return unless parent
+
+            return if or_assignment_to_instance_variable?(node)
+
+            add_offense(receiver) do |corrector|
+              perform_autocorrect(
+                corrector: corrector, current_node: receiver,
+                parent_node: parent, type: type, gda: root_gda, is_array_arg: is_array_arg
+              )
+            end
+          end
+
+          # @param node [RuboCop::AST::Node]
+          def db_query_node?(node)
+            return db_query_methods.include?(node.children[1]) if node.children.count >= 3
+
+            child = node.children.first
+            return false unless child
+
+            child.children.count >= 3 && db_query_methods.include?(child.children[1])
+          end
+
+          # Whether match to `@instance_var ||=`
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def or_assignment_to_instance_variable?(node)
+            _or_assignment_to_instance_variable?(node.parent&.parent) ||
+              _or_assignment_to_instance_variable?(node.parent&.parent&.parent)
+          end
+
+          # Whether match to `@instance_var ||=`
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def _or_assignment_to_instance_variable?(node)
+            node&.or_asgn_type? && node.child_nodes&.first&.ivasgn_type?
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @return [RuboCop::AST::Node]
+          def parent_loop_node(node)
+            node.each_ancestor.find { |ancestor| loop?(ancestor, node) }
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L106
+          def loop?(ancestor, node)
+            keyword_loop?(ancestor.type) ||
+              kernel_loop?(ancestor) ||
+              node_within_enumerable_loop?(node, ancestor) ||
+              csv_loop?(ancestor)
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L112
+          def keyword_loop?(type)
+            LOOP_TYPES.include?(type)
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L116
+          def node_within_enumerable_loop?(node, ancestor)
+            enumerable_loop?(ancestor) do |receiver|
+              receiver != node && !receiver&.descendants&.include?(node)
+            end
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L130
+          def enumerable_method?(method_name)
+            ENUMERABLE_METHOD_NAMES.include?(method_name)
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param current_node [RuboCop::AST::Node]
+          # @param parent_node [RuboCop::AST::Node]
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param is_array_arg [Boolean]
+          def perform_autocorrect(corrector:, current_node:, parent_node:, type:, gda:, is_array_arg:) # rubocop:disable Metrics/ParameterLists
+            return unless enabled_database?
+
+            corrector = Correctors::NPlusOneQueryCorrector.new(
+              corrector: corrector, current_node: current_node, is_array_arg: is_array_arg,
+              parent_node: parent_node, type: type, gda: gda, connection: connection
+            )
+            corrector.correct
+          end
+        end
+      end
+    end
+  end
+end