dbviewer 0.3.15 → 0.3.16

data/lib/dbviewer/database_manager.rb

@@ -2,13 +2,17 @@ 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
+    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
@@ -17,6 +21,12 @@ module Dbviewer
       @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
 
@@ -64,77 +74,25 @@ module Dbviewer
     # @param table_name [String] Name of the table
     # @return [Integer] Number of records
     def table_count(table_name)
-      model = get_model_for(table_name)
-      model.count
+      @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 page [Integer] Page number (1-based)
-    # @param order_by [String] Column to sort by
-    # @param direction [String] Sort direction ('ASC' or 'DESC')
-    # @param per_page [Integer] Number of records per page
+    # @param query_params [TableQueryParams] Query parameters for pagination and sorting
     # @return [ActiveRecord::Result] Result set with columns and rows
-    def table_records(table_name, page = 1, order_by = nil, direction = "ASC", per_page = nil, column_filters = nil)
-      page = [ 1, page.to_i ].max
-      default_per_page = self.class.default_per_page
-      column_filters ||= {}
-      max_records = self.class.max_records
-      per_page = (per_page || default_per_page).to_i
-
-      # Ensure we don't fetch too many records for performance/memory reasons
-      per_page = [ per_page, max_records ].min
-
-      model = get_model_for(table_name)
-      query = model.all
-
-      # Apply column filters if provided
-      if column_filters.present?
-        column_filters.each do |column, value|
-          next if value.blank?
-          next unless column_exists?(table_name, column)
-
-          # Use LIKE for string-based searches, = for exact matches on other types
-          column_info = table_columns(table_name).find { |c| c[:name] == column }
-          if column_info
-            column_type = column_info[:type].to_s
-
-            if column_type =~ /char|text|string|uuid|enum/i
-              query = query.where("#{connection.quote_column_name(column)} LIKE ?", "%#{value}%")
-            else
-              # For numeric types, try exact match if value looks like a number
-              if value =~ /\A[+-]?\d+(\.\d+)?\z/
-                query = query.where(column => value)
-              else
-                # Otherwise, try string comparison for non-string fields
-                query = query.where("CAST(#{connection.quote_column_name(column)} AS CHAR) LIKE ?", "%#{value}%")
-              end
-            end
-          end
-        end
-      end
-
-      # Apply sorting if provided
-      if order_by.present? && column_exists?(table_name, order_by)
-        direction = %w[ASC DESC].include?(direction.to_s.upcase) ? direction.to_s.upcase : "ASC"
-        query = query.order("#{connection.quote_column_name(order_by)} #{direction}")
-      end
-
-      # Apply pagination
-      records = query.limit(per_page).offset((page - 1) * per_page)
-
-      # Get column names for consistent ordering
-      column_names = table_columns(table_name).map { |c| c[:name] }
-
-      # Format results
-      @query_executor.to_result_set(records, column_names)
+    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_count(table_name)
+      @table_query_operations.record_count(table_name)
     end
 
     # Get the number of records in a table with filters applied
@@ -142,36 +100,7 @@ module Dbviewer
     # @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 = {})
-      model = get_model_for(table_name)
-      query = model.all
-
-      # Apply column filters if provided
-      if column_filters.present?
-        column_filters.each do |column, value|
-          next if value.blank?
-          next unless column_exists?(table_name, column)
-
-          # Use LIKE for string-based searches, = for exact matches on other types
-          column_info = table_columns(table_name).find { |c| c[:name] == column }
-          if column_info
-            column_type = column_info[:type].to_s
-
-            if column_type =~ /char|text|string|uuid|enum/i
-              query = query.where("#{connection.quote_column_name(column)} LIKE ?", "%#{value}%")
-            else
-              # For numeric types, try exact match if value looks like a number
-              if value =~ /\A[+-]?\d+(\.\d+)?\z/
-                query = query.where(column => value)
-              else
-                # Otherwise, try string comparison for non-string fields
-                query = query.where("CAST(#{connection.quote_column_name(column)} AS CHAR) LIKE ?", "%#{value}%")
-              end
-            end
-          end
-        end
-      end
-
-      query.count
+      @table_query_operations.filtered_record_count(table_name, column_filters)
     end
 
     # Get the number of columns in a table
@@ -201,7 +130,7 @@ module Dbviewer
     # @return [ActiveRecord::Result] Result set with columns and rows
     # @raise [StandardError] If the query is invalid or unsafe
     def execute_query(sql)
-      @query_executor.execute_query(sql)
+      @table_query_operations.execute_query(sql)
     end
 
     # Execute a SQLite PRAGMA command without adding a LIMIT clause
@@ -209,7 +138,7 @@ module Dbviewer
     # @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)
-      @query_executor.execute_sqlite_pragma(pragma)
+      @table_query_operations.execute_sqlite_pragma(pragma)
     end
 
     # Query a table with more granular control using ActiveRecord
@@ -221,28 +150,15 @@ module Dbviewer
     # @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)
-      model = get_model_for(table_name)
-      query = model.all
-
-      query = query.select(select) if select.present?
-      query = query.where(where) if where.present?
-      query = query.order(order) if order.present?
-
-      # Get max records from configuration
-      max_records = self.class.max_records
-      query = query.limit([ limit || max_records, max_records ].min) # Apply safety limit
-      query = query.offset(offset) if offset.present?
-
-      # Get column names for the result set
-      column_names = if select.is_a?(Array)
-        select
-      elsif select.is_a?(String) && !select.include?("*")
-        select.split(",").map(&:strip)
-      else
-        table_columns(table_name).map { |c| c[:name] }
-      end
-
-      @query_executor.to_result_set(query, column_names)
+      @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

data/lib/dbviewer/query_analyzer.rb

@@ -14,6 +14,51 @@ module Dbviewer
       }.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 = []
@@ -49,6 +94,91 @@ module Dbviewer
 
     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