dbviewer 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 628884438be23468b7910e2a13c14b2aa00cc6361f01cb09b53ecdcf1d8a0b78
-  data.tar.gz: e9952d0c11ae3669b2604ac208f1a4ae224c37eb4d5f2b1074c4f284bb0bc24a
+  metadata.gz: d16f8924e91f06f61088b4948397aa23530cd6e4a89e00ab483cc047ea5fc492
+  data.tar.gz: 98091d292dfe7c42f0644dc1734fb298f532cfc6f99e0176ff1ae517c8db1cc8
 SHA512:
-  metadata.gz: 369f106d728156712416e6d1f65c51e156ec1357e717c5cc4f95e9fe16dbe696e3a06b8c70a2ef2fd6ae559dd0e7ad7b73fc6a5b2e0ccc396a756633d733c2dd
-  data.tar.gz: 273df74ea6e69b327b01faecb4b3572983fbd461ee042c41ba2402729482ead2b9ebaed117c95158ff01def2e1a1373aaf0fed75d8268d8546b0f3e38d2ff2ae
+  metadata.gz: a423fec219eaf8f40adde10a316cd4e45f33eb27d514ead5a0da735db3a475ac1ac430851cc347095106ca011dda72eae4ab68a01cba8ea8782ab132c99de8b6
+  data.tar.gz: 57594e053bf4bd1389da099fa91236af80e579bfc6f0ebd72da5081187c16a2343717c803632781bf39eb8d5281151cc8614def62c035b1b35dfd2f8946da631

data/app/controllers/concerns/dbviewer/database_operations.rb

@@ -5,7 +5,7 @@ module Dbviewer
     extend ActiveSupport::Concern
 
     included do
-      helper_method :current_table?, :get_database_name if respond_to?(:helper_method)
+      helper_method :current_table?, :get_database_name, :get_adapter_name if respond_to?(:helper_method)
     end
 
     # Initialize the database manager
@@ -44,9 +44,33 @@ module Dbviewer
       "Database"
     end
 
+    # Get the name of the current database adapter
+    def get_adapter_name
+      adapter = database_manager.connection.adapter_name
+
+      # Format the adapter name for better display
+      case adapter.downcase
+      when /mysql/
+        "MySQL"
+      when /postgres/
+        "PostgreSQL"
+      when /sqlite/
+        "SQLite"
+      when /oracle/
+        "Oracle"
+      when /sqlserver/, /mssql/
+        "SQL Server"
+      else
+        adapter.titleize # Fallback to titleized version
+      end
+    rescue => e
+      Rails.logger.error("Error retrieving adapter name: #{e.message}")
+      "Unknown"
+    end
+
     # Fetch all tables with their stats
     # By default, don't include record counts for better performance on sidebar
-    def fetch_tables_with_stats(include_record_counts = false)
+    def fetch_tables(include_record_counts = false)
       database_manager.tables.map do |table_name|
         table_stats = {
           name: table_name
@@ -62,7 +86,7 @@ module Dbviewer
     # Gather database analytics information
     def fetch_database_analytics
       # For analytics, we do need record counts
-      tables = fetch_tables_with_stats(include_record_counts: true)
+      tables = fetch_tables(include_record_counts: true)
 
       # Calculate overall statistics
       analytics = {
@@ -77,48 +101,6 @@ module Dbviewer
       analytics
     end
 
-    # Calculate approximate schema size
-    def calculate_schema_size
-      adapter = database_manager.connection.adapter_name.downcase
-
-      case adapter
-      when /mysql/
-        query = <<-SQL
-          SELECT
-            SUM(data_length + index_length) AS size
-          FROM
-            information_schema.TABLES
-          WHERE
-            table_schema = DATABASE()
-        SQL
-        result = database_manager.execute_query(query).first
-        result ? result["size"].to_i : nil
-      when /postgres/
-        query = <<-SQL
-          SELECT pg_database_size(current_database()) AS size
-        SQL
-        result = database_manager.execute_query(query).first
-        result ? result["size"].to_i : nil
-      when /sqlite/
-        # For SQLite, we need to use the special PRAGMA method without LIMIT
-        # Get page count
-        page_count_result = database_manager.execute_sqlite_pragma("page_count")
-        page_count = page_count_result.first.values.first.to_i
-
-        # Get page size
-        page_size_result = database_manager.execute_sqlite_pragma("page_size")
-        page_size = page_size_result.first.values.first.to_i
-
-        # Calculate total size
-        page_count * page_size
-      else
-        nil # Unsupported database type for size calculation
-      end
-    rescue => e
-      Rails.logger.error("Error calculating database size: #{e.message}")
-      nil
-    end
-
     # Get column information for a specific table
     def fetch_table_columns(table_name)
       database_manager.table_columns(table_name)

data/app/controllers/dbviewer/api/database_controller.rb

@@ -2,12 +2,8 @@ module Dbviewer
   module Api
     class DatabaseController < BaseController
       def size
-        begin
-          size = calculate_schema_size
-          render_success(schema_size: size)
-        rescue => e
-          render_error("Error calculating schema size: #{e.message}")
-        end
+        size = database_manager.fetch_schema_size
+        render_success(schema_size: size)
       end
     end
   end

data/app/controllers/dbviewer/api/queries_controller.rb

@@ -2,17 +2,27 @@ module Dbviewer
   module Api
     class QueriesController < BaseController
       def recent
-        @recent_queries = if Dbviewer.configuration.enable_query_logging
-          Dbviewer::Logger.instance.recent_queries(limit: 10)
-        else
-          []
-        end
-
         render_success({
-          enabled: Dbviewer.configuration.enable_query_logging,
-          queries: @recent_queries
+          enabled: query_logging_enabled?,
+          queries: fetch_recent_queries
         })
       end
+
+      private
+
+      def fetch_recent_queries
+        return [] unless query_logging_enabled?
+
+        Dbviewer::Logger.instance.recent_queries(limit: queries_limit)
+      end
+
+      def query_logging_enabled?
+        Dbviewer.configuration.enable_query_logging
+      end
+
+      def queries_limit
+        10
+      end
     end
   end
 end

data/app/controllers/dbviewer/api/tables_controller.rb

@@ -2,38 +2,63 @@ module Dbviewer
   module Api
     class TablesController < BaseController
       def index
-        tables = fetch_tables_with_stats(include_record_counts: false)
-        render_success(total_tables: tables.size)
+        tables_count = fetch_tables_count
+        render_success(total_tables: tables_count)
       end
 
       def records
-        tables = fetch_tables_with_stats(include_record_counts: true)
+        tables_stats = fetch_tables_stats
+        render_success(tables_stats)
+      end
 
-        records_data = {
-          total_records: tables.sum { |t| t[:record_count] },
-          largest_tables: tables.sort_by { |t| -t[:record_count] }.first(10),
-          empty_tables: tables.select { |t| t[:record_count] == 0 },
-          avg_records_per_table: tables.any? ? (tables.sum { |t| t[:record_count] }.to_f / tables.size).round(1) : 0
-        }
+      def relationships_count
+        total_relationships = calculate_total_relationships
+        render_success(total_relationships: total_relationships)
+      end
+
+      private
 
-        render_success(records_data)
+      def fetch_tables_count
+        fetch_tables(include_record_counts: false).size
       end
 
-      def relationships_count
-        begin
-          tables = fetch_tables_with_stats(include_record_counts: false)
-          total_relationships = 0
-
-          tables.each do |table|
-            metadata = fetch_table_metadata(table[:name])
-            total_relationships += metadata[:foreign_keys].size if metadata && metadata[:foreign_keys]
-          end
-
-          render_success(total_relationships: total_relationships)
-        rescue => e
-          render_error("Error calculating relationship count: #{e.message}")
+      def fetch_tables_stats
+        tables = fetch_tables(include_record_counts: true)
+
+        {
+          total_records: calculate_total_records(tables),
+          largest_tables: find_largest_tables(tables),
+          empty_tables: find_empty_tables(tables),
+          avg_records_per_table: calculate_average_records(tables)
+        }
+      end
+
+      def calculate_total_relationships
+        tables = fetch_tables(include_record_counts: false)
+
+        tables.sum do |table|
+          metadata = fetch_table_metadata(table[:name])
+          metadata&.dig(:foreign_keys)&.size || 0
         end
       end
+
+      def calculate_total_records(tables)
+        tables.sum { |table| table[:record_count] }
+      end
+
+      def find_largest_tables(tables, limit = 10)
+        tables.sort_by { |table| -table[:record_count] }.first(limit)
+      end
+
+      def find_empty_tables(tables)
+        tables.select { |table| table[:record_count] == 0 }
+      end
+
+      def calculate_average_records(tables)
+        return 0 if tables.empty?
+
+        (calculate_total_records(tables).to_f / tables.size).round(1)
+      end
     end
   end
 end

data/app/controllers/dbviewer/application_controller.rb

@@ -19,7 +19,7 @@ module Dbviewer
     end
 
     def set_tables
-      @tables = fetch_tables_with_stats
+      @tables = fetch_tables
     end
   end
 end

data/app/controllers/dbviewer/home_controller.rb

@@ -6,7 +6,7 @@ module Dbviewer
     private
 
     def set_tables
-      @tables = fetch_tables_with_stats(include_record_counts: true)
+      @tables = fetch_tables(include_record_counts: true)
     end
   end
 end

data/app/controllers/dbviewer/tables_controller.rb

@@ -7,7 +7,7 @@ module Dbviewer
     before_action :set_global_filters, only: [ :show, :export_csv ]
 
     def index
-      @tables = fetch_tables_with_stats(include_record_counts: true)
+      @tables = fetch_tables(include_record_counts: true)
     end
 
     def show
@@ -60,7 +60,7 @@ module Dbviewer
     def query
       @read_only_mode = true # Flag to indicate we're in read-only mode
       @columns = fetch_table_columns(@table_name)
-      @tables = fetch_tables_with_stats  # Fetch tables for sidebar
+      @tables = fetch_tables  # Fetch tables for sidebar
 
       prepare_query
       execute_query

data/app/views/dbviewer/home/index.html.erb

@@ -3,7 +3,7 @@
     <div class="col">
       <h1 class="h3 mb-2">Database Overview</h1>
       <p class="database-connection-info">
-        Connected to database: <span class="badge rounded-pill database-name-badge"><%= get_database_name %></span>
+        Connected to <%= get_adapter_name %> database: <span class="badge rounded-pill database-name-badge"><%= get_database_name %></span>
       </p>
     </div>
   </div>

data/lib/dbviewer/database_manager.rb

@@ -180,8 +180,48 @@ module Dbviewer
       @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

data/lib/dbviewer/engine.rb

@@ -20,8 +20,23 @@ module Dbviewer
     initializer "dbviewer.notifications" do
       ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
         event = ActiveSupport::Notifications::Event.new(*args)
+
+        next if skip_internal_query?(event)
+
         Logger.instance.add(event)
       end
     end
+
+    private
+
+    def skip_internal_query?(event)
+      caller_locations = caller_locations(1)
+      return false unless caller_locations
+
+      # Look for dbviewer in the call stack
+      caller_locations.any? { |l| l.path.include?("dbviewer") }
+    rescue
+      false
+    end
   end
 end

data/lib/dbviewer/logger.rb

@@ -12,7 +12,6 @@ module Dbviewer
     def add(event)
       # Return early if query logging is disabled
       return unless Dbviewer.configuration.enable_query_logging
-      return if QueryParser.should_skip_query?(event)
 
       current_time = Time.now
       @storage.add({

data/lib/dbviewer/query_parser.rb

@@ -68,15 +68,5 @@ module Dbviewer
     rescue
       []
     end
-
-    # Determine if a query should be skipped based on content
-    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?("pg_catalog") ||
-      from_dbviewer?(event)
-    end
   end
 end

data/lib/dbviewer/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Wailan Tirajoh
@@ -100,7 +100,6 @@ files:
 - lib/dbviewer/table_query_params.rb
 - lib/dbviewer/version.rb
 - lib/generators/dbviewer/initializer_generator.rb
-- lib/generators/dbviewer/structured_api_generator.rb
 - lib/generators/dbviewer/templates/initializer.rb
 - lib/tasks/dbviewer_tasks.rake
 homepage: https://github.com/wailantirajoh/dbviewer

data/lib/generators/dbviewer/structured_api_generator.rb

@@ -1,11 +0,0 @@
-module Dbviewer
-  module Generators
-    class StructuredApiGenerator < Rails::Generators::Base
-      source_root File.expand_path("../templates", __FILE__)
-
-      def create_initializer
-        template "structured_api_initializer.rb", "config/initializers/dbviewer_structured_api.rb"
-      end
-    end
-  end
-end