dbviewer 0.5.2 → 0.5.3

data/lib/dbviewer/database_manager.rb

@@ -1,249 +0,0 @@
-require "dbviewer/cache_manager"
-require "dbviewer/table_metadata_manager"
-require "dbviewer/dynamic_model_factory"
-require "dbviewer/query_executor"
-require "dbviewer/table_query_operations"
-require "dbviewer/error_handler"
-
-module Dbviewer
-  # DatabaseManager handles all database interactions for the DBViewer engine
-  # It provides methods to access database structure and data
-  class DatabaseManager
-    attr_reader :connection, :adapter_name, :table_query_operations
-
-    # Expose query_operations as an alias
-    alias_method :query_operations, :table_query_operations
-
-    # Initialize the database manager
-    def initialize
-      ensure_connection
-      @cache_manager = CacheManager.new(self.class.configuration)
-      @table_metadata_manager = TableMetadataManager.new(@connection, @cache_manager)
-      @dynamic_model_factory = DynamicModelFactory.new(@connection, @cache_manager)
-      @query_executor = QueryExecutor.new(@connection, self.class.configuration)
-      @table_query_operations = TableQueryOperations.new(
-        @connection,
-        @dynamic_model_factory,
-        @query_executor,
-        @table_metadata_manager
-      )
-      reset_cache_if_needed
-    end
-
-    # Get configuration from class method or Dbviewer
-    def self.configuration
-      Dbviewer.configuration
-    end
-
-    # Get default per page from configuration
-    def self.default_per_page
-      configuration.default_per_page
-    end
-
-    # Get max records from configuration
-    def self.max_records
-      configuration.max_records
-    end
-
-    # Get cache expiry from configuration
-    def self.cache_expiry
-      configuration.cache_expiry
-    end
-
-    # Returns a sorted list of all tables in the database
-    # @return [Array<String>] List of table names
-    def tables
-      @table_metadata_manager.tables
-    end
-
-    # Returns column information for a specific table
-    # @param table_name [String] Name of the table
-    # @return [Array<Hash>] List of column details with name, type, null, default
-    def table_columns(table_name)
-      @table_metadata_manager.table_columns(table_name)
-    end
-
-    # Get detailed metadata about a table (primary keys, indexes, foreign keys)
-    # @param table_name [String] Name of the table
-    # @return [Hash] Table metadata
-    def table_metadata(table_name)
-      @table_metadata_manager.table_metadata(table_name)
-    end
-
-    # Get the total count of records in a table
-    # @param table_name [String] Name of the table
-    # @return [Integer] Number of records
-    def table_count(table_name)
-      @table_query_operations.table_count(table_name)
-    end
-
-    # Get records from a table with pagination and sorting
-    # @param table_name [String] Name of the table
-    # @param query_params [TableQueryParams] Query parameters for pagination and sorting
-    # @return [ActiveRecord::Result] Result set with columns and rows
-    def table_records(table_name, query_params)
-      @table_query_operations.table_records(
-        table_name,
-        query_params
-      )
-    end
-
-    # Get the number of records in a table (alias for table_count)
-    # @param table_name [String] Name of the table
-    # @return [Integer] Number of records
-    def record_count(table_name)
-      @table_query_operations.record_count(table_name)
-    end
-
-    # Get the number of records in a table with filters applied
-    # @param table_name [String] Name of the table
-    # @param column_filters [Hash] Hash of column_name => filter_value for filtering
-    # @return [Integer] Number of filtered records
-    def filtered_record_count(table_name, column_filters = {})
-      @table_query_operations.filtered_record_count(table_name, column_filters)
-    end
-
-    # Get the number of columns in a table
-    # @param table_name [String] Name of the table
-    # @return [Integer] Number of columns
-    def column_count(table_name)
-      table_columns(table_name).size
-    end
-
-    # Get the primary key of a table
-    # @param table_name [String] Name of the table
-    # @return [String, nil] Primary key column name or nil if not found
-    def primary_key(table_name)
-      @table_metadata_manager.primary_key(table_name)
-    end
-
-    # Check if a column exists in a table
-    # @param table_name [String] Name of the table
-    # @param column_name [String] Name of the column
-    # @return [Boolean] true if column exists, false otherwise
-    def column_exists?(table_name, column_name)
-      @table_metadata_manager.column_exists?(table_name, column_name)
-    end
-
-    # Execute a raw SQL query after validating for safety
-    # @param sql [String] SQL query to execute
-    # @return [ActiveRecord::Result] Result set with columns and rows
-    # @raise [StandardError] If the query is invalid or unsafe
-    def execute_query(sql)
-      @table_query_operations.execute_query(sql)
-    end
-
-    # Execute a SQLite PRAGMA command without adding a LIMIT clause
-    # @param pragma [String] PRAGMA command to execute (without the "PRAGMA" keyword)
-    # @return [ActiveRecord::Result] Result set with the PRAGMA value
-    # @raise [StandardError] If the query is invalid or cannot be executed
-    def execute_sqlite_pragma(pragma)
-      @table_query_operations.execute_sqlite_pragma(pragma)
-    end
-
-    # Query a table with more granular control using ActiveRecord
-    # @param table_name [String] Name of the table
-    # @param select [String, Array] Columns to select
-    # @param order [String, Hash] Order by clause
-    # @param limit [Integer] Maximum number of records to return
-    # @param offset [Integer] Offset from which to start returning records
-    # @param where [String, Hash] Where conditions
-    # @return [ActiveRecord::Result] Result set with columns and rows
-    def query_table(table_name, select: nil, order: nil, limit: nil, offset: nil, where: nil)
-      @table_query_operations.query_table(
-        table_name,
-        select: select,
-        order: order,
-        limit: limit,
-        offset: offset,
-        where: where,
-        max_records: self.class.max_records
-      )
-    end
-
-    # Get table indexes
-    # @param table_name [String] Name of the table
-    # @return [Array<Hash>] List of indexes with details
-    def fetch_indexes(table_name)
-      @table_metadata_manager.fetch_indexes(table_name)
-    end
-
-    # Get foreign keys
-    # @param table_name [String] Name of the table
-    # @return [Array<Hash>] List of foreign keys with details
-    def fetch_foreign_keys(table_name)
-      @table_metadata_manager.fetch_foreign_keys(table_name)
-    end
-
-    # Clear all caches - useful when schema changes are detected
-    def clear_all_caches
-      @cache_manager.clear_all
-    end
-
-    # Calculate the total size of the database schema
-    # @return [Integer, nil] Database size in bytes or nil if unsupported
-    def fetch_schema_size
-      case adapter_name
-      when /mysql/
-        fetch_mysql_size
-      when /postgres/
-        fetch_postgres_size
-      when /sqlite/
-        fetch_sqlite_size
-      else
-        nil # Unsupported database type for size calculation
-      end
-    end
-
-    private
-
-    def fetch_mysql_size
-      query = "SELECT SUM(data_length + index_length) AS size FROM information_schema.TABLES WHERE table_schema = DATABASE()"
-      fetch_size_from_query(query)
-    end
-
-    def fetch_postgres_size
-      query = "SELECT pg_database_size(current_database()) AS size"
-      fetch_size_from_query(query)
-    end
-
-    def fetch_sqlite_size
-      page_count = fetch_sqlite_pragma_value("page_count")
-      page_size = fetch_sqlite_pragma_value("page_size")
-      page_count * page_size
-    end
-
-    def fetch_sqlite_pragma_value(pragma_name)
-      execute_sqlite_pragma(pragma_name).first.values.first.to_i
-    end
-
-    def fetch_size_from_query(query)
-      result = execute_query(query).first
-      result ? result["size"].to_i : nil
-    end
-
-    # Ensure we have a valid database connection
-    # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter] The database connection
-    def ensure_connection
-      return @connection if @connection
-
-      ErrorHandler.with_error_handling("establishing database connection") do
-        @connection = ActiveRecord::Base.connection
-        @adapter_name = @connection.adapter_name.downcase
-        @connection
-      end
-    end
-
-    # Reset caches if they've been around too long
-    def reset_cache_if_needed
-      @cache_manager.reset_if_needed
-    end
-
-    # Get a dynamic AR model for a table
-    # @param table_name [String] Name of the table
-    # @return [Class] ActiveRecord model class
-    def get_model_for(table_name)
-      @dynamic_model_factory.get_model_for(table_name)
-    end
-  end
-end

data/lib/dbviewer/dynamic_model_factory.rb

@@ -1,60 +0,0 @@
-module Dbviewer
-  # DynamicModelFactory creates and manages ActiveRecord models for database tables
-  class DynamicModelFactory
-    # Initialize with a connection and cache manager
-    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
-    # @param cache_manager [Dbviewer::CacheManager] Cache manager instance
-    def initialize(connection, cache_manager)
-      @connection = connection
-      @cache_manager = cache_manager
-    end
-
-    # Get or create an ActiveRecord model for a table
-    # @param table_name [String] Name of the table
-    # @return [Class] ActiveRecord model class for the table
-    def get_model_for(table_name)
-      cached_model = @cache_manager.get_model(table_name)
-      return cached_model if cached_model
-
-      model = create_model_for(table_name)
-      @cache_manager.store_model(table_name, model)
-      model
-    end
-
-    private
-
-    # Create a new ActiveRecord model for a table
-    # @param table_name [String] Name of the table
-    # @return [Class] ActiveRecord model class for the table
-    def create_model_for(table_name)
-      model_name = table_name.classify
-
-      # Create a new model class dynamically
-      model = Class.new(ActiveRecord::Base) do
-        self.table_name = table_name
-
-        # Some tables might not have primary keys, so we handle that
-        begin
-          primary_key = connection.primary_key(table_name)
-          self.primary_key = primary_key if primary_key.present?
-        rescue
-          self.primary_key = "id"
-        end
-
-        # Disable STI
-        self.inheritance_column = :_type_disabled
-
-        # Disable timestamps for better compatibility
-        self.record_timestamps = false
-      end
-
-      # Set model name constant if not already taken
-      # Use a namespace to avoid polluting the global namespace
-      unless Dbviewer.const_defined?("DynamicModel_#{model_name}")
-        Dbviewer.const_set("DynamicModel_#{model_name}", model)
-      end
-
-      model
-    end
-  end
-end

data/lib/dbviewer/error_handler.rb

@@ -1,18 +0,0 @@
-module Dbviewer
-  # ErrorHandler provides centralized error handling for database operations
-  class ErrorHandler
-    class << self
-      # Execute a block with error handling
-      # @param operation_name [String] Description of the operation for logging
-      # @param default_return [Object] Value to return on error
-      # @yield Block to execute
-      # @return [Object] Result of block or default value on error
-      def with_error_handling(operation_name, default_return = nil)
-        yield
-      rescue => e
-        Rails.logger.error("[DBViewer] Error #{operation_name}: #{e.message}")
-        default_return
-      end
-    end
-  end
-end

data/lib/dbviewer/logger.rb

@@ -1,77 +0,0 @@
-module Dbviewer
-  # Logger captures and analyzes SQL queries for debugging and performance monitoring
-  class Logger
-    include Singleton
-
-    def initialize
-      set_storage
-      Rails.logger.info("[DBViewer] Query Logger initialized with #{mode} storage mode")
-    end
-
-    # Add a new SQL event query to the logger
-    def add(event)
-      # Return early if query logging is disabled
-      return unless Dbviewer.configuration.enable_query_logging
-      return if QueryParser.should_skip_query?(event)
-
-      current_time = Time.now
-      @storage.add({
-        sql: event.payload[:sql],
-        name: event.payload[:name],
-        timestamp: current_time,
-        duration_ms: event.duration.round(2),
-        binds: QueryParser.format_binds(event.payload[:binds]),
-        request_id: ActiveSupport::Notifications.instrumenter.id,
-        thread_id: Thread.current.object_id.to_s,
-        caller: event.payload[:caller]
-      })
-    end
-
-    # Clear all stored queries
-    def clear
-      @storage.clear
-    end
-
-    # Get recent queries, optionally filtered
-    def recent_queries(limit: 100, table_filter: nil, request_id: nil, min_duration: nil)
-      @storage.filter(
-        limit: limit,
-        table_filter: table_filter,
-        request_id: request_id,
-        min_duration: min_duration
-      )
-    end
-
-    # Get stats about all queries
-    def stats
-      stats_for_queries(@storage.all)
-    end
-
-    # Calculate stats for a specific set of queries (can be filtered)
-    def stats_for_queries(queries)
-      QueryAnalyzer.generate_stats(queries)
-    end
-
-    class << self
-      extend Forwardable
-
-      # Delegate add method to the singleton instance so that it can be called directly on sql events
-      def_delegators :instance, :add
-    end
-
-    private
-
-    def mode
-      @mode ||= Dbviewer.configuration.query_logging_mode || :memory
-    end
-
-    def set_storage
-      @storage ||= case mode
-      when :file
-        Storage::FileStorage.new
-      else
-        Storage::InMemoryStorage.new
-      end
-    end
-  end
-end

data/lib/dbviewer/query_analyzer.rb

@@ -1,239 +0,0 @@
-module Dbviewer
-  # QueryAnalyzer handles analysis of query patterns and statistics
-  class QueryAnalyzer
-    # Calculate statistics for a collection of queries
-    def self.generate_stats(queries)
-      {
-        total_count: queries.size,
-        total_duration_ms: queries.sum { |q| q[:duration_ms] },
-        avg_duration_ms: calculate_average_duration(queries),
-        max_duration_ms: queries.map { |q| q[:duration_ms] }.max || 0,
-        tables_queried: extract_queried_tables(queries),
-        potential_n_plus_1: detect_potential_n_plus_1(queries),
-        slowest_queries: get_slowest_queries(queries)
-      }.merge(calculate_request_stats(queries))
-    end
-
-    # Instance methods for query analysis
-    attr_reader :connection, :adapter_name
-
-    # Initialize the analyzer for instance methods
-    # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
-    def initialize(connection)
-      @connection = connection
-      @adapter_name = connection.adapter_name.downcase
-    end
-
-    # Check if a table has an index on a column
-    # @param table_name [String] Name of the table
-    # @param column_name [String] Name of the column
-    # @return [Boolean] True if column has an index, false otherwise
-    def has_index_on?(table_name, column_name)
-      indexes = connection.indexes(table_name)
-      indexes.any? do |index|
-        index.columns.include?(column_name) ||
-        (index.columns.length == 1 && index.columns[0] == column_name)
-      end
-    end
-
-    # Analyze a query and provide performance statistics and recommendations
-    # @param table_name [String] Name of the table
-    # @param query_params [TableQueryParams] Query parameters with filters
-    # @return [Hash] Analysis results with statistics and recommendations
-    def analyze_query(table_name, query_params)
-      results = {
-        table: table_name,
-        filters: query_params.column_filters.keys,
-        analysis: [],
-        recommendations: []
-      }
-
-      # Check created_at filter performance
-      if query_params.column_filters["created_at"].present?
-        analyze_timestamp_query(table_name, "created_at", results)
-      end
-
-      # Add general performance recommendations based on database type
-      add_database_specific_recommendations(results)
-
-      results
-    end
-
-    # Detect potential N+1 query patterns
-    def self.detect_potential_n_plus_1(queries)
-      potential_issues = []
-
-      # Group queries by request_id
-      queries.group_by { |q| q[:request_id] }.each do |request_id, request_queries|
-        # Skip if there are too few queries to indicate a problem
-        next if request_queries.size < 5
-
-        # Look for repeated patterns within this request
-        analyze_request_patterns(request_id, request_queries, potential_issues)
-      end
-
-      # Sort by number of repetitions (most problematic first)
-      potential_issues.sort_by { |issue| -issue[:count] }
-    end
-
-    # Get the slowest queries from the dataset
-    def self.get_slowest_queries(queries, limit: 5)
-      # Return top N slowest queries with relevant info
-      queries.sort_by { |q| -q[:duration_ms] }
-        .first(limit)
-        .map do |q|
-          {
-            sql: q[:sql],
-            duration_ms: q[:duration_ms],
-            timestamp: q[:timestamp],
-            request_id: q[:request_id],
-            name: q[:name]
-          }
-        end
-    end
-
-    private
-
-    # Analyze timestamp column query performance
-    def analyze_timestamp_query(table_name, column_name, results)
-      # Check if column exists
-      begin
-        unless connection.column_exists?(table_name, column_name)
-          results[:analysis] << "Column '#{column_name}' not found in table '#{table_name}'"
-          return
-        end
-
-        # Check if there's an index on the timestamp column
-        unless has_index_on?(table_name, column_name)
-          results[:recommendations] << {
-            type: "missing_index",
-            message: "Consider adding an index on '#{column_name}' for faster filtering",
-            sql: index_creation_sql(table_name, column_name)
-          }
-        end
-
-        # Estimate data distribution if possible
-        if adapter_supports_statistics?(adapter_name)
-          add_data_distribution_stats(table_name, column_name, results)
-        end
-      rescue => e
-        results[:analysis] << "Error analyzing timestamp query: #{e.message}"
-      end
-    end
-
-    # Check if adapter supports statistics gathering
-    def adapter_supports_statistics?(adapter_name)
-      adapter_name.include?("postgresql")
-    end
-
-    # Add data distribution statistics
-    def add_data_distribution_stats(table_name, column_name, results)
-      case adapter_name
-      when /postgresql/
-        begin
-          # Get approximate date range and distribution
-          range_query = "SELECT min(#{column_name}), max(#{column_name}) FROM #{table_name}"
-          range_result = connection.execute(range_query).first
-
-          if range_result["min"] && range_result["max"]
-            min_date = range_result["min"]
-            max_date = range_result["max"]
-
-            results[:analysis] << {
-              type: "date_range",
-              min_date: min_date,
-              max_date: max_date,
-              span_days: ((Time.parse(max_date) - Time.parse(min_date)) / 86400).round
-            }
-          end
-        rescue => e
-          results[:analysis] << "Error getting date distribution: #{e.message}"
-        end
-      end
-    end
-
-    # Generate SQL for index creation
-    def index_creation_sql(table_name, column_name)
-      index_name = "index_#{table_name.gsub('.', '_')}_on_#{column_name}"
-      "CREATE INDEX #{index_name} ON #{table_name} (#{column_name})"
-    end
-
-    # Add database-specific recommendations
-    def add_database_specific_recommendations(results)
-      case adapter_name
-      when /mysql/
-        results[:recommendations] << {
-          type: "performance",
-          message: "For MySQL, consider optimizing the query with appropriate indexes and use EXPLAIN to verify query plan"
-        }
-      when /postgresql/
-        results[:recommendations] << {
-          type: "performance",
-          message: "For PostgreSQL, consider using EXPLAIN ANALYZE to verify query execution plan"
-        }
-      when /sqlite/
-        results[:recommendations] << {
-          type: "performance",
-          message: "For SQLite, consider using EXPLAIN QUERY PLAN to verify query execution strategy"
-        }
-      end
-    end
-
-    def self.calculate_average_duration(queries)
-      queries.any? ? (queries.sum { |q| q[:duration_ms] } / queries.size.to_f).round(2) : 0
-    end
-
-    def self.calculate_request_stats(queries)
-      # Calculate request groups statistics
-      requests = queries.group_by { |q| q[:request_id] }
-      {
-        request_count: requests.size,
-        avg_queries_per_request: queries.any? ? (queries.size.to_f / requests.size).round(2) : 0,
-        max_queries_per_request: requests.map { |_id, reqs| reqs.size }.max || 0
-      }
-    end
-
-    def self.extract_queried_tables(queries)
-      tables = Hash.new(0)
-
-      queries.each do |query|
-        extracted = QueryParser.extract_tables(query[:sql])
-        extracted.each { |table| tables[table] += 1 }
-      end
-
-      tables.sort_by { |_table, count| -count }.first(10).to_h
-    end
-
-    def self.analyze_request_patterns(request_id, request_queries, potential_issues)
-      # Group similar queries within this request
-      patterns = {}
-
-      request_queries.each do |query|
-        # Normalize the query to detect patterns
-        normalized = QueryParser.normalize(query[:sql])
-        patterns[normalized] ||= []
-        patterns[normalized] << query
-      end
-
-      # Look for patterns with many repetitions
-      patterns.each do |pattern, pattern_queries|
-        next if pattern_queries.size < 5  # Only interested in repeated patterns
-
-        # Check if these queries target the same table
-        tables = QueryParser.extract_tables(pattern_queries.first[:sql])
-        target_table = tables.size == 1 ? tables.first : nil
-
-        # Add to potential issues
-        total_time = pattern_queries.sum { |q| q[:duration_ms] }
-        potential_issues << {
-          request_id: request_id,
-          pattern: pattern_queries.first[:sql],
-          count: pattern_queries.size,
-          table: target_table,
-          total_duration_ms: total_time.round(2),
-          avg_duration_ms: (total_time / pattern_queries.size).round(2)
-        }
-      end
-    end
-  end
-end

data/lib/dbviewer/query_collection.rb

@@ -1,37 +0,0 @@
-module Dbviewer
-  # QueryCollection handles the storage and retrieval of SQL queries
-  # This class is maintained for backward compatibility
-  # New code should use InMemoryStorage or FileStorage directly
-  class QueryCollection < InMemoryStorage
-    # Maximum number of queries to keep in memory
-    MAX_QUERIES = 1000
-
-    # Get recent queries, optionally filtered
-    def filter(limit: 100, table_filter: nil, request_id: nil, min_duration: nil)
-      result = all
-
-      # Apply filters if provided
-      result = filter_by_table(result, table_filter) if table_filter.present?
-      result = filter_by_request_id(result, request_id) if request_id.present?
-      result = filter_by_duration(result, min_duration) if min_duration.present?
-
-      # Return most recent queries first, limited to requested amount
-      result.reverse.first(limit)
-    end
-
-    private
-
-    def filter_by_table(queries, table_filter)
-      queries.select { |q| q[:sql].downcase.include?(table_filter.downcase) }
-    end
-
-    def filter_by_request_id(queries, request_id)
-      queries.select { |q| q[:request_id].to_s.include?(request_id) }
-    end
-
-    def filter_by_duration(queries, min_duration)
-      min_ms = min_duration.to_f
-      queries.select { |q| q[:duration_ms] >= min_ms }
-    end
-  end
-end