sql_query_analyzer 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 584bbafae1893ed4f45410cc46eafe6e120e98990205b6843f2e82cc9dd3b9f0
-  data.tar.gz: fe27bac5ebe7e38cc961c6abdffa5fc2bf0eef37f97864cd8ed23a7cb1599d70
+  metadata.gz: de53885b50c1f9d62d98d6713ac536f29b30ebdada947a54bde86610cbc594f2
+  data.tar.gz: 3211b01b3d49e290bb9a7724a3527602b6a80c3cd2d9b7416160967885c6b7dc
 SHA512:
-  metadata.gz: 893727f91285119c0734f23f76e594f5f5085041cdbe9e3f750f785791de417a23f2b44c8f1f4a1b5392dc605e23b26d35acfe4c675f3ea93a089be6157e4711
-  data.tar.gz: e703a05ad2758df8b778bd872b2f6eecffe05855c7f48a2a603ddbe34ed17d5914b8eef67aed3491d44c0e5843099d47d3e6783fbb5b590b15ac7ad83bb149f3
+  metadata.gz: 8bbd2f6b1c5cc37034909e5f4a7e24aefc77e2d7d5719ee0d2d5908873249a01ba6ec9d32641658d0d316119ca9b30ce1da0cfbf31d43db02b49930321a92288
+  data.tar.gz: 2c016cca40185f82db401a0a582f5746c15072d6726ebcf7f6ad4e2ff228aecff6e863c00a08ff1da0dce5c7b43d9549e3b047dded9da5255af6f77b0576396c

data/lib/sql_query_analyzer/execute.rb

@@ -1,7 +1,8 @@
 module SqlQueryAnalyzer
   class Execute
-    def self.explain_sql(raw_sql)
-      ActiveRecord::Base.connection.execute("EXPLAIN ANALYZE #{raw_sql}")
+    def self.explain_sql(raw_sql, run)
+      query_with_options = run ? "EXPLAIN ANALYZE #{raw_sql}" : "EXPLAIN #{raw_sql}"
+      ActiveRecord::Base.connection.execute(query_with_options)
     end
   end
 end

data/lib/sql_query_analyzer/explain_analyzer.rb

@@ -1,7 +1,7 @@
 # lib/sql_query_analyzer/explain_analyzer.rb
 module SqlQueryAnalyzer
   module ExplainAnalyzer
-    def explain_with_suggestions
+    def explain_with_suggestions(run: false)
 
       unless self.is_a?(ActiveRecord::Relation)
         puts "⚠️ Not an ActiveRecord Relation. Skipping explain_with_suggestions."
@@ -10,7 +10,7 @@ module SqlQueryAnalyzer
 
       raw_sql = self.to_sql
 
-      explain_output = SqlQueryAnalyzer::Execute.explain_sql(raw_sql)
+      explain_output = SqlQueryAnalyzer::Execute.explain_sql(raw_sql, run)
       engine = SqlQueryAnalyzer::SuggestionEngine.new(explain_output, raw_sql)
       suggestions = engine.analyze
 

data/lib/sql_query_analyzer/sequential_scan_advisor.rb

@@ -1,54 +1,75 @@
 module SqlQueryAnalyzer
   class SequentialScanAdvisor
-    def initialize(line_text)
-      @line_text = line_text
+    attr_reader :query_plan
+
+    def initialize(query_plan)
+      @query_plan = query_plan
     end
 
     def enhanced_message
       table_name, column_names = extract_table_and_columns
-      return nil unless table_name
 
-      if column_names.empty?
-        return "⚡ Sequential Scan detected on '#{table_name}', but no filter condition found. Likely a full table read (e.g., SELECT *), or small table size makes index use unnecessary."
-      end
+      return nil unless sequential_scan_detected?
 
-      missing_indexes = column_names.select do |column|
-        !index_exists?(table_name, column)
+      if column_names.empty?
+        return "👉 [CRITICAL] ⚡ Sequential Scan detected on '#{table_name}', " \
+               "but no filter condition found. Likely a full table read " \
+               "(e.g., SELECT *), or small table size makes index use unnecessary."
       end
 
-      if missing_indexes.any?
-        "⚡ Sequential Scan detected on '#{table_name}'. Consider adding indexes on: #{missing_indexes.join(', ')}."
-      else
-        "⚡ Sequential Scan detected on '#{table_name}', but indexes seem to exist. Might be due to low table size or outdated stats."
+      messages = []
+      messages << "👉 [CRITICAL] ⚡ Sequential Scan detected on '#{table_name}', " \
+                  "and filter involves columns: #{column_names.join(', ')}."
+      if missing_composite_index?(table_name, column_names)
+        messages << "💡 Consider adding a composite index on: #{column_names.join(', ')}"
       end
+      messages.join("\n")
     end
 
     private
 
+    def sequential_scan_detected?
+      query_plan.include?("Seq Scan on")
+    end
+
     def extract_table_and_columns
-      # Simplified pattern: "Seq Scan on users  (cost=...)"
-      if @line_text =~ /Seq Scan on (\w+)/
-        table_name = $1
-        columns = extract_filter_columns(@line_text)
-        [table_name, columns]
-      else
-        [nil, []]
-      end
+      table_name = query_plan.match(/Seq Scan on (\w+)/)&.captures&.first
+      [ table_name, extract_columns_from_filter ]
     end
 
-    def extract_filter_columns(text)
-      # Example EXPLAIN line might include: "Filter: (email = 'x')"
-      text.scan(/Filter: \((.*?)\)/).flatten
-          .flat_map { |f| f.scan(/\b(\w+)\s*=/) }
-          .flatten
+    def extract_columns_from_filter
+      # Grab the Filter line out of the full plan
+      filter_line = query_plan.lines.find { |l| l.strip.start_with?("Filter:") }
+      return [] unless filter_line
+
+      # Remove the "Filter:" prefix and any Postgres typecasts
+      cleaned = filter_line
+                  .sub("Filter:", "")
+                  .gsub(/::[a-zA-Z_ ]+/, "")
+                  .downcase
+
+      # Pull actual column names for this table from the schema
+      table_name = query_plan.match(/Seq Scan on (\w+)/)&.captures&.first
+      return [] unless table_name
+      schema_cols = ActiveRecord::Base
+                      .connection
+                      .columns(table_name.to_sym)
+                      .map(&:name)
+                      .map(&:downcase)
+
+      # Of all schema columns, pick those mentioned in the cleaned filter
+      extracted = schema_cols.select { |col| cleaned.include?(col) }.uniq
+      extracted
     end
 
-    def index_exists?(table_name, column)
-      ActiveRecord::Base.connection.indexes(table_name).any? do |idx|
-        idx.columns.include?(column)
-      end
-    rescue => e
-      false # Assume false in case of table missing or dev env differences
+    def missing_composite_index?(table_name, columns)
+      existing = ActiveRecord::Base
+                   .connection
+                   .indexes(table_name.to_sym)
+                   .map(&:columns)
+                   .map { |cols| cols.map(&:downcase) }
+
+      !existing.any? { |idx_cols| idx_cols == columns || idx_cols.first(columns.length) == columns }
     end
   end
 end

data/lib/sql_query_analyzer/suggestion_engine.rb

@@ -1,6 +1,7 @@
 require_relative 'suggestion_rules'
 require_relative 'query_plan_presenter'
 require_relative 'sql_level_rules'
+require_relative 'sequential_scan_advisor'
 
 module SqlQueryAnalyzer
   class Suggestion
@@ -8,7 +9,7 @@ module SqlQueryAnalyzer
 
     def initialize(severity, message)
       @severity = severity
-      @message = message
+      @message  = message
     end
 
     def to_s
@@ -19,51 +20,53 @@ module SqlQueryAnalyzer
   class SuggestionEngine
     def initialize(explain_output, sql = nil)
       @explain_output = explain_output
-      @sql = sql
+      @sql            = sql
     end
 
     def analyze
-      output = []
-      warnings = []
-      total_cost, rows_estimate, actual_time = nil
+      warnings       = []
+      total_cost     = nil
+      rows_estimate  = nil
+      actual_time    = nil
+
+      # Build the full plan text (all lines) so advisors can see Filters, etc.
+      full_plan = @explain_output.map { |row| row["QUERY PLAN"] }.join("\n")
 
       @explain_output.each_with_index do |row, idx|
         line = row["QUERY PLAN"]
-        output << line
 
+        # Capture cost & estimates
         if line =~ /cost=\d+\.\d+\.\.(\d+\.\d+) rows=(\d+)/
-          total_cost = $1.to_f
+          total_cost    = $1.to_f
           rows_estimate = $2.to_i
         end
-
         actual_time ||= $1.to_f if line =~ /actual time=(\d+\.\d+)/
 
         SuggestionRules.all.each do |rule|
-          if rule[:matcher].call(line)
+          next unless rule[:matcher].call(line)
 
-            suggestion = Suggestion.new(rule[:severity], rule[:message])
-            if rule[:message].include?("Sequential Scan")
-              dynamic_msg = SequentialScanAdvisor.new(line).enhanced_message
-              suggestion = Suggestion.new(rule[:severity], dynamic_msg) if dynamic_msg
-            end
-
-            warnings << {
-              line_number: idx + 1,
-              line_text: line,
-              suggestion: suggestion
-            }
+          suggestion = Suggestion.new(rule[:severity], rule[:message])
+          if rule[:message].include?("Sequential Scan")
+            dynamic = SequentialScanAdvisor.new(full_plan).enhanced_message
+            suggestion = Suggestion.new(rule[:severity], dynamic) if dynamic
           end
+
+          warnings << {
+            line_number: idx + 1,
+            line_text:   line,
+            suggestion:  suggestion
+          }
         end
       end
 
       warnings.concat(SqlLevelRules.evaluate(@sql))
 
       presenter = QueryPlanPresenter.new(
-        output: output,
-        warnings: warnings,
-        total_cost: total_cost,
+        output:        @explain_output.map { |r| r["QUERY PLAN"] },
+        warnings:      warnings,
+        total_cost:    total_cost,
         rows_estimate: rows_estimate,
-        actual_time: actual_time
+        actual_time:   actual_time
       )
 
       presenter.display

data/lib/sql_query_analyzer/suggestion_rules.rb

@@ -33,7 +33,7 @@ module SqlQueryAnalyzer
           message: "🔀 Merge Join used. Efficient if input is sorted properly; check indexes."
         },
         {
-          matcher: ->(line) { line.downcase.include?('cte') || line.downcase.include?('with') },
+          matcher: ->(line) { line&.match?(/^\s*WITH\s+\w+\s+AS\s*\(/i) },
           severity: :info,
           message: "🔧 CTE usage detected. Be aware CTEs can materialize (costly) in Postgres < 12."
         }

data/lib/sql_query_analyzer/version.rb

@@ -1,5 +1,5 @@
 # lib/sql_query_analyzer/version.rb
 module SqlQueryAnalyzer
   
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_query_analyzer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Anoob Bava