dbviewer 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d10de35b5f14855ae9b48f687d54ebc97d5fef12049575ca0c3d2ff05803407
-  data.tar.gz: bf2ced6c5eb2ac2e6c643d3bee0fb0e37e552c9e96f3fbc6a401e760130337bc
+  metadata.gz: bf5af06afd4454013148e7f43eaa347b3726383bd9094fbe74b5e3394482d6e6
+  data.tar.gz: 8a64dc26217a82eda9d7db0723279b24a7d8f0e6f877f97e149e2cb421e8f195
 SHA512:
-  metadata.gz: 15fe890300e21acdddcd3d5452bd4ac2ff6d1bb65e889cff892e9c1dca0d16929f2af33bf2b848278353c82c9d0fecfb8a540f40ffc8c58801f953566d3416d0
-  data.tar.gz: 12c1bee1aee7989157c7faf79c69fa101a81412503c762917d91e65d0624444eb4bc86a45cce37ee9a7efb13573542e65a92529be95f333c6522babb192cfb41
+  metadata.gz: d15ebd1b469850e457d3ebd5043d26df998b6921c51d83dc6d8fdb6b45bd6dc3f00f8179bb5d39542e26e202607af5c8bde45712ee33a59c2ffed0534d9171a6
+  data.tar.gz: e2addc067f7646dd9d30b80f68552db53a955f8fd9cbbb36e785dda08e3e5ce62b38e23321cdfc98df451f4e50a1ecd32b486ef4a970d28cf20ca36f940b465c

data/app/controllers/dbviewer/entity_relationship_diagrams_controller.rb

@@ -1,8 +1,6 @@
 module Dbviewer
   class EntityRelationshipDiagramsController < ApplicationController
     def index
-      @tables = fetch_tables_with_stats
-
       if @tables.present?
         @table_relationships = fetch_table_relationships
       else
@@ -11,7 +9,7 @@ module Dbviewer
       end
 
       respond_to do |format|
-        format.html # Default to HTML view
+        format.html
         format.json do
           render json: {
             tables: @tables,

data/app/controllers/dbviewer/home_controller.rb

@@ -1,10 +1,13 @@
 module Dbviewer
   class HomeController < ApplicationController
-    skip_before_action :set_tables
-
     def index
-      @tables = fetch_tables_with_stats(include_record_counts: true)
       @analytics = fetch_database_analytics
     end
+
+    private
+
+    def set_tables
+      @tables = fetch_tables_with_stats(include_record_counts: true)
+    end
   end
 end

data/app/controllers/dbviewer/logs_controller.rb

@@ -3,7 +3,7 @@ module Dbviewer
     before_action :set_filters, only: [ :index ]
 
     def index
-      @queries = Dbviewer::Logger.instance.recent_queries(
+      @queries = dbviewer_logger.recent_queries(
         limit: @limit,
         table_filter: @table_filter,
         request_id: @request_id,
@@ -11,16 +11,16 @@ module Dbviewer
       )
 
       if @request_id.present? || @table_filter.present? || @min_duration.present?
-        @stats = Dbviewer::Logger.instance.stats_for_queries(@queries)
+        @stats = dbviewer_logger.stats_for_queries(@queries)
         @filtered_stats = true
       else
-        @stats = Dbviewer::Logger.instance.stats
+        @stats = dbviewer_logger.stats
         @filtered_stats = false
       end
     end
 
     def destroy_all
-      Dbviewer::Logger.instance.clear
+      dbviewer_logger.clear
       flash[:success] = "Query logs cleared successfully"
 
       redirect_to logs_path
@@ -35,5 +35,9 @@ module Dbviewer
       @limit = (params[:limit] || 100).to_i
       @limit = 1000 if @limit > 1000
     end
+
+    def dbviewer_logger
+      @dbviewer_logger ||= Dbviewer::Logger.instance
+    end
   end
 end

data/lib/dbviewer/cache_manager.rb

@@ -0,0 +1,78 @@
+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

data/lib/dbviewer/configuration.rb

@@ -48,32 +48,4 @@ module Dbviewer
       @admin_credentials = nil
     end
   end
-
-  # Class accessor for configuration
-  class << self
-    attr_accessor :configuration
-  end
-
-  # Configure the engine with a block
-  #
-  # @example
-  #   Dbviewer.configure do |config|
-  #     config.per_page_options = [10, 25, 50]
-  #     config.default_per_page = 25
-  #   end
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield(configuration) if block_given?
-  end
-
-  # Reset configuration to defaults
-  def self.reset_configuration
-    self.configuration = Configuration.new
-  end
-
-  # Get the current configuration
-  # Creates a default configuration if none exists
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
 end

data/lib/dbviewer/database_manager.rb

@@ -1,114 +1,71 @@
+require "dbviewer/cache_manager"
+require "dbviewer/table_metadata_manager"
+require "dbviewer/dynamic_model_factory"
+require "dbviewer/query_executor"
+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
 
-    # Default number of records per page if not specified
-    DEFAULT_PER_PAGE = 20
-
-    # Max number of records to return in any query for safety
-    MAX_RECORDS = 10000
-
-    # Cache for dynamically created AR models
-    @@dynamic_models = {}
-
-    # Cache for table column info
-    @@table_columns_cache = {}
+    # 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)
+      reset_cache_if_needed
+    end
 
-    # Cache for table metadata
-    @@table_metadata_cache = {}
+    # Get configuration from class method or Dbviewer
+    def self.configuration
+      Dbviewer.configuration
+    end
 
-    # Cache expiration time in seconds (5 minutes)
-    CACHE_EXPIRY = 300
+    # Get default per page from configuration
+    def self.default_per_page
+      configuration.default_per_page
+    end
 
-    # Last cache reset time
-    @@cache_last_reset = Time.now
+    # Get max records from configuration
+    def self.max_records
+      configuration.max_records
+    end
 
-    def initialize
-      ensure_connection
-      reset_cache_if_needed
+    # 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
-      return [] unless connection.respond_to?(:tables)
-
-      begin
-        # Get and sort tables, cache is handled at the database adapter level
-        connection.tables.sort
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving tables: #{e.message}")
-        []
-      end
+      @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)
-      return [] if table_name.blank?
-
-      # Return from cache if available
-      return @@table_columns_cache[table_name] if @@table_columns_cache[table_name]
-
-      begin
-        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
-        @@table_columns_cache[table_name] = columns
-        columns
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving columns for table #{table_name}: #{e.message}")
-        []
-      end
+      @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)
-      return {} if table_name.blank?
-
-      # Return from cache if available
-      return @@table_metadata_cache[table_name] if @@table_metadata_cache[table_name]
-
-      begin
-        metadata = {
-          primary_key: primary_key(table_name),
-          indexes: fetch_indexes(table_name),
-          foreign_keys: fetch_foreign_keys(table_name)
-        }
-
-        # Cache the result
-        @@table_metadata_cache[table_name] = metadata
-        metadata
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving metadata for table #{table_name}: #{e.message}")
-        { primary_key: nil, indexes: [], foreign_keys: [] }
-      end
+      @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)
-      begin
-        model = get_model_for(table_name)
-        model.count
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting records in table #{table_name}: #{e.message}")
-        0
-      end
+      model = get_model_for(table_name)
+      model.count
     end
 
     # Get records from a table with pagination and sorting
@@ -120,13 +77,9 @@ module Dbviewer
     # @return [ActiveRecord::Result] Result set with columns and rows
     def table_records(table_name, page = 1, order_by = nil, direction = "ASC", per_page = nil)
       page = [ 1, page.to_i ].max
-
-      # Use class method if defined, otherwise fall back to constant
-      default_per_page = self.class.respond_to?(:default_per_page) ? self.class.default_per_page : DEFAULT_PER_PAGE
-      max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-
+      default_per_page = self.class.default_per_page
+      max_records = self.class.max_records
       per_page = (per_page || default_per_page).to_i
-      per_page = default_per_page if per_page <= 0
 
       # Ensure we don't fetch too many records for performance/memory reasons
       per_page = [ per_page, max_records ].min
@@ -143,8 +96,11 @@ module Dbviewer
       # Apply pagination
       records = query.limit(per_page).offset((page - 1) * per_page)
 
-      # Transform the ActiveRecord::Relation to the format expected by the application
-      to_result_set(records, table_name)
+      # 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)
     end
 
     # Get the number of records in a table (alias for table_count)
@@ -158,24 +114,14 @@ module Dbviewer
     # @param table_name [String] Name of the table
     # @return [Integer] Number of columns
     def column_count(table_name)
-      begin
-        table_columns(table_name).size
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting columns in table #{table_name}: #{e.message}")
-        0
-      end
+      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)
-      begin
-        connection.primary_key(table_name)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving primary key for table #{table_name}: #{e.message}")
-        nil
-      end
+      @table_metadata_manager.primary_key(table_name)
     end
 
     # Check if a column exists in a table
@@ -183,15 +129,7 @@ module Dbviewer
     # @param column_name [String] Name of the column
     # @return [Boolean] true if column exists, false otherwise
     def column_exists?(table_name, column_name)
-      return false if table_name.blank? || column_name.blank?
-
-      begin
-        columns = table_columns(table_name)
-        columns.any? { |col| col[:name].to_s == column_name.to_s }
-      rescue => e
-        Rails.logger.error("[DBViewer] Error checking column existence for #{column_name} in #{table_name}: #{e.message}")
-        false
-      end
+      @table_metadata_manager.column_exists?(table_name, column_name)
     end
 
     # Execute a raw SQL query after validating for safety
@@ -199,31 +137,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)
-      # Use the SqlValidator class to validate and normalize the SQL query
-      begin
-        # Validate and normalize the SQL
-        normalized_sql = ::Dbviewer::SqlValidator.validate!(sql.to_s)
-
-        # Get max records from configuration if available
-        max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-
-        # 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
+      @query_executor.execute_query(sql)
     end
 
     # Execute a SQLite PRAGMA command without adding a LIMIT clause
@@ -231,16 +145,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)
-      begin
-        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 => error
-        Rails.logger.error("[DBViewer] SQLite pragma error: #{error.message} for pragma: #{pragma}")
-        raise error
-      end
+      @query_executor.execute_sqlite_pragma(pragma)
     end
 
     # Query a table with more granular control using ActiveRecord
@@ -252,76 +157,47 @@ 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)
-      begin
-        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 if available
-        max_records = self.class.respond_to?(:max_records) ? self.class.max_records : MAX_RECORDS
-        query = query.limit([ limit || max_records, max_records ].min) # Apply safety limit
-        query = query.offset(offset) if offset.present?
-
-        to_result_set(query, table_name)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error querying table #{table_name}: #{e.message}")
-        raise e
+      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)
     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)
-      return [] if table_name.blank?
-
-      begin
-        # Only some adapters support index retrieval
-        if connection.respond_to?(:indexes)
-          connection.indexes(table_name).map do |index|
-            {
-              name: index.name,
-              columns: index.columns,
-              unique: index.unique
-            }
-          end
-        else
-          []
-        end
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving indexes for table #{table_name}: #{e.message}")
-        []
-      end
+      @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)
-      return [] if table_name.blank?
-
-      begin
-        # Only some adapters support foreign key retrieval
-        if connection.respond_to?(:foreign_keys)
-          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
-        else
-          []
-        end
-      rescue => e
-        Rails.logger.error("[DBViewer] Error retrieving foreign keys for table #{table_name}: #{e.message}")
-        []
-      end
+      @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
 
     private
@@ -331,120 +207,23 @@ module Dbviewer
     def ensure_connection
       return @connection if @connection
 
-      begin
+      ErrorHandler.with_error_handling("establishing database connection") do
         @connection = ActiveRecord::Base.connection
         @adapter_name = @connection.adapter_name.downcase
         @connection
-      rescue => e
-        Rails.logger.error("[DBViewer] Database connection error: #{e.message}")
-        raise e
       end
     end
 
     # Reset caches if they've been around too long
     def reset_cache_if_needed
-      # Get cache expiry from configuration if available
-      cache_expiry = self.class.respond_to?(:cache_expiry) ? self.class.cache_expiry : CACHE_EXPIRY
-
-      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
+      @cache_manager.reset_if_needed
     end
 
-    # Clear all caches - useful when schema changes are detected
-    def clear_all_caches
-      @@dynamic_models = {}
-      @@table_columns_cache = {}
-      @@table_metadata_cache = {}
-      @@cache_last_reset = Time.now
-      Rails.logger.debug("[DBViewer] All caches cleared")
-    end
-
-    # Dynamically create an ActiveRecord model for a table
+    # Get a dynamic AR model for a table
     # @param table_name [String] Name of the table
-    # @return [Class] ActiveRecord model class for the table
+    # @return [Class] ActiveRecord model class
     def get_model_for(table_name)
-      return nil if table_name.blank?
-
-      begin
-        model_name = table_name.classify
-
-        # Return cached model if available
-        return @@dynamic_models[table_name] if @@dynamic_models[table_name]
-
-        # 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 => e
-            # If we can't determine the primary key, default to id or set to nil
-            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
-
-        # Cache the model
-        @@dynamic_models[table_name] = model
-        model
-      rescue => e
-        Rails.logger.error("[DBViewer] Error creating model for table #{table_name}: #{e.message}")
-        raise e
-      end
-    end
-
-    # Convert ActiveRecord::Relation to the expected result format
-    # @param records [ActiveRecord::Relation] Records to convert
-    # @param table_name [String] Name of the table
-    # @return [ActiveRecord::Result] Result set with columns and rows
-    def to_result_set(records, table_name)
-      begin
-        column_names = table_columns(table_name).map { |c| c[:name] }
-
-        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 for table #{table_name}: #{e.message}")
-        ActiveRecord::Result.new([], [])
-      end
-    end
-
-    # 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
+      @dynamic_model_factory.get_model_for(table_name)
     end
   end
 end

data/lib/dbviewer/dynamic_model_factory.rb

@@ -0,0 +1,60 @@
+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/engine.rb

@@ -12,9 +12,11 @@ module Dbviewer
       Dbviewer.setup
     end
 
-    # Handle database connections at the appropriate time
-    config.to_prepare do
-      ActiveRecord::Base.connection if Rails.application.initialized?
+    initializer "dbviewer.notifications" do
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        Logger.instance.add(event)
+      end
     end
   end
 end

data/lib/dbviewer/error_handler.rb

@@ -0,0 +1,18 @@
+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

@@ -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.2"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Wailan Tirajoh
@@ -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