Collection View

The Collection View is your primary interface for browsing, viewing, and analyzing documents in MongoDB collections. It offers three distinct viewing modes—Tree View, Table View, and BSON View—each optimized for different use cases. Master the keyboard shortcuts to navigate efficiently through your data.

Keyboard Shortcuts

Master these keyboard shortcuts to navigate the Collection View efficiently:

View Mode Switching

Navigation & Selection

Document Operations

Search & Filter

View Controls

Tree View Specific

Tree View

Tree View displays documents in an expandable hierarchical structure, making it ideal for exploring nested objects and arrays. Each field is displayed as a node that can be expanded or collapsed, allowing you to focus on the data you need.

Understanding Tree View Structure

Each node in the tree displays:

• Expand/Collapse Icon - Triangle icon to toggle node visibility (▶ collapsed, ▼ expanded)
• Type Icon - Visual indicator of data type (📄 object, 📋 array, "abc" string, 123 number, etc.)
• Field Name - The key name in the document (colored based on type)
• Field Value - The actual value, with syntax highlighting
• Array/Object Count - Number of items in arrays or fields in objects (shown in gray)

Data Type Visualization

Tree View uses color coding and icons to distinguish data types:

Working with Arrays

Arrays in Tree View are displayed with special handling:

• Array Index - Each item shows its zero-based index: [0], [1], [2]
• Item Count - Array nodes show total item count: items (25)
• Pagination - Large arrays (>100 items) are paginated with "Load More" buttons
• Mixed Types - Arrays with different types show type icons for each item
• Nested Arrays - Multi-dimensional arrays can be expanded recursively

Context Menu Actions

Right-click any field in Tree View to access these actions:

• Copy Field Name - Copy the field key to clipboard
• Copy Field Path - Copy dot-notation path (e.g., user.profile.email)
• Copy Field Value - Copy the value as JSON
• Copy as MongoDB Query - Generate query filter for this field/value pair
• Edit Value - Open inline editor to modify the value
• Delete Field - Remove this field from the document
• Add Field - Add a new sibling field at this level
• Expand All Children - Recursively expand all nested nodes
• Collapse All Children - Collapse all nested nodes

Table View

Table View displays documents in a spreadsheet-like format with rows and columns, perfect for comparing values across documents and performing bulk operations. Each unique field in your documents becomes a column, allowing you to see patterns and outliers at a glance.

Understanding Table View Layout

The table is organized as follows:

• Header Row - Field names with sort indicators and menu access
• Data Rows - One row per document, alternating row colors for readability
• Selection Column - Leftmost column with checkboxes for multi-select
• _id Column - Always first data column, shows document ObjectId
• Field Columns - Automatically detected from all loaded documents
• Nested Fields - Displayed with dot notation (e.g., address.city)

Column Management

Customize the table display with powerful column controls:

Showing/Hiding Columns

• Right-click any column header to open the column menu
• Check/uncheck columns to show/hide them from view
• Hidden columns are remembered per collection
• Use "Show All Columns" to reset visibility

Sorting Columns

• Single Column Sort - Click header to sort ascending, click again for descending
• Multi-Column Sort - Hold Shift and click headers to add secondary sort levels
• Remove Sort - Click sorted column a third time to remove sort
• Sort Indicators - ↑ ascending, ↓ descending, numbers show sort priority (1, 2, 3...)

Resizing Columns

• Hover between column headers until resize cursor appears
• Click and drag to adjust width manually
• Double-click the border to auto-fit column to content width
• Right-click and select "Auto-fit All Columns" to resize all at once

Reordering Columns

• Click and drag any column header to move it
• A visual indicator shows the drop position
• Drop the column in the new position
• Column order is saved and persists across sessions

Cell Data Display

Table View intelligently displays different data types in cells:

Bulk Operations

Select multiple documents to perform batch operations:

Selection Methods

• Single Select - Click checkbox in selection column
• Range Select - Click first row, hold Shift, click last row
• Multi-Select - Hold Ctrl/Cmd and click individual rows
• Select All - Click header checkbox or press Ctrl+A
• Deselect All - Click header checkbox again or press Escape

Available Bulk Actions

• Delete Selected - Remove all selected documents (with confirmation)
• Export Selected - Export selected rows to JSON or CSV
• Duplicate Selected - Create copies of selected documents
• Update Field - Set a field value across all selected documents
• Remove Field - Delete a field from all selected documents

BSON View

BSON View displays the raw JSON/BSON representation of your documents with syntax highlighting and formatting. This view is perfect for developers who prefer working directly with the document structure, copying JSON for code, or verifying the exact data format.

BSON Format Options

Toggle between different JSON formatting modes:

Extended JSON (MongoDB Format)

Default format that preserves MongoDB-specific types:

{
  "_id": { "$oid": "507f1f77bcf86cd799439011" },
  "createdAt": { "$date": "2026-04-02T10:30:00.000Z" },
  "tags": [ "mongodb", "database" ],
  "metadata": {
    "version": { "$numberInt": "2" },
    "active": true
  }
}

Strict JSON

Standard JSON format, converting MongoDB types to strings:

{
  "_id": "507f1f77bcf86cd799439011",
  "createdAt": "2026-04-02T10:30:00.000Z",
  "tags": [ "mongodb", "database" ],
  "metadata": {
    "version": 2,
    "active": true
  }
}

Shell Format

MongoDB shell format with constructors:

{
  _id: ObjectId("507f1f77bcf86cd799439011"),
  createdAt: ISODate("2026-04-02T10:30:00.000Z"),
  tags: [ "mongodb", "database" ],
  metadata: {
    version: NumberInt(2),
    active: true
  }
}

Code Editor Features

BSON View includes a full-featured code editor:

• Auto-Indentation - Automatically indents nested structures as you type
• Bracket Matching - Highlights matching braces, brackets, and parentheses
• Auto-Closing - Automatically closes quotes, brackets, and braces
• Multi-Cursor - Hold Alt/Option and click to place multiple cursors
• Column Selection - Hold Alt+Shift and drag to select rectangular regions
• Find & Replace - Ctrl+F to search, Ctrl+H for find-and-replace
• Go to Line - Ctrl+G to jump to specific line number
• Undo/Redo - Full undo history with Ctrl+Z and Ctrl+Y

Validation & Error Highlighting

When editing JSON directly, the editor validates syntax in real-time:

• Syntax Errors - Red squiggly underlines for invalid JSON
• Error Messages - Hover over errors to see detailed descriptions
• Type Validation - Warns about invalid MongoDB extended JSON types
• Required Fields - Highlights missing required fields like _id
• Save Prevention - Cannot save document while errors exist

Copying JSON

Multiple options for copying document data:

• Copy Document - Click copy icon to copy entire formatted JSON
• Copy Selection - Select text and press Ctrl+C to copy highlighted portion
• Copy as Shell Command - Right-click and copy as MongoDB shell insert command
• Copy as Code - Copy with language-specific formatting (JavaScript, Python, etc.)

Explain Query Performance

The Explain feature provides detailed insights into how MongoDB executes your queries, helping you identify performance bottlenecks, optimize indexes, and understand query execution plans. Use Explain to analyze any query running in the Collection View.

Explain Verbosity Levels

Choose the appropriate level of detail for your analysis:

Understanding Execution Stats

The Execution Stats view shows key performance metrics:

Overall Query Metrics

• Total Execution Time - Total time to execute the query in milliseconds
• Documents Examined - Number of documents MongoDB scanned
• Documents Returned - Number of documents matching the query
• Execution Success - Whether the query completed without errors
• Number of Yields - Times the query yielded to other operations

Index Usage

• Index Used - Name of the index MongoDB selected (or "COLLSCAN" for collection scan)
• Index Keys Examined - Number of index entries scanned
• Index Bounds - Min/max values scanned in the index
• Multi-key Index - Whether the index covers array fields

Stage Breakdown

The execution plan is broken down into stages:

• IXSCAN - Index scan (good - using an index)
• FETCH - Fetching full documents after index scan
• COLLSCAN - Collection scan (warning - no index used)
• SORT - In-memory sort operation (warning - consider sort index)
• PROJECTION - Field projection/selection
• LIMIT - Limiting results (efficient)
• SKIP - Skipping documents (can be inefficient for large values)

Performance Indicators

VisuaLeaf highlights potential performance issues with visual indicators:

Explain Visualization

The execution plan is displayed as an interactive tree:

• Stage Nodes - Each stage shown as expandable node
• Parent-Child Relationships - Shows how data flows through stages
• Stage Metrics - Timing and document counts for each stage
• Highlighted Bottlenecks - Slow stages highlighted in red/yellow
• Interactive Exploration - Click stages to see detailed metrics

Optimization Recommendations

VisuaLeaf automatically analyzes explain output and provides actionable recommendations:

Common Recommendations

• Create Index - Suggests specific index to create based on query pattern
• Compound Index - Recommends combining multiple fields in one index
• Covered Query - Suggests projection to make query fully covered by index
• Index Direction - Recommends ascending/descending based on sort order
• Query Rewrite - Suggests alternative query syntax for better performance

Example Recommendation Panel

db.users.createIndex({ status: 1, createdAt: -1 })

Comparing Query Performance

Use Explain to compare different query approaches:

1. Run Explain on your original query
2. Save the execution stats
3. Modify the query (add index, change filter, etc.)
4. Run Explain again
5. Compare side-by-side to see improvement

Best Practices

Choosing the Right View Mode

• Use Tree View when exploring unfamiliar data structures or working with deeply nested documents
• Use Table View when comparing values across multiple documents or performing bulk operations
• Use BSON View when copying JSON for code, verifying exact formats, or making precise edits

Performance Tips

• Limit the number of documents loaded (use filters and pagination)
• Hide unnecessary columns in Table View to improve rendering performance
• Collapse large arrays in Tree View when not needed
• Use Explain regularly to catch inefficient queries early
• Create indexes based on your most common query patterns

Workflow Efficiency

• Memorize keyboard shortcuts for your most frequent actions
• Save custom column layouts in Table View for different use cases
• Use search (Ctrl+F) across all view modes to quickly locate data
• Take advantage of context menus (right-click) for quick access to actions
• Switch view modes frequently—each mode has strengths for different tasks

Related Documentation

• Collection Management - Creating, renaming, and deleting collections
• Collection Statistics - Analyzing collection metrics and storage
• MongoDB Query - Writing queries to filter collection data
• Aggregation Pipeline - Complex data transformations and analytics
• Index Management - Creating and optimizing indexes
• Export Data - Exporting documents to JSON, CSV, and other formats