rubocop-isucon 0.1.0 → 1.0.0

data/lib/rubocop/cop/isucon/mysql2/many_join_table.rb

@@ -53,32 +53,7 @@ module RuboCop
         #
         class ManyJoinTable < Base
           include Mixin::Mysql2XqueryMethods
-
-          MSG = "Avoid SQL with lots of JOINs"
-
-          # @param node [RuboCop::AST::Node]
-          def on_send(node)
-            with_xquery(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
+          include Mixin::ManyJoinTableMethods
         end
       end
     end

data/lib/rubocop/cop/isucon/mysql2/n_plus_one_query.rb

@@ -6,7 +6,7 @@ module RuboCop
       module Mysql2
         # rubocop:disable Layout/LineLength
 
-        # Checks that N+1 query is not used
+        # Checks that there’s no N+1 query
         #
         # @note If `Database` isn't configured, auto-correct will not be available. (Only offense detection can be used)
         #
@@ -51,126 +51,16 @@ module RuboCop
         class NPlusOneQuery < Base
           # rubocop:enable Layout/LineLength
 
-          include Mixin::DatabaseMethods
           include Mixin::Mysql2XqueryMethods
+          include Mixin::NPlusOneQueryMethods
 
           extend AutoCorrector
 
-          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) # rubocop:disable Metrics/MethodLength
-            with_error_handling(node) do
-              with_xquery(node) do |type, root_gda|
-                receiver, = *node.children
-
-                next unless receiver.send_type?
-
-                parent = parent_loop_node(receiver)
-                next unless parent
-
-                next 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
-                  )
-                end
-              end
-            end
-          end
-
           private
 
-          # 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]
-          def perform_autocorrect(corrector:, current_node:, parent_node:, type:, gda:)
-            return unless enabled_database?
-
-            corrector = Correctors::Mysql2NPlusOneQueryCorrector.new(
-              corrector: corrector, current_node: current_node,
-              parent_node: parent_node, type: type, gda: gda, connection: connection
-            )
-            corrector.correct
+          # [Boolean]
+          def array_arg?
+            false
           end
         end
       end

data/lib/rubocop/cop/isucon/mysql2/select_asterisk.rb

@@ -26,144 +26,10 @@ module RuboCop
         #   db.xquery('SELECT users.id, users.name FROM users')
         #
         class SelectAsterisk < Base
-          include Mixin::DatabaseMethods
           include Mixin::Mysql2XqueryMethods
+          include Mixin::SelectAsteriskMethods
 
           extend AutoCorrector
-
-          MSG = "Use SELECT with column names. (e.g. `SELECT id, name FROM table_name`)"
-
-          TODO = "# TODO: Remove needless columns if necessary\n"
-
-          # @param node [RuboCop::AST::Node]
-          def on_send(node)
-            with_error_handling(node) do
-              with_xquery(node) do |type, root_gda|
-                next unless 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:)
-            root_gda.visit_all do |gda|
-              next unless gda.ast.respond_to?(:expr_list)
-
-              gda.ast.expr_list.each do |select_field_node|
-                check_and_register_offence_for_select_field_node(
-                  type: type, node: node, gda: gda,
-                  select_field_node: select_field_node
-                )
-              end
-            end
-          end
-
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param node [RuboCop::AST::Node]
-          # @param gda [RuboCop::Isucon::GDA::Client]
-          # @param select_field_node [GDA::Nodes::SelectField]
-          def check_and_register_offence_for_select_field_node(type:, node:, gda:, select_field_node:)
-            return unless select_field_node.respond_to?(:expr)
-
-            select_field = parse_select_field_node(select_field_node)
-
-            return unless select_field[:column_name] == "*"
-
-            loc = offense_location(type: type, node: node, gda_location: select_field_node.expr.location)
-            return unless loc
-
-            add_offense(loc) do |corrector|
-              perform_autocorrect(corrector: corrector, loc: loc, gda: gda, node: node,
-                                  select_table_name: select_field[:table_name])
-            end
-          end
-
-          # @param select_field_node [GDA::Nodes::SelectField]
-          # @return [Hash<Symbol, String>] table_name, column_name
-          def parse_select_field_node(select_field_node)
-            column_elements = select_field_node.expr.value.split(".", 2)
-
-            case column_elements.count
-            when 1
-              return { column_name: column_elements[0] }
-            when 2
-              return { table_name: column_elements[0], column_name: column_elements[1] }
-            end
-
-            {}
-          end
-
-          # @param corrector [RuboCop::Cop::Corrector]
-          # @param loc [Parser::Source::Range]
-          # @param gda [RuboCop::Isucon::GDA::Client]
-          # @param node [RuboCop::AST::Node]
-          # @param select_table_name [String,nil] table names included in the SELECT clause
-          def perform_autocorrect(corrector:, loc:, gda:, node:, select_table_name:)
-            return unless enabled_database?
-            return if gda.table_names.empty?
-
-            if select_table_name
-              return unless gda.table_names.include?(select_table_name)
-
-              replace_asterisk(corrector: corrector, loc: loc, table_name: select_table_name, table_prefix: true)
-            else
-              return unless gda.table_names.length == 1
-
-              replace_asterisk(corrector: corrector, loc: loc, table_name: gda.table_names[0], table_prefix: false)
-            end
-
-            insert_todo_comment(corrector: corrector, node: node)
-          end
-
-          # @param corrector [RuboCop::Cop::Corrector]
-          # @param loc [Parser::Source::Range]
-          # @param table_name [String]
-          # @param table_prefix [Boolean] Whether add table name to prefix (e.g. `users`.`name`)
-          def replace_asterisk(corrector:, loc:, table_name:, table_prefix:)
-            select_columns = columns_in_select_clause(table_name: table_name, table_prefix: table_prefix)
-            corrector.replace(loc, select_columns)
-          end
-
-          # @param table_name [String]
-          # @param table_prefix [Boolean] Whether add table name to prefix (e.g. `users`.`name`)
-          # @return [String]
-          def columns_in_select_clause(table_name:, table_prefix:)
-            column_names = connection.column_names(table_name)
-
-            column_names.map do |column|
-              if table_prefix
-                "`#{table_name}`.`#{column}`"
-              else
-                "`#{column}`"
-              end
-            end.join(", ")
-          end
-
-          # @param corrector [RuboCop::Cop::Corrector]
-          # @param node [RuboCop::AST::Node]
-          def insert_todo_comment(corrector:, node:)
-            current_line = node.loc.expression.line
-            current_line_range = node.loc.expression.source_buffer.line_range(current_line)
-
-            indent = node_indent_level(node)
-            comment_line = (" " * indent) + TODO
-            corrector.insert_before(current_line_range, comment_line)
-          end
-
-          # @param node [RuboCop::AST::Node]
-          # @return [Integer]
-          def node_indent_level(node)
-            node.loc.expression.source_line =~ /^(\s+)/
-            return 0 unless Regexp.last_match(1)
-
-            Regexp.last_match(1).length
-          end
         end
       end
     end

data/lib/rubocop/cop/isucon/mysql2/where_without_index.rb

@@ -10,93 +10,28 @@ module RuboCop
         #
         # @example
         #   # bad (user_id is not indexed)
-        #   db.xquery('SELECT id, title FROM articles WHERE used_id = ?', user_id)
+        #   db.xquery('SELECT id, title FROM articles WHERE user_id = ?', user_id)
         #
         #   # good (user_id is indexed)
-        #   db.xquery('SELECT id, title FROM articles WHERE used_id = ?', user_id)
+        #   db.xquery('SELECT id, title FROM articles WHERE user_id = ?', user_id)
         #
         #   # good (id is primary key)
         #   db.xquery('SELECT id, title FROM articles WHERE id = ?', id)
         #
         class WhereWithoutIndex < Base
-          include Mixin::DatabaseMethods
           include Mixin::Mysql2XqueryMethods
+          include Mixin::WhereWithoutIndexMethods
 
           MSG = "This where clause doesn't seem to have an index. " \
                 "(e.g. `ALTER TABLE %<table_name>s ADD INDEX index_%<column_name>s (%<column_name>s)`)"
 
-          # @param node [RuboCop::AST::Node]
-          def on_send(node)
-            with_error_handling(node) do
-              return unless enabled_database?
-
-              with_xquery(node) do |type, root_gda|
-                next unless root_gda
-                next if exists_index_in_where_clause_columns?(root_gda)
-
-                register_offense(type: type, node: node, root_gda: root_gda)
-              end
-            end
-          end
-
           private
 
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param node [RuboCop::AST::Node]
-          # @param root_gda [RuboCop::Isucon::GDA::Client]
-          def register_offense(type:, node:, root_gda:)
-            root_gda.visit_all do |gda|
-              next if gda.where_nodes.empty?
-
-              loc = offense_location(type: type, node: node, gda_location: gda.where_nodes.first.location)
-              next unless loc
-
-              message = offense_message(gda)
-              add_offense(loc, message: message)
-            end
-          end
-
-          # @param gda [RuboCop::Isucon::GDA::Client]
-          def offense_message(gda)
-            column_name = gda.where_conditions[0].column_operand
-            table_name = find_table_name_from_column_name(table_names: gda.table_names, column_name: column_name)
-            format(MSG, table_name: table_name, column_name: column_name)
-          end
-
-          # @param root_gda [RuboCop::Isucon::GDA::Client]
-          # @return [Boolean]
-          def exists_index_in_where_clause_columns?(root_gda)
-            root_gda.visit_all do |gda|
-              gda.table_names.each do |table_name|
-                return true if covered_where_column_in_index?(gda: gda, table_name: table_name)
-                return true if covered_where_column_in_primary_key?(gda: gda, table_name: table_name)
-              end
-            end
-
-            false
-          end
-
-          # @param gda [RuboCop::Isucon::GDA::Client]
-          # @param table_name [String]
-          # @return [Boolean]
-          def covered_where_column_in_index?(gda:, table_name:)
-            indexes = connection.indexes(table_name)
-            index_first_columns = indexes.map { |index| index.columns[0] }
-
-            gda.where_conditions.any? do |condition|
-              index_first_columns.include?(condition.column_operand)
-            end
-          end
-
-          # @param gda [RuboCop::Isucon::GDA::Client]
           # @param table_name [String]
-          # @return [Boolean]
-          def covered_where_column_in_primary_key?(gda:, table_name:)
-            primary_keys = connection.primary_keys(table_name)
-            return false if primary_keys.empty?
-
-            where_columns = gda.where_conditions.map(&:column_operand)
-            primary_keys.all? { |primary_key| where_columns.include?(primary_key) }
+          # @param column_name [String]
+          # @return [String]
+          def generate_offense_message(table_name:, column_name:)
+            format(MSG, table_name: table_name, column_name: column_name)
           end
         end
       end

data/lib/rubocop/cop/isucon/shell/backtick.rb

@@ -22,6 +22,13 @@ module RuboCop
         #     OpenSSL::Digest::SHA512.hexdigest(src)
         #   end
         #
+        #   # bad
+        #   `curl -s https://example.com`
+        #
+        #   # good
+        #   require "open-uri"
+        #   URI.open("https://example.com").read
+        #
         class Backtick < Base
           MSG = "Use pure-ruby code instead of external command execution if possible"
 

data/lib/rubocop/cop/isucon/sqlite3/join_without_index.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sqlite3
+        # Check for `JOIN` without index
+        #
+        # @note If `Database` isn't configured, this cop's feature (offense detection and auto-correct) will not be available.
+        #
+        # @example
+        #   # bad (user_id is not indexed)
+        #   db.execute('SELECT id, title FROM articles JOIN users ON users.id = articles.user_id')
+        #
+        #   # good (user_id is indexed)
+        #   db.execute('SELECT id, title FROM articles JOIN users ON users.id = articles.user_id')
+        #
+        class JoinWithoutIndex < Base
+          include Mixin::Sqlite3ExecuteMethods
+          include Mixin::JoinWithoutIndexMethods
+
+          MSG = "This join clause doesn't seem to have an index. " \
+                "(e.g. `CREATE INDEX index_%<table_name>s_%<column_name>s ON %<table_name>s (%<column_name>s)`)"
+
+          private
+
+          # @param table_name [String]
+          # @param column_name [String]
+          # @return [String]
+          def generate_offense_message(table_name:, column_name:)
+            format(MSG, table_name: table_name, column_name: column_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sqlite3/many_join_table.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sqlite3
+        # Check if SQL contains many JOINs
+        #
+        # @example CountTables: 3 (default)
+        #   # bad
+        #   totals = db.execute(
+        #     "SELECT IFNULL(SUM(`submissions`.`score`), 0) AS `total_score`" \
+        #     " FROM `users`" \
+        #     " JOIN `registrations` ON `users`.`id` = `registrations`.`user_id`" \
+        #     " JOIN `courses` ON `registrations`.`course_id` = `courses`.`id`" \
+        #     " LEFT JOIN `classes` ON `courses`.`id` = `classes`.`course_id`" \
+        #     " LEFT JOIN `submissions` ON `users`.`id` = `submissions`.`user_id` AND `submissions`.`class_id` = `classes`.`id`" \
+        #     " WHERE `courses`.`id` = ?" \
+        #     " GROUP BY `users`.`id`",
+        #     [course[:id]]
+        #   ).map { |_| _[:total_score] }
+        #
+        #   # good
+        #   registration_users_count =
+        #     db.execute("SELECT COUNT(`user_id`) AS cnt FROM `registrations` WHERE `course_id` = ?", [course[:id]]).first[:cnt]
+        #
+        #   totals = db.execute(<<~SQL, course[:id]).map { |_| _[:total_score] }
+        #     SELECT IFNULL(SUM(`submissions`.`score`), 0) AS `total_score`
+        #     FROM `submissions`
+        #     JOIN `classes` ON `classes`.`id` = `submissions`.`class_id`
+        #     WHERE `classes`.`course_id` = ?
+        #     GROUP BY `submissions`.`user_id`
+        #   SQL
+        #
+        #   if totals.count < registration_users_count
+        #     no_submissions_count = registration_users_count - totals.count
+        #     totals += [0] * no_submissions_count
+        #   end
+        #
+        # @example CountTables: 5
+        #   # good
+        #   totals = db.execute(
+        #     "SELECT IFNULL(SUM(`submissions`.`score`), 0) AS `total_score`" \
+        #     " FROM `users`" \
+        #     " JOIN `registrations` ON `users`.`id` = `registrations`.`user_id`" \
+        #     " JOIN `courses` ON `registrations`.`course_id` = `courses`.`id`" \
+        #     " LEFT JOIN `classes` ON `courses`.`id` = `classes`.`course_id`" \
+        #     " LEFT JOIN `submissions` ON `users`.`id` = `submissions`.`user_id` AND `submissions`.`class_id` = `classes`.`id`" \
+        #     " WHERE `courses`.`id` = ?" \
+        #     " GROUP BY `users`.`id`",
+        #     [course[:id]]
+        #   ).map { |_| _[:total_score] }
+        #
+        class ManyJoinTable < Base
+          include Mixin::Sqlite3ExecuteMethods
+          include Mixin::ManyJoinTableMethods
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sqlite3/n_plus_one_query.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sqlite3
+        # rubocop:disable Layout/LineLength
+
+        # Checks that there’s no N+1 query
+        #
+        # @note If `Database` isn't configured, auto-correct will not be available. (Only offense detection can be used)
+        #
+        # @note For the number of N+1 queries that can be detected by this cop, there are too few that can be corrected automatically
+        #
+        # @example
+        #   # bad
+        #   reservations = db.execute('SELECT * FROM `reservations` WHERE `schedule_id` = ?', [schedule_id]).map do |reservation|
+        #     reservation[:user] = db.execute('SELECT * FROM `users` WHERE `id` = ? LIMIT 1', [id]).first
+        #     reservation
+        #   end
+        #
+        #   # good
+        #   rows = db.xquery(<<~SQL, [schedule_id])
+        #     SELECT
+        #       r.id AS reservation_id,
+        #       r.schedule_id AS reservation_schedule_id,
+        #       r.user_id AS reservation_user_id,
+        #       r.created_at AS reservation_created_at,
+        #       u.id AS user_id,
+        #       u.email AS user_email,
+        #       u.nickname AS user_nickname,
+        #       u.staff AS user_staff,
+        #       u.created_at AS user_created_at
+        #     FROM `reservations` AS r
+        #     INNER JOIN users u ON u.id = r.user_id
+        #     WHERE r.schedule_id = ?
+        #   SQL
+        #
+        #   # bad
+        #   courses.map do |course|
+        #     teacher = db.execute('SELECT * FROM `users` WHERE `id` = ?', [course[:teacher_id]]).first
+        #   end
+        #
+        #   # good
+        #   # This is similar to ActiveRecord's preload
+        #   # c.f. https://guides.rubyonrails.org/active_record_querying.html#preload
+        #   courses.map do |course|
+        #     @users_by_id ||= db.execute('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 NPlusOneQuery < Base
+          # rubocop:enable Layout/LineLength
+
+          include Mixin::Sqlite3ExecuteMethods
+          include Mixin::NPlusOneQueryMethods
+
+          extend AutoCorrector
+
+          private
+
+          # [Boolean]
+          def array_arg?
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sqlite3/select_asterisk.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sqlite3
+        # Avoid `SELECT *` in `db.execute`
+        #
+        # @note If `Database` isn't configured, auto-correct will not be available. (Only offense detection can be used)
+        #
+        # @note This cop replaces `SELECT *` with a `SELECT` by the columns present in the table (e.g. `SELECT id, name`),
+        #       but does not check whether the columns are actually used.
+        #       Please manually delete unused columns after auto corrected
+        #
+        # @example
+        #   # bad
+        #   db.execute('SELECT * FROM users')
+        #
+        #   # bad
+        #   db.execute('SELECT users.* FROM users')
+        #
+        #   # good
+        #   db.execute('SELECT id, name FROM users')
+        #
+        #   # good
+        #   db.execute('SELECT users.id, users.name FROM users')
+        #
+        class SelectAsterisk < Base
+          include Mixin::Sqlite3ExecuteMethods
+          include Mixin::SelectAsteriskMethods
+
+          extend AutoCorrector
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sqlite3/where_without_index.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sqlite3
+        # Check for `WHERE` without index
+        #
+        # @note If `Database` isn't configured, this cop's feature (offense detection and auto-correct) will not be available.
+        #
+        # @example
+        #   # bad (user_id is not indexed)
+        #   db.execute('SELECT id, title FROM articles WHERE user_id = ?', [user_id])
+        #
+        #   # good (user_id is indexed)
+        #   db.execute('SELECT id, title FROM articles WHERE user_id = ?', [user_id])
+        #
+        #   # good (id is primary key)
+        #   db.execute('SELECT id, title FROM articles WHERE id = ?', [id])
+        #
+        class WhereWithoutIndex < Base
+          include Mixin::Sqlite3ExecuteMethods
+          include Mixin::WhereWithoutIndexMethods
+
+          MSG = "This where clause doesn't seem to have an index. " \
+                "(e.g. `CREATE INDEX index_%<table_name>s_%<column_name>s ON %<table_name>s (%<column_name>s)`)"
+
+          private
+
+          # @param table_name [String]
+          # @param column_name [String]
+          # @return [String]
+          def generate_offense_message(table_name:, column_name:)
+            format(MSG, table_name: table_name, column_name: column_name)
+          end
+        end
+      end
+    end
+  end
+end