dbviewer 0.5.1 → 0.5.3

data/config/routes.rb

@@ -27,6 +27,13 @@ Dbviewer::Engine.routes.draw do
       end
     end
 
+    resources :entity_relationship_diagrams, only: [] do
+      collection do
+        get "relationships"
+        get "table_relationships"
+      end
+    end
+
     resource :database, only: [], controller: "database" do
       get "size"
     end

data/lib/dbviewer/database/cache_manager.rb

@@ -0,0 +1,78 @@
+module Dbviewer
+  module Database
+    # CacheManager handles caching concerns for the DatabaseManager
+    # It provides an abstraction layer for managing caches efficiently
+    class CacheManager
+      # Initialize the cache manager
+      # @param cache_expiry [Integer] Cache expiration time in seconds (default: 300)
+      def initialize(cache_expiry = 300)
+        @cache_expiry = cache_expiry
+        @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
+        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
+end

data/lib/dbviewer/database/dynamic_model_factory.rb

@@ -0,0 +1,62 @@
+module Dbviewer
+  module Database
+    # 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::Database::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
+end

data/lib/dbviewer/database/manager.rb

@@ -0,0 +1,204 @@
+module Dbviewer
+  module Database
+    # Manager handles all database interactions for the DBViewer engine
+    # It provides methods to access database structure and data
+    class Manager
+      attr_reader :connection, :adapter_name, :table_query_operations
+
+      # Initialize the database manager
+      def initialize
+        ensure_connection
+        @cache_manager = ::Dbviewer::Database::CacheManager.new(configuration.cache_expiry)
+        @table_metadata_manager = ::Dbviewer::Database::MetadataManager.new(@connection, @cache_manager)
+        @dynamic_model_factory = ::Dbviewer::Database::DynamicModelFactory.new(@connection, @cache_manager)
+        @query_executor = ::Dbviewer::Query::Executor.new(@connection, configuration)
+        @table_query_operations = ::Dbviewer::Datatable::QueryOperations.new(
+          @connection,
+          @dynamic_model_factory,
+          @query_executor,
+          @table_metadata_manager
+        )
+        reset_cache_if_needed
+      end
+
+      # Get configuration from class method or Dbviewer
+      def configuration
+        @configuration ||= Dbviewer.configuration
+      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 [Dbviewer::Datatable::QueryParams] 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
+
+      # 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
+
+        @connection = ActiveRecord::Base.connection
+        @adapter_name = @connection.adapter_name.downcase
+        @connection
+      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
+end

data/lib/dbviewer/database/metadata_manager.rb

@@ -0,0 +1,129 @@
+module Dbviewer
+  module Database
+    # MetadataManager handles retrieving and managing table structure information
+    class MetadataManager
+      # Initialize with a connection and cache manager
+      # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter] Database connection
+      # @param cache_manager [Dbviewer::Database::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),
+          reverse_foreign_keys: fetch_reverse_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
+
+      # Get reverse foreign keys (tables that reference this table)
+      # @param table_name [String] Name of the table
+      # @return [Array<Hash>] List of reverse foreign keys with details
+      def fetch_reverse_foreign_keys(table_name)
+        tables
+          .reject { |other_table| other_table == table_name }
+          .flat_map do |other_table|
+            @connection.foreign_keys(other_table)
+              .select { |fk| fk.to_table == 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,
+                  relationship_type: "has_many"
+                }
+              end
+          end
+      end
+    end
+  end
+end