sql_genius 0.9.0

data/app/controllers/concerns/sql_genius/ai_features.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module AiFeatures
+    extend ActiveSupport::Concern
+
+    def suggest
+      unless sql_genius_config.ai_enabled?
+        return render(json: { error: "AI features are not configured." }, status: :not_found)
+      end
+
+      prompt = params[:prompt].to_s.strip
+      return render(json: { error: "Please describe what you want to query." }, status: :unprocessable_entity) if prompt.blank?
+
+      service = SqlGenius::Core::Ai::Suggestion.new(rails_connection, ai_client, ai_config_for_core)
+      result = service.call(prompt, queryable_tables)
+      sql = sanitize_ai_sql(result["sql"].to_s)
+      render(json: { sql: sql, explanation: result["explanation"] })
+    rescue StandardError => e
+      render(json: { error: "AI suggestion failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def optimize
+      unless sql_genius_config.ai_enabled?
+        return render(json: { error: "AI features are not configured." }, status: :not_found)
+      end
+
+      sql = params[:sql].to_s.strip
+      explain_rows = Array(params[:explain_rows]).map { |row| row.respond_to?(:values) ? row.values : Array(row) }
+
+      if sql.blank? || explain_rows.blank?
+        return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity)
+      end
+
+      service = SqlGenius::Core::Ai::Optimization.new(rails_connection, ai_client, ai_config_for_core)
+      result = service.call(sql, explain_rows, queryable_tables)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Optimization failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def describe_query
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      sql = params[:sql].to_s.strip
+      return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
+
+      result = SqlGenius::Core::Ai::DescribeQuery.new(ai_client, ai_config_for_core).call(sql)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Explanation failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def schema_review
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::SchemaReview.new(ai_client, ai_config_for_core, rails_connection).call(params[:table].to_s.strip.presence)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Schema review failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def rewrite_query
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      sql = params[:sql].to_s.strip
+      return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
+
+      result = SqlGenius::Core::Ai::RewriteQuery.new(ai_client, ai_config_for_core, rails_connection).call(sql)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Rewrite failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def index_advisor
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      sql = params[:sql].to_s.strip
+      explain_rows = Array(params[:explain_rows]).map { |row| row.respond_to?(:values) ? row.values : Array(row) }
+      return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity) if sql.blank? || explain_rows.blank?
+
+      result = SqlGenius::Core::Ai::IndexAdvisor.new(ai_client, ai_config_for_core, rails_connection).call(sql, explain_rows)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Index advisor failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def anomaly_detection
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+      return ai_unsupported_on_postgresql("Anomaly detection") if connected_to_postgresql?
+
+      connection = ActiveRecord::Base.connection
+
+      # Gather recent slow queries
+      slow_data = []
+      if sql_genius_config.redis_url
+        redis = Redis.new(url: sql_genius_config.redis_url)
+        raw = redis.lrange(SlowQueryMonitor.redis_key, 0, 99)
+        slow_data = raw.map do |e|
+          JSON.parse(e)
+        rescue
+          nil
+        end.compact
+      end
+
+      # Gather top query stats
+      stats = []
+      begin
+        results = connection.exec_query(<<~SQL)
+          SELECT DIGEST_TEXT, COUNT_STAR AS calls,
+            ROUND(SUM_TIMER_WAIT / 1000000000, 1) AS total_time_ms,
+            ROUND(AVG_TIMER_WAIT / 1000000000, 1) AS avg_time_ms,
+            SUM_ROWS_EXAMINED AS rows_examined, SUM_ROWS_SENT AS rows_sent,
+            FIRST_SEEN, LAST_SEEN
+          FROM performance_schema.events_statements_summary_by_digest
+          WHERE SCHEMA_NAME = #{connection.quote(connection.current_database)}
+            AND DIGEST_TEXT IS NOT NULL
+          ORDER BY SUM_TIMER_WAIT DESC LIMIT 30
+        SQL
+        stats = results.rows.map { |r| { sql: r[0].to_s.truncate(200), calls: r[1], total_ms: r[2], avg_ms: r[3], rows_examined: r[4], rows_sent: r[5], first_seen: r[6], last_seen: r[7] } }
+      rescue
+        # performance_schema may not be available
+      end
+
+      slow_summary = slow_data.first(50).map { |q| "#{q["duration_ms"]}ms @ #{q["timestamp"]}: #{q["sql"].to_s.truncate(150)}" }.join("\n")
+      stats_summary = stats.map { |q| "calls=#{q[:calls]} avg=#{q[:avg_ms]}ms total=#{q[:total_ms]}ms exam=#{q[:rows_examined]} sent=#{q[:rows_sent]}: #{q[:sql]}" }.join("\n")
+      domain_ctx = sql_genius_config.ai_system_context.present? ? "\nDomain context:\n#{sql_genius_config.ai_system_context}" : ""
+
+      messages = [
+        { role: "system", content: <<~PROMPT },
+          You are a MySQL query anomaly detector. Analyze the following query data and identify:
+          1. Queries with degrading performance (high avg time relative to complexity)
+          2. N+1 query patterns (same template called many times in short windows)
+          3. Full table scans (rows_examined >> rows_sent)
+          4. Sudden new query patterns that may indicate code changes
+          5. Queries creating excessive temp tables or sorts
+          #{domain_ctx}
+
+          Respond with JSON: {"report": "markdown-formatted health report organized by severity. For each finding, explain the issue, affected query, and recommended fix."}
+        PROMPT
+        { role: "user", content: "Recent Slow Queries (last #{slow_data.size}):\n#{slow_summary.presence || "None captured"}\n\nTop Queries by Total Time:\n#{stats_summary.presence || "Not available"}" },
+      ]
+
+      result = ai_client.chat(messages: messages)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Anomaly detection failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def root_cause
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+      return ai_unsupported_on_postgresql("Root cause analysis") if connected_to_postgresql?
+
+      connection = ActiveRecord::Base.connection
+
+      # PROCESSLIST
+      processlist = connection.exec_query("SHOW FULL PROCESSLIST")
+      process_info = processlist.rows.map { |r| "ID=#{r[0]} User=#{r[1]} Host=#{r[2]} DB=#{r[3]} Command=#{r[4]} Time=#{r[5]}s State=#{r[6]} SQL=#{r[7].to_s.truncate(200)}" }.join("\n")
+
+      # Key status variables
+      status_rows = connection.exec_query("SHOW GLOBAL STATUS")
+      status = {}
+      status_rows.each { |r| status[(r["Variable_name"] || r["variable_name"]).to_s] = (r["Value"] || r["value"]).to_s }
+
+      key_stats = [
+        "Threads_connected",
+        "Threads_running",
+        "Innodb_row_lock_waits",
+        "Innodb_row_lock_current_waits",
+        "Innodb_buffer_pool_reads",
+        "Innodb_buffer_pool_read_requests",
+        "Slow_queries",
+        "Created_tmp_disk_tables",
+        "Connections",
+        "Aborted_connects",
+      ].map { |k| "#{k}=#{status[k]}" }.join(", ")
+
+      # InnoDB status (truncated)
+      innodb_status = ""
+      begin
+        result = connection.exec_query("SHOW ENGINE INNODB STATUS")
+        innodb_status = result.rows.first&.last.to_s.truncate(3000)
+      rescue ActiveRecord::StatementInvalid
+        # InnoDB status may be unavailable depending on MySQL user privileges
+      end
+
+      # Recent slow queries
+      slow_summary = ""
+      if sql_genius_config.redis_url
+        redis = Redis.new(url: sql_genius_config.redis_url)
+        raw = redis.lrange(SlowQueryMonitor.redis_key, 0, 19)
+        slows = raw.map do |e|
+          JSON.parse(e)
+        rescue
+          nil
+        end.compact
+        slow_summary = slows.map { |q| "#{q["duration_ms"]}ms: #{q["sql"].to_s.truncate(150)}" }.join("\n")
+      end
+
+      domain_ctx = sql_genius_config.ai_system_context.present? ? "\nDomain context:\n#{sql_genius_config.ai_system_context}" : ""
+
+      messages = [
+        { role: "system", content: <<~PROMPT },
+          You are a MySQL incident responder. The user is asking "why is the database slow right now?" Analyze the provided data and give a root cause diagnosis. Consider:
+          - Lock contention (row locks, metadata locks, table locks)
+          - Long-running queries blocking others
+          - Connection exhaustion
+          - Buffer pool thrashing (low hit rate)
+          - Disk I/O saturation
+          - Replication lag
+          - Unusual query patterns
+          #{domain_ctx}
+
+          Respond with JSON: {"diagnosis": "markdown-formatted root cause analysis. Start with a 1-2 sentence summary, then detailed findings. Include specific actionable steps to resolve the issue."}
+        PROMPT
+        { role: "user", content: "PROCESSLIST:\n#{process_info}\n\nKey Status:\n#{key_stats}\n\nInnoDB Status (excerpt):\n#{innodb_status.presence || "Not available"}\n\nRecent Slow Queries:\n#{slow_summary.presence || "None captured"}" },
+      ]
+
+      result = ai_client.chat(messages: messages)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Root cause analysis failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def migration_risk
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      migration_sql = params[:migration].to_s.strip
+      return render(json: { error: "Migration SQL or Ruby code is required." }, status: :unprocessable_entity) if migration_sql.blank?
+
+      result = SqlGenius::Core::Ai::MigrationRisk.new(ai_client, ai_config_for_core, rails_connection).call(migration_sql)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Migration risk assessment failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def variable_review
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::VariableReviewer.new(ai_client, ai_config_for_core, rails_connection).call
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Variable review failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def connection_advisor
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::ConnectionAdvisor.new(ai_client, ai_config_for_core, rails_connection).call
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Connection advisor failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def workload_digest
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::WorkloadDigest.new(rails_connection, ai_client, ai_config_for_core).call
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Workload digest failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def innodb_health
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::InnodbInterpreter.new(ai_client, ai_config_for_core, rails_connection).call
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "InnoDB health analysis failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def index_planner
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      tables = params[:tables].present? ? Array(params[:tables]) : nil
+      result = SqlGenius::Core::Ai::IndexPlanner.new(ai_client, ai_config_for_core, rails_connection).call(tables)
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Index planner failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    def pattern_grouper
+      return ai_not_configured unless sql_genius_config.ai_enabled?
+
+      result = SqlGenius::Core::Ai::PatternGrouper.new(rails_connection, ai_client, ai_config_for_core).call
+      render(json: result)
+    rescue StandardError => e
+      render(json: { error: "Pattern grouper failed: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    private
+
+    RAILS_DOMAIN_CONTEXT = <<~CTX
+      This is a Ruby on Rails application. Do NOT recommend adding foreign key constraints (FOREIGN KEY / REFERENCES); Rails handles referential integrity at the application layer. DO recommend indexes on foreign key columns for join performance.
+    CTX
+
+    def ai_client
+      SqlGenius::Core::Ai::Client.new(ai_config_for_core)
+    end
+
+    def ai_config_for_core
+      cfg = sql_genius_config
+      SqlGenius::Core::Ai::Config.new(
+        client: cfg.ai_client,
+        endpoint: cfg.ai_endpoint,
+        api_key: cfg.ai_api_key,
+        model: cfg.ai_model,
+        auth_style: cfg.ai_auth_style,
+        system_context: cfg.ai_system_context,
+        domain_context: RAILS_DOMAIN_CONTEXT,
+      )
+    end
+
+    def ai_not_configured
+      render(json: { error: "AI features are not configured." }, status: :not_found)
+    end
+
+    def ai_unsupported_on_postgresql(feature_name)
+      render(
+        json: { error: "#{feature_name} is MySQL/MariaDB-only and is not available on PostgreSQL." },
+        status: :unprocessable_entity,
+      )
+    end
+
+    def connected_to_postgresql?
+      rails_connection.server_version.postgresql?
+    rescue StandardError
+      false
+    end
+  end
+end

data/app/controllers/concerns/sql_genius/database_analysis.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module DatabaseAnalysis
+    extend ActiveSupport::Concern
+
+    def duplicate_indexes
+      duplicates = SqlGenius::Core::Analysis::DuplicateIndexes
+        .new(rails_connection, blocked_tables: sql_genius_config.blocked_tables)
+        .call
+      render(json: duplicates)
+    end
+
+    def table_sizes
+      tables = SqlGenius::Core::Analysis::TableSizes.new(rails_connection).call
+      render(json: tables)
+    end
+
+    def query_stats
+      sort = params[:sort].to_s
+      limit = params.fetch(:limit, SqlGenius::Core::Analysis::QueryStats::MAX_LIMIT).to_i
+      queries = SqlGenius::Core::Analysis::QueryStats.new(rails_connection).call(sort: sort, limit: limit)
+      render(json: queries)
+    rescue ActiveRecord::StatementInvalid => e
+      render(json: { error: "#{query_stats_source_name} #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
+    end
+
+    def unused_indexes
+      result = SqlGenius::Core::Analysis::UnusedIndexes.new(
+        rails_connection,
+        min_scans: sql_genius_config.min_unused_index_scans,
+      ).call
+      render(json: {
+        indexes: result.indexes,
+        stats_reset_at: result.stats_reset_at,
+        min_scans: result.min_scans,
+      })
+    rescue ActiveRecord::StatementInvalid => e
+      render(json: { error: "#{unused_indexes_source_name} #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
+    end
+
+    def server_overview
+      overview = SqlGenius::Core::Analysis::ServerOverview.new(rails_connection).call
+      render(json: overview)
+    rescue => e
+      render(json: { error: "Failed to load server overview: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    private
+
+    def query_stats_source_name
+      if rails_connection.server_version.postgresql?
+        "Query statistics require the pg_stat_statements extension to be installed."
+      else
+        "Query statistics require performance_schema to be enabled."
+      end
+    end
+
+    def unused_indexes_source_name
+      if rails_connection.server_version.postgresql?
+        "Unused index detection requires pg_stat_user_indexes (always available on PostgreSQL — check connection)."
+      else
+        "Unused index detection requires performance_schema."
+      end
+    end
+  end
+end

data/app/controllers/concerns/sql_genius/query_execution.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module QueryExecution
+    extend ActiveSupport::Concern
+
+    def execute
+      sql = params[:sql].to_s.strip
+      row_limit = if params[:row_limit].present?
+        params[:row_limit].to_i.clamp(1, sql_genius_config.max_row_limit)
+      else
+        sql_genius_config.default_row_limit
+      end
+
+      runner_config = SqlGenius::Core::QueryRunner::Config.new(
+        blocked_tables: sql_genius_config.blocked_tables,
+        masked_column_patterns: sql_genius_config.masked_column_patterns,
+        query_timeout_ms: sql_genius_config.query_timeout_ms,
+      )
+      runner = SqlGenius::Core::QueryRunner.new(rails_connection, runner_config)
+
+      begin
+        result = runner.run(sql, row_limit: row_limit)
+      rescue SqlGenius::Core::QueryRunner::Rejected => e
+        audit(:rejection, sql: sql, reason: e.message)
+        return render(json: { error: e.message }, status: :unprocessable_entity)
+      rescue SqlGenius::Core::QueryRunner::Timeout
+        audit(:error, sql: sql, error: "Query timeout")
+        return render(json: { error: "Query exceeded the #{sql_genius_config.query_timeout_ms / 1000} second timeout limit.", timeout: true }, status: :unprocessable_entity)
+      rescue ActiveRecord::StatementInvalid => e
+        audit(:error, sql: sql, error: e.message)
+        return render(json: { error: "Query error: #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
+      end
+
+      audit(:query, sql: sql, execution_time_ms: result.execution_time_ms, row_count: result.row_count)
+
+      render(json: {
+        columns: result.columns,
+        rows: result.rows,
+        row_count: result.row_count,
+        execution_time_ms: result.execution_time_ms,
+        truncated: result.truncated,
+      })
+    end
+
+    def explain
+      sql = params[:sql].to_s.strip
+      skip_validation = params[:from_slow_query] == "true"
+
+      runner_config = SqlGenius::Core::QueryRunner::Config.new(
+        blocked_tables: sql_genius_config.blocked_tables,
+        masked_column_patterns: sql_genius_config.masked_column_patterns,
+        query_timeout_ms: sql_genius_config.query_timeout_ms,
+      )
+      explainer = SqlGenius::Core::QueryExplainer.new(rails_connection, runner_config)
+
+      result = explainer.explain(sql, skip_validation: skip_validation)
+      render(json: { columns: result.columns, rows: result.rows })
+    rescue SqlGenius::Core::QueryRunner::Rejected,
+           SqlGenius::Core::QueryExplainer::Truncated => e
+      render(json: { error: e.message }, status: :unprocessable_entity)
+    rescue ActiveRecord::StatementInvalid => e
+      render(json: { error: "Explain error: #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
+    end
+
+    private
+
+    def sanitize_ai_sql(sql)
+      sql.gsub(/```(?:sql)?\s*/i, "").gsub("```", "").strip
+    end
+
+    def audit(type, **attrs)
+      logger = sql_genius_config.audit_logger
+      return unless logger
+
+      prefix = "[#{Time.current.iso8601}] [sql_genius]"
+      case type
+      when :query
+        logger.info("#{prefix} rows=#{attrs[:row_count]} time=#{attrs[:execution_time_ms]}ms sql=#{attrs[:sql].squish}")
+      when :rejection
+        logger.warn("#{prefix} REJECTED reason=#{attrs[:reason]} sql=#{attrs[:sql].to_s.squish}")
+      when :error
+        logger.error("#{prefix} ERROR error=#{attrs[:error]} sql=#{attrs[:sql].to_s.squish}")
+      end
+    end
+  end
+end

data/app/controllers/concerns/sql_genius/shared_view_helpers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module SharedViewHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :path_for, :render_partial, :capability?
+    end
+
+    # URL path helper for shared templates.
+    #   path_for(:execute) # => "/sql_genius/execute"
+    #
+    # When @digest is set (query detail page), routes that require a digest
+    # param (query_detail, query_history) are generated with it automatically.
+    #
+    # `:query_detail_prefix` returns the engine-mount-aware base path that
+    # the dashboard JS appends a digest to (so query stat rows link to
+    # /sql_genius/queries/${digest} rather than /queries/${digest}).
+    #
+    # Uses SqlGenius::Engine.routes.url_helpers directly rather than the
+    # `sql_genius` proxy: in production with eager loading, the proxy
+    # method isn't always injected onto the engine's controller in time,
+    # which surfaces as `NameError: undefined local variable or method
+    # 'sql_genius'` the first time a view tries to build a URL.
+    def path_for(name)
+      helpers = SqlGenius::Engine.routes.url_helpers
+      case name
+      when :query_detail_prefix
+        "#{helpers.root_path}queries/"
+      when :query_detail, :query_history
+        if @digest
+          helpers.public_send("#{name}_path", digest: @digest)
+        else
+          helpers.public_send("#{name}_path", digest: "")
+        end
+      else
+        helpers.public_send("#{name}_path")
+      end
+    end
+
+    # Partial renderer for shared templates.
+    #   render_partial(:tab_dashboard) # => view_context.render partial: "sql_genius/queries/tab_dashboard"
+    def render_partial(name)
+      view_context.render(partial: "sql_genius/queries/#{name}")
+    end
+
+    # Capability flag for shared templates. Used to hide AI feature buttons
+    # whose underlying service has no equivalent on the connected dialect
+    # (e.g. InnoDB Health, Variable Review, Connection Advisor, Root Cause
+    # Analysis, and Anomaly Detection all read MySQL-specific server state
+    # via SHOW commands / performance_schema).
+    #
+    # All other capabilities default to true — the Rails adapter owns every
+    # route, including Redis-backed slow_queries.
+    def capability?(name)
+      case name
+      when :mysql_only_ai
+        !connected_to_postgresql?
+      else
+        true
+      end
+    end
+
+    private
+
+    def connected_to_postgresql?
+      SqlGenius::Core::Connection::ActiveRecordAdapter
+        .new(ActiveRecord::Base.connection)
+        .server_version
+        .postgresql?
+    rescue StandardError
+      false
+    end
+  end
+end

data/app/controllers/sql_genius/base_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  class BaseController < SqlGenius.configuration.base_controller.constantize
+    layout "sql_genius/application"
+    before_action :authenticate_sql_genius!
+
+    private
+
+    def authenticate_sql_genius!
+      unless SqlGenius.configuration.authenticate.call(self)
+        render(plain: "Not authorized", status: :unauthorized)
+      end
+    end
+
+    def sql_genius_config
+      SqlGenius.configuration
+    end
+
+    # Wraps ActiveRecord::Base.connection in a Core::Connection::ActiveRecordAdapter.
+    # Every controller action that delegates to a Core::* service calls this
+    # instead of instantiating the adapter inline. Shared across all concerns
+    # (QueryExecution, DatabaseAnalysis, AiFeatures) via BaseController's
+    # private method lookup.
+    def rails_connection
+      SqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
+    end
+  end
+end

data/app/controllers/sql_genius/queries_controller.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  class QueriesController < BaseController
+    include QueryExecution
+    include DatabaseAnalysis
+    include AiFeatures
+    include SharedViewHelpers
+
+    def index
+      @featured_tables = if sql_genius_config.featured_tables.any?
+        sql_genius_config.featured_tables.sort
+      else
+        queryable_tables.sort
+      end
+      @all_tables = queryable_tables.sort
+      @ai_enabled = sql_genius_config.ai_enabled?
+      @framework_version_major = Rails::VERSION::MAJOR
+      @framework_version_minor = Rails::VERSION::MINOR
+      @identifier_quote_char = identifier_quote_char
+      render("sql_genius/queries/dashboard")
+    end
+
+    def columns
+      result = SqlGenius::Core::Analysis::Columns.new(
+        rails_connection,
+        blocked_tables: sql_genius_config.blocked_tables,
+        masked_column_patterns: sql_genius_config.masked_column_patterns,
+        default_columns: sql_genius_config.default_columns,
+      ).call(table: params[:table])
+
+      case result.status
+      when :ok        then render(json: result.columns)
+      when :blocked   then render(json: { error: result.error_message }, status: :forbidden)
+      when :not_found then render(json: { error: result.error_message }, status: :not_found)
+      end
+    end
+
+    def query_detail
+      @digest = params[:digest].to_s
+      render("sql_genius/queries/query_detail")
+    end
+
+    def query_history
+      digest = params[:digest].to_s
+
+      query_history_service = SqlGenius::Core::Analysis::QueryHistory.new(rails_connection)
+      current_query = query_history_service.call(digest)
+      history = fetch_query_history_series(digest, query_history_service)
+
+      render(json: { query: current_query, history: history })
+    rescue StandardError => e
+      render(json: { error: e.message }, status: :unprocessable_entity)
+    end
+
+    def slow_queries
+      unless sql_genius_config.redis_url.present?
+        return render(json: [], status: :ok)
+      end
+
+      require "redis"
+      redis = Redis.new(url: sql_genius_config.redis_url)
+      key = SlowQueryMonitor.redis_key
+      raw = redis.lrange(key, 0, 199)
+      queries = raw.map do |entry|
+        JSON.parse(entry)
+      rescue JSON::ParserError
+        nil
+      end.compact
+      render(json: queries)
+    rescue StandardError => e
+      render(json: { error: "Slow query error: #{e.message}" }, status: :unprocessable_entity)
+    end
+
+    private
+
+    def identifier_quote_char
+      ActiveRecord::Base.connection.quote_table_name("sql_genius_identifier_probe")[0]
+    end
+
+    def queryable_tables
+      ActiveRecord::Base.connection.tables - sql_genius_config.blocked_tables
+    end
+
+    def fetch_query_history_series(digest, query_history_service)
+      return [] unless SqlGenius.stats_history
+
+      digest_text = query_history_service.digest_text_for(digest)
+      return [] unless digest_text
+
+      SqlGenius.stats_history.series_for(digest_text)
+    end
+  end
+end