Introduction to DBeaver: The Free Universal Database Manager

By /

Okay, here is the comprehensive article on DBeaver.

Introduction to DBeaver: The Free Universal Database Manager

In the modern technological landscape, data is the lifeblood of nearly every application, business process, and scientific endeavor. Databases, the structured repositories holding this vital information, come in a bewildering array of types, sizes, and vendors – from venerable relational systems like PostgreSQL and Oracle to nimble NoSQL solutions like MongoDB and Cassandra, and cloud-native powerhouses like Amazon Redshift and Google BigQuery. Managing, querying, and interacting with these diverse database systems often presents a significant challenge for developers, database administrators (DBAs), data analysts, and even students. Historically, this meant juggling a multitude of vendor-specific tools, each with its own interface, quirks, and learning curve.

Enter DBeaver, a powerful, free, open-source, and remarkably versatile universal database manager. It aims to be the Swiss Army knife for anyone working with databases, providing a unified, consistent, and feature-rich environment to connect to, explore, query, manipulate, and manage virtually any database system imaginable. Whether you’re a seasoned DBA managing complex enterprise deployments or a developer quickly needing to inspect a local SQLite database, DBeaver offers a compelling solution that simplifies workflows and boosts productivity.

This article provides a detailed introduction to DBeaver, exploring its core philosophy, key features, installation process, common use cases, and its position within the ecosystem of database tools. We will delve deep into its capabilities, demonstrating why it has become an indispensable tool for countless professionals and enthusiasts worldwide.

The Problem Space: Why a Universal Tool Matters

Before diving into DBeaver itself, it’s crucial to understand the challenges it addresses:

  1. Tool Proliferation: Different database vendors (Oracle, Microsoft, IBM, PostgreSQL Global Development Group, etc.) often provide their own proprietary management tools (SQL Developer, SSMS, Db2 Control Center, pgAdmin). While powerful for their specific ecosystems, using multiple tools leads to context switching, inconsistent user experiences, and the need to learn and maintain proficiency in several different applications.
  2. Vendor Lock-in: Relying solely on vendor-specific tools can inadvertently reinforce vendor lock-in, making it harder to evaluate or migrate to alternative database solutions.
  3. Diverse Data Stacks: Modern applications frequently utilize polyglot persistence – using different types of databases for different needs within the same system (e.g., PostgreSQL for relational data, Redis for caching, Elasticsearch for search). Managing this diverse stack requires tools that can bridge the gap.
  4. Cost: Many advanced, cross-database tools are commercial products with potentially significant licensing costs, putting them out of reach for individuals, small teams, or educational purposes.
  5. Learning Curve: Each new tool introduces a learning curve. A universal tool allows users to leverage their existing knowledge across different database backends.
  6. Consistency: Performing common tasks like writing SQL queries, browsing schemas, exporting data, or managing users should ideally feel consistent regardless of the underlying database technology.

DBeaver directly tackles these issues by providing a single, cohesive platform designed from the ground up for heterogeneity and extensibility.

What is DBeaver? A Deeper Look

DBeaver is fundamentally a desktop application written in Java, built upon the Eclipse platform. This foundation provides several key advantages:

  • Cross-Platform Compatibility: Being Java-based and leveraging the Eclipse framework, DBeaver runs natively on Windows, macOS, and Linux, ensuring a consistent experience across different operating systems.
  • Extensibility: The Eclipse plugin architecture allows DBeaver to be highly extensible. Its support for various databases is often implemented through plugins (drivers and UI extensions), and third parties or users can potentially develop their own extensions.
  • Mature Foundation: The Eclipse platform provides robust UI components, workspace management, and other foundational elements, allowing the DBeaver developers to focus on database-specific functionality.

Core Philosophy:

DBeaver’s design philosophy revolves around:

  • Universality: Aiming to support any database system that has a JDBC or ODBC driver. This includes virtually all relational databases and, increasingly (especially in the commercial versions), NoSQL and cloud databases.
  • Usability: Providing an intuitive and well-organized graphical user interface (GUI) that makes common database tasks easy to perform.
  • Features: Offering a rich set of features comparable to, and often exceeding, many single-database tools.
  • Open Source (Community Edition): The core DBeaver Community Edition (CE) is free and open-source (licensed under the Apache License 2.0), making it accessible to everyone. This fosters a strong community and encourages contributions.
  • Extensibility: Allowing users and developers to add support for new databases or features through plugins.

History and Evolution:

DBeaver was first released in 2011 by Serge Rider. It quickly gained popularity due to its broad database support and rich feature set, offered completely free. Over the years, it has seen continuous development, adding support for more databases, refining the UI, and incorporating powerful new features based on user feedback and evolving database technologies. Recognizing the need for dedicated support and more advanced features for enterprise users, a commercial Enterprise Edition (EE) was later introduced, offering additional capabilities while keeping the core Community Edition free and open-source.

DBeaver Community Edition (CE) vs. Enterprise Edition (EE):

It’s important to distinguish between the two main versions:

  • DBeaver Community Edition (CE):
    • Free and open-source.
    • Supports any database with a JDBC or ODBC driver (focus primarily on SQL databases).
    • Includes a vast array of features suitable for most developers, DBAs, and analysts working with relational databases.
    • Relies on community support forums.
  • DBeaver Enterprise Edition (EE):
    • Commercial, subscription-based product.
    • Includes all CE features.
    • Adds official support for various NoSQL databases (MongoDB, Cassandra, Redis, Couchbase, etc.) with dedicated extensions and UI elements.
    • Provides integration with enterprise cloud services (AWS, Google Cloud, Azure) for database discovery and management.
    • Offers advanced features like visual query builder, sophisticated data comparison, and mock data generation.
    • Includes technical support from the DBeaver team.
    • Often includes drivers for popular databases out-of-the-box.

For the remainder of this article, unless otherwise specified, we will focus primarily on the capabilities available in the widely used Community Edition, which itself is exceptionally powerful.

Core Features of DBeaver (Community Edition)

DBeaver CE packs an impressive punch. Let’s break down its most significant features:

1. Extensive Database Connectivity:

  • JDBC Driver Management: DBeaver’s cornerstone is its ability to connect to almost any database via a Java Database Connectivity (JDBC) driver. It comes bundled with drivers for the most popular open-source databases (like PostgreSQL, MySQL, MariaDB, SQLite, Firebird).
  • Automatic Driver Download: For many other databases (Oracle, SQL Server, Db2, Sybase, Teradata, etc.), DBeaver doesn’t bundle the drivers due to licensing restrictions. However, when you configure a connection for the first time, DBeaver intelligently detects the missing driver and offers to download it automatically from trusted Maven repositories or vendor websites. This significantly simplifies the setup process.
  • ODBC Support: In addition to JDBC, DBeaver can also connect via Open Database Connectivity (ODBC) drivers on Windows, further expanding its reach.
  • Connection Configuration: DBeaver provides a clear and comprehensive connection wizard. You can specify host, port, database name/SID, user credentials, and crucially, database-specific properties.
  • Advanced Security: Supports various authentication methods, including standard username/password, database-native authentication (like Windows authentication for SQL Server or Kerberos), and cloud IAM authentication (more prevalent in EE). It also supports SSH tunneling for secure connections to remote databases behind firewalls, SSL encryption, and proxy configurations.
  • Connection Management: Connections can be organized into folders, assigned colors for easy identification (e.g., red for production, green for development), and configured with specific network profiles or bootstrap queries that run upon connection.

2. Intuitive Database Navigation and Metadata Exploration:

  • Database Navigator View: This is the central hub for exploring database connections. It presents connections in a tree structure, allowing you to drill down through:
    • Databases/Catalogs
    • Schemas
    • Object Types (Tables, Views, Materialized Views, Procedures, Functions, Triggers, Sequences, Data Types, Packages, etc.)
    • Specific Objects (e.g., individual tables)
  • Object Details: Selecting an object in the navigator displays its detailed properties in dedicated tabs. For a table, you’ll see:
    • Properties: General info like name, owner, comment, creation date.
    • Columns: Detailed list of columns, data types, nullability, defaults, comments.
    • Constraints: Primary keys, foreign keys, unique constraints, check constraints.
    • Indexes: List of indexes, columns involved, uniqueness.
    • Foreign Keys: Both keys referencing this table and keys referenced by this table.
    • Partitions: (If applicable) Information about table partitioning.
    • DDL: The Data Definition Language (SQL script) required to recreate the object. This is invaluable for documentation, migration, and understanding object structure.
    • Dependencies: (Often) Objects that depend on this object or that this object depends on.
  • Filtering and Searching: The navigator allows filtering objects by name, making it easy to find specific tables or procedures in large schemas. You can also perform global metadata searches across databases.
  • Customization: The navigator view can be customized to show or hide specific object types or connections.

3. Powerful SQL Development Environment:

  • Feature-Rich SQL Editor: DBeaver includes a sophisticated SQL editor that significantly enhances productivity:
    • Syntax Highlighting: Code is color-coded based on SQL keywords, functions, strings, comments, etc., improving readability. Highlighting is database-specific, recognizing dialect variations.
    • Smart Code Completion (Auto-completion): As you type, DBeaver suggests relevant SQL keywords, schema names, table names, column names, and function names based on database metadata and context. This reduces typos and speeds up coding.
    • SQL Formatting: Includes a powerful and customizable SQL formatter to automatically indent and arrange code according to predefined or custom style rules, ensuring consistency.
    • SQL Templates: Define and use code snippets (templates) for frequently used SQL constructs (e.g., SELECT * FROM ..., INSERT INTO ..., common JOIN patterns). Templates can include variables that are prompted for upon insertion.
    • Bracket/Keyword Highlighting: Matching brackets and SQL block keywords (like BEGIN/END) are highlighted.
    • Parameter Binding: Supports executing parameterized queries using :variable or ? syntax. DBeaver prompts for parameter values before execution, preventing SQL injection vulnerabilities and allowing easy reuse of queries with different inputs.
    • Multiple Query Execution: You can write multiple SQL statements in a single editor tab, separated by delimiters (usually semicolons or configured delimiters). DBeaver allows executing the statement under the cursor, the selected text, or the entire script.
  • Execution Plans: For supported databases (like PostgreSQL, MySQL, Oracle, SQL Server), DBeaver can display the query execution plan (EXPLAIN PLAN). This is crucial for performance tuning, showing how the database intends to execute the query (e.g., which indexes it will use, join methods). Plans can often be viewed in both textual and graphical formats.
  • Script Execution: Execute large SQL scripts from files. DBeaver handles script execution robustly, providing progress feedback and error reporting. It supports database-specific script delimiters and commands.
  • Dynamic SQL Generation: DBeaver can automatically generate SQL statements (SELECT, INSERT, UPDATE, DELETE, MERGE, DDL) based on selected objects in the Database Navigator. Right-clicking a table, for instance, offers options to quickly generate a SELECT * statement or an INSERT template.
  • Query Manager: Keeps a history of executed queries, allowing you to easily review, re-run, or save past queries.

4. Versatile Data Viewing and Editing:

  • Grid-Based Results: Query results are displayed in a familiar spreadsheet-like grid.
  • Inline Editing: Perhaps one of DBeaver’s most convenient features is the ability to directly edit data within the results grid (if the underlying query/table is updatable and the connection is not read-only). Changes are highlighted, and you can save (commit) or discard (rollback) them. DBeaver intelligently generates the necessary UPDATE or DELETE statements behind the scenes.
  • Filtering and Sorting: Easily sort results by clicking column headers. Apply complex filters to the displayed data using various operators (equals, contains, greater than, IS NULL, etc.) without writing additional WHERE clauses. Filters can be applied client-side (on fetched data) or, where possible, DBeaver can re-execute the query with the filter conditions pushed down to the database server for efficiency.
  • Data Formats: Customize how data types (dates, times, numbers, binaries) are displayed. Binary data (BLOBs, CLOBs) can often be viewed or saved directly. Large text fields can be opened in a separate editor.
  • Cell View Modes: View cell content in different modes: value, full text (for long strings), dedicated viewer/editor (for JSON, XML, images if configured).
  • Calculated Columns (Virtual Columns): Add temporary columns to the result grid based on expressions calculated from other columns (client-side).
  • Row Management: Add new rows or delete existing rows directly from the grid (generating INSERT/DELETE statements).
  • Multiple Result Tabs: Executing multiple queries (or a script returning multiple result sets) opens results in separate tabs within the editor view.

5. Data Import, Export, and Transfer:

  • Flexible Data Export: Export data from tables or query results to various file formats:
    • CSV (Comma Separated Values) – Highly configurable (delimiter, quoting, encoding).
    • SQL INSERT statements.
    • HTML tables.
    • XML.
    • JSON.
    • TXT (Fixed-width or delimited).
    • XLS/XLSX (Microsoft Excel format – sometimes requires extra libraries or is enhanced in EE).
    • Others via extensions.
    • Exports can be configured for encoding, formatting, and handling of NULLs and binary data.
  • Data Import: Import data into database tables from CSV files. DBeaver provides a wizard to map CSV columns to table columns, configure data type conversions, and manage import settings (batch size, error handling).
  • Direct Data Transfer: A powerful feature allowing you to copy data directly from one database table to another, even across different database systems. DBeaver handles the mapping of data types (where possible) and streams the data efficiently. This is incredibly useful for migrations or setting up test environments. The wizard allows fine-grained control over column mapping and data conversion.

6. Entity-Relationship (ER) Diagrams:

  • Automatic Generation: DBeaver can automatically generate Entity-Relationship (ER) diagrams for database schemas or selected tables. It analyzes foreign key constraints to visualize relationships between tables.
  • Customization: Diagrams can be rearranged, tables can be added or removed, notes can be added, and the layout can be adjusted. Colors and display options can be customized.
  • Export: ER diagrams can be exported to various image formats (PNG, GIF, BMP) or graph formats (GraphML) for documentation or sharing.
  • Schema Exploration: ERDs provide an excellent visual way to understand the structure and relationships within a complex database schema.

7. Basic Database Administration Tools:

While not a full-fledged DBA administration suite like some vendor-specific tools, DBeaver CE provides essential administrative functions:

  • User Management: For many databases, you can view, create, modify, and delete users and roles/groups.
  • Permission Management: Grant and revoke privileges/permissions on database objects to users and roles.
  • Session Management: View active database sessions/connections and, in some cases, terminate them.
  • Basic Backup/Restore: DBeaver often provides convenient wrappers around the database’s native backup and restore command-line tools (like pg_dump/pg_restore for PostgreSQL, mysqldump for MySQL). It offers a GUI to configure and execute these operations.
  • Maintenance Tools: Provides access to common maintenance tasks like ANALYZE, VACUUM (for PostgreSQL), or index rebuilding, again often acting as a GUI front-end to native database commands.

8. Scripting and Automation:

  • DDL Generation: Easily generate DDL scripts for existing tables, schemas, or even entire databases. This is useful for version control, documentation, and migration.
  • SQL Script Execution: As mentioned earlier, execute complex SQL scripts with support for database-specific syntax and delimiters.
  • Command Line Interface: While primarily a GUI tool, DBeaver does offer some command-line parameters for tasks like executing scripts or performing data exports, enabling basic automation. (EE version typically has more advanced CLI options).

9. Extensibility via Plugins:

Being built on Eclipse, DBeaver supports a plugin architecture. While most users interact with the pre-packaged database extensions, this allows for:

  • Adding New Database Support: Developers can create plugins to add support for databases not covered out-of-the-box.
  • Adding Functionality: New features, viewers, editors, or tools can be integrated as plugins. The DBeaver Marketplace (accessible within the application) lists available extensions.

10. Cross-Platform Support:

Runs consistently on Windows, macOS, and various Linux distributions, providing flexibility for diverse development teams and environments.

Getting Started with DBeaver

Using DBeaver is straightforward:

  1. Download: Visit the official DBeaver website (dbeaver.io) and navigate to the Download section. Choose the Community Edition installer appropriate for your operating system (Windows installer, macOS package, Linux .deb/.rpm packages, or a platform-independent archive).
  2. Installation:
    • Windows: Run the installer and follow the wizard. You can typically choose whether to include bundled Java or use an existing JRE.
    • macOS: Open the downloaded .dmg file and drag the DBeaver application to your Applications folder.
    • Linux: Use your package manager (e.g., sudo dpkg -i dbeaver-ce_*.deb for Debian/Ubuntu, sudo rpm -ivh dbeaver-ce_*.rpm for Fedora/CentOS) or extract the archive and run the executable.
  3. Launch DBeaver: Start the application. On the first launch, it might ask if you want to create sample database connections (useful for exploring).
  4. Create a New Connection:
    • Click the “New Connection Wizard” button (looks like a plug with a plus sign) in the toolbar or go to Database -> New Database Connection.
    • A dialog appears listing supported database types. Select the type of database you want to connect to (e.g., PostgreSQL, MySQL, SQLite, Oracle). If your database isn’t listed directly but has a JDBC driver, you can often use the generic “JDBC” option.
    • Click “Next”.
    • Fill in the connection details:
      • Host/Server Address: The IP address or hostname of the database server. Use localhost or 127.0.0.1 for databases running on your local machine.
      • Port: The port number the database listens on (e.g., 5432 for PostgreSQL, 3306 for MySQL, 1521 for Oracle, 1433 for SQL Server).
      • Database/Database Name: The specific database or schema you want to connect to.
      • Authentication: Select the authentication type and enter your username and password (or configure other methods like Windows Authentication).
    • Driver Download (If Necessary): If DBeaver doesn’t have the driver, a “Download driver files” button will appear on the connection settings page. Click it, review the libraries, and click “Download”. DBeaver will fetch and install the driver automatically.
    • Test Connection: Click the “Test Connection” button at the bottom left. If successful, you’ll see a confirmation dialog with driver and server version information. If not, double-check your connection parameters (host, port, credentials, firewall rules).
    • Finish: Click “Finish”. The new connection will appear in the Database Navigator view.
  5. Explore: Expand the connection node in the Database Navigator to browse schemas, tables, views, and other objects. Double-click a table to open its data grid view. Right-click objects to see available actions (Generate SQL, View DDL, etc.).
  6. Open SQL Editor: Click the “New SQL Editor” button in the toolbar or right-click a connection and select “SQL Editor”. Start writing and executing queries using Ctrl+Enter (or the configured shortcut).

A Simple Walkthrough Example (Connecting to SQLite)

SQLite is a great database to start with as it’s file-based and requires minimal setup.

  1. Ensure SQLite Driver is Available: DBeaver usually bundles the SQLite JDBC driver.
  2. Create a New Connection: Open the New Connection Wizard and select “SQLite”.
  3. Set the Path: In the connection settings, the primary field is “Path”. Click “Browse” and either navigate to an existing SQLite database file (.db, .sqlite, .sqlite3) or type a path to a new file you want to create (e.g., /path/to/my_test_database.db). If the file doesn’t exist, DBeaver (via the driver) will create it upon connection.
  4. Test Connection: Click “Test Connection”. It should succeed almost instantly for a local file.
  5. Finish: Click “Finish”.
  6. Create a Table: Right-click the connection in the Database Navigator, choose “SQL Editor”. In the editor, type:
    sql
    CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    Execute the statement (Ctrl+Enter). Refresh the Database Navigator (right-click connection -> Refresh, or F5). You should now see the users table under the “Tables” node.
  7. Insert Data: In the SQL Editor, type:
    sql
    INSERT INTO users (name, email) VALUES
    ('Alice', '[email protected]'),
    ('Bob', '[email protected]');
    Execute this statement.
  8. View Data: Double-click the users table in the Database Navigator. A data grid will open showing the two rows you inserted.
  9. Edit Data: Double-click the cell containing ‘Bob’. Change the name to ‘Robert’. Notice the cell gets highlighted. Click the “Save” button (looks like a floppy disk) in the bottom toolbar of the data grid view. DBeaver executes the UPDATE statement.
  10. Query Data: Go back to the SQL Editor (or open a new one) and type:
    sql
    SELECT name, email FROM users WHERE name LIKE 'A%';
    Execute it. A new results tab will appear showing only Alice’s record.

This simple example demonstrates navigation, DDL execution, data insertion, inline editing, and querying – core tasks made easy by DBeaver’s interface.

Strengths of DBeaver

  • Universality: Its biggest strength. The ability to manage diverse databases from a single tool is a massive productivity booster.
  • Free and Open Source (CE): Makes powerful database management accessible to everyone. The active community contributes to its improvement.
  • Rich Feature Set: Offers capabilities comparable to or exceeding many commercial or vendor-specific tools (SQL editor, data import/export, ERDs, admin functions).
  • Ease of Use: Despite its power, the UI is generally intuitive, especially for common tasks. The driver auto-download feature is particularly user-friendly.
  • Cross-Platform: Works seamlessly on Windows, macOS, and Linux.
  • Active Development: The project is actively maintained with frequent updates, bug fixes, and new features.
  • Customization: Offers many options for customizing the UI, behavior, SQL formatting, and data display.
  • Connectivity Options: Robust support for SSH tunneling, SSL, and proxies is essential for secure remote access.

Potential Weaknesses/Considerations

  • Can Be Overwhelming: The sheer number of features and options can be initially daunting for new users.
  • Performance: While generally performant, working with extremely large result sets (millions of rows) in the data grid can sometimes consume significant memory or become sluggish, depending on the machine and JVM configuration. Fetching large datasets should be done judiciously.
  • Java Dependency: Requires a Java Runtime Environment (though installers often bundle one). Java applications can sometimes have higher memory footprints compared to native applications.
  • Reliance on Drivers: DBeaver’s capabilities for a specific database are ultimately limited by the features exposed by its JDBC or ODBC driver. Occasionally, highly database-specific or newly introduced features might not be immediately accessible via the generic interfaces DBeaver uses.
  • EE vs. CE Divide: Increasingly, advanced features, official NoSQL support, and dedicated cloud integrations are reserved for the commercial Enterprise Edition. While CE remains incredibly capable for SQL databases, users needing these specific features must consider EE.
  • UI Aesthetics: While functional, some users might find the Eclipse-based UI less modern-looking compared to some newer, purely native applications (though this is subjective and constantly improving).

DBeaver in the Ecosystem: Comparison with Alternatives

  • Vendor-Specific Tools (pgAdmin, MySQL Workbench, SQL Server Management Studio): These tools offer the deepest integration and support for every feature of their respective databases. However, they only work for that specific database. DBeaver competes by offering good enough support for most common tasks across many databases.
  • Oracle SQL Developer: Similar to the above, excellent for Oracle but limited elsewhere. DBeaver provides a strong alternative for Oracle users who also work with other databases. SQL Developer Data Modeler is more powerful for ER modeling than DBeaver’s basic ERD feature.
  • JetBrains DataGrip: A commercial competitor from JetBrains. DataGrip also offers universal database support, a highly polished UI, excellent code completion and refactoring tools, and deep integration with other JetBrains IDEs. Its main drawback compared to DBeaver CE is that it’s a paid product. Feature sets often overlap, with each having unique strengths.
  • SQLectron: An open-source, cross-platform SQL client built on Electron. Generally simpler than DBeaver with a more modern-looking UI, but often less feature-rich, especially regarding administration, import/export, and ERDs.
  • Azure Data Studio: Microsoft’s open-source, cross-platform tool, also built on Electron/VS Code. Initially focused on SQL Server and Azure databases, it’s extensible and gaining support for other databases (like PostgreSQL). It offers a modern UI and excellent editor but may not yet match DBeaver’s breadth of support or maturity in certain areas like data transfer or universal admin functions.

DBeaver’s unique selling proposition remains its powerful combination of universality, rich features, cross-platform nature, and its free, open-source Community Edition.

Conclusion

DBeaver stands as a testament to the power of open-source development and the value of a unified approach to a common problem. It successfully bridges the gap between disparate database systems, offering developers, administrators, and analysts a single, consistent, and remarkably capable tool for their daily tasks. From writing complex SQL queries with intelligent autocompletion and analyzing execution plans, to visually exploring schemas via ER diagrams, editing data directly in result grids, and seamlessly transferring data between different database engines, DBeaver streamlines workflows and reduces the friction inherent in working with diverse data environments.

While the Enterprise Edition offers compelling features for organizations with specific NoSQL or cloud integration needs, the Community Edition remains an exceptionally powerful and complete solution for the vast majority of users working with relational databases. Its ease of use, combined with its depth of functionality and the crucial advantage of being free and open-source, makes DBeaver an indispensable tool in the modern data professional’s arsenal. Whether you’re just starting your journey with databases or you’re a seasoned expert juggling multiple systems, DBeaver is undoubtedly worth exploring. It simplifies complexity, fosters productivity, and truly lives up to its name as the universal database manager.

Further Resources:

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top