QueryWise 0.2.0

data/app/models/query_analysis.rb

@@ -0,0 +1,47 @@
+class QueryAnalysis < ApplicationRecord
+  belongs_to :app_profile
+  has_many :optimization_suggestions, dependent: :destroy
+
+  validates :sql_query, presence: true
+  validates :analyzed_at, presence: true
+  validates :query_type, inclusion: { in: %w[SELECT INSERT UPDATE DELETE] }
+
+  before_save :generate_query_hash, :extract_table_name
+
+  scope :slow_queries, ->(threshold = 200) { where('duration_ms > ?', threshold) }
+  scope :by_table, ->(table_name) { where(table_name: table_name) }
+  scope :recent, -> { where('analyzed_at > ?', 24.hours.ago) }
+
+  def slow_query?(threshold = 200)
+    duration_ms && duration_ms > threshold
+  end
+
+  def similar_queries
+    return QueryAnalysis.none if query_hash.blank?
+
+    QueryAnalysis.where(query_hash: query_hash)
+                 .where.not(id: id)
+                 .where(app_profile: app_profile)
+  end
+
+  private
+
+  def generate_query_hash
+    # Create a normalized hash of the query for similarity detection
+    normalized_query = sql_query.gsub(/\d+/, '?')
+                                .gsub(/'[^']*'/, '?')
+                                .gsub(/\s+/, ' ')
+                                .strip
+                                .downcase
+    self.query_hash = Digest::SHA256.hexdigest(normalized_query)
+  end
+
+  def extract_table_name
+    return if sql_query.blank?
+
+    # Simple table name extraction - can be enhanced with pg_query
+    if sql_query.match(/(?:FROM|UPDATE|INTO)\s+([a-zA-Z_][a-zA-Z0-9_]*)/i)
+      self.table_name = $1.downcase
+    end
+  end
+end

data/app/models/query_pattern.rb

@@ -0,0 +1,55 @@
+class QueryPattern < ApplicationRecord
+  validates :pattern_type, presence: true,
+            inclusion: { in: %w[n_plus_one slow_query missing_index] }
+  validates :table_name, presence: true
+  validates :frequency, presence: true, numericality: { greater_than: 0 }
+  validates :first_seen, presence: true
+  validates :last_seen, presence: true
+  validates :pattern_signature, presence: true, uniqueness: true
+
+  before_validation :generate_pattern_signature, on: :create
+
+  scope :n_plus_one, -> { where(pattern_type: 'n_plus_one') }
+  scope :slow_queries, -> { where(pattern_type: 'slow_query') }
+  scope :missing_indexes, -> { where(pattern_type: 'missing_index') }
+  scope :frequent, ->(threshold = 5) { where('frequency >= ?', threshold) }
+  scope :recent, -> { where('last_seen > ?', 24.hours.ago) }
+
+  def self.record_pattern(type:, table:, column: nil, metadata: {})
+    signature = generate_signature(type, table, column)
+
+    pattern = find_or_initialize_by(pattern_signature: signature)
+
+    if pattern.persisted?
+      pattern.increment!(:frequency)
+      pattern.update!(last_seen: Time.current)
+    else
+      pattern.assign_attributes(
+        pattern_type: type,
+        table_name: table,
+        column_name: column,
+        frequency: 1,
+        first_seen: Time.current,
+        last_seen: Time.current,
+        metadata: metadata
+      )
+      pattern.save!
+    end
+
+    pattern
+  end
+
+  def self.generate_signature(type, table, column = nil)
+    parts = [type, table]
+    parts << column if column.present?
+    Digest::SHA256.hexdigest(parts.join(':'))
+  end
+
+  private
+
+  def generate_pattern_signature
+    self.pattern_signature = self.class.generate_signature(
+      pattern_type, table_name, column_name
+    )
+  end
+end

data/app/services/missing_index_detector_service.rb

@@ -0,0 +1,244 @@
+class MissingIndexDetectorService
+  attr_reader :queries, :frequency_threshold
+
+  def initialize(queries, frequency_threshold: 3)
+    @queries = Array(queries)
+    @frequency_threshold = frequency_threshold
+  end
+
+  def self.detect(queries, **options)
+    new(queries, **options).detect
+  end
+
+  def detect
+    index_suggestions = []
+    
+    # Group queries by table and analyze patterns
+    table_queries = group_queries_by_table
+    
+    table_queries.each do |table_name, table_queries_list|
+      suggestions = analyze_table_queries(table_name, table_queries_list)
+      index_suggestions.concat(suggestions)
+    end
+    
+    # Remove duplicate suggestions and sort by priority
+    deduplicate_and_prioritize(index_suggestions)
+  end
+
+  private
+
+  def group_queries_by_table
+    queries.group_by do |query|
+      parser = SqlParserService.new(query.sql_query)
+      parser.primary_table
+    end.reject { |table, _| table.nil? }
+  end
+
+  def analyze_table_queries(table_name, table_queries)
+    suggestions = []
+    
+    # Analyze WHERE clause patterns
+    where_column_frequency = analyze_where_patterns(table_queries)
+    suggestions.concat(generate_where_index_suggestions(table_name, where_column_frequency))
+    
+    # Analyze ORDER BY patterns
+    order_column_frequency = analyze_order_patterns(table_queries)
+    suggestions.concat(generate_order_index_suggestions(table_name, order_column_frequency))
+    
+    # Analyze composite index opportunities
+    composite_patterns = analyze_composite_patterns(table_queries)
+    suggestions.concat(generate_composite_index_suggestions(table_name, composite_patterns))
+    
+    # Analyze foreign key patterns
+    foreign_key_patterns = analyze_foreign_key_patterns(table_queries)
+    suggestions.concat(generate_foreign_key_index_suggestions(table_name, foreign_key_patterns))
+    
+    suggestions
+  end
+
+  def analyze_where_patterns(table_queries)
+    column_frequency = Hash.new(0)
+    
+    table_queries.each do |query|
+      parser = SqlParserService.new(query.sql_query)
+      next unless parser.valid?
+      
+      parser.where_columns.each do |column|
+        # Clean column name (remove table prefix if present)
+        clean_column = column.split('.').last
+        column_frequency[clean_column] += 1
+      end
+    end
+    
+    column_frequency.select { |_, freq| freq >= frequency_threshold }
+  end
+
+  def analyze_order_patterns(table_queries)
+    column_frequency = Hash.new(0)
+    
+    table_queries.each do |query|
+      parser = SqlParserService.new(query.sql_query)
+      next unless parser.valid?
+      
+      parser.order_by_columns.each do |column|
+        clean_column = column.split('.').last
+        column_frequency[clean_column] += 1
+      end
+    end
+    
+    column_frequency.select { |_, freq| freq >= frequency_threshold }
+  end
+
+  def analyze_composite_patterns(table_queries)
+    pattern_frequency = Hash.new(0)
+    
+    table_queries.each do |query|
+      parser = SqlParserService.new(query.sql_query)
+      next unless parser.valid?
+      
+      where_columns = parser.where_columns.map { |col| col.split('.').last }
+      
+      # Look for queries with multiple WHERE conditions
+      if where_columns.length > 1
+        # Sort columns to create consistent pattern
+        pattern = where_columns.sort.join(',')
+        pattern_frequency[pattern] += 1
+      end
+    end
+    
+    pattern_frequency.select { |_, freq| freq >= frequency_threshold }
+  end
+
+  def analyze_foreign_key_patterns(table_queries)
+    fk_frequency = Hash.new(0)
+    
+    table_queries.each do |query|
+      parser = SqlParserService.new(query.sql_query)
+      next unless parser.valid?
+      
+      parser.where_columns.each do |column|
+        clean_column = column.split('.').last
+        # Detect foreign key patterns (ending with _id)
+        if clean_column.match?(/\w+_id$/)
+          fk_frequency[clean_column] += 1
+        end
+      end
+    end
+    
+    fk_frequency.select { |_, freq| freq >= frequency_threshold }
+  end
+
+  def generate_where_index_suggestions(table_name, column_frequency)
+    suggestions = []
+    
+    column_frequency.each do |column, frequency|
+      suggestions << {
+        type: 'single_column_index',
+        table_name: table_name,
+        columns: [column],
+        frequency: frequency,
+        priority: calculate_priority(frequency),
+        reason: 'Frequently used in WHERE clauses',
+        sql: "CREATE INDEX idx_#{table_name}_#{column} ON #{table_name}(#{column});",
+        impact: 'high',
+        description: "Column '#{column}' is used in WHERE clauses #{frequency} times"
+      }
+    end
+    
+    suggestions
+  end
+
+  def generate_order_index_suggestions(table_name, column_frequency)
+    suggestions = []
+    
+    column_frequency.each do |column, frequency|
+      suggestions << {
+        type: 'order_by_index',
+        table_name: table_name,
+        columns: [column],
+        frequency: frequency,
+        priority: calculate_priority(frequency),
+        reason: 'Frequently used in ORDER BY clauses',
+        sql: "CREATE INDEX idx_#{table_name}_#{column}_order ON #{table_name}(#{column});",
+        impact: 'medium',
+        description: "Column '#{column}' is used in ORDER BY clauses #{frequency} times"
+      }
+    end
+    
+    suggestions
+  end
+
+  def generate_composite_index_suggestions(table_name, pattern_frequency)
+    suggestions = []
+    
+    pattern_frequency.each do |pattern, frequency|
+      columns = pattern.split(',')
+      column_list = columns.join(', ')
+      index_name = "idx_#{table_name}_#{columns.join('_')}"
+      
+      suggestions << {
+        type: 'composite_index',
+        table_name: table_name,
+        columns: columns,
+        frequency: frequency,
+        priority: calculate_priority(frequency, bonus: 1), # Composite indexes get priority bonus
+        reason: 'Frequently used together in WHERE clauses',
+        sql: "CREATE INDEX #{index_name} ON #{table_name}(#{column_list});",
+        impact: 'high',
+        description: "Columns '#{column_list}' are frequently used together #{frequency} times"
+      }
+    end
+    
+    suggestions
+  end
+
+  def generate_foreign_key_index_suggestions(table_name, fk_frequency)
+    suggestions = []
+    
+    fk_frequency.each do |fk_column, frequency|
+      suggestions << {
+        type: 'foreign_key_index',
+        table_name: table_name,
+        columns: [fk_column],
+        frequency: frequency,
+        priority: calculate_priority(frequency, bonus: 2), # Foreign keys get high priority
+        reason: 'Foreign key used in WHERE clauses',
+        sql: "CREATE INDEX idx_#{table_name}_#{fk_column} ON #{table_name}(#{fk_column});",
+        impact: 'high',
+        description: "Foreign key '#{fk_column}' is used in WHERE clauses #{frequency} times"
+      }
+    end
+    
+    suggestions
+  end
+
+  def calculate_priority(frequency, bonus: 0)
+    base_priority = case frequency
+    when 0..2
+      1
+    when 3..5
+      2
+    when 6..10
+      3
+    when 11..14
+      4
+    else
+      5
+    end
+
+    [base_priority + bonus, 5].min # Cap at 5
+  end
+
+  def deduplicate_and_prioritize(suggestions)
+    # Group by table and columns to remove duplicates
+    unique_suggestions = suggestions.group_by do |suggestion|
+      [suggestion[:table_name], suggestion[:columns].sort]
+    end.map do |_, grouped|
+      # Keep the highest priority suggestion for each unique combination
+      grouped.max_by { |s| s[:priority] }
+    end
+    
+    # Sort by priority (highest first) and frequency
+    unique_suggestions.sort_by { |s| [-s[:priority], -s[:frequency]] }
+  end
+end

data/app/services/n_plus_one_detector_service.rb

@@ -0,0 +1,177 @@
+class NPlusOneDetectorService
+  attr_reader :queries, :time_window, :threshold
+
+  def initialize(queries, time_window: 5.seconds, threshold: 3)
+    @queries = queries.sort_by(&:analyzed_at)
+    @time_window = time_window
+    @threshold = threshold
+  end
+
+  def self.detect(queries, **options)
+    new(queries, **options).detect
+  end
+
+  def detect
+    n_plus_one_patterns = []
+
+    # Group queries by their normalized signature
+    query_groups = group_queries_by_signature
+
+    query_groups.each do |signature, grouped_queries|
+      next if grouped_queries.length < threshold
+
+      # Check if queries are clustered in time (indicating N+1 pattern)
+      time_clusters = find_time_clusters(grouped_queries)
+
+      time_clusters.each do |cluster|
+        next if cluster.length < threshold
+
+        pattern = analyze_cluster_for_n_plus_one(cluster)
+        n_plus_one_patterns << pattern if pattern
+      end
+    end
+
+    n_plus_one_patterns
+  end
+
+  private
+
+  def group_queries_by_signature
+    queries.group_by do |query|
+      parser = SqlParserService.new(query.sql_query)
+      parser.query_signature
+    end
+  end
+
+  def find_time_clusters(queries)
+    clusters = []
+    current_cluster = []
+    
+    queries.each do |query|
+      if current_cluster.empty?
+        current_cluster = [query]
+      else
+        time_diff = query.analyzed_at - current_cluster.last.analyzed_at
+        
+        if time_diff <= time_window
+          current_cluster << query
+        else
+          clusters << current_cluster if current_cluster.length >= threshold
+          current_cluster = [query]
+        end
+      end
+    end
+    
+    clusters << current_cluster if current_cluster.length >= threshold
+    clusters
+  end
+
+  def analyze_cluster_for_n_plus_one(cluster)
+    # Parse the first query to understand the pattern
+    first_query = cluster.first
+    parser = SqlParserService.new(first_query.sql_query)
+    
+    return nil unless parser.valid?
+    return nil unless parser.query_type == 'SELECT'
+    return nil unless parser.potential_n_plus_one?
+    
+    # Verify all queries in cluster have same structure but different parameters
+    return nil unless all_queries_similar_structure?(cluster)
+    
+    # Extract the pattern details
+    where_conditions = parser.where_conditions
+    id_condition = where_conditions.find do |c|
+      column = c[:column]
+      column && column.match?(/\bid\b|_id$/i)
+    end
+
+    return nil unless id_condition
+    
+    {
+      type: 'n_plus_one',
+      table_name: parser.primary_table,
+      column_name: id_condition[:column],
+      query_count: cluster.length,
+      time_span: cluster.last.analyzed_at - cluster.first.analyzed_at,
+      first_query: first_query,
+      sample_queries: cluster.first(5), # Keep first 5 as samples
+      pattern_signature: parser.query_signature,
+      severity: calculate_severity(cluster.length),
+      suggestion: generate_suggestion(parser, cluster)
+    }
+  end
+
+  def all_queries_similar_structure?(cluster)
+    return true if cluster.length <= 1
+    
+    first_signature = SqlParserService.new(cluster.first.sql_query).query_signature
+    
+    cluster.all? do |query|
+      SqlParserService.new(query.sql_query).query_signature == first_signature
+    end
+  end
+
+  def calculate_severity(query_count)
+    case query_count
+    when 0..5
+      'low'
+    when 6..15
+      'medium'
+    when 16..50
+      'high'
+    else
+      'critical'
+    end
+  end
+
+  def generate_suggestion(parser, cluster)
+    table_name = parser.primary_table
+    where_conditions = parser.where_conditions
+    id_condition = where_conditions.find do |c|
+      column = c[:column]
+      column && column.match?(/\bid\b|_id$/i)
+    end
+    
+    if id_condition
+      foreign_key = id_condition[:column]
+      
+      if foreign_key.end_with?('_id')
+        # This looks like a foreign key lookup
+        association_name = foreign_key.gsub('_id', '').pluralize
+        
+        {
+          title: "Use includes() to avoid N+1 queries",
+          description: "Detected #{cluster.length} similar queries on #{table_name} table. " \
+                      "This appears to be an N+1 query pattern where you're loading #{table_name} " \
+                      "records one by one instead of using eager loading.",
+          rails_suggestion: "Use `includes(:#{association_name})` or `preload(:#{association_name})` " \
+                           "to load all related records in a single query.",
+          example_code: "# Instead of:\n" \
+                       "users.each { |user| user.#{association_name}.count }\n\n" \
+                       "# Use:\n" \
+                       "users.includes(:#{association_name}).each { |user| user.#{association_name}.count }",
+          sql_suggestion: "Consider using a JOIN or IN clause to fetch all records at once."
+        }
+      else
+        {
+          title: "Optimize repeated ID lookups",
+          description: "Detected #{cluster.length} similar queries looking up records by ID. " \
+                      "Consider batching these lookups.",
+          rails_suggestion: "Use `where(id: [id1, id2, id3])` to fetch multiple records at once.",
+          example_code: "# Instead of multiple queries:\n" \
+                       "ids.each { |id| #{table_name.classify}.find(id) }\n\n" \
+                       "# Use:\n" \
+                       "#{table_name.classify}.where(id: ids)",
+          sql_suggestion: "Use WHERE id IN (...) to fetch multiple records in a single query."
+        }
+      end
+    else
+      {
+        title: "Optimize repeated queries",
+        description: "Detected #{cluster.length} similar queries that could be optimized.",
+        rails_suggestion: "Consider batching these queries or using eager loading.",
+        sql_suggestion: "Analyze the query pattern and consider using JOINs or IN clauses."
+      }
+    end
+  end
+end