dbviewer 0.5.2 → 0.5.4

data/lib/dbviewer/query_executor.rb

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

@@ -1,53 +0,0 @@
-module Dbviewer
-  # QueryParser handles parsing SQL queries and extracting useful information
-  class QueryParser
-    # 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?("pg_catalog")
-    end
-  end
-end

data/lib/dbviewer/table_metadata_manager.rb

@@ -1,136 +0,0 @@
-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),
-        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)
-      reverse_fks = []
-
-      # Get all tables and check their foreign keys
-      tables.each do |other_table|
-        next if other_table == table_name
-
-        begin
-          @connection.foreign_keys(other_table).each do |fk|
-            if fk.to_table == table_name
-              reverse_fks << {
-                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
-        rescue => e
-          Rails.logger.error("[DBViewer] Error retrieving foreign keys for table #{other_table}: #{e.message}")
-        end
-      end
-
-      reverse_fks
-    end
-  end
-end