# Data Sources and Drivers dialog

Procedure: Enable the Database Tools and SQL plugin

This functionality relies on the  Database Tools and SQL plugin, which  is bundled and enabled in IntelliJ IDEA   by default. If the relevant features are not available, make sure that you did not disable the plugin.

> **Note:**
> Database Tools and SQL functionality support is limited in IntelliJ IDEA without the Ultimate subscription.

1. Press `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)) to open settings and then select `Plugins`.

2. Open the Installed tab, find the Database Tools and SQL plugin, and select the checkbox next to the plugin name.

To access the  Data Sources and Drivers  dialog, perform one of the following actions:

* In the Database tool window , click the Data Source Properties button ![the Data Source Properties button](https://resources.jetbrains.com/help/img/idea/2026.2/database-plugin.icons.expui.manageDataSources.svg).

* In the Database tool window , click the Add button ![the Add button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg) and navigate to `Data Source | <data_source_vendor>`.

## Overview

In the Data Sources and Drivers dialog, you can manage your [data sources](managing-data-sources.html#data_sources) and database drivers.

![the Data Sources and Drivers dialog](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog.png)

> **Note:**
> A driver is a collection that includes [database
> driver](https://en.wikipedia.org/wiki/JDBC_driver) files and default settings for creating a data source.

### Left pane controls

When you select an item from the list of data sources and drivers, settings of the item appear on the right side of the dialog.

#### Toolbar

| Item | Shortcut | Description |
| --- | --- | --- |
| ![the Add button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg) | `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Ctrl+N` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (NetBeans), `Ctrl+N` (Visual Studio), `⌘ N` (Visual Studio (macOS)), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)) |    Create a data source or a driver.                                    Android SQLite to create a data source for an SQLite database located on an Android device or emulator. An Android application module and Android SDK are required and must be defined in IntelliJ IDEA.      For more information, refer to [Android SQLite data source settings](#android).     |
| ![the Remove icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.remove.svg) | `Delete` (Windows), `⌦` (macOS), `⌦` (IntelliJ IDEA Classic (macOS)), `⌦` (macOS System Shortcuts), `Delete` (XWin), `Delete` (GNOME), `Delete` (KDE), `Delete` (Emacs), `Delete` (Sublime Text), `⌦` (Sublime Text (macOS)), `Delete` (NetBeans), `Delete` (Visual Studio), `⌦` (Visual Studio (macOS)), `Delete` (Eclipse), `⌦` (Eclipse (macOS)) | Remove the selected item or items from the list. |
| ![the Duplicate icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.copy.svg) | `Ctrl+D` (Windows), `⌘ D` (macOS), `⌘ D` (IntelliJ IDEA Classic (macOS)), `⌘ D` (macOS System Shortcuts), `Ctrl+D` (XWin), `Ctrl+D` (GNOME), `Ctrl+D` (KDE), `Meta+D` (Emacs), `Ctrl+Shift+D` (Sublime Text), `⌘ ⇧ D` (Sublime Text (macOS)), `Ctrl+D` (NetBeans), `Ctrl+D` (Visual Studio), `⌘ D` (Visual Studio (macOS)), `Ctrl+D` (Eclipse), `Ctrl+D` (Eclipse (macOS)) | Create a copy of the selected data source or driver. |
| ![the Go to Driver icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.settings.svg) | `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `Ctrl+B` (NetBeans), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `F3` (Eclipse), `F3` (Eclipse (macOS)) | Navigate to the driver settings that are associated with the selected data source. |
|    ![the Make Global icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.export.svg) ![the Move to Project icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.import.svg)    |  |    Move the selected data source to the global or project level.       For more information about global and project levels, refer to  [Data sources](managing-data-sources.html).     |
|    ![the Back icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.actions.back.svg) ![the Forward icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.actions.forward.svg)    |  | Switch between recently-used items. |

#### Context menu

| Item | Shortcut | Description |
| --- | --- | --- |
| ![the Add button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg) Add | `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Ctrl+N` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (NetBeans), `Ctrl+N` (Visual Studio), `⌘ N` (Visual Studio (macOS)), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)) |    Create a data source or a driver.       * Android SQLite to create a data source for an SQLite database located on an Android device or emulator. An Android application module and Android SDK are required and must be defined in IntelliJ IDEA. For more information, refer to [Android SQLite data source settings](#android).    |
| ![the Remove icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.remove.svg) Remove | `Delete` (Windows), `⌦` (macOS), `⌦` (IntelliJ IDEA Classic (macOS)), `⌦` (macOS System Shortcuts), `Delete` (XWin), `Delete` (GNOME), `Delete` (KDE), `Delete` (Emacs), `Delete` (Sublime Text), `⌦` (Sublime Text (macOS)), `Delete` (NetBeans), `Delete` (Visual Studio), `⌦` (Visual Studio (macOS)), `Delete` (Eclipse), `⌦` (Eclipse (macOS)) | Remove the selected item or items from the list. |
| ![the Duplicate icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.copy.svg) Duplicate | `Ctrl+D` (Windows), `⌘ D` (macOS), `⌘ D` (IntelliJ IDEA Classic (macOS)), `⌘ D` (macOS System Shortcuts), `Ctrl+D` (XWin), `Ctrl+D` (GNOME), `Ctrl+D` (KDE), `Meta+D` (Emacs), `Ctrl+Shift+D` (Sublime Text), `⌘ ⇧ D` (Sublime Text (macOS)), `Ctrl+D` (NetBeans), `Ctrl+D` (Visual Studio), `⌘ D` (Visual Studio (macOS)), `Ctrl+D` (Eclipse), `Ctrl+D` (Eclipse (macOS)) | Create a copy of the selected data source or driver. |
| ![the Go to Driver icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.settings.svg) Go to Driver | `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `Ctrl+B` (NetBeans), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `F3` (Eclipse), `F3` (Eclipse (macOS)) | Navigate to the driver settings that are associated with the selected data source. |
|    ![the Make Global icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.export.svg) Make Global     ![the Move to Project icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.import.svg) Move to Project    |  |    Move the selected data source to the global or project level.       For more information about global and project levels, refer to     [Data sources](managing-data-sources.html).  |
| Change Driver |  | Associate a data source with a driver. |
| ![the Reset Changes icon](https://resources.jetbrains.com/help/img/idea/2026.2/app-client.expui.vcs.revert.svg) Reset Changes | `Ctrl+Alt+Z` (Windows), `⌘ ⌥ Z` (macOS), `⌘ ⌥ Z` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ Z` (macOS System Shortcuts), `Ctrl+Alt+Z` (XWin), `Ctrl+Alt+Z` (GNOME), `Ctrl+Alt+Z` (KDE), `Ctrl+Alt+Z` (Emacs), `Ctrl+Alt+Z` (Sublime Text), `⌘ ⌥ Z` (Sublime Text (macOS)), `Ctrl+Alt+Z` (NetBeans), `Ctrl+Alt+Z` (Visual Studio), `⌘ ⌥ Z` (Visual Studio (macOS)), `Ctrl+Alt+Z` (Eclipse), `⌃ ⌥ ⇧ Z` (Eclipse (macOS)) | Revert changes for the selected item. |
| Load Sources |  |    Load source code of database objects for the selected category of schemas.    |
| ![the Show Driver Usages icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.search.svg) Show Driver Usages | `Alt+F7` (Windows), `⌥ F7` (macOS), `⌥ F7` (IntelliJ IDEA Classic (macOS)), `⌃ U` (macOS System Shortcuts), `Alt+F7` (XWin), `Alt+Shift+7` (GNOME), `Alt+Shift+7` (KDE), `Alt+F7` (Emacs), `Alt+F7` (Sublime Text), `⌥ F7` (Sublime Text (macOS)), `Alt+F7` (NetBeans), `Shift+F12` (Visual Studio), `⇧ F12` (Visual Studio (macOS)), `Ctrl+G` (Eclipse), `⌘ ⇧ G` (Eclipse (macOS)) | Show data sources that use the selected driver. |

## Android SQLite data source settings

Specify the settings for the SQLite database located on an Android device or emulator.

| Item | Description |
| --- | --- |
| Name | Use this field to edit the name of the data source. |
| Device |    Specify where the target database is located. This may be an Android device connected to your computer or a running Android device emulator.      If [none] is the only option in the list, connect the device to your computer or start the emulator. Unless you do that, you won't be able to configure the data source.   |
| Package name |  Specify the name of the application package the target database is associated with. For more information about application packages, refer to [Android documentation](http://developer.android.com/guide/topics/manifest/manifest-element.html#package). Select a package name suggested by IntelliJ IDEA or type its ID.    For the database to be accessible, the corresponding application must be built as debuggable and installed on the device or the emulator.       IntelliJ IDEA run configurations, by default, build Android applications in the debug mode. Alternatively, you can generate the APK in the debug mode.     |
| Storage |    Select:       * Internal if the database is stored in the internal memory of the device or the emulator.    * External if the database is stored in the external memory of the device or the emulator.    |
| Database |    If the database is stored in the internal memory, specify the database name. One of the names suggested by IntelliJ IDEA may do.      If the database is stored in the external memory, specify the database location relative to the memory root. This may be something like `Android/data/<application_ID>/<database_name>`.    |
| Download | If the necessary SQLite driver files are missing, you can download them by clicking the Download link in the lower part of the dialog.  |

## Data Sources

The Data Sources section includes settings of regular data sources and DDL data sources.

### Regular

Settings pane of a regular data source includes the following tabs: General, Options, SSH/SSL, Schemas, Advanced.

![General tab of the Data Sources and Drivers dialog](https://resources.jetbrains.com/help/img/idea/2026.2/db_connection_general_tab.png)

For more information about managing and creating regular data sources, refer to  [Data sources](managing-data-sources.html). To learn more about connection settings of a certain database, refer to the dedicated topic.

Creating and configuring data sources of different databases
: * [Amazon DocumentDB](documentdb.html)
:
: * [Amazon DynamoDB](dynamodb.html)
:
: * [Amazon Redshift](amazon-redshift.html)
:
: * [Apache Cassandra](apache-cassandra.html)
:
: * [Apache Derby](apache-derby.html)
:
: * [Apache Hive](apache-hive.html)
:
: * [Azure SQL Database](azure-sql-database.html)
:
: * [ClickHouse](clickhouse.html)
:
: * [CockroachDB](cockroachdb.html)
:
: * [Couchbase Query Service](couchbase-query.html)
:
: * [Exasol](exasol.html)
:
: * [Google BigQuery](bigquery.html)
:
: * [Greenplum](greenplum.html)
:
: * [H2](h2.html)
:
: * [HSQLDB](hsqldb.html)
:
: * [IBM Db2 LUW](ibm-db2-luw.html)
:
: * [MariaDB](mariadb.html)
:
: * [Microsoft SQL Server](microsoft-sql-server.html)
:
: * [Microsoft SQL Server LocalDB](connecting-to-sql-server-express-localdb.html)
:
: * [MongoDB](mongodb.html)
:
: * [MySQL](mysql.html)
:
: * [Oracle](oracle.html)
:
: * [PostgreSQL](postgresql.html)
:
: * [Redis](redis.html)
:
: * [Snowflake](snowflake.html)
:
: * [SQLite](sqlite.html)
:
: * [Sybase ASE](sybase-ase.html)
:
: * [Vertica](vertica.html)

#### General

The General tab includes settings that you need to specify for a database connection.

The set of fields and controls on the tab depends on the option selected in the Connection type list.

![Data Source and Drivers dialog: General tab of Data Sources settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_db_general.png)

| Item | Description |
| --- | --- |
| Connection type |    A connection type that you want to use for the database connection.       * URL only This option, generally, is for editing the database connection URL directly. When you select this option, only the following fields are available: User, Password, and URL. You should edit the URL right in the field. Your user name and password, if necessary, are specified in the corresponding fields or within the URL in the format appropriate for the JDBC driver that you are using. > **Note:** > For the URL only connection type, the JDBC URL is stored in plain text as is, and is also available in [IDE log file](troubleshooting-materials.html#locate-ide-log) and [data source information](managing-data-sources.html#share-data-sources-between-different-ide-instances).    * Other connection types When using any other of the options (the options are DBMS-specific), IntelliJ IDEA forms the database connection URL automatically using the info in the fields above the URL field. In all such cases, normally, you don't need to edit the URL (though you can if you want).   |
| Driver | Specify the driver from the Drivers list that you want to use for the connection.  |
| File |    The path to the database file.     Use the Open icon (![The Open icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.general.ellipsis.svg)) to select an existing database file.     The Save icon (![the Save button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg)) creates a copy of a database file and changes a path to the copy location.   |
| Path |    The path to the database file or folder.     Use the Open icon (![The Open icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.general.ellipsis.svg)) to select an existing database file or a folder.    |
| Host |    The hostname (domain name) or the IP address (IPv4 or IPv6) of the computer where the database is located. If the database is on your local computer, specify `localhost` or `127.0.0.1`.      If you are using SSH, the database host must be accessible by the specified domain name or IP address from the computer on which the SSH proxy runs. See [SSH/SSL tab](#sshAndSsl).    |
| Port | The database port number. |
| Database | The name of the target database or schema. |
| User | The name of your database user account. |
| Password | The password for the [database user](#user). |
| Save | Save settings for the password field. You can select the following options for storing your password:       * Never: password is prompted each time you establish a connection with a database.    * Until restart: password is saved only for the current IntelliJ IDEA run. If you exit IntelliJ IDEA and open it again, you have to provide the password again.    * For session: password is saved only for the current connection session with a database (until you disconnect from it). You can terminate the connection by pressing the Deactivate icon (![the Terminate icon](https://resources.jetbrains.com/help/img/idea/2026.2/database-plugin.icons.expui.killDataSourceProcess.svg)) or `Ctrl+F2` (Windows), `⌘ F2` (macOS), `⌘ F2` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ .` (macOS System Shortcuts), `Ctrl+F2` (XWin), `Ctrl+F2` (GNOME), `Ctrl+2` (KDE), `Ctrl+F2` (Emacs), `Ctrl+F2` (Sublime Text), `Ctrl+F2` (Sublime Text (macOS)), `Shift+F5` (NetBeans), `Shift+F5` (Visual Studio), `⇧ F5` (Visual Studio (macOS)), `Ctrl+F2` (Eclipse), `⌘ F2` (Eclipse (macOS)).    * Forever: password is saved in the IntelliJ IDEA storage. You do not need to provide the password next time you open IntelliJ IDEA.    * IDE Passwords Settings: click to access the IDE password storage settings. You can also access them by opening the Appearance & Behavior \| System Settings \| Passwords settings page `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)) . For more information about the IDE passwords settings, refer to [Passwords](reference-ide-settings-password-safe.html) topic.    |
| Create database | Adds an argument to the URL to create a database. This option is available only in some database management systems (for example, in the Apache Derby (Embedded)).  |
| URL |    The URL that IntelliJ IDEA will use to connect to the database. The user interface for specifying the URL is different depending on which option is selected in the Connection type list.       > **Warning:** > For  the URL only connection type, the URL field contents are stored in plain text, and are also available in the [IDE log file](troubleshooting-materials.html#locate-ide-log) and  [data source settings file](managing-data-sources.html#locate_the_datasources_xml_file). > > > > Use the designated fields  to provide your sensitive connection details  instead of putting them into the URL field.     |
| Test Connection | Verifies that the database connection settings are correct and IntelliJ IDEA can communicate with the database. To copy the communication information, click the Copy. |

#### Options

The Options tab includes settings of the database connection.

The set of fields and controls on the tab depends on the option selected in the Connection type list.

![Data Source and Drivers dialog: Options tab of Data Sources settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_db_options.png)

| Item | Description |
| --- | --- |
| Connection |
| Read-only |    Set the read-only status. Select the checkbox to protect the data source from accidental data modifications.      If the checkbox is selected, you cannot modify the data in the [Data editor](data-editor-and-viewer.html).      Data modifications might be possible in the [query console](query-consoles.html) if the driver does not support the read-only status.    |
| Transaction control |    Set the [isolation level](https://en.wikipedia.org/wiki/Isolation_(database_systems)) for database transactions and the mode of how the transactions are committed.      Transaction modes:       * Auto: the current transaction is committed automatically when you submit your local changes to the database server.    * Manual: changes submitted to the database server are accumulated in a transaction that can either be committed or rolled back.     The list of available transaction isolation levels depends on the DBMS.    |
| Switch schema |    Define a mode that IntelliJ IDEA uses to switch schemas.       * Automatic: switch schemas automatically or manually. When this option is enabled, the previously configured search path or the current schema are restored automatically between IDE restarts.    * Manual: switch schemas manually only.    * Disable: do not switch schemas.    |
| Time zone | Select a time zone to use with the data source. For example, select the time zone of the host that your data source is connected to. |
| Run keep-alive query each | Run a keep-alive query to keep the connection alive. You can define the custom query in the driver settings for unsupported databases. |
| Auto-disconnect after | Disconnect from the database after the specified number of seconds. |
| Single database mode |    In the database tree view, show and enable only the database that you specified in the connection settings.     When you connect to a data source, IntelliJ IDEA can retrieve and display you all the databases that the data source has. But in some cases (for example, with certain settings of PgBouncer), you can or are allowed to work only with a certain database. In the database tree view with the Single database mode enabled, you see only the database that you specified in the connection settings.      Consider using this setting for PostgreSQL, Azure SQL Database, Greenplum, Amazon Redshift.    |
| Session control |     Select one of the [modes](managing-connection-sessions.html#manage_sessions) of distributing client connections among sessions:        * Single shared session: A single session is shared across multiple clients, including introspection.    * Two sessions: shared and introspection: The IDE uses two sessions: one for introspection and the `default` session shared by all other clients.    * Dedicated sessions: Each new client creates a separate session.    |
| Startup script |    Specifies an SQL query that will run each time you establish a connection.      To use [built-in IDE macros](built-in-macros.html) in your startup script, click ![](https://resources.jetbrains.com/help/img/idea/2026.2/app-client.expui.inline.variables.svg) Insert Macros.       Note: if Dedicated sessions is selected in Session control, each new query console creates a new connection.     |
| Introspection |
| Auto sync |    Synchronize the actual state of the database automatically. The state of the database means the database tree view that you see in the   Database   tool window .     If the Auto sync checkbox is selected, the view of the data source is automatically updated:       * When you click OK in the Data Sources and Drivers dialog.    * When you run DDL SQL statements in the [query consoles](query-consoles.html) associated with the data source. Starting from version 2024.2, for Oracle and Microsoft SQL Server, IntelliJ IDEA analyzes which objects could be potentially modified by the query and only refreshes the set of these objects. > **Note:** > If the statement indirectly modifies any other objects, the IDE can miss such modifications. In this case, click ![the Refresh icon](https://resources.jetbrains.com/help/img/idea/2026.2/app-client.expui.general.refresh.svg) Refresh on the toolbar of the Project tool window to perform a complete model refresh.     If the Auto sync checkbox is cleared, the view of the data source in the   Database   tool window  is synchronized with the actual state of the database only when you click the Refresh button ![the Refresh button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.refresh.svg) or press `Ctrl+F5` (Windows), `⌘ R` (macOS), `⌃ F5` (IntelliJ IDEA Classic (macOS)), `⌘ R` (macOS System Shortcuts), `Ctrl+F5` (XWin), `Ctrl+F5` (GNOME), `Ctrl+5` (KDE), `Ctrl+F5` (Emacs), `Ctrl+F5` (Sublime Text), `⌘ R` (Sublime Text (macOS)), `Ctrl+F5` (NetBeans), `Ctrl+Alt+R` (Visual Studio), `⌘ ⌥ R` (Visual Studio (macOS)), `Ctrl+F5` (Eclipse), `Ctrl+F5` (Eclipse (macOS))) in the toolbar.     |
| Load sources for |    Load source code of views, procedures, packages and other database objects for the selected category of schemas: all schemas (All schemas), all schemas excluding system schemas (All excl. system schemas), or disable the feature (None).      To change this setting for several data sources simultaneously, select the corresponding data sources. Right-click the selection and navigate to [Load                             Sources](#load_sources_context_menu) and select an option.   |
| Default level |  Default introspection level for the database objects.   |
| Use session template | Select a [template](#session_template) to be used for your sessions. |
| Warn when editing outdated DDL | Display a notification if the cached DDL differs from the actual DDL in the database.     Every time you open source code, IntelliJ IDEA displays you a version loaded during the indexing process. But if someone changes the source code from another workstation, the indexed version becomes outdated.     If your version is older than the one in the database, you see the following notification: `Cached object differs from the object in the database`.    |
| Track databases/schemas creation and deletion | When you create, delete, or rename a schema, IntelliJ IDEA updates the list of available schemas in the introspection scope window. To see the introspection scope, click the button near the data source name in the   Database   tool window .      ![Introspection scope window](https://resources.jetbrains.com/help/img/idea/2026.2/connection_flow_show_databases_and_schemas.png)  |
|  Use pre-introspected objects for system catalogs that are not introspected |    Toggles the usage of pre-introspected objects for system catalogs.       For more information about introspection and system catalogs, refer to  [Pre-introspected objects from system catalogs](pre-introspected-objects-from-system-catalogs.html).     |
| Automatic introspection interval N minutes | Run introspection for the data source once in the specified number of minutes. |
|  Virtual objects and attributes |     Defines a path to `external-data.xml` that stores relations of virtual foreign keys, expressions of virtual columns, and statements of virtual views.        For more information about virtual database objects, refer to  [Virtual objects section topics](database-objects.html).     |
| Other |
| Code style | Select a code style that you want to use for schemas.                               For more information about code style customization, refer to  [Code styles for SQL](configure-the-sql-code-style.html).                       |
| Before connection | Select tasks that IntelliJ IDEA will perform before the first connection (at the start of a process in which the JDBC driver works). Tasks are run sequentially.    |
| Session Templates |  Create templates for your sessions. Template settings override general connection settings of a data source. In a template, you can set the following options: Authentication, Read-only, Startup script, Driver.  |

#### SSH/SSL

The SSH/SSL tab includes settings for the [SSH](#ssh) or [SSL](#ssl) connection.

![Data Source and Drivers dialog: SSH/SSL tab of Data Sources settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_db_sshssl.png)

##### SSH

|  Item  |  Description  |
| --- | --- |
| Use SSH tunnel |  Select this checkbox to enable connecting via SSH. Then   choose one of the created SSH configurations from the list, or click ![the Browse button](https://resources.jetbrains.com/help/img/idea/2026.2/app.general.ellipsis.svg) and create a new configuration  as described in [Create SSH configurations](create-ssh-configurations.html)  .   |
| SSH configuration |    Select an SSH configuration to use for the connection.     To create a new SSH configuration, click the  Add SSH configuration button (![the Browse button](https://resources.jetbrains.com/help/img/idea/2026.2/app.general.ellipsis.svg)). Alternatively, press `Shift+Enter` (Windows), `⇧ ⏎` (macOS), `⇧ ⏎` (IntelliJ IDEA Classic (macOS)), `⇧ ⏎` (macOS System Shortcuts), `Shift+Enter` (XWin), `Shift+Enter` (GNOME), `Shift+Enter` (KDE), `Shift+Enter` (Emacs), `Ctrl+Enter` (Sublime Text), `⌘ ⏎` (Sublime Text (macOS)), `Shift+Enter` (NetBeans), `Shift+Enter` (Visual Studio), `⇧ ⏎` (Visual Studio (macOS)), `Shift+Enter` (Eclipse), `⇧ ⏎` (Eclipse (macOS)).     To copy the existing SSH configuration, click the Copy button (![the Copy Configuration button button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.copy.svg)).    |

##### SSL

|  Item  |  Description  |
| --- | --- |
|  Use SSL tunnel  |  Enable settings for configuring the SSL connection.  |
| Copy from |    Copy SSH settings from the existing data source.       Click the link and select the corresponding data source.     |
| CA file |    Specify the path to the SSL Certificate Authority (CA) certificate file. The certificate file must be the same certificate as used by the server.     |
| Use truststore |    Select the truststore to use the certificates that it contains.        * IDE: Use the certificates that are accepted by the IDE. You can add new accepted certificates in `Settings \| Appearance & Behavior \| System Settings \| Server Certificates`.    * JAVA: Use JAVA truststore certificates.    * System: Use System truststore certificates.      JAVA and System certificates can require updates.    |
| Client certificate file | Specify the path to your (client) public key certificate file.  |
| Client key file | Specify the path to your (client) private key file.  |

#### Schemas

Select the databases and [schemas](http://en.wikipedia.org/wiki/Database_schema) to be shown in the   Database   tool window .

![Data Source and Drivers dialog: Schemas tab of Data Sources settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_db_schemas.png)

|  Item |  Description |
| --- | --- |
| ![the Refresh button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.refresh.svg) | Refresh the list of the databases and schemas. |
| ![the Expand All button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.expandAll.svg) | Expand all nodes in all trees. |
| ![the Collapse All button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.collapseAll.svg) | Collapse all nodes in all trees. |
| ![the Filter field](https://resources.jetbrains.com/help/img/idea/2026.2/DBSchemasSearchField.png) |  Filter the contents in trees. Only the databases and schemas whose names contain the specified text are shown. |
| Schema pattern |    Define a pattern to select the necessary databases and schemas. To get the info about the syntax to be used, place the caret into the field and press `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `Ctrl+Q` (NetBeans), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)).        * `@`: the current database or schema.    * `*`: every database or schema. You can list schemas after `*:`.      Consider the following examples:        * `*:*`: all schemas in all databases.    * `@:*`: all schemas from the current database    * `@:@`: only the current schema    * `*:dbo\|@:@\|db1:s1,s2,s3`: the `dbo` schema from all databases, the current schema, schemas `s1,s2,s3` from the `db1` database.    |
|  Object filter |    Limit the set of tables and other database objects that are shown in the   Database   tool window  for each data source.     For example, if you limit the resolve scope to `table:actor.*`, then only the `actor` table will be accessible in the   Database   tool window  ( `View  \| Tool Windows \|  Database` ).     All other tables will be out of the scope. IntelliJ IDEA does not resolve objects that are not displayed in the   Database   tool window .      ![Object is not resolved](https://resources.jetbrains.com/help/img/idea/2026.2/db_object_filter_table_not_resolved.png)    Use the following pattern when you compose an expression for the Object filter field.       `<type>:[-]<pattern>`, where:        * `<type>` might be an aggregate, collation, event, fdw, ftable, mview, operator, package, role, routine, sequence, synonym, table, user, view, vtable.    * `<pattern>` is a regular expression. To exclude an item, prepend with `-` (minus). For more information about regular expressions, refer to [Class Patterns](https://docs.oracle.com/javase/1.5.0/docs/api/java/util/regex/Pattern.html) at JavaTM 2 Platform Standard Edition 5.0 API Specification.      > **Note:** > The field only defines which objects are visible in   Database   tool window  and does not affect the introspection scope.    |
| Show internal system schemas   | Show or hide internal system schemas (for example, `pg_toast` or `pg_temp`). The option is available for PostgreSQL only. |
| Show template databases   | Show or hide template databases (for example, `template1`, `template0`). The option is available for PostgreSQL only. |

#### Advanced

![Data Source and Drivers dialog: Advanced tab of Data Sources settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_db_advanced.png)

The Advanced tab includes the database connection properties, options and environment variables for the JVM database driver.

The table on the Advanced tab displays a set of connection options that are passed to the database driver as key and value pairs.

When you select a cell in the Name column, the description of the corresponding option is shown underneath the table.

To add a row, start editing the values in the last row, where <user defined> and <value> are shown. A new row is added to the table automatically.

|  Item |  Description |
| --- | --- |
|  VM options |    JVM options for the database driver.      For certain Oracle Database versions (for example, Oracle version 9), there might be connection problems when you and your database server are in different time zones. You can specify the time offset for your timezone in the VM Option field (for example, `-Duser.timezone=UTC+03:00`). Alternatively, set the variable `oracle.jdbc.timezoneAsRegion` to `false` in the table on the Advanced tab.   |
|  VM environment |    Environment variables for the database driver JVM.      For example, encoding-related issues in an Oracle database can be solved by setting the `NLS_LANG` variable (like `NLS_LANG=Russian_CIS.CL8MSWIN1251`). For more information, refer to [Oracle                         NLS_LANG FAQ](http://www.oracle.com/technetwork/products/globalization/nls-lang-099431.html).                 |
|  Working directory |    The working directory for the process that handles working with data sources. Also, all relative paths are resolved relatively to this directory (for example, paths in driver properties).     For example, if you create a file-based database like SQLite and do not set the path for the SQLITE file, the file will be created in this working directory.    |

For more information, refer to your DBMS documentation.

### DDL Data Sources

A DDL data source is defined by its name and can reference one or more DDL files and another data source (a parent data source).

|  Item |  Description |
| --- | --- |
|  Name |  The data source name. |
|  Sources  |    List of files that contain the necessary DDL definitions.        * ![the Add button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg) `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Ctrl+N` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (NetBeans), `Ctrl+N` (Visual Studio), `⌘ N` (Visual Studio (macOS)), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)). Add a DDL SQL file or files to the data source definition. In the dialog that opens, select the necessary file or files.    * ![the Remove button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.remove.svg) (`Alt+Delete` (Windows), `⌘ ⌦` (macOS), `⌘ ⌦` (IntelliJ IDEA Classic (macOS)), `⌘ ⌦` (macOS System Shortcuts), `Alt+Delete` (XWin), `Alt+Delete` (GNOME), `Alt+Delete` (KDE), `Alt+Delete` (Emacs), `Alt+Delete` (Sublime Text), `⌘ ⌦` (Sublime Text (macOS)), `Alt+Delete` (NetBeans), `Ctrl+R, D` (Visual Studio), `⌘ R, D` (Visual Studio (macOS)), `Alt+Delete` (Eclipse), `Alt+Delete` (Eclipse (macOS))). Remove the selected file or files from the list.    * ![the Up button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.up.svg) (`Alt+Up` (Windows), `⌃ ⇧ ↑` (macOS), `⌃ ↑` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ ↑` (macOS System Shortcuts), `Alt+Up` (XWin), `Alt+Up` (GNOME), `Alt+Up` (KDE), `Alt+Up` (Emacs), `Alt+Up` (Sublime Text), `Alt+Up` (Sublime Text (macOS)), `Ctrl+Alt+Up` (NetBeans), `Alt+Up` (Visual Studio), `⌃ ⇧ ↑` (Visual Studio (macOS)), `Ctrl+Shift+Up` (Eclipse), `⌃ ⌥ ↑` (Eclipse (macOS))). Move the selected file one line up in the list.    * ![the Down button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.down.svg) (`Alt+Down` (Windows), `⌃ ⇧ ↓` (macOS), `⌃ ↓` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ ↓` (macOS System Shortcuts), `Alt+Down` (XWin), `Alt+Down` (GNOME), `Alt+Down` (KDE), `Alt+Down` (Emacs), `Alt+Down` (Sublime Text), `Alt+Down` (Sublime Text (macOS)), `Ctrl+Alt+Down` (NetBeans), `Alt+Down` (Visual Studio), `⌃ ⇧ ↓` (Visual Studio (macOS)), `Ctrl+Shift+Down` (Eclipse), `⌃ ⌥ ↓` (Eclipse (macOS))). Move the selected file one line down in the list.   |
|  Extend |     Optionally,  you can select another data source as a parent in the Extend list. As a result, the data source that you are editing inherits all DDL definitions from its parent.    If you do not want to use the parent data source, select <none>.     |

## Data Source Templates

[Data source templates](data-source-templates.html) are stored in your [JetBrains Account](https://sales.jetbrains.com/hc/en-gb/articles/208459005-What-is-JetBrains-Account).

![Data Source Templates tab in the Data Source and Drivers dialog](https://resources.jetbrains.com/help/img/idea/2026.2/db_data_source_settings_templates_tab.png)

Name
: Name of the template.

Create Data Source
: Creates a new data source using the template.

### General

Same as in the Data Sources section, excluding the User and Password fields.

### Advanced

Same as in the Data Sources section.

## Clouds

![Cloud tab in the Data Source and Drivers dialog](https://resources.jetbrains.com/help/img/idea/2026.2/db_cloud_providers_dialog.png)

### Configuration

Connection settings depend on the cloud provider.  For more information about the settings, refer to  the provider's topic in the [Clouds](clouds.html) section.

| Item | Description |
| --- | --- |
| Test Connection |  Verifies that the cloud provider connection settings are correct and IntelliJ IDEA can establish connection to the account in it.  |
|  Next: Select Databases  |  Switches to the Databases tab where IntelliJ IDEA displays databases available in the could provider account.  |

### Databases

In the databases pane of the tab, IntelliJ IDEA displays databases available in the could provider account.

| Item | Description |
| --- | --- |
|  ![the Search databases icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.search.svg) Search databases  |     Filters the databases list. Only the databases and schemas whose names contain the specified text are shown.     |
|  ![the Refresh databases icon](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.refresh.svg)  |    Refreshes the list of databases stored in the cloud provider.    |
| Create Data Source |  Creates a data source for the databases selected in the databases pane with their connection settings filled in automatically.  |

## Drivers

Settings pane of a driver includes the following tabs: General, Options, Advanced.

### General

The General tab includes settings for driver files, URL templates, and driver classes.

![Data Source and Drivers dialog: General tab of Drivers settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_drivers_general.png)

|  Item |  Description |
| --- | --- |
|  Class |  The fully qualified name of the driver class to be used. |
| Driver Files |    IntelliJ IDEA uses [JDBC drivers](https://en.wikipedia.org/wiki/JDBC_driver) to interact with a database. You can download and use a driver from the IntelliJ IDEA driver repository or specify the driver that you store on your computer.       To download and use the latest driver version, click the Download ver. N link.      You can also specify and use a driver with a particular version number. Click the ver. <version_number> link and select the driver version that you want to use. The selected version is downloaded and applied automatically.      You can use the driver that is already available on your computer. In that case, click the Add button ![the Add button](https://resources.jetbrains.com/help/img/idea/2026.2/app.expui.general.add.svg) and select the driver files (with the JAR extension).    |
|  URL templates |    The templates used to construct the database URL. The text in curly brackets represents variables. Consider the following examples:        * `{host}`: the domain name or IP address of the database host.    * `{port}`: the database port number.    * `{database}`: the name of the database or schema.      Optional fragments are in square brackets, for example, `[:{port}]`.      Template names correspond to the names of the options in the [URL option list](#db_url).   |

### Options

![Data Source and Drivers dialog: Options tab of Drivers settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_drivers_options.png)

|  Item |  Description |
| --- | --- |
| Connection |
|  Transaction control  |    Set the [isolation level](https://en.wikipedia.org/wiki/Isolation_(database_systems)) for database transactions and the mode of how the transactions are committed.        * Auto The current transaction is committed automatically when you submit your local changes to the database server.    * Manual The changes submitted to the database server are accumulated in a transaction that can either be committed or rolled back.    |
| Switch schema | Define a mode that IntelliJ IDEA uses to switch schemas.       * Automatic: switch schemas automatically or manually.    * Manual: switch schemas manually only.    * Disable: do not switch schemas.   |
| Startup script |    Specifies an SQL query that will run each time you establish a connection.      To use [built-in IDE macros](built-in-macros.html) in your startup script, click ![](https://resources.jetbrains.com/help/img/idea/2026.2/app-client.expui.inline.variables.svg) Insert Macros.       Note: if Dedicated sessions is selected in Session control, each new query console creates a new connection.     |
| Keep-alive query | A keep-alive query that will run to keep the connection alive. |
| Introspection |
| Auto sync |  The default setting for the [auto sync option](#auto_sync). |
| Load sources for |    Load source code of database objects for the selected category of schemas.    |
| Send application info |  When connecting to a database server, IntelliJ IDEA sends the info about itself if this checkbox is selected. |
| Connection |
|  Dialect |  The SQL dialect associated with the corresponding data sources.  |
| Code style | Selects a code style that you want to use for the data sources that use this driver.                       For more information about code style customization, refer to  [Code styles for SQL](configure-the-sql-code-style.html).               |
| Format synced sources | Apply the code style to source code of database objects after synchronization. |

### Advanced

The Advanced tab includes JVM options, environment variables, and options that can be passed to the database driver as key-value pairs.

To start editing a value in the table, double-click the corresponding Value field.

To add a row, start editing the values in the last row, where <user defined> and <value> are shown. A new row will be added to the table automatically.

![Data Source and Drivers dialog: Advanced tab of Drivers settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_drivers_advanced.png)

|  Item |  Description |
| --- | --- |
|  VM Options |  The default options for the JVM in which the database driver runs. The driver is started as a separate process in the JVM. |
|  VM environment |    Environment variables for the database driver JVM.      For example, encoding-related issues in an Oracle database can be solved by setting the `NLS_LANG` variable (like `NLS_LANG=Russian_CIS.CL8MSWIN1251`). For more information, refer to [Oracle                                 NLS_LANG FAQ](http://www.oracle.com/technetwork/products/globalization/nls-lang-099431.html).                         |

#### Expert options

> **Warning:**
> Use these options with caution and when required by the JetBrains support team.

| Item | Description |
| --- | --- |
| Disable incremental introspection |    Do not perform the incremental introspection. The option is available for Oracle, Microsoft SQL Server, PostgreSQL and similar databases.       With the incremental introspection, the introspector detects objects changed in the database after the previous introspection and loads only these objects.  When you enable this option, the introspector always loads all objects. It might greatly increase the introspection time.     |
| Do not use xmin in queries to pgdatabase | Do not use the `xmin` attribute in queries to the `pg_database` table. Use this workaround when `xmin` is absent in `pg_database`. Note that your database might be corrupted. The option is available only for PostgreSQL. |
| Introspect using JDBC metadata | Switch to the JDBC-based introspector. Available for all the databases.      To retrieve information about database objects (DB metadata), IntelliJ IDEA uses the following introspectors:        * A native introspector (might be unavailable for certain DBMS). The native introspector uses DBMS-specific tables and views as a source of metadata. It can retrieve DBMS-specific details and produce a more precise picture of database objects.    * A JDBC-based introspector (available for all the DBMS). The JDBC-based introspector uses the metadata provided by the JDBC driver. It can retrieve only standard information about database objects and their properties.      Consider using the JDBC-based introspector when the native introspector fails or is not available.       The native introspector can fail when your database server version is older than the minimum version supported by IntelliJ IDEA.       You can try to switch to the JDBC-based introspector to fix problems with retrieving the database structure information from your database. For example, when the schemas that exist in your database or database objects below the schema level are not shown in the   Database   tool window .     |
| Isolate class path | Isolate class path used by JDBC driver. |
| Use IDE proxy settings | Passes IDE proxy settings to JDBC process. |

### Kubernetes

> **Note:**
> This functionality relies on the [Kubernetes](https://plugins.jetbrains.com/plugin/10485-kubernetes)  plugin, which   you need to install and enable.   For more information, refer to [Open plugin settings](managing-plugins.html#open-plugin-settings).

With IntelliJ IDEA, you can connect to a database running in a Kubernetes cluster.

The Kubernetes tab is not available for embedded databases (for example, SQLite, Apache Derby, or HSQLDB) that don't have dedicated ports.

| Item | Description |
| --- | --- |
|  Use Kubernetes port forwarding  |  Enables port forwarding.  |
|  Cluster  |  Select a Kubernetes cluster to use.  |
|  Namespace  |  Select a namespace, which determines the available set of resources.  |
|  Resource type  |  Select the type of resource.  |
|  Resource  |  Select a resource to connect to.  |
|  Host port  |  Enter a local port to forward data to and from.  |
|  Container port  |  Enter a remote port of the cluster resource.  |

## DDL Mappings

![Data Source and Drivers dialog: list of DDL mappings settings](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_dialog_ddlmappings_main.png)

| Item | Description |
| --- | --- |
| Name | Name of the DDL mapping.   |
| Data Source | Sets the regular data source. |
| DDL Data Source | Sets the DDL data source. |
| Scope | Sets the scope of regular data source database objects that will be mapped to the DDL data source SQL files. |

## Problems

In the Data Sources and Drivers dialog, if potential issues with your data sources are detected, a number will appear next to the Problems menu option. Clicking Problems will show a list of the issues along with options to resolve them.

![Problems detected](https://resources.jetbrains.com/help/img/idea/2026.2/data_sources_and_drivers_problems.png)

## See also

### Language and Framework-Specific Guidelines

[Database Tools and SQL](relational-databases.html)

### Procedures

[Create a data source](managing-data-sources.html#create_a_data_source) [Data sources](managing-data-sources.html)

### Reference

[Database tool window](database-tool-window.html)