dbviewer 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bf35f21728dd04ca42715af60f89f48b1bfdb4e7111b00f75e801a33bc17c47
-  data.tar.gz: 2d54d185da3255486a7f5b92ad44430916ae8af7ac2e0674c09424d14ef08a6f
+  metadata.gz: cbd62dc61d3960414f9f2496634d3241eadf3270c424006190d3cf2a6f909a15
+  data.tar.gz: 83365d3965efc2b431b61c085ebc7b15d6e23564c785e584ede10f015efd143d
 SHA512:
-  metadata.gz: 22e06d88b9cfcb981f5760a2a1d9fdf790f10e83012e4637a42468be02c68a22cb0fd2aeb43f05119ad34d251aec67fc9fc84223adb1eeff79a2ba922982a49f
-  data.tar.gz: 893e168a8c704c21a8fed6ccb2291952e1b028f0182a63d71dd3be7ec7d659599921640c7174d6ed888cdcab134171b015ab1af194f90ddeafd09c3f3ac3d6e6
+  metadata.gz: 6587f9a6cbe948f32bf45a36ba60c40ea06109e534c3fffdb78bb6a727e80c6676b7cb8027df1ff9876bb4eaab37688e565e10372f321277f377980667f53923
+  data.tar.gz: f93fe7e8f7cb1721f65e17a01288fa17be0bd2fdee25b278f157cfe56a85e9fe6a943cd8d5f58bd8a1a5cc604fb5e5b84b541d2a76e0f1663e86a248ff6ef3d9

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

@@ -1,3 +1,5 @@
+require "csv"
+
 module Dbviewer
   module DatabaseOperations
     extend ActiveSupport::Concern
@@ -373,39 +375,19 @@ module Dbviewer
 
     # Export table data to CSV
     def export_table_to_csv(table_name, query_params = nil, include_headers = true)
-      require "csv"
-
-      begin
-        if query_params.is_a?(Dbviewer::TableQueryParams)
-          # Use the query params object directly
-          records = database_manager.query_operations.table_records(table_name, query_params)
-        else
-          # Legacy support for the old method signature
-          limit = query_params.is_a?(Numeric) ? query_params : 10000
-          records = database_manager.table_records(
-            table_name,
-            1, # First page
-            nil, # Default sorting
-            "asc",
-            limit # Limit number of records
-          )
-        end
+      records = database_manager.query_operations.table_records(table_name, query_params)
 
-        csv_data = CSV.generate do |csv|
-          # Add headers if requested
-          csv << records.columns if include_headers
+      csv_data = CSV.generate do |csv|
+        # Add headers if requested
+        csv << records.columns if include_headers
 
-          # Add rows
-          records.rows.each do |row|
-            csv << row.map { |cell| format_csv_value(cell) }
-          end
+        # Add rows
+        records.rows.each do |row|
+          csv << row.map { |cell| format_csv_value(cell) }
         end
-
-        csv_data
-      rescue => e
-        Rails.logger.error("CSV Export error for table #{table_name}: #{e.message}")
-        raise "Error exporting to CSV: #{e.message}"
       end
+
+      csv_data
     end
 
     private

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

@@ -18,23 +18,6 @@ module Dbviewer
       end
     end
 
-    # Set pagination parameters from request or defaults
-    def set_pagination_params
-      @current_page = [ 1, params[:page].to_i ].max
-      @per_page = params[:per_page] ? params[:per_page].to_i : self.class.default_per_page
-      @per_page = self.class.default_per_page unless self.class.per_page_options.include?(@per_page)
-    end
-
-    # Set sorting parameters from request or defaults
-    def set_sorting_params
-      @order_by = params[:order_by].presence ||
-                  database_manager.primary_key(@table_name).presence ||
-                  (@columns.first ? @columns.first[:name] : nil)
-
-      @order_direction = params[:order_direction].upcase if params[:order_direction].present?
-      @order_direction = "ASC" unless self.class::VALID_SORT_DIRECTIONS.include?(@order_direction)
-    end
-
     def fetch_total_count(table_name, query_params)
       if query_params.column_filters.present? && query_params.column_filters.values.any?(&:present?)
         fetch_filtered_record_count(table_name, query_params.column_filters)

data/app/controllers/dbviewer/home_controller.rb

@@ -2,6 +2,9 @@ module Dbviewer
   class HomeController < ApplicationController
     def index
       @analytics = fetch_database_analytics
+      if Dbviewer.configuration.enable_query_logging
+        @recent_queries = Dbviewer::Logger.instance.recent_queries(limit: 10)
+      end
     end
 
     private

data/app/controllers/dbviewer/tables_controller.rb

@@ -3,22 +3,14 @@ module Dbviewer
     include Dbviewer::PaginationConcern
 
     before_action :set_table_name, except: [ :index ]
+    before_action :set_query_filters, only: [ :show, :export_csv ]
+    before_action :set_global_filters, only: [ :show, :export_csv ]
 
     def index
       @tables = fetch_tables_with_stats(include_record_counts: true)
     end
 
     def show
-      set_pagination_params
-      set_sorting_params
-
-      # Get column filters from params first
-      @column_filters = params[:column_filters].presence ? params[:column_filters].to_enum.to_h : {}
-
-      # Then apply global creation filters (this will modify @column_filters)
-      set_global_filters
-
-      # Now create the query params with the combined filters
       query_params = Dbviewer::TableQueryParams.new(
         page: @current_page,
         per_page: @per_page,
@@ -33,7 +25,7 @@ module Dbviewer
       @metadata = fetch_table_metadata(@table_name)
 
       if @records.nil?
-        column_names = @columns.map { |c| c[:name] }
+        column_names = @columns.map { |column| column[:name] }
         @records = ActiveRecord::Result.new(column_names, [])
       end
 
@@ -57,28 +49,11 @@ module Dbviewer
     end
 
     def mini_erd
-      begin
-        @erd_data = fetch_mini_erd_for_table(@table_name)
-
-        if @erd_data[:error].present?
-          Rails.logger.error("Mini ERD error: #{@erd_data[:error]}")
-        end
-
-        respond_to do |format|
-          format.json { render json: @erd_data }
-          format.html { render layout: false }
-        end
-      rescue => e
-        Rails.logger.error("Error generating Mini ERD: #{e.message}")
-        Rails.logger.error(e.backtrace.join("\n"))
-
-        @error_message = e.message
-        @erd_data = { tables: [], relationships: [], error: @error_message }
+      @erd_data = fetch_mini_erd_for_table(@table_name)
 
-        respond_to do |format|
-          format.json { render json: { error: @error_message }, status: :internal_server_error }
-          format.html { render layout: false }
-        end
+      respond_to do |format|
+        format.json { render json: @erd_data }
+        format.html { render layout: false }
       end
     end
 
@@ -87,9 +62,6 @@ module Dbviewer
       @columns = fetch_table_columns(@table_name)
       @tables = fetch_tables_with_stats  # Fetch tables for sidebar
 
-      # Set active table for sidebar highlighting
-      @active_table = @table_name
-
       prepare_query
       execute_query
 
@@ -103,36 +75,19 @@ module Dbviewer
         return
       end
 
-      limit = (params[:limit] || 10000).to_i
       include_headers = params[:include_headers] != "0"
-
-      # Apply global creation filters
-      set_global_filters
-
-      # Create query parameters for export
       query_params = Dbviewer::TableQueryParams.new(
-        page: 1,
-        per_page: limit,
-        order_by: nil,
-        direction: "asc",
+        page: @current_page,
+        per_page: (params[:limit] || 10000).to_i,
+        order_by: @order_by,
+        direction: @order_direction,
         column_filters: @column_filters.reject { |_, v| v.blank? }
       )
-
-      # Get filtered data for export
       csv_data = export_table_to_csv(@table_name, query_params, include_headers)
 
-      # Set filename with timestamp for uniqueness
       timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      filename = "#{@table_name}_#{timestamp}.csv"
 
-      # Add filter info to filename if filters are applied
-      filename_suffix = ""
-      if @creation_filter_start.present? || @creation_filter_end.present?
-        filename_suffix = "_filtered"
-      end
-
-      filename = "#{@table_name}#{filename_suffix}_#{timestamp}.csv"
-
-      # Send data as file
       send_data csv_data,
                 type: "text/csv; charset=utf-8; header=present",
                 disposition: "attachment; filename=#{filename}"
@@ -142,7 +97,20 @@ module Dbviewer
 
     def set_table_name
       @table_name = params[:id]
-    end    # Handle global creation datetime filters across tables
+    end
+
+    def set_query_filters
+      @current_page = [ 1, params[:page].to_i ].max
+      @per_page = params[:per_page] ? params[:per_page].to_i : self.class.default_per_page
+      @per_page = self.class.default_per_page unless self.class.per_page_options.include?(@per_page)
+      @order_by = params[:order_by].presence ||
+                  database_manager.primary_key(@table_name).presence ||
+                  (@columns.first ? @columns.first[:name] : nil)
+      @order_direction = params[:order_direction].upcase if params[:order_direction].present?
+      @order_direction = "ASC" unless self.class::VALID_SORT_DIRECTIONS.include?(@order_direction)
+      @column_filters = params[:column_filters].presence ? params[:column_filters].to_enum.to_h : {}
+    end
+
     def set_global_filters
       # Store creation filter datetimes in session to persist between table navigation
       if params[:creation_filter_start].present?
@@ -168,31 +136,25 @@ module Dbviewer
 
       # Apply creation filters to column_filters if the table has a created_at column
       if has_timestamp_column?(@table_name) && (@creation_filter_start.present? || @creation_filter_end.present?)
-        # Clear any existing created_at filters to avoid conflicts
-        @column_filters.delete("created_at")
-        @column_filters.delete("created_at_operator")
-        @column_filters.delete("created_at_end")
-
-        if @creation_filter_start.present? && @creation_filter_end.present?
-          # If both start and end are present, set up a range filter
-          @column_filters["created_at"] = @creation_filter_start
-          @column_filters["created_at_end"] = @creation_filter_end
-          # No need for operator when using start and end together
-          Rails.logger.info("[DBViewer] Setting creation filter range: #{@creation_filter_start} to #{@creation_filter_end}")
-        elsif @creation_filter_start.present?
-          # Only start date is present
-          @column_filters["created_at"] = @creation_filter_start
-          @column_filters["created_at_operator"] = "gte" # Greater than or equal
-          Rails.logger.info("[DBViewer] Setting creation filter start: #{@creation_filter_start}")
-        elsif @creation_filter_end.present?
-          # Only end date is present
-          @column_filters["created_at"] = @creation_filter_end
-          @column_filters["created_at_operator"] = "lte" # Less than or equal
-          Rails.logger.info("[DBViewer] Setting creation filter end: #{@creation_filter_end}")
-        end
-      else
-        if @creation_filter_start.present? || @creation_filter_end.present?
-          Rails.logger.info("[DBViewer] Creation filter present but table #{@table_name} has no created_at column")
+        # Clear any existing created_at filters
+        %w[created_at created_at_operator created_at_end].each { |key| @column_filters.delete(key) }
+
+        case
+        when @creation_filter_start.present? && @creation_filter_end.present?
+          @column_filters.merge!({
+            "created_at" => @creation_filter_start,
+            "created_at_end" => @creation_filter_end
+          })
+        when @creation_filter_start.present?
+          @column_filters.merge!({
+            "created_at" => @creation_filter_start,
+            "created_at_operator" => "gte"
+          })
+        when @creation_filter_end.present?
+          @column_filters.merge!({
+            "created_at" => @creation_filter_end,
+            "created_at_operator" => "lte"
+          })
         end
       end
     end

data/app/helpers/dbviewer/application_helper.rb

@@ -14,6 +14,110 @@ module Dbviewer
       @database_manager ||= ::Dbviewer::DatabaseManager.new
     end
 
+    # Extract column type from columns info
+    def column_type_from_info(column_name, columns)
+      return nil unless columns.present?
+
+      column_info = columns.find { |c| c[:name].to_s == column_name.to_s }
+      column_info ? column_info[:type].to_s.downcase : nil
+    end
+
+    # Determine default operator based on column type
+    def default_operator_for_column_type(column_type)
+      if column_type && column_type =~ /char|text|string|uuid|enum/i
+        "contains"
+      else
+        "eq"
+      end
+    end
+
+    # Generate operator options based on column type
+    def operator_options_for_column_type(column_type)
+      if column_type && (column_type =~ /datetime/ || column_type =~ /^date$/ || column_type =~ /^time$/)
+        # Date/Time operators
+        [
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "<", "lt" ],
+          [ ">", "gt" ],
+          [ "≤", "lte" ],
+          [ "≥", "gte" ]
+        ]
+      elsif column_type && column_type =~ /int|float|decimal|double|number|numeric|real|money|bigint|smallint|tinyint|mediumint|bit/i
+        # Numeric operators
+        [
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "<", "lt" ],
+          [ ">", "gt" ],
+          [ "≤", "lte" ],
+          [ "≥", "gte" ]
+        ]
+      else
+        # Text operators
+        [
+          [ "contains", "contains" ],
+          [ "not contains", "not_contains" ],
+          [ "=", "eq" ],
+          [ "≠", "neq" ],
+          [ "starts with", "starts_with" ],
+          [ "ends with", "ends_with" ]
+        ]
+      end
+    end
+
+    # Render column filter input based on column type
+    def render_column_filter_input(form, column_name, column_type, column_filters)
+      if column_type && column_type =~ /datetime/
+        form.datetime_local_field("column_filters[#{column_name}]",
+          value: column_filters[column_name],
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      elsif column_type && column_type =~ /^date$/
+        form.date_field("column_filters[#{column_name}]",
+          value: column_filters[column_name],
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      elsif column_type && column_type =~ /^time$/
+        form.time_field("column_filters[#{column_name}]",
+          value: column_filters[column_name],
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      else
+        form.text_field("column_filters[#{column_name}]",
+          value: column_filters[column_name],
+          placeholder: "",
+          class: "form-control form-control-sm column-filter rounded-0",
+          data: { column: column_name })
+      end
+    end
+
+    # Render operator select for column filter
+    def render_operator_select(form, column_name, column_type, column_filters)
+      # Get previously selected operator or default
+      default_operator = default_operator_for_column_type(column_type)
+      selected_operator = column_filters["#{column_name}_operator"]
+      selected_operator = default_operator if selected_operator.nil? || selected_operator == "default"
+
+      # Get appropriate options
+      operator_options = operator_options_for_column_type(column_type)
+
+      form.select("column_filters[#{column_name}_operator]",
+        options_for_select(operator_options, selected_operator),
+        { include_blank: false },
+        { class: "form-select form-select-sm operator-select" })
+    end
+
+    # Render complete filter input group for a column
+    def render_column_filter(form, column_name, columns, column_filters)
+      column_type = column_type_from_info(column_name, columns)
+
+      content_tag(:div, class: "filter-input-group") do
+        render_operator_select(form, column_name, column_type, column_filters) +
+        render_column_filter_input(form, column_name, column_type, column_filters)
+      end
+    end
+
     def format_cell_value(value)
       return "NULL" if value.nil?
       return value.to_s.truncate(100) unless value.is_a?(String)
@@ -41,6 +145,91 @@ module Dbviewer
       end
     end
 
+    # Common parameters for pagination and filtering
+    def common_params(options = {})
+      params = {
+        order_by: @order_by,
+        order_direction: @order_direction,
+        per_page: @per_page,
+        column_filters: @column_filters
+      }.merge(options)
+
+      # Add creation filters if they exist
+      params[:creation_filter_start] = @creation_filter_start if @creation_filter_start.present?
+      params[:creation_filter_end] = @creation_filter_end if @creation_filter_end.present?
+
+      params
+    end
+
+    # Render pagination UI
+    def render_pagination(table_name, current_page, total_pages, params = {})
+      return unless total_pages && total_pages > 1
+
+      content_tag(:nav, 'aria-label': "Page navigation") do
+        content_tag(:ul, class: "pagination justify-content-center") do
+          prev_link = content_tag(:li, class: "page-item #{current_page == 1 ? 'disabled' : ''}") do
+            link_to "«", table_path(table_name, params.merge(page: [ current_page - 1, 1 ].max)), class: "page-link"
+          end
+
+          # Calculate page range to display
+          start_page = [ 1, current_page - 2 ].max
+          end_page = [ start_page + 4, total_pages ].min
+          start_page = [ 1, end_page - 4 ].max
+
+          # Generate page links
+          page_links = (start_page..end_page).map do |page_num|
+            content_tag(:li, class: "page-item #{page_num == current_page ? 'active' : ''}") do
+              link_to page_num, table_path(table_name, params.merge(page: page_num)), class: "page-link"
+            end
+          end.join.html_safe
+
+          next_link = content_tag(:li, class: "page-item #{current_page == total_pages ? 'disabled' : ''}") do
+            link_to "»", table_path(table_name, params.merge(page: [ current_page + 1, total_pages ].min)), class: "page-link"
+          end
+
+          prev_link + page_links + next_link
+        end
+      end
+    end
+
+    # Generate URL parameters for per-page dropdown
+    def per_page_url_params(table_name)
+      # Start with the dynamic part for the select element
+      url_params = "per_page=' + this.value + '&page=1"
+
+      # Add all other common parameters except per_page and page which we already set
+      params = common_params.except(:per_page, :page)
+
+      # Convert the params hash to URL parameters
+      params.each do |key, value|
+        if key == :column_filters && value.is_a?(Hash) && value.reject { |_, v| v.blank? }.any?
+          value.reject { |_, v| v.blank? }.each do |filter_key, filter_value|
+            url_params += "&column_filters[#{filter_key}]=#{CGI.escape(filter_value.to_s)}"
+          end
+        elsif value.present?
+          url_params += "&#{key}=#{CGI.escape(value.to_s)}"
+        end
+      end
+
+      url_params
+    end
+
+    # Render time grouping links
+    def time_grouping_links(table_name, current_grouping)
+      params = common_params
+
+      content_tag(:div, class: "btn-group btn-group-sm", role: "group", 'aria-label': "Time grouping") do
+        [
+          link_to("Hourly", table_path(table_name, params.merge(time_group: "hourly")),
+                 class: "btn btn-outline-primary #{current_grouping == 'hourly' ? 'active' : ''}"),
+          link_to("Daily", table_path(table_name, params.merge(time_group: "daily")),
+                 class: "btn btn-outline-primary #{current_grouping == 'daily' ? 'active' : ''}"),
+          link_to("Weekly", table_path(table_name, params.merge(time_group: "weekly")),
+                 class: "btn btn-outline-primary #{current_grouping == 'weekly' ? 'active' : ''}")
+        ].join.html_safe
+      end
+    end
+
     # Dark mode helper methods
 
     # Returns the theme toggle icon based on the current theme
@@ -159,23 +348,8 @@ module Dbviewer
         "none"
       end
 
-      # Build parameters for the sort link
-      sort_params = {
-        order_by: column_name,
-        order_direction: sort_direction,
-        page: current_page,
-        per_page: per_page,
-        column_filters: column_filters
-      }
-
-      # Add creation filter parameters if they're in the controller
-      if defined?(@creation_filter_start) && @creation_filter_start.present?
-        sort_params[:creation_filter_start] = @creation_filter_start
-      end
-
-      if defined?(@creation_filter_end) && @creation_filter_end.present?
-        sort_params[:creation_filter_end] = @creation_filter_end
-      end
+      # Use common_params helper to build parameters
+      sort_params = common_params(order_by: column_name, order_direction: sort_direction)
 
       link_to table_path(table_name, sort_params),
         class: "d-flex align-items-center text-decoration-none text-reset column-sort-link",
@@ -187,5 +361,127 @@ module Dbviewer
           content_tag(:span, sort_icon(column_name, current_order_by, current_direction), class: "sort-icon-container")
       end
     end
+
+    # Render a complete table header row with sortable columns
+    def render_sortable_header_row(records, order_by, order_direction, table_name, current_page, per_page, column_filters)
+      return content_tag(:tr) { content_tag(:th, "No columns available") } unless records&.columns
+
+      content_tag(:tr) do
+        # Start with action column header (sticky first column)
+        headers = [
+          content_tag(:th, class: "px-3 py-2 text-center action-column action-column-header", width: "60px", rowspan: 2) do
+            content_tag(:span, "Actions")
+          end
+        ]
+
+        # Add all data columns
+        headers += records.columns.map do |column_name|
+          is_sorted = order_by == column_name
+          content_tag(:th, class: "px-3 py-2 sortable-column #{is_sorted ? 'sorted' : ''}") do
+            sortable_column_header(column_name, order_by, order_direction, table_name, current_page, per_page, column_filters)
+          end
+        end
+
+        headers.join.html_safe
+      end
+    end
+
+    # Render the column filters row
+    def render_column_filters_row(form, records, columns, column_filters)
+      return content_tag(:tr) { content_tag(:th, "") } unless records&.columns
+
+      content_tag(:tr, class: "column-filters") do
+        filters = records.columns.map do |column_name|
+          content_tag(:th, class: "p-0") do
+            render_column_filter(form, column_name, columns, column_filters)
+          end
+        end
+
+        filters.join.html_safe
+      end
+    end
+
+    # Render a cell that may include a foreign key link
+    def render_table_cell(cell, column_name, metadata)
+      cell_value = format_cell_value(cell)
+      foreign_key = metadata && metadata[:foreign_keys] ?
+                    metadata[:foreign_keys].find { |fk| fk[:column] == column_name } :
+                    nil
+
+      if foreign_key && !cell.nil?
+        fk_params = { column_filters: { foreign_key[:primary_key] => cell } }
+        fk_params = fk_params.merge(common_params.except(:column_filters))
+
+        content_tag(:td, title: "#{cell_value} (Click to view referenced record)") do
+          link_to(cell_value, table_path(foreign_key[:to_table], fk_params),
+                  class: "text-decoration-none foreign-key-link") +
+          content_tag(:i, "", class: "bi bi-link-45deg text-muted small")
+        end
+      else
+        content_tag(:td, cell_value, title: cell_value)
+      end
+    end
+
+    # Render a table row with cells
+    def render_table_row(row, records, metadata)
+      content_tag(:tr) do
+        # Start with action column (sticky first column)
+        cells = [ render_action_cell(row, records.columns, metadata) ]
+
+        # Add all data cells
+        cells += row.each_with_index.map do |cell, cell_index|
+          column_name = records.columns[cell_index]
+          render_table_cell(cell, column_name, metadata)
+        end
+
+        cells.join.html_safe
+      end
+    end
+
+    # Render the entire table body with rows
+    def render_table_body(records, metadata)
+      if records.nil? || records.rows.nil? || records.empty?
+        content_tag(:tbody) do
+          content_tag(:tr) do
+            # Adding +1 to account for the action column
+            total_columns = records&.columns&.size.to_i + 1
+            content_tag(:td, "No records found or table is empty.", colspan: total_columns, class: "text-center")
+          end
+        end
+      else
+        content_tag(:tbody) do
+          records.rows.map do |row|
+            render_table_row(row, records, metadata)
+          end.join.html_safe
+        end
+      end
+    end
+
+    # Render action buttons for a record
+    def render_action_cell(row_data, columns, metadata = nil)
+      data_attributes = {}
+
+      # Create a hash of column_name: value pairs for data attributes
+      columns.each_with_index do |column_name, index|
+        data_attributes[column_name] = row_data[index].to_s
+      end
+
+      content_tag(:td, class: "text-center action-column") do
+        button_tag(
+          type: "button",
+          class: "btn btn-sm btn-primary view-record-btn",
+          title: "View Record Details",
+          data: {
+            bs_toggle: "modal",
+            bs_target: "#recordDetailModal",
+            record_data: data_attributes.to_json,
+            foreign_keys: metadata && metadata[:foreign_keys] ? metadata[:foreign_keys].to_json : "[]",
+            reverse_foreign_keys: metadata && metadata[:reverse_foreign_keys] ? metadata[:reverse_foreign_keys].to_json : "[]"
+          }
+        ) do
+          content_tag(:i, "", class: "bi bi-eye")
+        end
+      end
+    end
   end
 end

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

@@ -1,9 +1,5 @@
 <% content_for :title, "Entity Relationship Diagram" %>
 
-<% content_for :sidebar do %>
-  <%= render 'dbviewer/shared/sidebar' %>
-<% end %>
-
 <div class="container-fluid h-100">
   <div class="row h-100">
     <div class="col-md-12 p-0">