pg_canary 0.2.0 → 0.3.0

data/lib/pg_canary/rules/base.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/inflections"
+
 module PgCanary
   module Rules
     # Base class for detection rules.
     #
-    # A rule implements #check(query) and returns an array of Detection.
-    # Configuration flows in explicitly through the QueryContext
-    # (query.config); rules never reach for global state themselves.
+    # A rule instance is built per analyzed query, holds that query's state,
+    # and implements #check returning an array of Detection.
     class Base
-      include PgQuerySupport
-
       class << self
         def all
           subclasses.sort_by(&:name)
@@ -17,52 +16,104 @@ module PgCanary
 
         # :leading_wildcard_like for LeadingWildcardLike
         def rule_name
-          @rule_name ||= name.split("::").last
-                             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                             .downcase.to_sym
+          @rule_name ||= name.demodulize.underscore.to_sym
+        end
+
+        def option(name, default:)
+          options[name] = default
         end
 
-        # Rule-specific options and their defaults, e.g. { threshold: 1000 }.
-        # Declared statically so RuleConfig can generate real accessors.
         def options
-          {}
+          @options ||= {}
         end
-      end
 
-      def check(_query)
-        raise NotImplementedError, "#{self.class} must implement #check"
+        def default_enabled(value = nil)
+          if value.nil?
+            raise NotImplementedError, "#{self} must declare default_enabled" if @default_enabled.nil?
+
+            @default_enabled
+          else
+            @default_enabled = value
+          end
+        end
+
+        def enabled?(config)
+          setting = config.rules.public_send(rule_name).enabled
+          setting.nil? ? default_enabled : setting
+        end
+
+        def check(**state)
+          new(**state).check
+        end
       end
 
-      def enabled?(config)
-        setting = config.rules[self.class.rule_name].enabled
-        setting.nil? ? default_enabled : setting
+      def initialize(sql:, config:, connection:, parse_result:, scopes:, binds: [], type_casted_binds: nil)
+        @sql = sql
+        @config = config
+        @connection = connection
+        @parse_result = parse_result
+        @scopes = scopes
+        @binds = binds || []
+        @type_casted_binds = type_casted_binds
       end
 
-      def default_enabled
-        raise NotImplementedError, "#{self.class} must declare #default_enabled (true for Tier 1, false for Tier 2)"
+      def check
+        raise NotImplementedError, "#{self.class} must implement #check"
       end
 
       private
 
-      def rule_config(query)
-        query.config.rules[self.class.rule_name]
-      end
+        attr_reader :sql, :config, :connection, :parse_result, :scopes
 
-      def applicable_table?(query, table)
-        !query.config.ignore_table?(table)
-      end
+        def each_scope(&)
+          scopes.each(&)
+        end
 
-      def detection(query, message:, suggestion: nil, table: nil, columns: nil)
-        Detection.new(
-          rule_name: self.class.rule_name,
-          severity: rule_config(query).severity || :warning,
-          sql: query.sql,
-          table: table,
-          columns: Array(columns),
-          message: message,
-          suggestion: suggestion
-        )
-      end
+        # Value for a ParamRef ($n, 1-based). nil when unknown.
+        def bind_value(number)
+          index = number - 1
+          return nil if index.negative?
+
+          casted = @type_casted_binds
+          return casted[index] if casted.is_a?(Array) && index < casted.length
+
+          bind = @binds[index]
+          return nil if bind.nil?
+
+          bind.respond_to?(:value_for_database) ? bind.value_for_database : bind
+        end
+
+        def indexes(table)
+          SchemaIntrospection.indexes(connection, table)
+        end
+
+        def column_type(table, column)
+          SchemaIntrospection.column_type(connection, table, column)
+        end
+
+        # => { column_name => sql_type }
+        def column_types(table)
+          SchemaIntrospection.column_types(connection, table)
+        end
+
+        def rule_config
+          config.rules.public_send(self.class.rule_name)
+        end
+
+        def applicable_table?(table)
+          !config.ignore_table?(table)
+        end
+
+        def detection(message:, suggestion: nil, table: nil, columns: nil)
+          Detection.new(
+            rule_name: self.class.rule_name,
+            sql: sql,
+            table: table,
+            columns: Array(columns),
+            message: message,
+            suggestion: suggestion
+          )
+        end
     end
   end
 end

data/lib/pg_canary/rules/definitions/array_search_without_gin.rb

@@ -5,30 +5,30 @@ module PgCanary
     # Searching an array column (@>, <@, &&, or value = ANY(column)) without
     # a GIN index scans every row.
     class ArraySearchWithoutGin < Base
+      default_enabled true
+
       include IndexPredicates
 
-      def default_enabled
-        true
-      end
+      using PgCanary::PgQueryRefinement
 
       ARRAY_OPS = %w[@> <@ &&].freeze
 
-      def check(query)
+      def check
         detections = []
-        query.each_scope do |scope|
+        each_scope do |scope|
           next unless scope.where_clause
 
-          walk_within_scope(scope.where_clause) do |node|
+          scope.where_clause.walk_scope do |node|
             next unless node.is_a?(PgQuery::A_Expr)
 
             case node.kind
             when :AEXPR_OP
-              operator = operator_name(node)
+              operator = node.operator
               next unless ARRAY_OPS.include?(operator)
 
-              detections << inspect_sides(query, scope, [node.lexpr, node.rexpr], operator)
+              detections << inspect_sides(scope, [node.lexpr, node.rexpr], operator)
             when :AEXPR_OP_ANY
-              detections << inspect_sides(query, scope, [node.rexpr], "= ANY(column)")
+              detections << inspect_sides(scope, [node.rexpr], "= ANY(column)")
             end
           end
         end
@@ -37,35 +37,34 @@ module PgCanary
 
       private
 
-      def inspect_sides(query, scope, sides, operator)
-        sides.each do |side|
-          column_ref = strip_type_casts(side)
-          next unless column_ref.is_a?(PgQuery::ColumnRef)
+        def inspect_sides(scope, sides, operator)
+          sides.each do |side|
+            column_ref = side&.strip_casts
+            next unless column_ref.is_a?(PgQuery::ColumnRef)
 
-          table, column = scope.resolve(column_ref)
-          next unless table && column
-          next unless applicable_table?(query, table)
-          next unless array_type?(query.column_type(table, column))
-          next if gin_index_on?(query, table, column)
+            table, column = scope.resolve(column_ref)
+            next unless table && column
+            next unless applicable_table?(table)
+            next unless array_type?(column_type(table, column))
+            next if gin_index_on?(table, column)
 
-          return detection(
-            query,
-            table: table,
-            columns: column,
-            message: "Array search (#{operator}) on #{table}.#{column} has no GIN index " \
-                     "and will scan every row in production.",
-            suggestion: <<~SUGGESTION.chomp
-              Consider a GIN index on the array column:
-                CREATE INDEX index_#{table}_on_#{column} ON #{table} USING gin (#{column});
-            SUGGESTION
-          )
+            return detection(
+              table: table,
+              columns: column,
+              message: "Array search (#{operator}) on #{table}.#{column} has no GIN index " \
+                       "and will scan every row in production.",
+              suggestion: <<~SUGGESTION.chomp
+                Consider a GIN index on the array column:
+                  CREATE INDEX index_#{table}_on_#{column} ON #{table} USING gin (#{column});
+              SUGGESTION
+            )
+          end
+          nil
         end
-        nil
-      end
 
-      def array_type?(sql_type)
-        sql_type&.end_with?("[]")
-      end
+        def array_type?(sql_type)
+          sql_type&.end_with?("[]")
+        end
     end
   end
 end

data/lib/pg_canary/rules/definitions/cartesian_join.rb

@@ -6,99 +6,98 @@ module PgCanary
     # tables, or a comma join whose WHERE clause never connects the tables —
     # produces a cross product whose row count is the product of both sides.
     class CartesianJoin < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+
+      using PgCanary::PgQueryRefinement
 
-      def check(query)
+      def check
         detections = []
-        query.each_scope do |scope|
+        each_scope do |scope|
           scope.stmt.from_clause.each do |item|
-            each_join(unwrap_node(item)) do |join|
-              detections << join_detection(query, join) if unconditioned?(join)
+            each_join(item.unwrap) do |join|
+              detections << join_detection(join) if unconditioned?(join)
             end
           end
-          detections << comma_detection(query, scope) if comma_cartesian?(scope)
+          detections << comma_detection(scope) if comma_cartesian?(scope)
         end
         detections
       end
 
       private
 
-      def each_join(node, &)
-        return unless node.is_a?(PgQuery::JoinExpr)
+        def each_join(node, &)
+          return unless node.is_a?(PgQuery::JoinExpr)
 
-        yield node
-        each_join(unwrap_node(node.larg), &)
-        each_join(unwrap_node(node.rarg), &)
-      end
+          yield node
+          each_join(node.larg&.unwrap, &)
+          each_join(node.rarg&.unwrap, &)
+        end
 
-      def unconditioned?(join)
-        join.jointype == :JOIN_INNER &&
-          join.quals.nil? &&
-          !join.is_natural &&
-          join.using_clause.empty? &&
-          real_table?(join.rarg) &&
-          joinable_side?(join.larg)
-      end
+        def unconditioned?(join)
+          join.jointype == :JOIN_INNER &&
+            join.quals.nil? &&
+            !join.is_natural &&
+            join.using_clause.empty? &&
+            real_table?(join.rarg) &&
+            joinable_side?(join.larg)
+        end
 
-      # Restrict to joins between real tables so that deliberate cross joins
-      # against functions (generate_series etc.) stay silent.
-      def real_table?(node)
-        unwrap_node(node).is_a?(PgQuery::RangeVar)
-      end
+        # Restrict to joins between real tables so that deliberate cross joins
+        # against functions (generate_series etc.) stay silent.
+        def real_table?(node)
+          node&.unwrap.is_a?(PgQuery::RangeVar)
+        end
 
-      def joinable_side?(node)
-        inner = unwrap_node(node)
-        inner.is_a?(PgQuery::RangeVar) || inner.is_a?(PgQuery::JoinExpr)
-      end
+        def joinable_side?(node)
+          inner = node&.unwrap
+          inner.is_a?(PgQuery::RangeVar) || inner.is_a?(PgQuery::JoinExpr)
+        end
 
-      # FROM a, b (2+ plain tables) with no column-to-column equality in WHERE.
-      def comma_cartesian?(scope)
-        plain_tables = scope.stmt.from_clause.map { |n| unwrap_node(n) }.grep(PgQuery::RangeVar)
-        return false if plain_tables.length < 2
+        # FROM a, b (2+ plain tables) with no column-to-column equality in WHERE.
+        def comma_cartesian?(scope)
+          plain_tables = scope.stmt.from_clause.map(&:unwrap).grep(PgQuery::RangeVar)
+          return false if plain_tables.length < 2
 
-        !cross_table_equality?(scope)
-      end
+          !cross_table_equality?(scope)
+        end
 
-      def cross_table_equality?(scope)
-        return false unless scope.where_clause
+        def cross_table_equality?(scope)
+          return false unless scope.where_clause
 
-        found = false
-        walk_within_scope(scope.where_clause) do |node|
-          next unless node.is_a?(PgQuery::A_Expr) && comparison_expr?(node)
+          found = false
+          scope.where_clause.walk_scope do |node|
+            next unless node.is_a?(PgQuery::A_Expr) && node.comparison?
 
-          left = unwrap_node(node.lexpr)
-          right = unwrap_node(node.rexpr)
-          next unless left.is_a?(PgQuery::ColumnRef) && right.is_a?(PgQuery::ColumnRef)
+            left = node.lexpr&.unwrap
+            right = node.rexpr&.unwrap
+            next unless left.is_a?(PgQuery::ColumnRef) && right.is_a?(PgQuery::ColumnRef)
 
-          left_table, = scope.resolve(left)
-          right_table, = scope.resolve(right)
-          found ||= left_table && right_table && left_table != right_table
+            left_table, = scope.resolve(left)
+            right_table, = scope.resolve(right)
+            found ||= left_table && right_table && left_table != right_table
+          end
+          found
         end
-        found
-      end
 
-      def join_detection(query, join)
-        tables = [join.larg, join.rarg].map { |n| unwrap_node(n) }
-                                       .grep(PgQuery::RangeVar).map(&:relname)
-        build(query, tables)
-      end
+        def join_detection(join)
+          tables = [join.larg, join.rarg].map(&:unwrap)
+                                         .grep(PgQuery::RangeVar).map(&:relname)
+          build(tables)
+        end
 
-      def comma_detection(query, scope)
-        build(query, scope.tables)
-      end
+        def comma_detection(scope)
+          build(scope.tables)
+        end
 
-      def build(query, tables)
-        detection(
-          query,
-          table: tables.first,
-          message: "JOIN between #{tables.join(" and ")} has no join condition, producing a cross " \
-                   "product — the result grows with the product of both tables' row counts.",
-          suggestion: "Add a join condition (ON / USING). If a cross product is really intended, " \
-                      "add the table to config.ignore_tables to silence this."
-        )
-      end
+        def build(tables)
+          detection(
+            table: tables.first,
+            message: "JOIN between #{tables.join(" and ")} has no join condition, producing a cross " \
+                     "product — the result grows with the product of both tables' row counts.",
+            suggestion: "Add a join condition (ON / USING). If a cross product is really intended, " \
+                        "add the table to config.ignore_tables to silence this."
+          )
+        end
     end
   end
 end

data/lib/pg_canary/rules/definitions/correlated_subquery_in_select.rb

@@ -5,26 +5,25 @@ module PgCanary
     # A scalar subquery in the SELECT list that references the outer table
     # runs once per result row (N+1 inside a single query).
     class CorrelatedSubqueryInSelect < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+
+      using PgCanary::PgQueryRefinement
 
-      def check(query)
+      def check
         detections = []
-        query.each_scope do |scope|
+        each_scope do |scope|
           scope.stmt.target_list.each do |target|
-            res_target = unwrap_node(target)
+            res_target = target.unwrap
             next unless res_target.is_a?(PgQuery::ResTarget)
 
-            walk_within_scope(res_target.val) do |node|
+            res_target.val.walk_scope do |node|
               next unless node.is_a?(PgQuery::SubLink) && node.sub_link_type == :EXPR_SUBLINK
 
               table, column = correlated_reference(node, scope)
               next unless table && column
-              next unless applicable_table?(query, table)
+              next unless applicable_table?(table)
 
               detections << detection(
-                query,
                 table: table,
                 columns: column,
                 message: "Scalar subquery in the SELECT list references #{table}.#{column} from the " \
@@ -40,37 +39,37 @@ module PgCanary
 
       private
 
-      # [table, column] of the first outer-scope reference inside the
-      # subquery, or nil when the subquery is self-contained.
-      def correlated_reference(sublink, outer_scope)
-        subselect = unwrap_node(sublink.subselect)
-        return nil unless subselect.is_a?(PgQuery::SelectStmt)
+        # [table, column] of the first outer-scope reference inside the
+        # subquery, or nil when the subquery is self-contained.
+        def correlated_reference(sublink, outer_scope)
+          subselect = sublink.subselect&.unwrap
+          return nil unless subselect.is_a?(PgQuery::SelectStmt)
 
-        inner_names = inner_relation_names(subselect)
-        found = nil
-        walk_ast(subselect) do |node|
-          next unless found.nil? && node.is_a?(PgQuery::ColumnRef)
+          inner_names = inner_relation_names(subselect)
+          found = nil
+          subselect.walk do |node|
+            next unless found.nil? && node.is_a?(PgQuery::ColumnRef)
 
-          fields = column_ref_fields(node)
-          next unless fields && fields.length >= 2
-          next if inner_names.include?(fields[-2])
+            fields = node.field_names
+            next unless fields && fields.length >= 2
+            next if inner_names.include?(fields[-2])
 
-          found = outer_scope.resolve(node)
+            found = outer_scope.resolve(node)
+          end
+          found
         end
-        found
-      end
 
-      # Every relation name/alias visible anywhere inside the subquery.
-      def inner_relation_names(subselect)
-        names = []
-        walk_ast(subselect) do |node|
-          next unless node.is_a?(PgQuery::RangeVar)
+        # Every relation name/alias visible anywhere inside the subquery.
+        def inner_relation_names(subselect)
+          names = []
+          subselect.walk do |node|
+            next unless node.is_a?(PgQuery::RangeVar)
 
-          names << node.relname
-          names << node.alias.aliasname if node.alias
+            names << node.relname
+            names << node.alias.aliasname if node.alias
+          end
+          names
         end
-        names
-      end
     end
   end
 end

data/lib/pg_canary/rules/definitions/count_star_without_where.rb

@@ -2,16 +2,16 @@
 
 module PgCanary
   module Rules
-    # Tier 2 (opt-in): SELECT COUNT(*) without WHERE. Because of MVCC,
+    # SELECT COUNT(*) without WHERE. Because of MVCC,
     # PostgreSQL has no O(1) row count — this scans the whole table.
     class CountStarWithoutWhere < Base
-      def default_enabled
-        false
-      end
+      default_enabled false
+
+      using PgCanary::PgQueryRefinement
 
-      def check(query)
+      def check
         detections = []
-        query.each_scope do |scope|
+        each_scope do |scope|
           stmt = scope.stmt
           next if stmt.where_clause || stmt.group_clause.any?
           next unless count_star?(stmt)
@@ -20,10 +20,9 @@ module PgCanary
           next unless tables.length == 1
 
           table = tables.first
-          next unless applicable_table?(query, table)
+          next unless applicable_table?(table)
 
           detections << detection(
-            query,
             table: table,
             message: "COUNT(*) without WHERE scans the whole #{table} table — PostgreSQL's MVCC " \
                      "has no O(1) row count.",
@@ -39,15 +38,15 @@ module PgCanary
 
       private
 
-      def count_star?(stmt)
-        stmt.target_list.any? do |target|
-          res_target = unwrap_node(target)
-          next false unless res_target.is_a?(PgQuery::ResTarget)
+        def count_star?(stmt)
+          stmt.target_list.any? do |target|
+            res_target = target.unwrap
+            next false unless res_target.is_a?(PgQuery::ResTarget)
 
-          func = unwrap_node(res_target.val)
-          func.is_a?(PgQuery::FuncCall) && func.agg_star && function_name(func) == "count"
+            func = res_target.val&.unwrap
+            func.is_a?(PgQuery::FuncCall) && func.agg_star && func.function_name == "count"
+          end
         end
-      end
     end
   end
 end

data/lib/pg_canary/rules/definitions/deep_offset.rb

@@ -7,25 +7,21 @@ module PgCanary
     # bind ($n), which static SQL linters cannot do.
     # Threshold: config.rules.deep_offset.threshold (default 1000).
     class DeepOffset < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+      option :threshold, default: 1000
 
-      def self.options
-        { threshold: 1000 }
-      end
+      using PgCanary::PgQueryRefinement
 
-      def check(query)
-        threshold = rule_config(query).threshold
+      def check
+        threshold = rule_config.threshold
         detections = []
-        query.each_scope do |scope|
+        each_scope do |scope|
           next unless scope.stmt.limit_offset
 
-          value = numeric_value(query, scope.stmt.limit_offset)
+          value = numeric_value(scope.stmt.limit_offset)
           next unless value && value >= threshold
 
           detections << detection(
-            query,
             table: scope.tables.length == 1 ? scope.tables.first : nil,
             message: "OFFSET #{value} reads and discards #{value} rows before returning anything — " \
                      "offset pagination degrades linearly with page depth.",
@@ -40,20 +36,20 @@ module PgCanary
 
       private
 
-      def numeric_value(query, node)
-        node = strip_type_casts(node)
-        case node
-        when PgQuery::A_Const
-          value = constant_value(node)
-          value.is_a?(Numeric) ? value.to_i : nil
-        when PgQuery::ParamRef
-          begin
-            Integer(query.bind_value(node.number), exception: false)
-          rescue TypeError
-            nil
+        def numeric_value(node)
+          node = node&.strip_casts
+          case node
+          when PgQuery::A_Const
+            value = node.value
+            value.is_a?(Numeric) ? value.to_i : nil
+          when PgQuery::ParamRef
+            begin
+              Integer(bind_value(node.number), exception: false)
+            rescue TypeError
+              nil
+            end
           end
         end
-      end
     end
   end
 end