rubocop-isucon 0.1.0

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Helper methods for `db.xquery` or `db.query` in AST
+        module Mysql2XqueryMethods
+          extend NodePattern::Macros
+
+          # @!method find_xquery(node)
+          #   @param node [RuboCop::AST::Node]
+          def_node_search :find_xquery, <<~PATTERN
+            (send (send nil? _) {:xquery | :query} (${str dstr lvar ivar cvar} $...) ...)
+          PATTERN
+
+          NON_STRING_WARNING_MSG = "Warning: non-string was passed to `query` or `xquery` 1st argument. " \
+                                   "So argument doesn't parsed as SQL (%<file_path>s:%<line_num>d)"
+
+          # @param node [RuboCop::AST::Node]
+          # @yieldparam type [Symbol] Node type. one of `:str`, `:dstr`
+          # @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)
+            find_xquery(node) do |type, params|
+              sql = xquery_param(type: type, params: params)
+
+              unless sql
+                warn format(NON_STRING_WARNING_MSG, file_path: processed_source.file_path, line_num: node.loc.expression.line)
+              end
+
+              root_gda = sql ? RuboCop::Isucon::GDA::Client.new(sql) : nil
+
+              yield type, root_gda
+            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
+
+            end_pos = begin_pos + gda_location.length
+            Parser::Source::Range.new(node.loc.expression.source_buffer, begin_pos, end_pos)
+          end
+
+          private
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param params [Array<RuboCop::AST::Node>]
+          # @return [String,nil]
+          def xquery_param(type:, params:)
+            case type
+            when :str
+              return params[0]
+            when :dstr
+              if params.all? { |param| param.respond_to?(:value) }
+                # heredoc
+                return params.map(&:value).join
+              end
+            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
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Helper methods for {RuboCop::Cop::Isucon::Sinatra}
+        module SinatraMethods
+          extend NodePattern::Macros
+
+          # @!method subclass_of_sinatra_base?(node)
+          #   Whether match to `class AnyClass < Sinatra::Base` node
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :subclass_of_sinatra_base?, <<~PATTERN
+            (class (const nil? _) (const (const nil? :Sinatra) :Base) ...)
+          PATTERN
+
+          # @!method subclass_of_sinatra_base_contains_logging?(node)
+          #   Whether match to `class AnyClass < Sinatra::Base` node and contains :logging configuration
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :subclass_of_sinatra_base_contains_logging?, <<~PATTERN
+            (class (const nil? _) (const (const nil? :Sinatra) :Base) ... `(send nil? _ (sym :logging)))
+          PATTERN
+
+          # Whether parent node match to `class AnyClass < Sinatra::Base` node
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def parent_is_sinatra_app?(node)
+            node.each_ancestor.any? { |ancestor| subclass_of_sinatra_base?(ancestor) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # 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.xquery('SELECT id, title FROM articles JOIN users ON users.id = articles.user_id')
+        #
+        #   # good (user_id is indexed)
+        #   db.xquery('SELECT id, title FROM articles JOIN users ON users.id = articles.user_id')
+        #
+        class JoinWithoutIndex < Base
+          include Mixin::DatabaseMethods
+          include Mixin::Mysql2XqueryMethods
+
+          MSG = "This join 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|
+                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)
+            format(MSG, table_name: join_operand.table_name, column_name: join_operand.column_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # Check if SQL contains many JOINs
+        #
+        # @example CountTables: 3 (default)
+        #   # bad
+        #   totals = db.xquery(
+        #     "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.xquery("SELECT COUNT(`user_id`) AS cnt FROM `registrations` WHERE `course_id` = ?", course[:id]).first[:cnt]
+        #
+        #   totals = db.xquery(<<~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.xquery(
+        #     "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::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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # rubocop:disable Layout/LineLength
+
+        # Checks that N+1 query is not used
+        #
+        # @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.xquery('SELECT * FROM `reservations` WHERE `schedule_id` = ?', schedule_id).map do |reservation|
+        #     reservation[:user] = db.xquery('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.xquery('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.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 NPlusOneQuery < Base
+          # rubocop:enable Layout/LineLength
+
+          include Mixin::DatabaseMethods
+          include Mixin::Mysql2XqueryMethods
+
+          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
+          end
+        end
+      end
+    end
+  end
+end