pg_canary 0.2.0 → 0.3.0

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

@@ -2,90 +2,89 @@
 
 module PgCanary
   module Rules
-    # Tier 2 (opt-in): equality/range predicates on columns with no index
+    # equality/range predicates on columns with no index
     # whose leading column could serve them. Depends on production table
     # size — a 30-row lookup table is fine without indexes — hence disabled
     # by default.
     class UnindexedWhere < Base
-      def default_enabled
-        false
-      end
+      default_enabled false
+
+      using PgCanary::PgQueryRefinement
 
-      def check(query)
-        query.each_scope.with_object([]) do |scope, detections|
+      def check
+        each_scope.with_object([]) do |scope, detections|
           next unless scope.where_clause
 
-          predicate_columns(query, scope).each do |table, columns|
-            next unless applicable_table?(query, table)
-            next if served_by_index?(query, table, columns)
+          predicate_columns(scope).each do |table, columns|
+            next unless applicable_table?(table)
+            next if served_by_index?(table, columns)
 
-            detections << build(query, table, columns)
+            detections << build(table, columns)
           end
         end
       end
 
       private
 
-      # => { table => [column, ...] } for plain-column predicates in WHERE.
-      def predicate_columns(_query, scope)
-        result = Hash.new { |h, k| h[k] = [] }
-        walk_within_scope(scope.where_clause) do |node|
-          next unless node.is_a?(PgQuery::A_Expr) && indexable_predicate?(node)
+        # => { table => [column, ...] } for plain-column predicates in WHERE.
+        def predicate_columns(scope)
+          result = Hash.new { |h, k| h[k] = [] }
+          scope.where_clause.walk_scope do |node|
+            next unless node.is_a?(PgQuery::A_Expr) && indexable_predicate?(node)
 
-          [node.lexpr, node.rexpr].each do |side|
-            column_ref = unwrap_node(side)
-            next unless column_ref.is_a?(PgQuery::ColumnRef)
-            next unless constant_side?(node, side)
+            [node.lexpr, node.rexpr].each do |side|
+              column_ref = side&.unwrap
+              next unless column_ref.is_a?(PgQuery::ColumnRef)
+              next unless constant_side?(node, side)
 
-            table, column = scope.resolve(column_ref)
-            result[table] << column if table && column
+              table, column = scope.resolve(column_ref)
+              result[table] << column if table && column
+            end
           end
+          result.transform_values(&:uniq)
         end
-        result.transform_values(&:uniq)
-      end
 
-      def indexable_predicate?(a_expr)
-        comparison_expr?(a_expr) ||
-          %i[AEXPR_IN AEXPR_BETWEEN AEXPR_LIKE AEXPR_ILIKE].include?(a_expr.kind)
-      end
+        def indexable_predicate?(a_expr)
+          a_expr.comparison? ||
+            %i[AEXPR_IN AEXPR_BETWEEN AEXPR_LIKE AEXPR_ILIKE].include?(a_expr.kind)
+        end
 
-      # Only count `column <op> constant-ish` predicates; column-to-column
-      # comparisons (join conditions in WHERE) are not our business here.
-      def constant_side?(a_expr, column_side)
-        other = a_expr.lexpr.equal?(column_side) ? a_expr.rexpr : a_expr.lexpr
-        node = strip_type_casts(other)
-        case node
-        when PgQuery::A_Const, PgQuery::ParamRef
-          true
-        when PgQuery::List
-          node.items.all? { |i| strip_type_casts(i).is_a?(PgQuery::A_Const) || strip_type_casts(i).is_a?(PgQuery::ParamRef) }
-        else
-          false
+        # Only count `column <op> constant-ish` predicates; column-to-column
+        # comparisons (join conditions in WHERE) are not our business here.
+        def constant_side?(a_expr, column_side)
+          other = a_expr.lexpr.equal?(column_side) ? a_expr.rexpr : a_expr.lexpr
+          node = other&.strip_casts
+          case node
+          when PgQuery::A_Const, PgQuery::ParamRef
+            true
+          when PgQuery::List
+            node.items.all? { |i| i.strip_casts.is_a?(PgQuery::A_Const) || i.strip_casts.is_a?(PgQuery::ParamRef) }
+          else
+            false
+          end
         end
-      end
 
-      # Leftmost-prefix rule: an index helps when its leading column is one
-      # of the predicate columns.
-      def served_by_index?(query, table, columns)
-        query.indexes(table).any? do |index|
-          index.leading_column && columns.include?(index.leading_column)
+        # Leftmost-prefix rule: an index helps when its leading column is one
+        # of the predicate columns.
+        def served_by_index?(table, columns)
+          indexes(table).any? do |index|
+            index.leading_column && columns.include?(index.leading_column)
+          end
         end
-      end
 
-      def build(query, table, columns)
-        column_list = columns.join(", ")
-        detection(
-          query,
-          table: table,
-          columns: columns,
-          message: "No index leads with any of the WHERE predicate columns (#{table}.#{column_list}). " \
-                   "Depending on production row counts, this becomes a full scan.",
-          suggestion: <<~SUGGESTION.chomp
-            Consider adding an index (equality columns first):
-              CREATE INDEX index_#{table}_on_#{columns.join("_and_")} ON #{table} (#{column_list});
-          SUGGESTION
-        )
-      end
+        def build(table, columns)
+          column_list = columns.join(", ")
+          detection(
+            table: table,
+            columns: columns,
+            message: "No index leads with any of the WHERE predicate columns (#{table}.#{column_list}). " \
+                     "Depending on production row counts, this becomes a full scan.",
+            suggestion: <<~SUGGESTION.chomp
+              Consider adding an index (equality columns first):
+                CREATE INDEX index_#{table}_on_#{columns.join("_and_")} ON #{table} (#{column_list});
+            SUGGESTION
+          )
+        end
     end
   end
 end

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

@@ -2,21 +2,18 @@
 
 module PgCanary
   module Rules
-    # Tier 2 (opt-in): UNION without ALL deduplicates the combined result by
+    # UNION without ALL deduplicates the combined result by
     # sorting/hashing all rows. When the branches cannot overlap (or
     # duplicates are acceptable), UNION ALL skips that work. Whether
     # deduplication is intended is the author's call, hence opt-in.
     class UnionInsteadOfUnionAll < Base
-      def default_enabled
-        false
-      end
+      default_enabled false
 
-      def check(query)
-        union = query.scopes.find { |scope| scope.stmt.op == :SETOP_UNION && !scope.stmt.all }
+      def check
+        union = scopes.find { |scope| scope.stmt.op == :SETOP_UNION && !scope.stmt.all }
         return [] unless union
 
         [detection(
-          query,
           message: "UNION (without ALL) sorts/hashes the entire combined result to remove duplicates.",
           suggestion: "If the branches cannot produce overlapping rows — or duplicates are acceptable — use UNION ALL."
         )]

data/lib/pg_canary/rules/detection.rb

@@ -8,7 +8,7 @@ module PgCanary
     # fired, on which query, which table/columns are involved, why it is a
     # problem, and how to fix it.
     Detection = Struct.new(
-      :rule_name, :severity, :sql, :table, :columns,
+      :rule_name, :sql, :table, :columns,
       :message, :suggestion, :location, :fingerprint,
       keyword_init: true
     ) do

data/lib/pg_canary/rules/index_predicates.rb

@@ -9,31 +9,31 @@ module PgCanary
 
       private
 
-      def trgm_index?(query, table, column)
-        query.indexes(table).any? do |index|
-          TRGM_ACCESS_METHODS.include?(index.using) &&
-            index.columns.include?(column) &&
-            index.opclasses[column].to_s.include?("trgm")
+        def trgm_index?(table, column)
+          indexes(table).any? do |index|
+            TRGM_ACCESS_METHODS.include?(index.using) &&
+              index.columns.include?(column) &&
+              index.opclasses[column].to_s.include?("trgm")
+          end
         end
-      end
 
-      def gin_index_on?(query, table, column)
-        query.indexes(table).any? { |index| index.using == "gin" && index.columns.include?(column) }
-      end
+        def gin_index_on?(table, column)
+          indexes(table).any? { |index| index.using == "gin" && index.columns.include?(column) }
+        end
 
-      # Any expression index whose expression mentions the column.
-      # Deliberately loose (column-level word match, not expression
-      # equality) to avoid false positives.
-      def expression_index_referencing?(query, table, column)
-        query.indexes(table).any? do |index|
-          index.expressions&.match?(/\b#{Regexp.escape(column)}\b/)
+        # Any expression index whose expression mentions the column.
+        # Deliberately loose (column-level word match, not expression
+        # equality) to avoid false positives.
+        def expression_index_referencing?(table, column)
+          indexes(table).any? do |index|
+            index.expressions&.match?(/\b#{Regexp.escape(column)}\b/)
+          end
         end
-      end
 
-      # Whether any index's leading column is +column+ (leftmost-prefix rule).
-      def index_leading_with?(query, table, column)
-        query.indexes(table).any? { |index| index.leading_column == column }
-      end
+        # Whether any index's leading column is +column+ (leftmost-prefix rule).
+        def index_leading_with?(table, column)
+          indexes(table).any? { |index| index.leading_column == column }
+        end
     end
   end
 end

data/lib/pg_canary/rules/schema_introspection.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module PgCanary
+  module Rules
+    # Index and column metadata for the rules, read through ActiveRecord's
+    # schema cache — caching, invalidation and thread safety ride on Rails.
+    # The catalog queries ActiveRecord issues are named "SCHEMA", which the
+    # Subscriber already ignores, so they are never analyzed themselves.
+    module SchemaIntrospection
+      IndexInfo = Struct.new(
+        :name,        # index name
+        :using,       # access method: "btree", "gin", "gist", ...
+        :columns,     # [String] — empty for expression indexes
+        :opclasses,   # { column => opclass } for non-default opclasses
+        :expressions, # SQL string of the indexed expressions, or nil
+        keyword_init: true
+      ) do
+        def leading_column
+          columns.first
+        end
+      end
+
+      module_function
+
+      # => [IndexInfo] — includes the primary key, which ActiveRecord's
+      # #indexes omits.
+      def indexes(connection, table)
+        cache = connection.schema_cache
+        return [] unless cache.data_source_exists?(table)
+
+        list = cache.indexes(table).map { |definition| index_info(definition) }
+        primary_key = Array(cache.primary_keys(table))
+        if primary_key.any?
+          list << IndexInfo.new(name: "#{table}_pkey", using: "btree",
+                                columns: primary_key, opclasses: {}, expressions: nil)
+        end
+        list
+      rescue StandardError => e
+        PgCanary.internal_error(e)
+        []
+      end
+
+      def column_type(connection, table, column)
+        column_types(connection, table)[column]
+      end
+
+      # => { column_name => sql_type } e.g. { "id" => "bigint", "tags" => "text[]" }
+      def column_types(connection, table)
+        cache = connection.schema_cache
+        return {} unless cache.data_source_exists?(table)
+
+        cache.columns(table).to_h do |column|
+          type = column.sql_type
+          type = "#{type}[]" if column.respond_to?(:array?) && column.array?
+          [column.name, type]
+        end
+      rescue StandardError => e
+        PgCanary.internal_error(e)
+        {}
+      end
+
+      # ActiveRecord returns plain-column indexes with an Array of column
+      # names, and expression indexes with the expressions as one SQL String.
+      def index_info(definition)
+        expressions = definition.columns.is_a?(String) ? definition.columns : nil
+        columns = expressions ? [] : Array(definition.columns)
+        opclasses = definition.opclasses
+        opclasses = columns.to_h { |c| [c, opclasses.to_s] } unless opclasses.is_a?(Hash)
+        IndexInfo.new(name: definition.name, using: definition.using.to_s,
+                      columns: columns, opclasses: opclasses, expressions: expressions)
+      end
+    end
+  end
+end

data/lib/pg_canary/rules/scope.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module PgCanary
+  module Rules
+    # One SELECT scope (top-level statement, CTE, subquery, ...) with its
+    # own FROM-clause alias resolution.
+    class Scope
+      using PgCanary::PgQueryRefinement
+
+      attr_reader :stmt, :aliases
+
+      def initialize(stmt)
+        @stmt = stmt
+        @aliases = {}
+        collect_aliases(stmt.from_clause)
+      end
+
+      def where_clause
+        stmt.where_clause
+      end
+
+      # => [PgQuery::SortBy]
+      def sort_items
+        stmt.sort_clause.map(&:unwrap).grep(PgQuery::SortBy)
+      end
+
+      def limited?
+        !stmt.limit_count.nil?
+      end
+
+      # Real table names referenced directly in this scope's FROM clause.
+      def tables
+        @aliases.values.compact.uniq
+      end
+
+      # Resolves a ColumnRef to [table, column]. Returns nil when the ref
+      # cannot be attributed to a real table unambiguously (unknown alias,
+      # subquery output, multiple candidate tables for an unqualified ref).
+      def resolve(column_ref)
+        fields = column_ref.field_names
+        return nil if fields.nil? || fields.empty?
+
+        column = fields.last
+        if fields.length >= 2
+          table = @aliases[fields[-2]]
+          table ? [table, column] : nil
+        else
+          tables.length == 1 ? [tables.first, column] : nil
+        end
+      end
+
+      private
+
+        def collect_aliases(from_clause)
+          from_clause.each { |node| collect_from_node(node.unwrap) }
+        end
+
+        def collect_from_node(node)
+          case node
+          when PgQuery::RangeVar
+            name = node.alias&.aliasname
+            name = node.relname if name.nil? || name.empty?
+            @aliases[name] = node.relname
+          when PgQuery::JoinExpr
+            collect_from_node(node.larg&.unwrap)
+            collect_from_node(node.rarg&.unwrap)
+          when PgQuery::RangeSubselect
+            name = node.alias&.aliasname
+            @aliases[name] = nil if name && !name.empty?
+          end
+        end
+    end
+  end
+end

data/lib/pg_canary/subscriber.rb

@@ -25,17 +25,17 @@ module PgCanary
 
       private
 
-      def analysis_target?(payload)
-        return false if payload[:cached]
-        return false if payload[:name] && IGNORED_NAMES.include?(payload[:name])
-        return false unless payload[:sql]&.match?(SELECT_PREFIX)
+        def analysis_target?(payload)
+          return false if payload[:cached]
+          return false if payload[:name] && IGNORED_NAMES.include?(payload[:name])
+          return false unless payload[:sql]&.match?(SELECT_PREFIX)
 
-        !!payload[:connection]&.adapter_name&.match?(/postg/i)
-      end
+          !!payload[:connection]&.adapter_name&.match?(/postg/i)
+        end
 
-      def detector
-        @detector ||= Detector.new(PgCanary.config)
-      end
+        def detector
+          @detector ||= Detector.new(PgCanary.config)
+        end
     end
   end
 end

data/lib/pg_canary/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgCanary
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/pg_canary.rb

@@ -5,10 +5,10 @@ require "pg_query"
 
 require_relative "pg_canary/version"
 require_relative "pg_canary/configuration"
-require_relative "pg_canary/pg_query_support"
-require_relative "pg_canary/schema_introspection"
+require_relative "pg_canary/pg_query_refinement"
+require_relative "pg_canary/rules/schema_introspection"
 require_relative "pg_canary/rules/detection"
-require_relative "pg_canary/rules/query_context"
+require_relative "pg_canary/rules/scope"
 require_relative "pg_canary/rules/base"
 require_relative "pg_canary/rules/index_predicates"
 Dir[File.join(__dir__, "pg_canary", "rules", "definitions", "*.rb")].each { |file| require file }
@@ -35,24 +35,24 @@ module PgCanary
 
     private
 
-    def logger
-      config.logger || default_logger
-    end
+      def logger
+        config.logger || default_logger
+      end
 
-    def default_logger
-      @default_logger ||= begin
-        require "logger"
-        ::Logger.new($stderr)
+      def default_logger
+        @default_logger ||= begin
+          require "logger"
+          ::Logger.new($stderr)
+        end
       end
-    end
 
-    def warn_once(message)
-      @warned ||= {}
-      return if @warned[message]
+      def warn_once(message)
+        @warned ||= {}
+        return if @warned[message]
 
-      @warned[message] = true
-      logger.warn(message)
-    end
+        @warned[message] = true
+        logger.warn(message)
+      end
   end
 
   if defined?(Rails::Railtie)
@@ -67,7 +67,7 @@ module PgCanary
 
       config.after_initialize do
         config = PgCanary.config
-        config.enabled = Rails.env.development? || Rails.env.test? if config.enabled.nil?
+        config.enabled = Rails.env.development? if config.enabled.nil?
         config.logger ||= Rails.logger
         Subscriber.subscribe! if config.enabled
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_canary
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - kyuuri1791
@@ -68,7 +68,7 @@ files:
 - lib/pg_canary/configuration.rb
 - lib/pg_canary/detector.rb
 - lib/pg_canary/middleware.rb
-- lib/pg_canary/pg_query_support.rb
+- lib/pg_canary/pg_query_refinement.rb
 - lib/pg_canary/rules/base.rb
 - lib/pg_canary/rules/definitions/array_search_without_gin.rb
 - lib/pg_canary/rules/definitions/cartesian_join.rb
@@ -93,8 +93,8 @@ files:
 - lib/pg_canary/rules/definitions/union_instead_of_union_all.rb
 - lib/pg_canary/rules/detection.rb
 - lib/pg_canary/rules/index_predicates.rb
-- lib/pg_canary/rules/query_context.rb
-- lib/pg_canary/schema_introspection.rb
+- lib/pg_canary/rules/schema_introspection.rb
+- lib/pg_canary/rules/scope.rb
 - lib/pg_canary/subscriber.rb
 - lib/pg_canary/version.rb
 homepage: https://github.com/kyuuri1791/pg_canary

data/lib/pg_canary/pg_query_support.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module PgCanary
-  # Helpers over the pg_query protobuf AST — the unwrapping, traversal and
-  # value extraction the pg_query gem does not provide itself. Mix into
-  # anything that inspects parsed queries (include for instance level,
-  # extend for class level).
-  module PgQuerySupport
-    COMPARISON_OPS = %w[= <> != < > <= >=].freeze
-
-    private
-
-    # --- unwrapping wrapper nodes -------------------------------------
-
-    # Unwraps a PgQuery::Node (oneof wrapper) into its inner message.
-    def unwrap_node(node)
-      return nil if node.nil?
-      return node unless node.is_a?(PgQuery::Node)
-
-      node.node ? node.inner : nil
-    end
-
-    # Strips TypeCast wrappers: `'foo'::text` → the A_Const for 'foo'.
-    def strip_type_casts(node)
-      node = unwrap_node(node)
-      node = unwrap_node(node.arg) while node.is_a?(PgQuery::TypeCast)
-      node
-    end
-
-    # --- traversal ----------------------------------------------------
-
-    # Depth-first walk over every protobuf message under +node+, yielding
-    # each unwrapped message. When +prune+ returns true for a message, it is
-    # yielded but its children are not visited.
-    def walk_ast(node, prune: nil, &block)
-      node = unwrap_node(node)
-      return if node.nil?
-      return unless node.is_a?(Google::Protobuf::MessageExts)
-
-      yield node
-      return if prune&.call(node)
-
-      each_ast_child(node) { |child| walk_ast(child, prune: prune, &block) }
-    end
-
-    # Yields every message-typed child of a protobuf message.
-    def each_ast_child(node, &block)
-      node.class.descriptor.each do |field|
-        next unless field.type == :message
-
-        value = node[field.name]
-        next if value.nil?
-
-        if value.is_a?(Google::Protobuf::RepeatedField)
-          value.each(&block)
-        else
-          yield value
-        end
-      end
-    end
-
-    # Walk that does not descend into nested sub-selects, so each scope is
-    # analyzed exactly once. Yielding starts at the given node's children,
-    # i.e. pass a where_clause / sort item, not a whole statement.
-    def walk_within_scope(node, &)
-      root_seen = false
-      walk_ast(node, prune: lambda { |msg|
-        if root_seen
-          msg.is_a?(PgQuery::SelectStmt)
-        else
-          root_seen = true # never prune the root itself
-          false
-        end
-      }, &)
-    end
-
-    # --- reading values out of nodes ----------------------------------
-
-    # ["users", "name"] for "users"."name"; nil when the ref contains A_Star.
-    def column_ref_fields(column_ref)
-      fields = column_ref.fields.map { |f| unwrap_node(f) }
-      return nil unless fields.all?(PgQuery::String)
-
-      fields.map(&:sval)
-    end
-
-    def string_values(nodes)
-      nodes.map { |n| unwrap_node(n) }.grep(PgQuery::String).map(&:sval)
-    end
-
-    # Operator name of an A_Expr, e.g. "=", "~~", "~~*".
-    def operator_name(a_expr)
-      string_values(a_expr.name).last
-    end
-
-    # Unqualified, downcased function name of a FuncCall.
-    def function_name(func_call)
-      string_values(func_call.funcname).last&.downcase
-    end
-
-    # Ruby value of an A_Const: Integer, Float, String, true/false or nil.
-    def constant_value(a_const)
-      case a_const.val
-      when :ival then a_const.ival.ival
-      when :fval then a_const.fval.fval.to_f
-      when :sval then a_const.sval.sval
-      when :boolval then a_const.boolval.boolval
-      end
-    end
-
-    def comparison_expr?(a_expr)
-      a_expr.kind == :AEXPR_OP && COMPARISON_OPS.include?(operator_name(a_expr))
-    end
-  end
-end