pg_canary 0.2.0 → 0.3.0

data/lib/pg_canary/rules/query_context.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-module PgCanary
-  module Rules
-    # What a rule's #check receives: everything about one executed query —
-    # the parsed AST (as Scopes), bind parameter values, the configuration,
-    # and access to schema metadata via the connection the query ran on.
-    class QueryContext
-      include PgQuerySupport
-
-      # One SELECT scope (top-level statement, CTE, subquery, ...) with its
-      # own FROM-clause alias resolution.
-      class Scope
-        include PgQuerySupport
-
-        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 { |n| unwrap_node(n) }.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_fields(column_ref)
-          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(unwrap_node(node)) }
-        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(unwrap_node(node.larg))
-            collect_from_node(unwrap_node(node.rarg))
-          when PgQuery::RangeSubselect
-            name = node.alias&.aliasname
-            @aliases[name] = nil if name && !name.empty?
-          end
-        end
-      end
-
-      attr_reader :sql, :connection, :parse_result, :config
-
-      def initialize(sql:, connection:, parse_result:, config:, binds: [], type_casted_binds: nil)
-        @sql = sql
-        @connection = connection
-        @parse_result = parse_result
-        @config = config
-        @binds = binds || []
-        @type_casted_binds = type_casted_binds
-      end
-
-      # Cannot fail: a QueryContext is only built for SQL that already parsed.
-      def fingerprint
-        @fingerprint ||= PgQuery.fingerprint(sql)
-      end
-
-      # All SELECT scopes in the statement, including CTEs, subqueries in
-      # FROM/WHERE and UNION branches.
-      def scopes
-        @scopes ||= begin
-          stmts = []
-          parse_result.tree.stmts.each do |raw|
-            walk_ast(raw.stmt) { |msg| stmts << msg if msg.is_a?(PgQuery::SelectStmt) }
-          end
-          stmts.map { |s| Scope.new(s) }
-        end
-      end
-
-      def each_scope(&)
-        scopes.each(&)
-      end
-
-      # All real table names touched anywhere in the query.
-      def tables
-        @tables ||= scopes.flat_map(&:tables).uniq
-      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
-
-      # --- schema metadata for the query's connection ---
-
-      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
-    end
-  end
-end

data/lib/pg_canary/schema_introspection.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module PgCanary
-  # 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