mysql_genius 0.1.0 → 0.3.0

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

@@ -1,44 +1,47 @@
+# frozen_string_literal: true
+
 module MysqlGenius
   module AiFeatures
     extend ActiveSupport::Concern
 
     def suggest
       unless mysql_genius_config.ai_enabled?
-        return render json: { error: "AI features are not configured." }, status: :not_found
+        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?
+      return render(json: { error: "Please describe what you want to query." }, status: :unprocessable_entity) if prompt.blank?
 
       result = AiSuggestionService.new.call(prompt, queryable_tables)
       sql = sanitize_ai_sql(result["sql"].to_s)
-      render json: { sql: sql, explanation: result["explanation"] }
+      render(json: { sql: sql, explanation: result["explanation"] })
     rescue StandardError => e
-      render json: { error: "AI suggestion failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "AI suggestion failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def optimize
       unless mysql_genius_config.ai_enabled?
-        return render json: { error: "AI features are not configured." }, status: :not_found
+        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
+        return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity)
       end
 
       result = AiOptimizationService.new.call(sql, explain_rows, queryable_tables)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Optimization failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Optimization failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def describe_query
       return ai_not_configured unless mysql_genius_config.ai_enabled?
+
       sql = params[:sql].to_s.strip
-      return render json: { error: "SQL is required." }, status: :unprocessable_entity if sql.blank?
+      return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
 
       messages = [
         { role: "system", content: <<~PROMPT },
@@ -50,32 +53,39 @@ module MysqlGenius
           #{ai_domain_context}
           Respond with JSON: {"explanation": "your plain-English explanation using markdown formatting"}
         PROMPT
-        { role: "user", content: sql }
+        { role: "user", content: sql },
       ]
 
       result = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Explanation failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Explanation failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def schema_review
       return ai_not_configured unless mysql_genius_config.ai_enabled?
+
       table = params[:table].to_s.strip
       connection = ActiveRecord::Base.connection
 
       tables_to_review = table.present? ? [table] : queryable_tables.first(20)
       schema_desc = tables_to_review.map do |t|
         next unless connection.tables.include?(t)
-        cols = connection.columns(t).map { |c| "#{c.name} #{c.sql_type}#{c.null ? '' : ' NOT NULL'}#{c.default ? " DEFAULT #{c.default}" : ''}" }
-        indexes = connection.indexes(t).map { |idx| "#{idx.unique ? 'UNIQUE ' : ''}INDEX #{idx.name} (#{idx.columns.join(', ')})" }
+
+        cols = connection.columns(t).map { |c| "#{c.name} #{c.sql_type}#{" NOT NULL" unless c.null}#{" DEFAULT #{c.default}" if c.default}" }
+        pk = connection.primary_key(t)
+        indexes = connection.indexes(t).map { |idx| "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})" }
         row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        "Table: #{t} (~#{row_count} rows)\nColumns: #{cols.join(', ')}\nIndexes: #{indexes.any? ? indexes.join(', ') : 'NONE'}"
+        desc = "Table: #{t} (~#{row_count} rows)\n"
+        desc += "Primary Key: #{pk || "NONE"}\n"
+        desc += "Columns: #{cols.join(", ")}\n"
+        desc += "Indexes: #{indexes.any? ? indexes.join(", ") : "NONE"}"
+        desc
       end.compact.join("\n\n")
 
       messages = [
         { role: "system", content: <<~PROMPT },
-          You are a MySQL schema reviewer. Analyze the following schema and identify anti-patterns and improvement opportunities. Look for:
+          You are a MySQL schema reviewer for a Ruby on Rails application. Analyze the following schema and identify anti-patterns and improvement opportunities. Look for:
           - Inappropriate column types (VARCHAR(255) for short values, TEXT where VARCHAR suffices, INT for booleans)
           - Missing indexes on foreign key columns or frequently filtered columns
           - Missing NOT NULL constraints where NULLs are unlikely
@@ -87,19 +97,20 @@ module MysqlGenius
           #{ai_domain_context}
           Respond with JSON: {"findings": "markdown-formatted findings organized by severity (Critical, Warning, Suggestion). Include specific ALTER TABLE statements where applicable."}
         PROMPT
-        { role: "user", content: schema_desc }
+        { role: "user", content: schema_desc },
       ]
 
       result = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Schema review failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Schema review failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def rewrite_query
       return ai_not_configured unless mysql_genius_config.ai_enabled?
+
       sql = params[:sql].to_s.strip
-      return render json: { error: "SQL is required." }, status: :unprocessable_entity if sql.blank?
+      return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
 
       schema = build_schema_for_query(sql)
 
@@ -122,30 +133,31 @@ module MysqlGenius
 
           Respond with JSON: {"original": "the original SQL", "rewritten": "the improved SQL", "changes": "markdown list of each change and why it helps"}
         PROMPT
-        { role: "user", content: sql }
+        { role: "user", content: sql },
       ]
 
       result = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Rewrite failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Rewrite failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def index_advisor
       return ai_not_configured unless mysql_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?
+      return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity) if sql.blank? || explain_rows.blank?
 
       connection = ActiveRecord::Base.connection
       tables_in_query = SqlValidator.extract_table_references(sql, connection)
 
       index_detail = tables_in_query.map do |t|
-        indexes = connection.indexes(t).map { |idx| "#{idx.unique ? 'UNIQUE ' : ''}INDEX #{idx.name} (#{idx.columns.join(', ')})" }
+        indexes = connection.indexes(t).map { |idx| "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})" }
         stats = connection.exec_query("SELECT INDEX_NAME, COLUMN_NAME, CARDINALITY, SEQ_IN_INDEX FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = #{connection.quote(connection.current_database)} AND TABLE_NAME = #{connection.quote(t)} ORDER BY INDEX_NAME, SEQ_IN_INDEX")
         cardinality = stats.rows.map { |r| "#{r[0]}.#{r[1]}: cardinality=#{r[2]}" }.join(", ")
         row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        "Table: #{t} (~#{row_count} rows)\nIndexes: #{indexes.any? ? indexes.join('; ') : 'NONE'}\nCardinality: #{cardinality}"
+        "Table: #{t} (~#{row_count} rows)\nIndexes: #{indexes.any? ? indexes.join("; ") : "NONE"}\nCardinality: #{cardinality}"
       end.join("\n\n")
 
       messages = [
@@ -160,17 +172,18 @@ module MysqlGenius
 
           Respond with JSON: {"indexes": "markdown-formatted recommendations with exact CREATE INDEX statements, rationale for column ordering, and estimated impact. Include any indexes that should be DROPPED as part of the change."}
         PROMPT
-        { role: "user", content: "Query:\n#{sql}\n\nEXPLAIN:\n#{explain_rows.map { |r| r.join(' | ') }.join("\n")}\n\nCurrent Indexes:\n#{index_detail}" }
+        { role: "user", content: "Query:\n#{sql}\n\nEXPLAIN:\n#{explain_rows.map { |r| r.join(" | ") }.join("\n")}\n\nCurrent Indexes:\n#{index_detail}" },
       ]
 
       result = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Index advisor failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Index advisor failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def anomaly_detection
       return ai_not_configured unless mysql_genius_config.ai_enabled?
+
       connection = ActiveRecord::Base.connection
 
       # Gather recent slow queries
@@ -178,7 +191,11 @@ module MysqlGenius
       if mysql_genius_config.redis_url
         redis = Redis.new(url: mysql_genius_config.redis_url)
         raw = redis.lrange(SlowQueryMonitor.redis_key, 0, 99)
-        slow_data = raw.map { |e| JSON.parse(e) rescue nil }.compact
+        slow_data = raw.map do |e|
+          JSON.parse(e)
+        rescue
+          nil
+        end.compact
       end
 
       # Gather top query stats
@@ -200,7 +217,7 @@ module MysqlGenius
         # 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")
+      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")
 
       messages = [
@@ -215,17 +232,18 @@ module MysqlGenius
 
           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'}" }
+        { 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 = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Anomaly detection failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Anomaly detection failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def root_cause
       return ai_not_configured unless mysql_genius_config.ai_enabled?
+
       connection = ActiveRecord::Base.connection
 
       # PROCESSLIST
@@ -237,16 +255,26 @@ module MysqlGenius
       status = {}
       status_rows.each { |r| status[(r["Variable_name"] || r["variable_name"]).to_s] = (r["Value"] || r["value"]).to_s }
 
-      key_stats = %w[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(", ")
+      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
+      rescue ActiveRecord::StatementInvalid
+        # InnoDB status may be unavailable depending on MySQL user privileges
       end
 
       # Recent slow queries
@@ -254,8 +282,12 @@ module MysqlGenius
       if mysql_genius_config.redis_url
         redis = Redis.new(url: mysql_genius_config.redis_url)
         raw = redis.lrange(SlowQueryMonitor.redis_key, 0, 19)
-        slows = raw.map { |e| JSON.parse(e) rescue nil }.compact
-        slow_summary = slows.map { |q| "#{q['duration_ms']}ms: #{q['sql'].to_s.truncate(150)}" }.join("\n")
+        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
 
       messages = [
@@ -272,19 +304,20 @@ module MysqlGenius
 
           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'}" }
+        { 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 = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Root cause analysis failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Root cause analysis failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     def migration_risk
       return ai_not_configured unless mysql_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?
+      return render(json: { error: "Migration SQL or Ruby code is required." }, status: :unprocessable_entity) if migration_sql.blank?
 
       connection = ActiveRecord::Base.connection
 
@@ -294,8 +327,9 @@ module MysqlGenius
 
       table_info = table_names.uniq.map do |t|
         next unless connection.tables.include?(t)
+
         row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        indexes = connection.indexes(t).map { |idx| "#{idx.name} (#{idx.columns.join(', ')})" }
+        indexes = connection.indexes(t).map { |idx| "#{idx.name} (#{idx.columns.join(", ")})" }
         "Table: #{t} (~#{row_count} rows, #{indexes.size} indexes)"
       end.compact.join("\n")
 
@@ -312,7 +346,8 @@ module MysqlGenius
         SQL
         matching = results.rows.select { |r| table_names.any? { |t| r[0].to_s.downcase.include?(t.downcase) } }
         active = matching.map { |r| "calls=#{r[1]} avg=#{r[2]}ms: #{r[0].to_s.truncate(200)}" }.join("\n")
-      rescue
+      rescue ActiveRecord::StatementInvalid
+        # performance_schema may be unavailable
       end
 
       messages = [
@@ -328,24 +363,27 @@ module MysqlGenius
 
           Respond with JSON: {"risk_level": "low|medium|high|critical", "assessment": "markdown-formatted risk assessment with specific recommendations and estimated lock duration"}
         PROMPT
-        { role: "user", content: "Migration:\n#{migration_sql}\n\nAffected Tables:\n#{table_info.presence || 'Could not determine'}\n\nActive Queries on These Tables:\n#{active.presence || 'None found or performance_schema unavailable'}" }
+        { role: "user", content: "Migration:\n#{migration_sql}\n\nAffected Tables:\n#{table_info.presence || "Could not determine"}\n\nActive Queries on These Tables:\n#{active.presence || "None found or performance_schema unavailable"}" },
       ]
 
       result = AiClient.new.chat(messages: messages)
-      render json: result
+      render(json: result)
     rescue StandardError => e
-      render json: { error: "Migration risk assessment failed: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Migration risk assessment failed: #{e.message}" }, status: :unprocessable_entity)
     end
 
     private
 
     def ai_not_configured
-      render json: { error: "AI features are not configured." }, status: :not_found
+      render(json: { error: "AI features are not configured." }, status: :not_found)
     end
 
     def ai_domain_context
+      parts = []
+      parts << "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 = mysql_genius_config.ai_system_context
-      ctx.present? ? "\nDomain context:\n#{ctx}" : ""
+      parts << "Domain context:\n#{ctx}" if ctx.present?
+      "\n" + parts.join("\n")
     end
 
     def build_schema_for_query(sql)
@@ -353,7 +391,7 @@ module MysqlGenius
       tables = SqlValidator.extract_table_references(sql, connection)
       tables.map do |t|
         cols = connection.columns(t).map { |c| "#{c.name} (#{c.type})" }
-        "#{t}: #{cols.join(', ')}"
+        "#{t}: #{cols.join(", ")}"
       end.join("\n")
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MysqlGenius
   module DatabaseAnalysis
     extend ActiveSupport::Concern
@@ -13,19 +15,20 @@ module MysqlGenius
         indexes.each do |idx|
           indexes.each do |other|
             next if idx.name == other.name
+
             # idx is duplicate if its columns are a left-prefix of other's columns
-            if idx.columns.size <= other.columns.size &&
-               other.columns.first(idx.columns.size) == idx.columns &&
-               !(idx.unique && !other.unique) # don't drop a unique index covered by a non-unique one
-              duplicates << {
-                table: table,
-                duplicate_index: idx.name,
-                duplicate_columns: idx.columns,
-                covered_by_index: other.name,
-                covered_by_columns: other.columns,
-                unique: idx.unique
-              }
-            end
+            next unless idx.columns.size <= other.columns.size &&
+              other.columns.first(idx.columns.size) == idx.columns &&
+              !(idx.unique && !other.unique) # don't drop a unique index covered by a non-unique one
+
+            duplicates << {
+              table: table,
+              duplicate_index: idx.name,
+              duplicate_columns: idx.columns,
+              covered_by_index: other.name,
+              covered_by_columns: other.columns,
+              unique: idx.unique,
+            }
           end
         end
       end
@@ -34,10 +37,15 @@ module MysqlGenius
       seen = Set.new
       duplicates = duplicates.reject do |d|
         key = [d[:table], [d[:duplicate_index], d[:covered_by_index]].sort].flatten.join(":")
-        seen.include?(key) ? true : (seen.add(key); false)
+        if seen.include?(key)
+          true
+        else
+          (seen.add(key)
+           false)
+        end
       end
 
-      render json: duplicates
+      render(json: duplicates)
     end
 
     def table_sizes
@@ -47,7 +55,10 @@ module MysqlGenius
       results = connection.exec_query(<<~SQL)
         SELECT
           table_name,
-          table_rows,
+          engine,
+          table_collation,
+          auto_increment,
+          update_time,
           ROUND(data_length / 1024 / 1024, 2) AS data_mb,
           ROUND(index_length / 1024 / 1024, 2) AS index_mb,
           ROUND((data_length + index_length) / 1024 / 1024, 2) AS total_mb,
@@ -59,29 +70,46 @@ module MysqlGenius
       SQL
 
       tables = results.map do |row|
+        table_name = row["table_name"] || row["TABLE_NAME"]
+        row_count = begin
+          connection.select_value("SELECT COUNT(*) FROM #{connection.quote_table_name(table_name)}")
+        rescue StandardError
+          nil
+        end
+
+        total_mb = (row["total_mb"] || 0).to_f
+        fragmented_mb = (row["fragmented_mb"] || 0).to_f
+
         {
-          table: row["table_name"] || row["TABLE_NAME"],
-          rows: row["table_rows"] || row["TABLE_ROWS"],
-          data_mb: row["data_mb"].to_f,
-          index_mb: row["index_mb"].to_f,
-          total_mb: row["total_mb"].to_f,
-          fragmented_mb: row["fragmented_mb"].to_f
+          table: table_name,
+          rows: row_count,
+          engine: row["engine"] || row["ENGINE"],
+          collation: row["table_collation"] || row["TABLE_COLLATION"],
+          auto_increment: row["auto_increment"] || row["AUTO_INCREMENT"],
+          updated_at: row["update_time"] || row["UPDATE_TIME"],
+          data_mb: (row["data_mb"] || 0).to_f,
+          index_mb: (row["index_mb"] || 0).to_f,
+          total_mb: total_mb,
+          fragmented_mb: fragmented_mb,
+          needs_optimize: total_mb > 0 && fragmented_mb > (total_mb * 0.1),
         }
       end
 
-      render json: tables
+      render(json: tables)
     end
 
     def query_stats
       connection = ActiveRecord::Base.connection
-      sort = %w[total_time avg_time calls rows_examined].include?(params[:sort]) ? params[:sort] : "total_time"
+      sort = ["total_time", "avg_time", "calls", "rows_examined"].include?(params[:sort]) ? params[:sort] : "total_time"
 
       order_clause = case sort
-                     when "total_time"    then "SUM_TIMER_WAIT DESC"
-                     when "avg_time"      then "AVG_TIMER_WAIT DESC"
-                     when "calls"         then "COUNT_STAR DESC"
-                     when "rows_examined" then "SUM_ROWS_EXAMINED DESC"
-                     end
+      when "total_time"    then "SUM_TIMER_WAIT DESC"
+      when "avg_time"      then "AVG_TIMER_WAIT DESC"
+      when "calls"         then "COUNT_STAR DESC"
+      when "rows_examined" then "SUM_ROWS_EXAMINED DESC"
+      end
+
+      limit = params.fetch(:limit, 50).to_i.clamp(1, 50)
 
       results = connection.exec_query(<<~SQL)
         SELECT
@@ -101,7 +129,7 @@ module MysqlGenius
           AND DIGEST_TEXT IS NOT NULL
           AND DIGEST_TEXT NOT LIKE 'EXPLAIN%'
         ORDER BY #{order_clause}
-        LIMIT 50
+        LIMIT #{limit}
       SQL
 
       queries = results.map do |row|
@@ -121,13 +149,13 @@ module MysqlGenius
           tmp_disk_tables: (row["tmp_disk_tables"] || row["TMP_DISK_TABLES"] || 0).to_i,
           sort_rows: (row["sort_rows"] || row["SORT_ROWS"] || 0).to_i,
           first_seen: row["FIRST_SEEN"] || row["first_seen"],
-          last_seen: row["LAST_SEEN"] || row["last_seen"]
+          last_seen: row["LAST_SEEN"] || row["last_seen"],
         }
       end
 
-      render json: queries
+      render(json: queries)
     rescue ActiveRecord::StatementInvalid => e
-      render json: { error: "Query statistics require performance_schema to be enabled. #{e.message.split(':').last.strip}" }, status: :unprocessable_entity
+      render(json: { error: "Query statistics require performance_schema to be enabled. #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
     end
 
     def unused_indexes
@@ -139,8 +167,8 @@ module MysqlGenius
           s.OBJECT_SCHEMA AS table_schema,
           s.OBJECT_NAME AS table_name,
           s.INDEX_NAME AS index_name,
-          s.COUNT_READ AS reads,
-          s.COUNT_WRITE AS writes,
+          s.COUNT_READ AS `reads`,
+          s.COUNT_WRITE AS `writes`,
           t.TABLE_ROWS AS table_rows
         FROM performance_schema.table_io_waits_summary_by_index_usage s
         JOIN information_schema.tables t
@@ -162,13 +190,13 @@ module MysqlGenius
           reads: (row["reads"] || row["READS"] || 0).to_i,
           writes: (row["writes"] || row["WRITES"] || 0).to_i,
           table_rows: (row["table_rows"] || row["TABLE_ROWS"] || 0).to_i,
-          drop_sql: "ALTER TABLE `#{table}` DROP INDEX `#{index_name}`;"
+          drop_sql: "ALTER TABLE `#{table}` DROP INDEX `#{index_name}`;",
         }
       end
 
-      render json: indexes
+      render(json: indexes)
     rescue ActiveRecord::StatementInvalid => e
-      render json: { error: "Unused index detection requires performance_schema. #{e.message.split(':').last.strip}" }, status: :unprocessable_entity
+      render(json: { error: "Unused index detection requires performance_schema. #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
     end
 
     def server_overview
@@ -215,11 +243,11 @@ module MysqlGenius
       questions = status["Questions"].to_i
       qps = uptime_seconds > 0 ? (questions.to_f / uptime_seconds).round(1) : 0
 
-      render json: {
+      render(json: {
         server: {
           version: version,
           uptime: "#{days}d #{hours}h #{minutes}m",
-          uptime_seconds: uptime_seconds
+          uptime_seconds: uptime_seconds,
         },
         connections: {
           max: max_conn,
@@ -230,7 +258,7 @@ module MysqlGenius
           threads_created: status["Threads_created"].to_i,
           aborted_connects: status["Aborted_connects"].to_i,
           aborted_clients: status["Aborted_clients"].to_i,
-          max_used: status["Max_used_connections"].to_i
+          max_used: status["Max_used_connections"].to_i,
         },
         innodb: {
           buffer_pool_mb: buffer_pool_mb,
@@ -239,7 +267,7 @@ module MysqlGenius
           buffer_pool_pages_free: status["Innodb_buffer_pool_pages_free"].to_i,
           buffer_pool_pages_total: status["Innodb_buffer_pool_pages_total"].to_i,
           row_lock_waits: status["Innodb_row_lock_waits"].to_i,
-          row_lock_time_ms: (status["Innodb_row_lock_time"].to_f).round(0)
+          row_lock_time_ms: status["Innodb_row_lock_time"].to_f.round(0),
         },
         queries: {
           questions: questions,
@@ -249,11 +277,11 @@ module MysqlGenius
           tmp_disk_tables: tmp_disk_tables,
           tmp_disk_pct: tmp_disk_pct,
           select_full_join: status["Select_full_join"].to_i,
-          sort_merge_passes: status["Sort_merge_passes"].to_i
-        }
-      }
+          sort_merge_passes: status["Sort_merge_passes"].to_i,
+        },
+      })
     rescue => e
-      render json: { error: "Failed to load server overview: #{e.message}" }, status: :unprocessable_entity
+      render(json: { error: "Failed to load server overview: #{e.message}" }, status: :unprocessable_entity)
     end
   end
 end