dbviewer 0.3.1 → 0.3.3

data/lib/dbviewer/logger.rb

@@ -4,13 +4,25 @@ module Dbviewer
     include Singleton
 
     def initialize
-      @request_counter = 0
-      @current_request_id = nil
-      @last_query_time = nil
-      @mutex = Mutex.new
+      set_storage
+      Rails.logger.info("[DBViewer] Query Logger initialized with #{mode} storage mode")
+    end
 
-      setup_storage
-      subscribe_to_sql_notifications
+    # Add a new SQL event query to the logger
+    def add(event)
+      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: event.transaction_id || current_time.to_i,
+        thread_id: Thread.current.object_id.to_s,
+        caller: event.payload[:caller]
+      })
     end
 
     # Clear all stored queries
@@ -38,65 +50,26 @@ module Dbviewer
       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
 
-    # TODO: pass storage class as a parameter to the constructor
-    def setup_storage
+    def set_storage
       @storage ||= case mode
       when :file
         Storage::FileStorage.new
       else
         Storage::InMemoryStorage.new
       end
-
-      Rails.logger.info("[DBViewer] Query Logger initialized with #{mode} storage mode")
-    end
-
-    def subscribe_to_sql_notifications
-      ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-
-        # Skip internal queries and schema queries
-        next if QueryParser.should_skip_query?(event)
-
-        # Record the query details
-        process_sql_event(event)
-      end
-    end
-
-    def process_sql_event(event)
-      @mutex.synchronize do
-        current_time = Time.now
-        update_request_id(current_time)
-        @last_query_time = current_time
-
-        # Create and store the query
-        @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: @current_request_id,
-          thread_id: Thread.current.object_id.to_s,
-          caller: event.payload[:caller]
-        })
-      end
-    end
-
-    # Generate a request ID if:
-    # 1. This is the first query, or
-    # 2. More than 1 second has passed since the last query
-    #
-    # TODO: explore rails request ID and implement it here, otherwise fallback to current approach
-    def update_request_id(current_time)
-      if @current_request_id.nil? || @last_query_time.nil? || (current_time - @last_query_time) > 1.0
-        @current_request_id = "req-#{Time.now.to_i}-#{@request_counter += 1}"
-      end
     end
   end
 end

data/lib/dbviewer/query_collection.rb

@@ -6,10 +6,6 @@ module Dbviewer
     # Maximum number of queries to keep in memory
     MAX_QUERIES = 1000
 
-    def initialize
-      super
-    end
-
     # Get recent queries, optionally filtered
     def filter(limit: 100, table_filter: nil, request_id: nil, min_duration: nil)
       result = all

data/lib/dbviewer/query_executor.rb

@@ -0,0 +1,91 @@
+module Dbviewer
+  # QueryExecutor handles executing SQL queries and formatting results
+  class QueryExecutor
+    # 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

data/lib/dbviewer/table_metadata_manager.rb

@@ -0,0 +1,104 @@
+module Dbviewer
+  # TableMetadataManager handles retrieving and managing table structure information
+  class TableMetadataManager
+    # 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 all tables in the database
+    # @return [Array<String>] List of table names
+    def tables
+      @connection.tables.sort
+    end
+
+    # Get column information for a table
+    # @param table_name [String] Name of the table
+    # @return [Array<Hash>] List of column details
+    def table_columns(table_name)
+      cached_columns = @cache_manager.get_columns(table_name)
+      return cached_columns if cached_columns
+
+      columns = @connection.columns(table_name).map do |column|
+        {
+          name: column.name,
+          type: column.type,
+          null: column.null,
+          default: column.default,
+          primary: column.name == primary_key(table_name)
+        }
+      end
+
+      # Cache the result
+      @cache_manager.store_columns(table_name, columns)
+      columns
+    end
+
+    # Get detailed metadata about a table
+    # @param table_name [String] Name of the table
+    # @return [Hash] Table metadata
+    def table_metadata(table_name)
+      cached_metadata = @cache_manager.get_metadata(table_name)
+      return cached_metadata if cached_metadata
+
+      metadata = {
+        primary_key: primary_key(table_name),
+        indexes: fetch_indexes(table_name),
+        foreign_keys: fetch_foreign_keys(table_name)
+      }
+
+      @cache_manager.store_metadata(table_name, metadata)
+      metadata
+    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)
+      @connection.primary_key(table_name)
+    rescue => e
+      Rails.logger.error("[DBViewer] Error retrieving primary key for table #{table_name}: #{e.message}")
+      nil
+    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)
+      columns = table_columns(table_name)
+      columns.any? { |col| col[:name].to_s == column_name.to_s }
+    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)
+      @connection.indexes(table_name).map do |index|
+        {
+          name: index.name,
+          columns: index.columns,
+          unique: index.unique
+        }
+      end
+    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)
+      @connection.foreign_keys(table_name).map do |fk|
+        {
+          name: fk.name,
+          from_table: fk.from_table,
+          to_table: fk.to_table,
+          column: fk.column,
+          primary_key: fk.primary_key
+        }
+      end
+    end
+  end
+end

data/lib/dbviewer/version.rb

@@ -1,3 +1,3 @@
 module Dbviewer
-  VERSION = "0.3.1"
+  VERSION = "0.3.3"
 end

data/lib/dbviewer.rb

@@ -1,7 +1,11 @@
 require "dbviewer/version"
 require "dbviewer/configuration"
 require "dbviewer/engine"
-require "dbviewer/initializer"
+require "dbviewer/error_handler"
+require "dbviewer/cache_manager"
+require "dbviewer/table_metadata_manager"
+require "dbviewer/dynamic_model_factory"
+require "dbviewer/query_executor"
 require "dbviewer/database_manager"
 require "dbviewer/sql_validator"
 
@@ -17,11 +21,6 @@ module Dbviewer
       @configuration ||= Configuration.new
     end
 
-    # Alias for backward compatibility
-    def config
-      configuration
-    end
-
     # Configure the engine with a block
     #
     # @example
@@ -30,7 +29,7 @@ module Dbviewer
     #     config.default_per_page = 25
     #   end
     def configure
-      yield(config) if block_given?
+      yield(configuration) if block_given?
     end
 
     # Reset configuration to defaults
@@ -40,18 +39,14 @@ module Dbviewer
 
     # This class method will be called by the engine when it's appropriate
     def setup
-      Dbviewer::Initializer.setup
+      ActiveRecord::Base.connection
+      Rails.logger.info "DBViewer successfully connected to database"
+    rescue => e
+      Rails.logger.error "DBViewer could not connect to database: #{e.message}"
     end
 
     # Initialize engine with default values or user-provided configuration
     def init
-      Dbviewer::DatabaseManager.singleton_class.class_eval do
-        define_method(:configuration) { Dbviewer.configuration }
-        define_method(:default_per_page) { Dbviewer.configuration.default_per_page }
-        define_method(:max_records) { Dbviewer.configuration.max_records }
-        define_method(:cache_expiry) { Dbviewer.configuration.cache_expiry }
-      end
-
       # Define class methods to access configuration
       Dbviewer::SqlValidator.singleton_class.class_eval do
         define_method(:configuration) { Dbviewer.configuration }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Wailan Tirajoh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-18 00:00:00.000000000 Z
+date: 2025-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -56,7 +56,6 @@ files:
 - app/controllers/concerns/dbviewer/error_handling.rb
 - app/controllers/concerns/dbviewer/pagination_concern.rb
 - app/controllers/dbviewer/application_controller.rb
-- app/controllers/dbviewer/databases_controller.rb
 - app/controllers/dbviewer/entity_relationship_diagrams_controller.rb
 - app/controllers/dbviewer/home_controller.rb
 - app/controllers/dbviewer/logs_controller.rb
@@ -83,18 +82,22 @@ files:
 - app/views/layouts/dbviewer/application.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/engine.rb
-- lib/dbviewer/initializer.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/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/version.rb
 - lib/tasks/dbviewer_tasks.rake
 homepage: https://github.com/wailantirajoh/dbviewer

data/lib/dbviewer/initializer.rb

@@ -1,23 +0,0 @@
-module Dbviewer
-  class Initializer
-    class << self
-      def setup
-        if defined?(ActiveRecord::Base)
-          Rails.logger.warn "ActiveRecord is not available, skipping database connection check"
-          return
-        end
-
-        ensure_activerecord_connection
-      end
-
-      private
-
-      def ensure_activerecord_connection
-        ActiveRecord::Base.connection
-        Rails.logger.info "DBViewer successfully connected to database"
-      rescue => e
-        Rails.logger.error "DBViewer could not connect to database: #{e.message}"
-      end
-    end
-  end
-end