pg_canary 0.2.0 → 0.3.0

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

@@ -2,23 +2,22 @@
 
 module PgCanary
   module Rules
-    # Tier 2 (opt-in): DISTINCT combined with JOIN. Frequently the DISTINCT
+    # DISTINCT combined with JOIN. Frequently the DISTINCT
     # only exists to undo row fanout caused by the join — the work of
     # producing and then deduplicating the duplicates is wasted. Legitimate
     # uses exist, hence opt-in.
     class DistinctWithJoin < 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|
           next unless scope.stmt.distinct_clause.any?
           next unless joined?(scope)
 
           detections << detection(
-            query,
             table: scope.tables.first,
             message: "DISTINCT combined with JOIN often hides row fanout from the join: duplicate rows " \
                      "are produced and then sorted/hashed away.",
@@ -31,9 +30,9 @@ module PgCanary
 
       private
 
-      def joined?(scope)
-        scope.stmt.from_clause.any? { |item| unwrap_node(item).is_a?(PgQuery::JoinExpr) }
-      end
+        def joined?(scope)
+          scope.stmt.from_clause.any? { |item| item.unwrap.is_a?(PgQuery::JoinExpr) }
+        end
     end
   end
 end

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

@@ -7,22 +7,22 @@ module PgCanary
     # Silent when a matching expression index (same function, same column)
     # exists.
     class FunctionOnColumn < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+
+      using PgCanary::PgQueryRefinement
 
       CHECKED_KINDS = %i[AEXPR_OP AEXPR_LIKE AEXPR_ILIKE AEXPR_IN AEXPR_BETWEEN].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) && CHECKED_KINDS.include?(node.kind)
 
             [node.lexpr, node.rexpr].each do |side|
-              detections << inspect_side(query, scope, side)
+              detections << inspect_side(scope, side)
             end
           end
         end
@@ -31,55 +31,54 @@ module PgCanary
 
       private
 
-      # The first ColumnRef inside the function call (arguments may nest,
-      # e.g. lower(trim(email))).
-      def first_column_ref(node)
-        found = nil
-        walk_within_scope(node) do |msg|
-          found ||= msg if msg.is_a?(PgQuery::ColumnRef)
+        # The first ColumnRef inside the function call (arguments may nest,
+        # e.g. lower(trim(email))).
+        def first_column_ref(node)
+          found = nil
+          node.walk_scope do |msg|
+            found ||= msg if msg.is_a?(PgQuery::ColumnRef)
+          end
+          found
         end
-        found
-      end
 
-      def inspect_side(query, scope, side)
-        func = strip_type_casts(side)
-        return nil unless func.is_a?(PgQuery::FuncCall)
+        def inspect_side(scope, side)
+          func = side&.strip_casts
+          return nil unless func.is_a?(PgQuery::FuncCall)
 
-        column_ref = first_column_ref(func)
-        return nil unless column_ref
+          column_ref = first_column_ref(func)
+          return nil unless column_ref
 
-        table, column = scope.resolve(column_ref)
-        return nil unless table && column
-        return nil unless applicable_table?(query, table)
+          table, column = scope.resolve(column_ref)
+          return nil unless table && column
+          return nil unless applicable_table?(table)
 
-        func_name = function_name(func)
-        return nil if expression_index?(query, table, column, func_name)
+          func_name = func.function_name
+          return nil if expression_index?(table, column, func_name)
 
-        detection(
-          query,
-          table: table,
-          columns: column,
-          message: "#{table}.#{column} is wrapped in #{func_name}() inside WHERE, " \
-                   "so a plain index on #{column} cannot be used.",
-          suggestion: <<~SUGGESTION.chomp
-            Consider adding an expression index:
-              CREATE INDEX index_#{table}_on_#{func_name}_#{column} ON #{table} ((#{func_name}(#{column})));
-          SUGGESTION
-        )
-      end
+          detection(
+            table: table,
+            columns: column,
+            message: "#{table}.#{column} is wrapped in #{func_name}() inside WHERE, " \
+                     "so a plain index on #{column} cannot be used.",
+            suggestion: <<~SUGGESTION.chomp
+              Consider adding an expression index:
+                CREATE INDEX index_#{table}_on_#{func_name}_#{column} ON #{table} ((#{func_name}(#{column})));
+            SUGGESTION
+          )
+        end
 
-      # Matches by (function name, column name) word match against the index
-      # expression SQL — a deliberate approximation that already avoids the
-      # common false positives.
-      def expression_index?(query, table, column, func_name)
-        query.indexes(table).any? do |index|
-          expressions = index.expressions
-          next false unless expressions
+        # Matches by (function name, column name) word match against the index
+        # expression SQL — a deliberate approximation that already avoids the
+        # common false positives.
+        def expression_index?(table, column, func_name)
+          indexes(table).any? do |index|
+            expressions = index.expressions
+            next false unless expressions
 
-          expressions.match?(/\b#{Regexp.escape(func_name)}\s*\(/i) &&
-            expressions.match?(/\b#{Regexp.escape(column)}\b/)
+            expressions.match?(/\b#{Regexp.escape(func_name)}\s*\(/i) &&
+              expressions.match?(/\b#{Regexp.escape(column)}\b/)
+          end
         end
-      end
     end
   end
 end

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

@@ -8,29 +8,25 @@ module PgCanary
     # SQL linters cannot see.
     # Threshold: config.rules.huge_in_list.threshold (default 500).
     class HugeInList < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+      option :threshold, default: 500
 
-      def self.options
-        { threshold: 500 }
-      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.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)
 
-            count = value_count(query, node)
+            count = value_count(node)
             next unless count && count > threshold
 
             table, column = resolve_lexpr(scope, node)
             detections << detection(
-              query,
               table: table,
               columns: column,
               message: "IN / ANY list with #{count} values (threshold: #{threshold}). Huge value lists " \
@@ -45,26 +41,26 @@ module PgCanary
 
       private
 
-      def value_count(query, a_expr)
-        case a_expr.kind
-        when :AEXPR_IN
-          list = unwrap_node(a_expr.rexpr)
-          list.is_a?(PgQuery::List) ? list.items.length : nil
-        when :AEXPR_OP_ANY
-          param = strip_type_casts(a_expr.rexpr)
-          return nil unless param.is_a?(PgQuery::ParamRef)
+        def value_count(a_expr)
+          case a_expr.kind
+          when :AEXPR_IN
+            list = a_expr.rexpr&.unwrap
+            list.is_a?(PgQuery::List) ? list.items.length : nil
+          when :AEXPR_OP_ANY
+            param = a_expr.rexpr&.strip_casts
+            return nil unless param.is_a?(PgQuery::ParamRef)
 
-          value = query.bind_value(param.number)
-          value.is_a?(Array) ? value.length : nil
+            value = bind_value(param.number)
+            value.is_a?(Array) ? value.length : nil
+          end
         end
-      end
 
-      def resolve_lexpr(scope, a_expr)
-        column_ref = strip_type_casts(a_expr.lexpr)
-        return nil unless column_ref.is_a?(PgQuery::ColumnRef)
+        def resolve_lexpr(scope, a_expr)
+          column_ref = a_expr.lexpr&.strip_casts
+          return nil unless column_ref.is_a?(PgQuery::ColumnRef)
 
-        scope.resolve(column_ref)
-      end
+          scope.resolve(column_ref)
+        end
     end
   end
 end

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

@@ -6,22 +6,22 @@ module PgCanary
     # (age = 1.5) makes PostgreSQL cast the *column* to numeric, which
     # disables its index. Restricted to cases provable from the AST alone.
     class ImplicitCast < Base
-      def default_enabled
-        true
-      end
+      default_enabled true
+
+      using PgCanary::PgQueryRefinement
 
       INTEGER_TYPES = %w[smallint integer bigint].freeze
       NUMERIC_TYPE_NAMES = %w[numeric decimal float4 float8].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|
-            next unless node.is_a?(PgQuery::A_Expr) && comparison_expr?(node)
+          scope.where_clause.walk_scope do |node|
+            next unless node.is_a?(PgQuery::A_Expr) && node.comparison?
 
-            detections << inspect_comparison(query, scope, node)
+            detections << inspect_comparison(scope, node)
           end
         end
         detections.compact
@@ -29,47 +29,46 @@ module PgCanary
 
       private
 
-      def inspect_comparison(query, scope, expr)
-        left = unwrap_node(expr.lexpr)
-        right = unwrap_node(expr.rexpr)
+        def inspect_comparison(scope, expr)
+          left = expr.lexpr&.unwrap
+          right = expr.rexpr&.unwrap
 
-        column_ref, value = if left.is_a?(PgQuery::ColumnRef)
-                              [left, right]
-                            elsif right.is_a?(PgQuery::ColumnRef)
-                              [right, left]
-                            end
-        return nil unless column_ref
-        return nil unless numeric_literal?(value)
+          column_ref, value = if left.is_a?(PgQuery::ColumnRef)
+                                [left, right]
+                              elsif right.is_a?(PgQuery::ColumnRef)
+                                [right, left]
+                              end
+          return nil unless column_ref
+          return nil unless numeric_literal?(value)
 
-        table, column = scope.resolve(column_ref)
-        return nil unless table && column
-        return nil unless applicable_table?(query, table)
+          table, column = scope.resolve(column_ref)
+          return nil unless table && column
+          return nil unless applicable_table?(table)
 
-        column_type = query.column_type(table, column)
-        return nil unless INTEGER_TYPES.include?(column_type)
+          type = column_type(table, column)
+          return nil unless INTEGER_TYPES.include?(type)
 
-        detection(
-          query,
-          table: table,
-          columns: column,
-          message: "Comparing #{table}.#{column} (#{column_type}) with a numeric literal implicitly " \
-                   "casts the column to numeric, disabling any index on #{column}.",
-          suggestion: "Use a literal that matches the column type (integer)."
-        )
-      end
+          detection(
+            table: table,
+            columns: column,
+            message: "Comparing #{table}.#{column} (#{type}) with a numeric literal implicitly " \
+                     "casts the column to numeric, disabling any index on #{column}.",
+            suggestion: "Use a literal that matches the column type (integer)."
+          )
+        end
 
-      # A numeric/float literal, or an explicit cast to numeric of a literal.
-      def numeric_literal?(node)
-        case node
-        when PgQuery::A_Const
-          node.val == :fval
-        when PgQuery::TypeCast
-          type = string_values(node.type_name.names).last
-          NUMERIC_TYPE_NAMES.include?(type) && strip_type_casts(node).is_a?(PgQuery::A_Const)
-        else
-          false
+        # A numeric/float literal, or an explicit cast to numeric of a literal.
+        def numeric_literal?(node)
+          case node
+          when PgQuery::A_Const
+            node.val == :fval
+          when PgQuery::TypeCast
+            type = node.type_name.names.string_values.last
+            NUMERIC_TYPE_NAMES.include?(type) && node.strip_casts.is_a?(PgQuery::A_Const)
+          else
+            false
+          end
         end
-      end
     end
   end
 end

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

@@ -8,28 +8,28 @@ module PgCanary
     # - key extraction (->> etc.) compared against a value needs a matching
     #   expression index
     class JsonbSearchWithoutGin < Base
+      default_enabled true
+
       include IndexPredicates
 
-      def default_enabled
-        true
-      end
+      using PgCanary::PgQueryRefinement
 
       CONTAINMENT_OPS = %w[@> <@ ? ?| ?&].freeze
       EXTRACTION_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) && node.kind == :AEXPR_OP
 
-            operator = operator_name(node)
+            operator = node.operator
             if CONTAINMENT_OPS.include?(operator)
-              detections << inspect_containment(query, scope, node, operator)
+              detections << inspect_containment(scope, node, operator)
             elsif EXTRACTION_OPS.include?(operator)
-              detections << inspect_extraction(query, scope, node, operator)
+              detections << inspect_extraction(scope, node, operator)
             end
           end
         end
@@ -38,67 +38,65 @@ module PgCanary
 
       private
 
-      def inspect_containment(query, scope, expr, operator)
-        table, column = jsonb_column(query, scope, [expr.lexpr, expr.rexpr])
-        return nil unless table
-        return nil if gin_index_on?(query, table, column)
-
-        detection(
-          query,
-          table: table,
-          columns: column,
-          message: "#{operator} search on jsonb column #{table}.#{column} has no GIN index " \
-                   "and will scan every row in production.",
-          suggestion: <<~SUGGESTION.chomp
-            Consider a GIN index (jsonb_path_ops is smaller/faster if you only use @>):
-              CREATE INDEX index_#{table}_on_#{column} ON #{table} USING gin (#{column});
-          SUGGESTION
-        )
-      end
+        def inspect_containment(scope, expr, operator)
+          table, column = jsonb_column(scope, [expr.lexpr, expr.rexpr])
+          return nil unless table
+          return nil if gin_index_on?(table, column)
+
+          detection(
+            table: table,
+            columns: column,
+            message: "#{operator} search on jsonb column #{table}.#{column} has no GIN index " \
+                     "and will scan every row in production.",
+            suggestion: <<~SUGGESTION.chomp
+              Consider a GIN index (jsonb_path_ops is smaller/faster if you only use @>):
+                CREATE INDEX index_#{table}_on_#{column} ON #{table} USING gin (#{column});
+            SUGGESTION
+          )
+        end
 
-      def inspect_extraction(query, scope, expr, operator)
-        table, column = jsonb_column(query, scope, [expr.lexpr])
-        return nil unless table
-        return nil if expression_index_referencing?(query, table, column)
-
-        key = extraction_key(expr)
-        expr_sql = "#{column} #{operator} #{key ? "'#{key}'" : "..."}"
-        detection(
-          query,
-          table: table,
-          columns: column,
-          message: "Filtering on #{table}.#{expr_sql} has no matching expression index, " \
-                   "so no index can serve this predicate.",
-          suggestion: <<~SUGGESTION.chomp
-            Consider an expression index on the extracted key:
-              CREATE INDEX index_#{table}_on_#{column}_key ON #{table} ((#{expr_sql.sub("...", "'key'")}));
-          SUGGESTION
-        )
-      end
+        def inspect_extraction(scope, expr, operator)
+          table, column = jsonb_column(scope, [expr.lexpr])
+          return nil unless table
+          return nil if expression_index_referencing?(table, column)
+
+          key = extraction_key(expr)
+          expr_sql = "#{column} #{operator} #{key ? "'#{key}'" : "..."}"
+          detection(
+            table: table,
+            columns: column,
+            message: "Filtering on #{table}.#{expr_sql} has no matching expression index, " \
+                     "so no index can serve this predicate.",
+            suggestion: <<~SUGGESTION.chomp
+              Consider an expression index on the extracted key:
+                CREATE INDEX index_#{table}_on_#{column}_key ON #{table} ((#{expr_sql.sub("...", "'key'")}));
+            SUGGESTION
+          )
+        end
 
-      # First side that is a jsonb-typed, resolvable column.
-      def jsonb_column(query, scope, sides)
-        sides.each do |side|
-          column_ref = strip_type_casts(side)
-          next unless column_ref.is_a?(PgQuery::ColumnRef)
+        # First side that is a jsonb-typed, resolvable column.
+        def jsonb_column(scope, sides)
+          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 query.column_type(table, column) == "jsonb"
+            table, column = scope.resolve(column_ref)
+            next unless table && column
+            next unless applicable_table?(table)
+            next unless column_type(table, column) == "jsonb"
 
-          return [table, column]
+            return [table, column]
+          end
+          nil
         end
-        nil
-      end
 
-      def extraction_key(expr)
-        const = strip_type_casts(expr.rexpr)
-        return nil unless const.is_a?(PgQuery::A_Const)
+        def extraction_key(expr)
+          const = expr.rexpr&.strip_casts
+          return nil unless const.is_a?(PgQuery::A_Const)
 
-        value = constant_value(const)
-        value.is_a?(String) ? value : nil
-      end
+          value = const.value
+          value.is_a?(String) ? value : nil
+        end
     end
   end
 end

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

@@ -7,21 +7,21 @@ module PgCanary
     # helps, so we stay silent when one exists on the column.
     # Bind parameters ($1) are resolved from the event's binds.
     class LeadingWildcardLike < Base
+      default_enabled true
+
       include IndexPredicates
 
-      def default_enabled
-        true
-      end
+      using PgCanary::PgQueryRefinement
 
       LIKE_KINDS = %i[AEXPR_LIKE AEXPR_ILIKE].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|
-            detections << inspect_expr(query, scope, node) if like_expr?(node)
+          scope.where_clause.walk_scope do |node|
+            detections << inspect_expr(scope, node) if like_expr?(node)
           end
         end
         detections.compact
@@ -29,49 +29,48 @@ module PgCanary
 
       private
 
-      def like_expr?(node)
-        node.is_a?(PgQuery::A_Expr) && LIKE_KINDS.include?(node.kind)
-      end
+        def like_expr?(node)
+          node.is_a?(PgQuery::A_Expr) && LIKE_KINDS.include?(node.kind)
+        end
 
-      def inspect_expr(query, scope, expr)
-        column_ref = strip_type_casts(expr.lexpr)
-        return nil unless column_ref.is_a?(PgQuery::ColumnRef)
+        def inspect_expr(scope, expr)
+          column_ref = expr.lexpr&.strip_casts
+          return nil unless column_ref.is_a?(PgQuery::ColumnRef)
 
-        pattern = pattern_value(query, expr.rexpr)
-        return nil unless pattern&.start_with?("%", "_")
+          pattern = pattern_value(expr.rexpr)
+          return nil unless pattern&.start_with?("%", "_")
 
-        table, column = scope.resolve(column_ref)
-        return nil unless table && column
-        return nil unless applicable_table?(query, table)
-        return nil if trgm_index?(query, table, column)
+          table, column = scope.resolve(column_ref)
+          return nil unless table && column
+          return nil unless applicable_table?(table)
+          return nil if trgm_index?(table, column)
 
-        operator = expr.kind == :AEXPR_ILIKE ? "ILIKE" : "LIKE"
-        detection(
-          query,
-          table: table,
-          columns: column,
-          message: "Leading-wildcard #{operator} (#{pattern.inspect}) on #{table}.#{column} cannot use " \
-                   "a btree index and will scan every row in production.",
-          suggestion: <<~SUGGESTION.chomp
-            Consider the pg_trgm extension with a GIN index:
-              CREATE EXTENSION IF NOT EXISTS pg_trgm;
-              CREATE INDEX index_#{table}_on_#{column}_trgm ON #{table} USING gin (#{column} gin_trgm_ops);
-          SUGGESTION
-        )
-      end
+          operator = expr.kind == :AEXPR_ILIKE ? "ILIKE" : "LIKE"
+          detection(
+            table: table,
+            columns: column,
+            message: "Leading-wildcard #{operator} (#{pattern.inspect}) on #{table}.#{column} cannot use " \
+                     "a btree index and will scan every row in production.",
+            suggestion: <<~SUGGESTION.chomp
+              Consider the pg_trgm extension with a GIN index:
+                CREATE EXTENSION IF NOT EXISTS pg_trgm;
+                CREATE INDEX index_#{table}_on_#{column}_trgm ON #{table} USING gin (#{column} gin_trgm_ops);
+            SUGGESTION
+          )
+        end
 
-      # Pattern string from a literal, a cast literal, or a bind parameter.
-      def pattern_value(query, rexpr)
-        node = strip_type_casts(rexpr)
-        case node
-        when PgQuery::A_Const
-          value = constant_value(node)
-          value.is_a?(String) ? value : nil
-        when PgQuery::ParamRef
-          value = query.bind_value(node.number)
-          value.is_a?(String) ? value : nil
+        # Pattern string from a literal, a cast literal, or a bind parameter.
+        def pattern_value(rexpr)
+          node = rexpr&.strip_casts
+          case node
+          when PgQuery::A_Const
+            value = node.value
+            value.is_a?(String) ? value : nil
+          when PgQuery::ParamRef
+            value = bind_value(node.number)
+            value.is_a?(String) ? value : nil
+          end
         end
-      end
     end
   end
 end