pg_insights 0.3.1 → 0.4.0

data/app/assets/stylesheets/pg_insights/application.css

@@ -383,6 +383,7 @@
   width: 100%;
   height: 100%;
   min-height: 200px;
+  max-height: 400px;
   padding: 12px;
   border: 2px solid #e5e7eb;
   border-radius: 6px;
@@ -392,6 +393,7 @@
   background: #fafbfc;
   color: #1f2937;
   resize: none;
+  overflow-y: auto;
   transition: border-color 0.2s ease;
 
   &:focus {
@@ -405,6 +407,24 @@
     color: #9ca3af;
     opacity: 0.8;
   }
+
+  &::-webkit-scrollbar {
+    width: 8px;
+  }
+
+  &::-webkit-scrollbar-track {
+    background: #f1f5f9;
+    border-radius: 4px;
+  }
+
+  &::-webkit-scrollbar-thumb {
+    background: #cbd5e1;
+    border-radius: 4px;
+    
+    &:hover {
+      background: #94a3b8;
+    }
+  }
 }
 
 .form-actions {
@@ -460,6 +480,31 @@
       transform: translateY(-1px);
     }
   }
+
+  &.btn-info {
+    background: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);
+    color: white;
+
+    &:hover {
+      background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%);
+      transform: translateY(-1px);
+      box-shadow: 0 2px 8px rgba(59, 130, 246, 0.3);
+    }
+
+    &:disabled {
+      background: #9ca3af !important;
+      cursor: not-allowed !important;
+      transform: none !important;
+      box-shadow: none !important;
+      opacity: 0.6;
+
+      &:hover {
+        background: #9ca3af !important;
+        transform: none !important;
+        box-shadow: none !important;
+      }
+    }
+  }
 }
 
 /* Query Examples Section */
@@ -723,7 +768,8 @@
   }
 
   .sql-editor {
-    font-size: 14px; /* Prevent zoom on iOS */
+    font-size: 14px;
+    max-height: 400px;
   }
 
   .form-actions {
@@ -747,4 +793,8 @@
   .results-panel {
     height: 30%;
   }
+
+  .sql-editor {
+    max-height: 400px;
+  }
 }

data/app/assets/stylesheets/pg_insights/results.css

@@ -50,11 +50,22 @@
   box-shadow: 0 1px 3px rgba(0,0,0,0.1);
 }
 
-.toggle-btn:hover:not(.active) {
+.toggle-btn:hover:not(.active):not(.disabled) {
   background: rgba(255,255,255,0.5);
   color: #475569;
 }
 
+.toggle-btn.disabled {
+  opacity: 0.6;
+  cursor: help;
+  pointer-events: auto;
+}
+
+.toggle-btn.disabled:hover {
+  background: transparent;
+  color: #64748b;
+}
+
 .toggle-icon {
   font-size: 14px;
 }

data/app/controllers/pg_insights/insights_controller.rb

@@ -6,7 +6,6 @@ module PgInsights
     protect_from_forgery with: :exception
 
     MAX_ROWS = 1_000
-    TIMEOUT = 5_000
 
     # GET /pg_insights
     # POST /pg_insights
@@ -27,6 +26,9 @@ module PgInsights
       @insight_queries = built_in_queries + saved_queries
 
       return unless request.post?
+
+      # Determine execution type from button clicked
+      execution_type = determine_execution_type
       sql = params.require(:sql)
 
       unless read_only?(sql)
@@ -34,19 +36,57 @@ module PgInsights
         return render :index, status: :unprocessable_entity
       end
 
-      sql = append_limit(sql, MAX_ROWS) unless sql.match?(/limit\s+\d+/i)
+      # Handle different execution types
+      case execution_type
+      when "execute"
+        handle_execute_only(sql)
+      when "analyze"
+        handle_analyze_only(sql)
+      when "both"
+        handle_execute_and_analyze(sql)
+      else
+        # Fallback to original behavior for backward compatibility
+        handle_execute_only(sql)
+      end
+
+      render :index
+    end
+
+    # POST /pg_insights/analyze
+    def analyze
+      sql = params.require(:sql)
+      execution_type = params.fetch(:execution_type, "analyze")
+      async = params.fetch(:async, false)
+
+      unless read_only?(sql)
+        render json: { error: "Only single SELECT statements are allowed" }, status: :unprocessable_entity
+        return
+      end
 
       begin
-        ActiveRecord::Base.connection.transaction do
-          ActiveRecord::Base.connection.execute("SET LOCAL statement_timeout = #{TIMEOUT}")
-          @result = ActiveRecord::Base.connection.exec_query(sql)
+        if async.to_s == "true"
+          execution = QueryAnalysisService.analyze_query_async(sql, execution_type: execution_type)
+          render json: {
+            execution_id: execution.id,
+            status: execution.status,
+            message: "Analysis started"
+          }
+        else
+          execution = QueryAnalysisService.execute_query(sql, execution_type: execution_type)
+          render json: format_execution_response(execution)
         end
-      rescue ActiveRecord::StatementInvalid, PG::Error => e
-        flash.now[:alert] = "Query Error: #{e.message}"
-        return render :index, status: :unprocessable_entity
+      rescue => e
+        Rails.logger.error "Analysis failed: #{e.message}"
+        render json: { error: e.message }, status: :internal_server_error
       end
+    end
 
-      render :index
+    # GET /pg_insights/execution/:id
+    def execution_status
+      execution = QueryExecution.find(params[:id])
+      render json: format_execution_response(execution)
+    rescue ActiveRecord::RecordNotFound
+      render json: { error: "Execution not found" }, status: :not_found
     end
 
     # GET /pg_insights/table_names
@@ -60,8 +100,171 @@ module PgInsights
       render json: { tables: [] }
     end
 
+    def query_history
+      @executions = QueryExecution.recent_history(10)
+
+      executions_data = @executions.map do |execution|
+        {
+          id: execution.id,
+          title: execution.display_title,
+          summary: execution.display_summary,
+          performance_class: execution.performance_class,
+          created_at: execution.created_at.strftime("%m/%d %H:%M"),
+          total_time_ms: execution.total_time_ms,
+          query_cost: execution.query_cost,
+          sql_text: execution.sql_text
+        }
+      end
+
+      respond_to do |format|
+        format.json { render json: executions_data }
+        format.html { redirect_to root_path }
+      end
+    end
+
+            def compare
+      # Handle nested parameters from form submission
+      execution_ids = params[:execution_ids] || params.dig(:insight, :execution_ids)
+
+      if execution_ids.blank? || execution_ids.size != 2
+        error_response = { error: "Please select exactly 2 queries to compare" }
+        respond_to do |format|
+          format.json { render json: error_response, status: :bad_request }
+          format.html { redirect_to root_path, alert: error_response[:error] }
+        end
+        return
+      end
+
+      begin
+                @execution_a = QueryExecution.find(execution_ids[0])
+        @execution_b = QueryExecution.find(execution_ids[1])
+
+        # Performance logging
+        Rails.logger.info "PgInsights: Comparing query executions #{@execution_a.id} vs #{@execution_b.id}"
+
+        start_time = Time.current
+        @comparison_data = generate_comparison_data(@execution_a, @execution_b)
+        comparison_duration = ((Time.current - start_time) * 1000).round(2)
+
+        Rails.logger.info "PgInsights: Comparison completed in #{comparison_duration}ms"
+
+        respond_to do |format|
+          format.json { render json: @comparison_data }
+          format.html { redirect_to root_path, notice: "Comparison completed" }
+        end
+      rescue ActiveRecord::RecordNotFound => e
+        error_response = { error: "One or both query executions not found" }
+        respond_to do |format|
+          format.json { render json: error_response, status: :not_found }
+          format.html { redirect_to root_path, alert: error_response[:error] }
+        end
+      rescue => e
+        Rails.logger.error "Comparison failed: #{e.message}"
+        Rails.logger.error e.backtrace.join("\n")
+
+        error_response = { error: "Comparison failed: #{e.message}" }
+        respond_to do |format|
+          format.json { render json: error_response, status: :internal_server_error }
+          format.html { redirect_to root_path, alert: error_response[:error] }
+        end
+      end
+    end
+
     private
 
+    def determine_execution_type
+      return "analyze" if params[:analyze_button].present?
+      return "both" if params[:both_button].present?
+      "execute" # Default
+    end
+
+    def handle_execute_only(sql)
+      sql = append_limit(sql, MAX_ROWS) unless sql.match?(/limit\s+\d+/i)
+
+      begin
+        ActiveRecord::Base.connection.transaction do
+          ActiveRecord::Base.connection.execute("SET LOCAL statement_timeout = #{PgInsights.query_execution_timeout_ms}")
+          @result = ActiveRecord::Base.connection.exec_query(sql)
+        end
+        @execution_type = "execute"
+      rescue ActiveRecord::StatementInvalid, PG::Error => e
+        flash.now[:alert] = "Query Error: #{e.message}"
+        nil
+      end
+    end
+
+    def handle_analyze_only(sql)
+      begin
+        @query_execution = QueryAnalysisService.execute_query(sql, execution_type: "analyze")
+        @execution_type = "analyze"
+      rescue => e
+        flash.now[:alert] = "Analysis Error: #{e.message}"
+        nil
+      end
+    end
+
+    def handle_execute_and_analyze(sql)
+      sql = append_limit(sql, MAX_ROWS) unless sql.match?(/limit\s+\d+/i)
+
+      begin
+        @query_execution = QueryAnalysisService.execute_query(sql, execution_type: "both")
+        @execution_type = "both"
+
+        # Extract regular result for backward compatibility
+        if @query_execution.success? && @query_execution.result_data
+          result_data = @query_execution.result_data
+          @result = ActiveRecord::Result.new(
+            result_data["columns"],
+            result_data["rows"],
+            result_data["column_types"] || {}
+          )
+        end
+      rescue => e
+        flash.now[:alert] = "Error: #{e.message}"
+        nil
+      end
+    end
+
+    def format_execution_response(execution)
+      response = {
+        id: execution.id,
+        status: execution.status,
+        execution_type: execution.execution_type
+      }
+
+      if execution.success?
+        # Include rich metrics for enhanced views
+        response[:metrics] = extract_metrics(execution)
+
+        if execution.has_result_data?
+          response[:result] = {
+            rows: execution.result_data["rows"],
+            columns: execution.result_data["columns"],
+            summary: execution.result_summary
+          }
+        end
+
+        if execution.has_plan_data?
+          response[:analysis] = {
+            execution_plan: execution.execution_plan,
+            plan_summary: execution.plan_summary,
+            performance_insights: execution.performance_insights,
+            timing: {
+              planning_time_ms: execution.planning_time_ms,
+              execution_time_ms: execution.execution_time_ms,
+              total_time_ms: execution.total_time_ms
+            },
+            cost: execution.query_cost,
+            stats: execution.execution_stats
+          }
+        end
+      elsif execution.failed?
+        response[:error] = execution.error_message
+      end
+
+      response
+    end
+
     def read_only?(sql)
       sql.strip!
       # Check for a single SELECT statement
@@ -72,6 +275,280 @@ module PgInsights
 
     def append_limit(sql, n)
       "#{sql.strip} LIMIT #{n}"
+    end
+
+        def generate_comparison_data(exec_a, exec_b)
+      begin
+        {
+          executions: {
+                      a: {
+            id: exec_a.id,
+            title: exec_a.respond_to?(:display_title) ? exec_a.display_title : "Query ##{exec_a.id}",
+            summary: exec_a.respond_to?(:display_summary) ? exec_a.display_summary : "",
+            sql_text: exec_a.sql_text,
+            metrics: extract_metrics(exec_a)
+          },
+          b: {
+            id: exec_b.id,
+            title: exec_b.respond_to?(:display_title) ? exec_b.display_title : "Query ##{exec_b.id}",
+            summary: exec_b.respond_to?(:display_summary) ? exec_b.display_summary : "",
+            sql_text: exec_b.sql_text,
+            metrics: extract_metrics(exec_b)
+          }
+          },
+          comparison: {
+            performance: calculate_performance_diff(exec_a, exec_b),
+            winner: determine_winner(exec_a, exec_b),
+            insights: generate_insights(exec_a, exec_b)
+          }
+        }
+      rescue => e
+        Rails.logger.error "Error in generate_comparison_data: #{e.message}"
+        Rails.logger.error "exec_a class: #{exec_a.class.name}, exec_b class: #{exec_b.class.name}"
+        Rails.logger.error e.backtrace.join("\n")
+        raise e
+      end
+    end
+
+    def extract_metrics(execution)
+      base_metrics = {
+        total_time_ms: execution.total_time_ms,
+        planning_time_ms: execution.planning_time_ms,
+        execution_time_ms: execution.execution_time_ms,
+        query_cost: execution.query_cost
+      }
+
+      # For queries with execution plans (EXPLAIN ANALYZE), extract from plan
+      if execution.execution_plan.present?
+        plan_metrics = extract_plan_metrics(execution)
+        base_metrics.merge(plan_metrics)
+      else
+        # For regular SELECT queries, use result data
+        base_metrics.merge(
+        rows_returned: execution.result_rows_count,
+          rows_scanned: nil
+        )
+      end
+    end
+
+    def calculate_performance_diff(exec_a, exec_b)
+      return {} unless exec_a.total_time_ms && exec_b.total_time_ms
+
+      time_diff_pct = ((exec_a.total_time_ms - exec_b.total_time_ms) / exec_a.total_time_ms * 100).round(1)
+      cost_diff_pct = if exec_a.query_cost && exec_b.query_cost
+        ((exec_a.query_cost - exec_b.query_cost) / exec_a.query_cost * 100).round(1)
+      else
+        nil
+      end
+
+      {
+        time_difference_pct: time_diff_pct,
+        cost_difference_pct: cost_diff_pct,
+        time_faster: time_diff_pct > 0 ? "b" : "a",
+        cost_cheaper: cost_diff_pct && cost_diff_pct > 0 ? "b" : "a"
+      }
+    end
+
+    def determine_winner(exec_a, exec_b)
+      return "unknown" unless exec_a.total_time_ms && exec_b.total_time_ms
+      exec_a.total_time_ms < exec_b.total_time_ms ? "a" : "b"
+    end
+
+    def generate_insights(exec_a, exec_b)
+      insights = []
+
+      if exec_a.total_time_ms && exec_b.total_time_ms
+        time_diff_pct = ((exec_a.total_time_ms - exec_b.total_time_ms).abs / [ exec_a.total_time_ms, exec_b.total_time_ms ].max * 100).round(1)
+
+        if time_diff_pct > 20
+          faster_query = exec_a.total_time_ms < exec_b.total_time_ms ? "Query A" : "Query B"
+          insights << "#{faster_query} is #{time_diff_pct}% faster in execution time"
+        end
+      end
+
+      # Add plan structure insights
+      if has_sequential_scan?(exec_a) && !has_sequential_scan?(exec_b)
+        insights << "Query B uses index scans while Query A uses sequential scans"
+      elsif has_sequential_scan?(exec_b) && !has_sequential_scan?(exec_a)
+        insights << "Query A uses index scans while Query B uses sequential scans"
+      end
+
+      insights
+    end
+
+    def extract_rows_scanned(execution)
+      return nil unless execution.execution_plan.present?
+
+      plan = execution.execution_plan.is_a?(Array) ? execution.execution_plan[0] : execution.execution_plan
+      extract_total_rows_from_plan(plan&.dig("Plan"))
+    end
+
+    def extract_total_rows_from_plan(node)
+      return 0 unless node
+
+      current_rows = node["Actual Rows"] || 0
+      child_rows = 0
+
+      if node["Plans"]&.any?
+        child_rows = node["Plans"].sum { |child| extract_total_rows_from_plan(child) }
+      end
+
+      current_rows + child_rows
+    end
+
+    def has_sequential_scan?(execution)
+      return false unless execution.execution_plan.present?
+
+      plan = execution.execution_plan.is_a?(Array) ? execution.execution_plan[0] : execution.execution_plan
+      check_for_seq_scan(plan&.dig("Plan"))
+    end
+
+    def extract_plan_metrics(execution)
+      plan_data = execution.execution_plan.is_a?(Array) ? execution.execution_plan[0] : execution.execution_plan
+      return {} unless plan_data && plan_data["Plan"]
+
+      root_plan = plan_data["Plan"]
+
+      {
+        rows_returned: root_plan["Actual Rows"],
+        rows_scanned: extract_total_rows_scanned(root_plan),
+        workers_planned: extract_workers_info(root_plan)[:planned],
+        workers_launched: extract_workers_info(root_plan)[:launched],
+        memory_usage_kb: extract_peak_memory_usage(root_plan),
+        sort_methods: extract_sort_methods(root_plan),
+        index_usage: extract_index_usage(root_plan),
+        node_count: count_plan_nodes(root_plan),
+        join_types: extract_join_types(root_plan),
+        scan_types: extract_scan_types(root_plan)
+      }
+    end
+
+    def extract_workers_info(node, workers_info = { planned: 0, launched: 0 })
+      return workers_info unless node
+
+      if node["Workers Planned"]
+        workers_info[:planned] = [ workers_info[:planned], node["Workers Planned"] ].max
+      end
+
+      if node["Workers Launched"]
+        workers_info[:launched] = [ workers_info[:launched], node["Workers Launched"] ].max
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| extract_workers_info(child, workers_info) }
+      end
+
+      workers_info
+    end
+
+    def extract_peak_memory_usage(node, max_memory = 0)
+      return max_memory unless node
+
+      if node["Peak Memory Usage"]
+        max_memory = [ max_memory, node["Peak Memory Usage"] ].max
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| max_memory = extract_peak_memory_usage(child, max_memory) }
+      end
+
+      max_memory
+    end
+
+    def extract_sort_methods(node, methods = Set.new)
+      return methods.to_a unless node
+
+      if node["Sort Method"]
+        methods.add(node["Sort Method"])
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| extract_sort_methods(child, methods) }
+      end
+
+      methods.to_a
+    end
+
+    def extract_index_usage(node, indexes = Set.new)
+      return indexes.to_a unless node
+
+      if node["Index Name"]
+        indexes.add(node["Index Name"])
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| extract_index_usage(child, indexes) }
+      end
+
+      indexes.to_a
+    end
+
+    def count_plan_nodes(node)
+      return 0 unless node
+
+      count = 1
+      if node["Plans"]&.any?
+        count += node["Plans"].sum { |child| count_plan_nodes(child) }
+      end
+      count
+    end
+
+    def extract_join_types(node, types = Set.new)
+      return types.to_a unless node
+
+      if node["Node Type"]&.include?("Join")
+        join_type = node["Join Type"] ? "#{node['Join Type']} #{node['Node Type']}" : node["Node Type"]
+        types.add(join_type)
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| extract_join_types(child, types) }
+      end
+
+      types.to_a
+    end
+
+    def extract_scan_types(node, types = Set.new)
+      return types.to_a unless node
+
+      if node["Node Type"]&.include?("Scan")
+        types.add(node["Node Type"])
+      end
+
+      if node["Plans"]&.any?
+        node["Plans"].each { |child| extract_scan_types(child, types) }
+      end
+
+      types.to_a
+    end
+
+    def extract_total_rows_scanned(node)
+      return 0 unless node
+
+      scanned_rows = 0
+
+      # Count rows from scan operations
+      if node["Node Type"]&.include?("Scan") && node["Actual Rows"]
+        scanned_rows += node["Actual Rows"] || 0
+      end
+
+      if node["Plans"]&.any?
+        scanned_rows += node["Plans"].sum { |child| extract_total_rows_scanned(child) }
+      end
+
+      scanned_rows
+    end
+
+    def check_for_seq_scan(node)
+      return false unless node
+
+      return true if node["Node Type"]&.include?("Seq Scan")
+
+      if node["Plans"]&.any?
+        return node["Plans"].any? { |child| check_for_seq_scan(child) }
+      end
+
+      false
     end
   end
 end