dbviewer 0.5.1 → 0.5.3

data/lib/dbviewer/query/collection.rb

@@ -0,0 +1,39 @@
+module Dbviewer
+  module Query
+    # Collection handles the storage and retrieval of SQL queries
+    # This class is maintained for backward compatibility
+    # New code should use InMemoryStorage or FileStorage directly
+    class Collection < ::Dbviewer::Storage::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
+end

data/lib/dbviewer/query/executor.rb

@@ -0,0 +1,93 @@
+module Dbviewer
+  module Query
+    # Executor handles executing SQL queries and formatting results
+    class Executor
+      # Initialize with a connection and configuration
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param config [Dbviewer::Configuration] Configuration object
+      def initialize(connection, config = nil)
+        @connection = connection
+        @config = config || Dbviewer.configuration
+      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)
+        # Validate and normalize the SQL
+        normalized_sql = ::Dbviewer::SqlValidator.validate!(sql.to_s)
+
+        # Get max records from configuration
+        max_records = @config.max_records || 10000
+
+        # Add a safety limit if not already present
+        unless normalized_sql =~ /\bLIMIT\s+\d+\s*$/i
+          normalized_sql = "#{normalized_sql} LIMIT #{max_records}"
+        end
+
+        # Log and execute the query
+        Rails.logger.debug("[DBViewer] Executing SQL query: #{normalized_sql}")
+        start_time = Time.now
+        result = @connection.exec_query(normalized_sql)
+        duration = Time.now - start_time
+
+        Rails.logger.debug("[DBViewer] Query completed in #{duration.round(2)}s, returned #{result.rows.size} rows")
+        result
+      rescue => e
+        Rails.logger.error("[DBViewer] SQL query error: #{e.message} for query: #{sql}")
+        raise e
+      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)
+        sql = "PRAGMA #{pragma}"
+        Rails.logger.debug("[DBViewer] Executing SQLite pragma: #{sql}")
+        result = @connection.exec_query(sql)
+        Rails.logger.debug("[DBViewer] Pragma completed, returned #{result.rows.size} rows")
+        result
+      rescue => e
+        Rails.logger.error("[DBViewer] SQLite pragma error: #{e.message} for pragma: #{pragma}")
+        raise e
+      end
+
+      # Convert ActiveRecord::Relation to a standard result format
+      # @param records [ActiveRecord::Relation] Records to convert
+      # @param column_names [Array<String>] Column names
+      # @return [ActiveRecord::Result] Result set with columns and rows
+      def to_result_set(records, column_names)
+        rows = records.map do |record|
+          column_names.map do |col|
+            # Handle serialized attributes
+            value = record[col]
+            serialize_if_needed(value)
+          end
+        end
+
+        ActiveRecord::Result.new(column_names, rows)
+      rescue => e
+        Rails.logger.error("[DBViewer] Error converting to result set: #{e.message}")
+        ActiveRecord::Result.new([], [])
+      end
+
+      private
+
+      # Serialize complex objects for display
+      # @param value [Object] Value to serialize
+      # @return [String, Object] Serialized value or original value
+      def serialize_if_needed(value)
+        case value
+        when Hash, Array
+          value.to_json rescue value.to_s
+        when Time, Date, DateTime
+          value.to_s
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/dbviewer/query/logger.rb

@@ -0,0 +1,108 @@
+require "singleton"
+require "forwardable"
+
+module Dbviewer
+  module Query
+    # Logger captures and analyzes SQL queries for debugging and performance monitoring
+    class Logger
+      include Singleton
+
+      def initialize
+        # Initialize with default values, will be configured later
+        @enable_query_logging = true
+        @query_logging_mode = :memory
+        set_storage
+        Rails.logger.info("[DBViewer] QueryLogger initialized with #{mode} storage mode")
+      end
+
+      # Configure the logger with settings
+      # @param enable_query_logging [Boolean] Whether query logging is enabled
+      # @param query_logging_mode [Symbol] Storage mode (:memory or :file)
+      def configure(enable_query_logging: true, query_logging_mode: :memory)
+        @enable_query_logging = enable_query_logging
+        @query_logging_mode = query_logging_mode
+        # Reinitialize storage if mode changed
+        @storage = nil
+        @mode = nil
+        set_storage
+        Rails.logger.info("[DBViewer] QueryLogger configured 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 @enable_query_logging
+        return if ::Dbviewer::Query::Parser.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: ::Dbviewer::Query::Parser.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)
+        Analyzer.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
+
+        # Configure the singleton instance
+        # @param enable_query_logging [Boolean] Whether query logging is enabled
+        # @param query_logging_mode [Symbol] Storage mode (:memory or :file)
+        def configure(enable_query_logging: true, query_logging_mode: :memory)
+          instance.configure(
+            enable_query_logging: enable_query_logging,
+            query_logging_mode: query_logging_mode
+          )
+        end
+      end
+
+      private
+
+      def mode
+        @mode ||= @query_logging_mode || :memory
+      end
+
+      def set_storage
+        @storage ||= case mode
+        when :file
+          Storage::FileStorage.new
+        else
+          Storage::InMemoryStorage.new
+        end
+      end
+    end
+  end
+end

data/lib/dbviewer/query/parser.rb

@@ -0,0 +1,56 @@
+module Dbviewer
+  module Query
+    # Parser handles parsing SQL queries and extracting useful information
+    class Parser
+      # Extract table names from an SQL query string
+      def self.extract_tables(sql)
+        return [] if sql.nil?
+
+        # Convert to lowercase for case-insensitive matching
+        sql = sql.downcase
+
+        # Extract table names after FROM or JOIN
+        sql.scan(/(?:from|join)\s+[`"']?(\w+)[`"']?/).flatten.uniq
+      end
+
+      # Normalize a SQL query to find similar patterns
+      # Replaces specific values with placeholders
+      def self.normalize(sql)
+        return "" if sql.nil?
+
+        sql.gsub(/\b\d+\b/, "N")
+           .gsub(/'[^']*'/, "'X'")
+           .gsub(/"[^"]*"/, '"X"')
+      end
+
+      # Format bind parameters for storage
+      def self.format_binds(binds)
+        return [] unless binds.respond_to?(:map)
+
+        binds.map do |bind|
+          if bind.respond_to?(:value)
+            bind.value
+          elsif bind.is_a?(Array) && bind.size == 2
+            bind.last
+          else
+            bind.to_s
+          end
+        end
+      rescue
+        []
+      end
+
+      # Determine if a query should be skipped based on content
+      # Rails and ActiveRecord often run internal queries that are not useful for logging
+      def self.should_skip_query?(event)
+        event.payload[:name] == "SCHEMA" ||
+        event.payload[:sql].include?("SHOW TABLES") ||
+        event.payload[:sql].include?("sqlite_master") ||
+        event.payload[:sql].include?("information_schema") ||
+        event.payload[:sql].include?("schema_migrations") ||
+        event.payload[:sql].include?("ar_internal_metadata") ||
+        event.payload[:sql].include?("pg_catalog")
+      end
+    end
+  end
+end

data/lib/dbviewer/storage/file_storage.rb

@@ -1,6 +1,3 @@
-require "json"
-require "time"
-
 module Dbviewer
   module Storage
     # FileStorage implements QueryStorage for storing queries in a log file

data/lib/dbviewer/version.rb

@@ -1,3 +1,3 @@
 module Dbviewer
-  VERSION = "0.5.1"
+  VERSION = "0.5.3"
 end

data/lib/dbviewer.rb

@@ -1,15 +1,26 @@
 require "dbviewer/version"
 require "dbviewer/configuration"
 require "dbviewer/engine"
-require "dbviewer/error_handler"
-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/database_manager"
 require "dbviewer/sql_validator"
 
+require "dbviewer/storage/base"
+require "dbviewer/storage/in_memory_storage"
+require "dbviewer/storage/file_storage"
+
+require "dbviewer/query/executor"
+require "dbviewer/query/analyzer"
+require "dbviewer/query/collection"
+require "dbviewer/query/logger"
+require "dbviewer/query/parser"
+
+require "dbviewer/database/cache_manager"
+require "dbviewer/database/dynamic_model_factory"
+require "dbviewer/database/manager"
+require "dbviewer/database/metadata_manager"
+
+require "dbviewer/datatable/query_operations"
+require "dbviewer/datatable/query_params"
+
 module Dbviewer
   # Main module for the database viewer
 
@@ -40,6 +51,12 @@ module Dbviewer
 
     # This class method will be called by the engine when it's appropriate
     def setup
+      # Configure the query logger with current configuration settings
+      Dbviewer::Query::Logger.configure(
+        enable_query_logging: configuration.enable_query_logging,
+        query_logging_mode: configuration.query_logging_mode
+      )
+
       ActiveRecord::Base.connection
       Rails.logger.info "DBViewer successfully connected to database"
     rescue => e

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Wailan Tirajoh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-28 00:00:00.000000000 Z
+date: 2025-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -57,6 +57,7 @@ files:
 - app/controllers/concerns/dbviewer/pagination_concern.rb
 - app/controllers/dbviewer/api/base_controller.rb
 - app/controllers/dbviewer/api/database_controller.rb
+- app/controllers/dbviewer/api/entity_relationship_diagrams_controller.rb
 - app/controllers/dbviewer/api/queries_controller.rb
 - app/controllers/dbviewer/api/tables_controller.rb
 - app/controllers/dbviewer/application_controller.rb
@@ -80,24 +81,23 @@ files:
 - app/views/layouts/dbviewer/shared/_sidebar.html.erb
 - config/routes.rb
 - lib/dbviewer.rb
-- lib/dbviewer/cache_manager.rb
 - lib/dbviewer/configuration.rb
-- lib/dbviewer/database_manager.rb
-- lib/dbviewer/dynamic_model_factory.rb
+- lib/dbviewer/database/cache_manager.rb
+- lib/dbviewer/database/dynamic_model_factory.rb
+- lib/dbviewer/database/manager.rb
+- lib/dbviewer/database/metadata_manager.rb
+- lib/dbviewer/datatable/query_operations.rb
+- lib/dbviewer/datatable/query_params.rb
 - lib/dbviewer/engine.rb
-- lib/dbviewer/error_handler.rb
-- lib/dbviewer/logger.rb
-- lib/dbviewer/query_analyzer.rb
-- lib/dbviewer/query_collection.rb
-- lib/dbviewer/query_executor.rb
-- lib/dbviewer/query_parser.rb
+- lib/dbviewer/query/analyzer.rb
+- lib/dbviewer/query/collection.rb
+- lib/dbviewer/query/executor.rb
+- lib/dbviewer/query/logger.rb
+- lib/dbviewer/query/parser.rb
 - lib/dbviewer/sql_validator.rb
 - lib/dbviewer/storage/base.rb
 - lib/dbviewer/storage/file_storage.rb
 - lib/dbviewer/storage/in_memory_storage.rb
-- lib/dbviewer/table_metadata_manager.rb
-- lib/dbviewer/table_query_operations.rb
-- lib/dbviewer/table_query_params.rb
 - lib/dbviewer/version.rb
 - lib/generators/dbviewer/initializer_generator.rb
 - lib/generators/dbviewer/templates/initializer.rb

data/lib/dbviewer/cache_manager.rb

@@ -1,78 +0,0 @@
-module Dbviewer
-  # CacheManager handles caching concerns for the DatabaseManager
-  # It provides an abstraction layer for managing caches efficiently
-  class CacheManager
-    # Initialize the cache manager
-    # @param config [Dbviewer::Configuration] Configuration object
-    def initialize(config = nil)
-      @config = config || Dbviewer.configuration
-      @dynamic_models = {}
-      @table_columns_cache = {}
-      @table_metadata_cache = {}
-      @cache_last_reset = Time.now
-    end
-
-    # Get a model from cache or return nil
-    # @param table_name [String] Name of the table
-    # @return [Class, nil] The cached model or nil if not found
-    def get_model(table_name)
-      @dynamic_models[table_name]
-    end
-
-    # Store a model in the cache
-    # @param table_name [String] Name of the table
-    # @param model [Class] ActiveRecord model class
-    def store_model(table_name, model)
-      @dynamic_models[table_name] = model
-    end
-
-    # Get column information from cache
-    # @param table_name [String] Name of the table
-    # @return [Array<Hash>, nil] The cached column information or nil if not found
-    def get_columns(table_name)
-      @table_columns_cache[table_name]
-    end
-
-    # Store column information in cache
-    # @param table_name [String] Name of the table
-    # @param columns [Array<Hash>] Column information
-    def store_columns(table_name, columns)
-      @table_columns_cache[table_name] = columns
-    end
-
-    # Get table metadata from cache
-    # @param table_name [String] Name of the table
-    # @return [Hash, nil] The cached metadata or nil if not found
-    def get_metadata(table_name)
-      @table_metadata_cache[table_name]
-    end
-
-    # Store table metadata in cache
-    # @param table_name [String] Name of the table
-    # @param metadata [Hash] Table metadata
-    def store_metadata(table_name, metadata)
-      @table_metadata_cache[table_name] = metadata
-    end
-
-    # Reset caches if they've been around too long
-    def reset_if_needed
-      cache_expiry = @config.cache_expiry || 300
-
-      if Time.now - @cache_last_reset > cache_expiry
-        @table_columns_cache = {}
-        @table_metadata_cache = {}
-        @cache_last_reset = Time.now
-        Rails.logger.debug("[DBViewer] Cache reset due to expiry after #{cache_expiry} seconds")
-      end
-    end
-
-    # Clear all caches - useful when schema changes are detected
-    def clear_all
-      @dynamic_models = {}
-      @table_columns_cache = {}
-      @table_metadata_cache = {}
-      @cache_last_reset = Time.now
-      Rails.logger.debug("[DBViewer] All caches cleared")
-    end
-  end
-end