DataGrip (EAP): alte Versionen herunterladen

Data import with AI agents
We’ve extended DataGrip’s database-specific MCP tools with data import. You can now ask an AI agent to import data from files into a database table. Supported formats currently include CSV, JSON, XLSX, and Parquet. With the database-data-import skill, the agent inspects the source data, suggests column mappings, and imports the data.
For example, you can tell your AI agent, “Import films.parquet into a new films table in the public schema of mydb”. The agent creates a new films table in the public schema and populates it with data from the file.
You can also import data into an existing table. The agent can suggest how to map the source columns to the table’s columns, even when their names differ. For example: “Import more_films.csv into the existing other_films table in the public schema of mydb”.
Import also works with data from another table or a query result. For example, you can save a summary of customer payments to a separate table by giving the agent a query to run and asking it to import the result into a new table.
The agent will run the query, create a new table, and populate it with the query result.
Updated tool window bar and default shortcuts
We’ve updated the tool window bar in the window header to include icons for Database Explorer, Database Output, Files, and Agent Sessions. The default tool window shortcuts have also changed:
- Agent Sessions now uses Cmd+2 (macOS) / Alt+2 (Windows/Linux), previously assigned to Files.
- Files now uses Cmd+4 (macOS) / Alt+4 (Windows/Linux), previously assigned to Run.
- Run no longer has a default shortcut.
You can customize these shortcuts at any time via Settings | Keymap.
New Database Output tool window
We’ve moved query results from Services to the new Database Output tool window. Like Services, it opens automatically at the bottom of the IDE when you run a query, a run configuration, or an SQL file.
To show or hide the tool window, click More tool windows on the toolbar in the window header and select Database Output.
The header combines the client selector with the Output, Query Plan, and Result tabs. By default, the contents of the tool window follow the active editor tab, showing the corresponding output, query plans, and query results.
The session clients tree is now in a dropdown on the right side of the toolbar.
Session management remains available in the Services tool window. To open session details for the selected client, select Manage sessions from the client dropdown.
To switch back to the Services tool window, open the IDE Settings dialog and navigate to Database | Query Execution | Output and Results. In Show results in, select Services tool window.
Support for MariaDB packages
We’ve added initial support for MariaDB packages. DataGrip now introspects packages and their bodies, displays them correctly in Database Explorer, and loads their source code. You can generate their DDL, drop them, and refresh individual packages.
In the code editor, we’ve improved support for package syntax, including IF NOT EXISTS, type declarations, user-defined parameter and return types, routine forward declarations, and CONDITION FOR SQLSTATE declarations. DataGrip also recognizes package syntax used with the default sql_mode.
In the code editor, we've improved support for package syntax, including:
- IF NOT EXISTS clauses in CREATE PACKAGE and CREATE PACKAGE BODY statements.
- RECORD, REF CURSOR, and associative array (TABLE OF … INDEX BY) type declarations.
- User-defined types for variables, routine parameters, and return types.
- Forward routine declarations in package bodies.
- CONDITION FOR SQLSTATE declarations.
DataGrip also recognizes the package syntax of the default sql_mode (SQL/PSM).
This initial support has a few limitations:
- Some package code may still show false syntax errors or unresolved references.
- Database Explorer does not show package members, such as routines and types.
- Navigation between a package and its body is not ye

Support for MariaDB sequences
DataGrip now recognizes MariaDB sequences and displays them in a dedicated sequences group under the schema node in Database Explorer. Previously, they appeared as tables.
To keep introspection efficient:
- For MariaDB 10.3-11.4, sequence properties are not introspected.
- For MariaDB 11.5 and later, sequence properties are introspected, except for the cache size and the sequence's table properties, such as its comment and engine.
Database connections disabled in untrusted projects
DataGrip now asks you to trust an untrusted project before connecting to a database. This also applies when you click Test Connection in the Data Sources and Drivers dialog.
Connecting to a database can execute potentially malicious code, like if the connection URL, startup scripts, or driver files have been tampered with. The dialog explains this risk and lets you trust the project to proceed or stay in safe mode, where database connections are disabled.
New mode for database transactions in query consoles
Previously, DataGrip offered two transaction modes to commit transactions to a database: Auto and Manual. Now we've added a third one - Transparent.
In this mode, as in Manual mode, you commit changes explicitly. Unlike Manual mode, it does not automatically issue SQL statements to set the isolation level, re-read the current search path, or create temporary savepoints around your statements. This is so that DataGrip sends only the statements you execute.
When establishing a connection, DataGrip still reads the current search path and sets it if a different one is configured.
This mode applies to a session. If you have several query consoles attached to the same session, switching one of them to Transparent mode also switches the others. Switching any of them to Auto mode switches the others to Auto, too.
Transparent mode comes in handy when only your own statements should run in the session, like when reproducing a bug, auditing what the IDE does, or working with a server where extra statements can cause side effects or appear in logs.
Bug fixes for Manual transaction mode
- DBE-26311: Executing COMMIT or ROLLBACK commands now works the same way as clicking the Commit or Rollback toolbar buttons.
- DBE-25789: In Single shared session session control mode, the Commit and Rollback toolbar buttons are now synced across query consoles.
- DBE-11547: COMMIT and ROLLBACK statements no longer fail and leave transactions in a failed state, allowing subsequent queries to run normally.
- DBE-26753: SAVEPOINT and RELEASE SAVEPOINT statements no longer fail.
- DBE-26757: SAVEPOINT and RELEASE SAVEPOINT statements now execute without triggering introspection.

Cross-database queries
We're starting this EAP with the release of a long-awaited feature: cross-database queries. You can now query data across different data sources, even when they use different DBMSs, and view the results directly without copying the data beforehand.
To make this possible, we're introducing the Workspace data source, which is based on DuckDB and runs in memory by default, so it does not require a database file.
Each project can have one Workspace data source. In its query console, you can reference tables from other data sources using a special syntax. To add this data source, click Add on the Database Explorer toolbar and select Workspace Data Source. Its default query console opens automatically, and you can create additional ones as needed.
In the Workspace query console, you can reference tables from other data sources using the following syntax:
- To reference a table directly, specify its data source and table name. Add the database and schema when needed:
#data_source[.database.schema].table
- To filter a table, add #filter(...) to the reference:
#data_source[.database.schema].table.#filter('condition')
- You can also use #query(...) to run a query against a data source:
#data_source[.database.schema].#query('query')
In #filter(...) and #query(...), you can use $$...$$ dollar-quoted strings instead of single quotes: #filter($$condition$$) and #query($$query$$).
Type # to select a data source using code completion. Here are a few examples of the syntax in use:
- Filter rows in a referenced table:
SELECT * FROM #PostgreSQL.guest.public.customer.#filter
('customer_id > 100');
- Run a query against a referenced data source:
SELECT * FROM #PostgreSQL.guest.public.#query($$
SELECT customer_id, amount
FROM payment WHERE amount > 5
$$);
- Join data from PostgreSQL and MySQL data sources:
SELECT c.first_name, c.last_name, p.amount
FROM #PostgreSQL.guest.public.customer c
JOIN #MySQL.sakila.payment p
ON c.customer_id = p.customer_id;
DuckDB support
DataGrip now offers full support for DuckDB, including a dedicated SQL dialect, DuckDB-specific syntax and functions, code completion, and database object introspection. To add a DuckDB data source, click Add on the Database Explorer toolbar and select Data Source | DuckDB.
Three connection types are available: default, In-memory, and URL only. The default option connects to a DuckDB database file specified by its path. In-memory creates a database in memory, while URL only uses the JDBC URL you provide as is.
Ability to pin columns in the data editor
We're also adding another long-requested feature that makes the data editor even easier to use. You can now pin columns to its left side. This keeps important data visible when you scroll horizontally through wide tables.
To pin one or more columns, select them, right-click on the header, and select Pin Column or Pin Columns. You can also select Pin Columns Up to Here to pin all columns up to the one you have selected.
A blue divider separates the pinned columns from the remaining ones, which you can scroll through horizontally.
To unpin columns, right-click a header and select Unpin Column, Unpin Columns, or Unpin All Columns.
Pinning actions are unavailable if the pinned section would take up too much horizontal space, leaving insufficient room to scroll the remaining columns.

AI agent skill set for databases
We're introducing database-tools - a new AI agent skill set for working with databases. Skills define reusable procedures for AI agents. They provide step-by-step instructions for completing complex tasks using existing DataGrip features, including MCP tools. This helps agents generate higher-quality results at a lower cost. The skill set is bundled with DataGrip.
To ensure the skill set is enabled, go to Settings | Tools | AI Assistant | Skills.
Data source management with MCP tools
We're expanding the list of MCP tools that assist AI agents in working with databases more efficiently and help reduce costs. In this release, we are expanding the list of tools with two new ones: create_database_connection and edit_database_connection. These will help agents with the following tasks:
- Creating new data sources
- Running test connections
- Diagnosing connection issues
- Updating existing data source settings
To improve how agents use these tools, we have described them in the database-tools skill set.
To have an agent create a new data source, ask it to do so and provide the connection details. The agent will create the data source and run a test connection.
The data source settings contain the connection details you provided.
If you need the agent to diagnose a connection issue or update an existing data source, ask it to do so, providing the details if needed.
Improvements to MCP tools and the AI Chat tool window
- Previously, AI agents received a generic "not done" error when an SQL query failed. Now, the agent receives an actual database message with an SQL error.
- The list_database_connections MCP tool now returns database connection information correctly. Previously, incorrect handling of parameters with default values caused an output schema error.
- The database schema attachment UI in the AI Chat tool window has been redesigned.
User consent for database operations in the CLI
When you work with an agent in a command-line interface (CLI) and the agent needs to perform an operation on a database, it now asks for user consent and shows what it is about to do. The consent form supports syntax highlighting for SQL queries.
Note that for multiline queries in Claude Code, the options at the bottom of the form might not be displayed properly. The current workaround is to resize the terminal window or switch the terminal UI to the default mode by running /tui default.
The Explain Plan raw format actions are back
In the previous release, we simplified the Explain Plan dropdown by removing the Explain Plan (Raw) and Explain Analyse (Raw) actions. This change affected workflows that regularly require these actions. In this release, we have addressed your feedback by bringing back the actions and making them accessible from the toolbar.
- We have added a Raw button to the left-hand toolbar of the Query Plan tab.
For the explain plan tree, the button opens the raw explain plan in the Raw inner tab. The explain plan tree also remains available in the Operation Tree inner tab.
- We have brought back the Explain Plan (Raw) and Explain Analyse (Raw) actions. To have them in the Explain Plan dropdown, go to Settings | Appearance & Behavior | Menus and Toolbars, select Explain Plan, and click Add. Then, select the actions from the list and click OK.
Place the actions in your preferred order. They will then appear in the Explain Plan dropdown.
- When you open an explain plan in raw format by using Explain Plan (Raw), the plan opens in the Query Plan tab, too. For this format, the toolbar on the left-hand side of the tab has the Show Tree button instead of Raw.
This button opens the Operations Tree inner tab with the explain plan tree. The raw plan remains available in the Raw tab.
If you use Explain Plan and Explain Plan (Raw) actions on the same query, DataGrip opens the corresponding inner tabs next to each other in the Query Plan tab.
Bundled JDBC drivers
Previously, DataGrip didn't include any JDBC drive

AI
- AI Assistant now remembers query results from previous interactions, allowing you to fetch additional rows without rerunning the query. This also works for statements that return data with RETURNING.
- When an AI agent creates a table, a column, or any other database object, DataGrip automatically introspects the database or schema you're working with. The newly created object will appear in the database explorer right away.
- Previously, when an AI agent couldn't find a referenced database object, it couldn't tell whether the object didn't exist or simply hadn't been introspected. Now, the agent can identify missing objects, suggest similarly named objects in case of typos, and recognize objects that haven't been introspected.
- Queries run by AI agents are now also tracked and logged in the data source query history. To check them, open the data source's query console by pressing ⇧⌘F10 (macOS) / Shift+Ctrl+F10 (Linux/Windows) and selecting any query console. In the query console tab, click Browse Query History on the toolbar.
- Database-specific MCP tools no longer require the AI Assistant plugin.

CLI
Our power users often need to automate environment setups. To address that, we've introduced a command line interface that allows you to programmatically manage your database connections and drivers.
The syntax is:
datagrip dataSources <command> [options] [arguments]
Available commands: list, manage.
The new CLI uses a batch-processing approach. Instead of running one command per action, you can pass a JSON file containing multiple instructions. The tool processes them in a single session and returns the results in JSON, making it perfect for shell pipelines.
The full documentation for this feature can be found here.

Non-modal Welcome screen
The Welcome screen, which appears when you start DataGrip for the first time or after you close all projects, is now non-modal. This means it appears as a regular IDE tab instead of a modal dialog, so you can continue working with the IDE while using it.
This new Welcome to DataGrip tab opens in the automatically created DataGripWorkspace project. It provides quick actions and useful links to help you get more familiar with the IDE and configure it to suit your needs.

Redesigned empty state in the database explorer
This update also includes a redesigned empty state in our database explorer, which offers quick actions for creating data sources in a new project. It also provides PostgreSQL, MySQL, and SQLite demo databases used in our Quick start guide that you can connect to and use to get familiar with basic DataGrip features.

Interactive onboarding tour
We're introducing an interactive onboarding tour that guides you through DataGrip's core features. It covers such basics as key actions in the database explorer, the data source settings dialog, query execution in a query console, viewing and working with query result sets, and submitting changes to a database.
For demonstration purposes, the tour includes a preset H2 playground data source and a short SQL script that runs against the playground database during one of the steps.
To take the tour, go to Help | Learn IDE Features in the main menu.

Custom query console names in editor tab headers
Different workflows and tasks require different information to be available at a glance. This is why we've added the ability to customize how query console names are displayed in editor tab headers – the first place you look when identifying an open file. The customization settings are located in Settings | Database | Query Files and Consoles.
Previously, only the data source name was displayed next to the file name. Now, you can use variables to add more details, such as the attached data source, database, schema, or search path. To use a variable, place the caret where you want to insert it in the Template field and click the corresponding variable button.
If you'd like to use this template for query files, too, select Use this template for query files.

Known issues:
- DBE-25800 Dump button in SQL Generator doesn't work
- DBE-26207 One-row data extractor fails with MissingPropertyException
- DBE-26075 No output shown for Script text execution in Run Configurations

SQL expressions in the data editor
You can now set cell values using SQL expressions instead of being limited to literal values.
Previously, when editing data in the grid, you could only enter static values or use the context menu to set a cell to NULL or its DEFAULT value. If you wanted to use a database function like NOW() or gen_random_uuid(), or perform a calculation, you had to manually write and execute an UPDATE statement in the console.
With this update, we're introducing a new Expression mode in the data editor. When editing a cell, you can now right-click it and choose Edit as SQL Expression, or enable Expression mode using the fx button in the Value editor.

Enter any valid SQL expression, and DataGrip will use the result as the new cell value.

When you submit the changes, the IDE incorporates your expression directly into the generated UPDATE or INSERT statement without escaping it as a string.
You can now use SQL expressions when editing multiple cells, too.

Two-session mode
Starting from this release, you'll be able to use a new mode, Two sessions: shared and introspection, in addition to the existing Single Session and Dedicated Sessions modes.
Before, there were two separate modes:
- Default: Each new client, such as a query console or data editor, creates a new connection to the database.
- Single-session: Every time you work with a data source, you use one and only one connection. It can be turned on by selecting the Single session mode checkbox.
Single-session mode exists to support scenarios where you want to share a single connection across multiple clients. However, this may be inconvenient because the same session is used by database introspection – the process of retrieving metadata.
That's why the new mode creates two sessions: one for introspection and the other for everything else.

Database colors: v2.0
We've completely reworked the colors system.

Now not only do database colors have a fresh and consistent UI, but they also add these new features:
- Custom colors now work differently. Before, the fixed #RRGGBB hex code looked the same across all IDE themes, meaning it only looked right in either the light or the dark theme, but not both. Now, you can simply set the Hue, and the system handles the shades automatically.

- Custom colors are available for folders, as well.
- The submenu has been moved up a level, so it's easier to locate.
- We've moved the color settings from the old dialog popup to the main Settings window.
[Snowflake] Role and warehouse switcher
Switching between database roles and warehouses just got a lot faster. For those working in Snowflake, you no longer need to manually execute SET ROLE commands or dig through connection settings to change your permissions for the current session.

A new dropdown menu in the query console toolbar lets you swap between available roles and warehouses instantly.

[PostgreSQL] PostgreSQL 18 support
DataGrip now supports PostgreSQL 18, which was released last year. Full support includes the following:
- OLD and NEW resolution in the RETURNING clauses.
- WITHOUT OVERLAPS in primary and unique constraints.
- PERIOD in foreign key constraints.
- GENERATED ALWAYS AS (...) [STORED | VIRTUAL] for columns.
- NOT ENFORCED and NOT VALID constraints.
Bug fixes
For a full list of bug fixes and improvements, please refer to the release notes.

Data Source and Drivers dialog improvements
We have made a few changes to the Data Sources and Drivers dialog.

1. The Data Sources, Clouds, Drivers, and DDL Mappings sections are now the main tabs in the dialog, located on the left-hand side.
2. If the Comment field is empty, it is hidden by default. To display it, click Add Comment next to the Name field.
3. For the Driver dropdown, if the selected driver has not been downloaded, DataGrip shows a corresponding comment. To download the driver, click Download near the dropdown.
4. The Connection type dropdown options are now tabs. If a data source has more than three connection types, they are displayed as a dropdown.
Also, the Create DDL Mapping action has been removed. You can create a DDL mapping on the DDL Mappings main tab.
Files are created with the SQL dialect and data source attached
When chatting with AI Assistant in the AI Chat tool window, you can create a file from a code snippet.

If there is any context about the SQL dialect, a data source, or a schema provided in the chat, you don’t have to attach any of those or set the dialect because DataGrip will do this automatically. The same goes for questions about a file that already has a data source attached: DataGrip will attach that data source to the newly created file.

DataGrip will store the created file in the current project directory.
[Oracle] Intention action for suppressing the resolve inspection for back label references
We have made the Suppress for back label references option easier to find and use. Previously, it was only available in the Settings dialog under Editor | Inspections | SQL.

Now, it can be toggled in intention actions. To enable or disable it, open the list of intention actions by clicking Alt+Enter (Windows/Linux) or Option+Enter (macOS), navigate to Enable option “Suppress for back label references”, and select or deselect the Suppress for back label references checkbox.

Execute Selection as Single Statement action in the context menu
We have added the Execute Selection as Single Statement action to the context menu of a code selection. Use this when you need to execute a certain chunk of code and DataGrip isn’t parsing it properly.

Query Files folder in the database explorer
You can access your query files in the database explorer. We have added a Query Files folder that appears under each data source node. To toggle this folder's visibility, click View Options on the tool window toolbar, and then select or deselect the Query Files option.

Explain Plan
We have made a few updates to the Explain Plan workflow to make it more discoverable, informative, and easy to use:
- The list of options in the Explain Plan dropdown on the code editor toolbar has been shortened. Now it only has Explain Plan and Explain Analyse on it.

- In the Services tool window, the Query Plan tab that displays the plan has been moved to the same level as the Output and Result tabs. It also has a new icon now.

- In the Query Plan tab, you can now view details of each plan row in a separate panel on the right-hand side of the tab.

- For the cells that contain a table name, quick documentation is available in a popup when you hover the cursor over it.

- The different views available for a query plan are displayed in separate inner tabs. These inner tabs can be seen at the bottom of the Query Plan tab. They are hidden by default and appear only when more than one tab is open. To open the Total Cost or Startup Cost tab, click Flame Graph on the left-hand toolbar and select the view you need.

- You can now copy the query plan in the database’s native format, for example, JSON or XML. To do this, click the Copy Original Query Plan button at the top of the left toolbar. This is supported for PostgreSQL, Amazon Redshift, MySQL, MariaDB, Oracle, Microsoft SQL Server, and Snowflake.

[Microsoft SQL Server] Support for JSON indexes
DataGrip now supports creating and modifying JSON indexes for Microsoft SQL Server. You c

This is the 2025.3 Beta. Please try it out and share your feedback with us!

Redesigned folders in Database Explorer
We have redesigned the folders that are used in Database Explorer. Previously, they were virtual and were not stored anywhere. Since these folders are essentially groups but not directories, their configuration information is now stored in .idea/db-forest-config.xml. You can add this configuration file to the VCS to share it with your colleagues, or you can also ignore it in the VCS. Any folders you may already have will be automatically converted to the new configuration.
In Database Explorer, you can arrange your folders in any way that works for you, as they are not sorted alphabetically. To do this, use the Move context menu action group or the corresponding shortcuts.

To create a new folder at the highest level, click New on the toolbar and select Folder. To create a new subfolder, select New | Folder in the relevant folder's context menu. A folder's name is not considered an identifier, so you can have two folders with the same name inside the same folder.
[Snowflake] Support for classes
Snowflake database functionality now supports Classes, including the following:
- Introspection of built-in classes and methods, as well as class instances.
- Parsing of DDL statements for class instances, related SHOW statements, and the foo!bar() syntax for method calls.
- Resolution of references to classes, class instances, and methods.
- Parameter info and signature inspection for method calls.

[Microsoft SQL Server] Support for VECTOR and JSON data types
We've also added support for the VECTOR and JSON data types that were introduced to Microsoft SQL Server 2025 earlier this year. These data types are now available in code completion suggestions, where they are highlighted properly, and you can also use them in the Create and Modify dialogs.

[Redis] Keys of different types in one group
We’ve added support for hierarchical Redis keys. Now, you can specify a separator, like :: or :, and keys will be displayed in the database explorer using a directory structure. For keys with names like user::<segment_01>::<segment_02>, the view is as follows:

To enable this view, specify a key separator on the General tab of the Data Sources and Drivers dialog.

Azure and Google Cloud support
We have added Azure and Google Cloud support to our cloud connection functionality. Now you can connect to your cloud account from DataGrip, discover the databases stored in it, and create data sources for any of them within the same Data Sources and Drivers dialog.
To connect to your account, navigate to New | Data Source from Cloud Provider and select the cloud you want to connect to.
For now, you need to have the Azure Cloud Explorer plugin installed to use the Azure support.

[Amazon Redshift] Introspection levels
This release adds the introspection levels feature to DataGrip’s Amazon Redshift functionality. With this feature, DataGrip automatically adjusts the amount of metadata loaded for a database based on its size, which can save you a significant amount of time because you don’t have to worry about large databases slowing things down. You can also select a different introspection level for each schema based on your task requirements.

Bug fixes and improvements
- DBE-23109: The Data Sources and Drivers dialog shortcut Cmd+; / Ctrl+; in query files now works as expected.

AWS cloud support
DataGrip now works with cloud database providers! From now on, you can connect your AWS account to the IDE, browse the list of databases you have in it, and choose the ones you’d like to connect to. DataGrip will create a new data source, filling in all connection details. Support for Azure and Google Cloud is to follow.
To connect to your AWS account, click New | Data Source from Cloud Provider | AWS.

All the cloud databases connected to your IDE are displayed in the Cloud tab of the Data Sources and Drivers dialog.

Explain Plan button on the query file toolbar
We have made the Explain Plan actions more accessible. Now you can click the Explain Plan button right on the query file toolbar to access them.

Action for the Migration to Query Files dialog
We recently bid farewell to query consoles, migrating them to query files. Originally, the migration dialog appeared in projects whose consoles had not yet been migrated. We’ve now added a Migrate Query Consoles to Query Files context menu action so you can access the dialog even if query files already exist in your project. The action is available in any query console left in a project. You can use it, for instance, if you chose not to migrate your consoles at first, or if you had only converted some of them back then and now need to migrate others.

[Microsoft SQL Server] Clustered and nonclustered columnstore indexes support
DataGrip now supports creating and modifying clustered and nonclustered columnstore indexes for Microsoft SQL Server. You can work with them in code generation and also use the indexes in the Create and Modify dialogs.

Bug fixes and improvements
- DBE-24279: Custom database drivers now work as expected.
- DBE-14950: [Oracle] Code highlighting now works for the following functions: ANY_VALUE, RAW_TO_UUID, SKEWNESS_POP, SKEWNESS_SAMP, STANDARD_HASH, UUID, UUID_TO_RAW, and VALIDATE_CONVERSION.

AI Assistant explanation for query plans
You can ask our AI Assistant to explain your query plans. To do this, right-click your query and go to Explain Plan | Explain Plan or Explain Plan | Explain Analyse. The plan will appear in the Plan tab of the Services tool window. On the left toolbar of the tab, click Analyze SQL Plan with AI (experimental). AI Assistant will then provide an explanation in the chat, where you can ask any additional questions you might have about the plan.
To use this feature, you need to have the AI Assistant plugin installed in your IDE.

AI Assistant query optimization
AI Assistant can now optimize your query for better performance and efficiency. It does this by:
- Automatically detecting inefficiencies such as redundant JOIN, missing indexes, or suboptimal execution plans.
- Providing actionable suggestions or automatically rewriting queries to improve performance.
- Leveraging Explain Plan outputs for deeper analysis and diagnostics.
You can ask AI Assistant to optimize your query by right-clicking it and selecting AI Actions | Optimize query with AI (experimental). AI Assistant will then give you a list of suggestions in the chat, and you can continue to ask any questions you might have there.

To use the AI Assistant query optimization feature, you need to have the AI Assistant plugin installed in your IDE. This feature may require you to attach the database schema so that it can suggest proper optimizations.

Main menu redesign
We have restructured and improved the main menu by clearing out some of the clutter and keeping only the most useful actions, such as Reformat Code, Recent Changes, Jump to Query File, and Show Query History. Now it is easier to find and invoke the actions you most often need.

Bug fixes and improvements
- DBE-23105: [PostgreSQL, Amazon Redshift] Unsupported statements can be run in the code editor.
- DBE-23733: [Oracle] CLOB 2GB+ files are now uploaded as expected.
- DBE-23480: [PostgreSQL] [CONCURRENTLY|FINALIZE] in DETACH PARTITION is now supported.
- DBE-24078: [PostgreSQL] Fixed missing quotes when passing array item types to the driver.
- DBE-10208: [Cassandra] Types without codec recognition now work as expected.
- DBE-23944: Metadata checking for a single table case has been improved.
- DBE-24182: [PostgreSQL] The Request and Copy Original DDL action now works as intended.
- DBE-23615: The Execute button in the Parameters dialog for user parameters has been fixed.

A Farewell to Consoles
- We've merged consoles and files.
- A migration dialog will help you transfer all your consoles to files and guide you through the new workflow.
- Query files are now saved in the queries folder within the project folder.
- Files with an attached database context now show a data source–like icon instead of the generic database icon used before.
- The Jump to Query File button on the Database Explorer toolbar lists all query files associated with the current data source.
- The old Database Consoles folder under Scratches and Consoles will remain for one more release cycle.
To learn more, read the blog post.

[PostgreSQL, Microsoft SQL Server] Introspection by levels
We are expanding the implementation of introspection by levels to more databases - this time, PostgreSQL and Microsoft SQL Server! DataGrip now automatically adjusts the amount of metadata loaded for these databases based on your database size. This means that for a larger database, you don't have to wait till all the metadata is loaded to start working with it.

Ability to attach database objects to the AI chat
The database context you provide to the AI chat can now be more specific. Previously, only the whole schema could be attached. Now, you can attach the database object you need to work with - for example, a table or a view. This can be particularly useful when you're working with larger schemas.
To attach a database object, type @ or # in the input field, select or type dbObject:, then select the object you want to attach from the list.

Cloud-based code completion
DataGrip now supports cloud-based code completion. It uses cloud resources to offer more precise code completion, leveraging greater computational power than local resources can provide. This feature allows the IDE to autocomplete single lines, blocks of code, and even entire scripts in real time based on the available context. The generated SQL is similar to how you would write your statements, matching your style and naming conventions.
With cloud-based code completion, DataGrip shows suggestions in the editor as you type, and you can also invoke them by pressing Option + Shift + \ (macOS) or Alt + Shift + \ (Windows/Linux). To disable this feature, go to Settings | Editor | General | Inline Completion, and then deselect the Enable cloud completion suggestions checkbox.
To use the cloud-based code completion feature, you need to have the AI Assistant plugin installed in your IDE. Once the plugin is installed, the feature is enabled by default.

Editable results for SELECT queries with JOIN clauses
After a decade in the works, this long-awaited feature is here! Previously, the result set grid for the SELECT queries with JOIN clauses was read-only. Now, you can run such queries, view the result set, and then edit cell values right in the query results grid. To do this, simply double-click a cell or select it and press Enter. Also, just as in any other grid, you can right-click the cell and select Open in Value Editor to edit the value in a separate pane that opens on the right.
The data editor allows you to edit the values both in the in-editor results and in the Services tool window. Once you edit a cell value, the following buttons become active on the Result tab's toolbar in the Services tool window: Revert Selected, Preview Pending Changes, Submit.

An additional toolbar with those buttons also appears at the bottom of the in-editor results pane.

When you submit your changes to the database, DataGrip displays the DML Preview dialog for you to check the generated statements first. To edit your changes, click Cancel and proceed with editing. To submit the changes, click Submit.

This feature is not supported for the SQL UNION operator, table self-join operation results, result sets with calculation result columns (for example, CONCAT), or NoSQL databases. To ensure proper results, the feature also requires a way to uniquely identify rows.
Grid heatmap
In the data editor, DataGrip now provides grid heatmaps with two color-scheme options, Diverging and Sequential. To enable the heatmap for your grid, click Table Coloring Options on the toolbar and select one of the schemes.
The Diverging color scheme emphasizes variation relative to a norm. It consists of two contrasting colors that deviate from a central value in two opposite directions.

The Sequential color scheme consists of a single color or a range of closely related colors that vary in intensity.

You can apply the heatmap color schemes to the whole table or to each column separately, or you can use coloring only for Boolean values.
One action for clearing all local filters in a grid
Now, you can clear the local filter for all columns in your grid using just one action. To do this, invoke the Find Action popup by pressing Cmd + Shift + A (macOS) or Ctrl + Shift + A (Windows/Linux), start typing Clear Local Filter For All Columns, and then select the action from the list.

[PostgreSQL] Smart refresh
DataGrip now supports the smart refresh mechanism for PostgreSQL databases. Previously, the IDE automatically refreshed the whole schema in the database explorer every time a DDL statement was executed. With the smart refresh mechanism implemented, DataGrip analyzes which objects could be potentially modified by the query and refreshes that specific set of objects only.
This means that if your database contains many objects, you do not have to wait for an extended period while the whole schema is refreshed each time you run a DDL statement. Since only one specific set of objects is synchronized, you can get back to work much more quickly than if every object needed to be refreshed and still have everything you need right in your database explorer.
[SQLite] WSL database file path
After much anticipation, DataGrip now supports WSL file paths for SQLite database files. We have implemented a solution to address the write-locking issue in WSL on our side. This means that you can now access your SQLite database under WSL and work with it without the database file being locked for you. To do this, go to the Data Sources and Drivers dialog and use the following file path format: \\wsl$\<os>\home\<username>\<database_file_name>.sqlite. For example, \\wsl.localhost\Ubuntu-24.04\home\alexey\identifier.sqlite.

[MongoDB] Support for read preference and replica set connectivity settings
You can now set the way read operations are routed to the members of a MongoDB replica set, and even define which replica set should be used. To do this, while configuring the connection to your MongoDB database, go to More Options and enable the corresponding option in the Data Sources and Drivers dialog. Once you select either of them from the list, a new field appears for you to specify the setting. To specify your desired read preference, select the one you need in the Read preference field. To define your replica set, simply type its name in the Replica set field.

Floating toolbar
DataGrip now displays a set of context-based and AI-driven actions available for a piece of code in a floating toolbar. Select any code in your code editor to make the toolbar appear. To customize the floating toolbar, use the kebab menu (three vertical dots). To hide it, you can either use the same menu or go to Settings | Advanced Settings | Editor and check the Hide floating toolbar for code editing option.

Bug fixes and improvements
- DBE-23330: The PostgreSQL formatter now supports specific statements of PostgreSQL-based dialects.
- DBE-22980: [Amazon Redshift] The CREATE RLS POLICY syntax for creating new row-level security policies is now supported.
- DBE-10415: The Cancel Running Statement button is now displayed when hovering over a query run progress icon in the gutter.
- DBE-23303: The query log in the Services tool window now displays the query start and query end timestamps.
- DBE-15068: SQL files remain attached to a data source after IDE restart.
- DBE-22215: Find Usages now works as expected.
- DBE-14636: [PostgreSQL] PostGIS aggregate functions are now supported.
- DBE-20895: [Snowflake] The new syntax support for the PIVOT and UNPIVOT commands now works as expected.
- DBE-22953: [BigQuery] Pipe query syntax is now supported.

Support for more cutting-edge LLMs
JetBrains AI Assistant is leveling up! We've added support for Claude 3.5 Sonnet and Claude 3.5 Haiku, provisioned in Amazon Bedrock. This means sharper responses, faster insights, and an even smoother experience.
We're also expanding the lineup of LLMs used by AI Assistant to include OpenAI's o1, o1-mini, and o3-mini, providing more versatility and speed. Whether you need deep analysis or quick yet well-considered insight, AI Assistant in DataGrip is up to the task like never before!
Support for loading full cell values in place
DataGrip has a setting that limits the amount of data that's loaded in each cell. This is designed to improve performance when there is too much data in your tables. Partially loaded cells look like this:
But in some cases, you need to load all of the data, and now that's possible! To do this, hover over the cell and click Reload Cell on the quick actions popup toolbar.
[SQL Server] .NET JDBC driver by JetBrains: Shared memory support
This JDBC driver was initially developed by the Rider team. From this release, it's also available in DataGrip.
The main feature of this driver is its support for the shared memory protocol. This protocol is used by clients to connect to the SQL Server instance that is running on the same machine. SQL Server's shared memory protocol is the simplest protocol, as it has no configurable settings that need to be tuned in order to use it.
[Oracle, SQLite] Suggestion to switch to single session mode when using temporary tables
When creating temporary tables, DataGrip now suggests you switch to single session mode. This mode will allow you to see these tables in the database explorer.

Support for tilde in path fields
We have supported the use of the tilde (~) in the path fields for SSL and BigQuery key and certificate files. Now, you can use the character to specify directories in the Data Sources and Drivers dialog. To do that for your SSL connection, open the dialog by pressing Cmd+; (macOS)/Ctrl+;(Windows/Linux), and select the data source you want to change the settings for. Then open the SSH/SSL tab and navigate to the SSL section.

[PostgreSQL, MySQL, MariaDB] Geo type data display
For the PostgreSQL, MySQL, and MariaDB spatial databases, DataGrip can now correctly display geo types raw in the grid.

Fixes
- DBE-20795: [Snowflake] ASOF JOIN syntax is now correctly interpreted.
- DBE-21374: Excel file import for larger files now works as expected.
- DBE-2570: [SQLite] DATETIME field data is now stored in TEXT format by default.
- DBE-9253: [Microsoft SQL Server] Execution of the currently selected query now works as expected.
- DBE-22637: The Shift + Enter shortcut behavior now works as intended.
- DBE-17082, DBE-17969: [Oracle, IBM Db2 LUW] The Enable DBMS_OUTPUT setting now works for existing consoles. The setting is now available in the IDE settings dialog and on the query console toolbar.
- DBE-12894: JOIN autocompletion now works as expected.

Hello! We are starting the EAP program for version 2025.1. This is the perfect opportunity to try new features before the official release and share your feedback with us.
Introspection by levels for MySQL and MariaDB
We're continuing our work to enhance introspection performance. Starting from 2025.1, there will be different introspection levels for MySQL and MariaDB, adjusting the amount of metadata that gets loaded depending on the size of your database. In other words, we won't load all the metadata if your database is large. This will greatly reduce introspection time and allow you to start working with newly connected data sources right away.
What are the introspection levels?
Level 1
- Icon:
- Metadata loaded: Names only.
- Main missing features: Modify Table, foreign key navigation, Find Usages, the ability to search in the text of views and procedures.
Level 2
- Icon:
- Metadata loaded: Everything except the source code of functions, procedures, views, events.
- Main missing features: Find Usages, the ability to search in the text of views and procedures.
Level 3
- Icon:
- Metadata loaded: Everything, just as in previous versions.
- Main missing features: None, all features are working as expected.
DataGrip now prioritizes the user experience and performance over the comprehensiveness of functionality. The default introspection level value is set to Auto select, which means that DataGrip uses an internal heuristic to detect how much metadata needs to be loaded.
For now, this heuristic looks like this:
Current schema:
- Level 1 when the number of schema objects is greater than 3000.
- Level 2 when the number of objects with sources is greater than 500.
- Level 3 in all other cases.
Other schemas:
- Level 1 when the number of schema objects is greater than 300.
- Level 2 when the number of objects with sources is greater than 50.
- Level 3 in all other cases.
We are considering whether to adjust the heuristic or even make it customizable.
By default, DataGrip will automatically set the introspection level. If you want to restore DataGrip's previous behavior, go to Data Source properties | Options | Introspection | Default level and select Level 3.
You can also manually select a level if you think that will maximize DataGrip's performance for your use cases.
To summarize, you should no longer experience any significant performance problems related to MySQL / MariaDB introspection. If you do, please let us know about them via our issue tracking system.
Attached schemas in the Explain with AI chat
Explanations of your queries are more effective with the full context! Now, when you ask AI Assistant to explain a query, the corresponding schema is automatically attached to the chat.
[Oracle] The ability to connect with a specific role
DBE-96 has been fixed. It's not every day we close a ticket with an ID less than 100! Starting with 2025.1, you can connect to Oracle and define the specific role for the connection in the connection dialog.
Simply select the desired role from the Authentication drop-down list:
The ability to download drivers from Maven
Version 2025.1 allows you to add custom repositories for downloading drivers. To do so, add the repositories you need to the mirrors attribute of the HOME_PATH/.m2/settings.xml file.
Important fixes
- DBE-9626: The color used for a data source is now applied to the attached file tab.
- DBE-21934: Value completion in the data editor inserts the correct string.
- DBE-18569: The Cancel button works as intended when downloading drivers.
- DBE-15201, DBE-20350: [SQL Server] Stored procedures and system objects are qualified with the relevant schema names if the corresponding setting is enabled.
- DBE-22250: [Snowflake] It is possible to remove Role and Schema after they've been added to the connection parameters.
- DBE-21514: [Oracle] Aliases are inserted for code completion of synonyms.
- DBE-17959 [PostgreSQL] UNIQUE NULLS NOT DISTINCT is now supported.

SQL error handling by AI Assistant
We have implemented a couple of useful actions for handling SQL query execution errors with AI Assistant. Now, for each error message, DataGrip shows two actions on the far right-hand side of the error message: Explain with AI and Fix with AI.

Explain with AI opens the AI chat, sends an automatic prompt, and gives you AI Assistant's explanation of the error.

Fix with AI generates a fix for the query execution error in the editor.

These two new actions work similarly to the Fix SQL Problem Under Caret and Explain SQL Problem Under Caret intention actions.
This feature requires attaching the database schema to suggest proper explanations and fixes.

[MySQL, MariaDB] Fragment introspection and smart refresh
DataGrip now supports fragment introspection for MySQL and MariaDB databases. With this feature supported, the smart refresh mechanism is now available for these databases, as well. Smart refresh allows the IDE to analyze which objects could potentially be modified by the query and refresh only those specific objects.
[Oracle Database] Auto-completion for the named parameters list
For Oracle databases, you now can use auto-completion for the named parameters list when calling a method with parameters. To do this, invoke the auto-completion popup by pressing Ctrl+Space, select the option that lists all parameters, and press Enter to insert it. Then, press Tab to go through the parameters.

[Google BigQuery] Table-valued functions support
We have improved the support for table-valued functions in BigQuery. Now, DataGrip properly detects both the TVFs and their return columns.

Text-to-SQL: in-editor diff for generated results
We have improved the experience of asking AI Assistant questions in the editor.

Now, when you ask AI Assistant to do something with a chunk of code, the editor area contains a diff with both the original and the generated code. AI Assistant's suggestions are highlighted with a different color and marked with the Revert icon in the gutter. You can also edit the resulting query yourself in the same area. Your changes are highlighted the same way.
For example, you can ask AI Assistant to retrieve more data with a query and then add an ORDER BY clause to the generated result.

Floating paging
To make the grid paging more noticeable in our data editor, we have moved it from the data editor tab toolbar to the bottom center.

In-editor results width
Previously, the width of the in-editor results grid was limited. Now, the grid adjusts to use the full width of your editor, allowing you to view more data.

Inspection for an excessive number of JOIN clauses
In certain cases, it is forbidden to run a query that contains an excessive number of JOIN clauses due to performance degradation. The editor can now identify and highlight such queries.
You can enable this inspection in the IDE settings. To do so, navigate to Editor | Inspections, expand the SQL section, and select Excessive JOIN count.

[SQL Server, Oracle] Smart refresh
DataGrip automatically refreshes the schema in the database explorer every time a DDL statement is executed. This applies when the Auto sync option is turned on in the data source properties.
This process could take a significant amount of time when the database contains many objects, for example, with Oracle databases, where the system catalogs are very slow.
Starting from the 2024.2 version, this refresh mechanism is more efficient than before. DataGrip now analyzes which objects could be potentially modified by the query and refreshes that specific set of objects only.
Important! Although we make every effort to ensure that DataGrip successfully detects modified objects in the majority of cases, if the statement modifies other objects indirectly, DataGrip may miss such modifications. For example, when dropping objects with cascade options or modifying tables used in procedures or functions. In this situation, you can call the Refresh action to make DataGrip perform a complete database refresh.

Mentioning database schemas in AI Assistant chat
You can attach your database schema to the AI Assistant chat by mentioning it in your prompt. To do this, enter your prompt using # followed by the database schema name, for example, “Give me the query to get all actor names from #public.”

AI Assistant will then analyze your schema and generate the query.

This feature is particularly important for other JetBrains IDEs, as they have no other way of attaching database schemas to the AI chat.
Other improvements
- DBE-20957: [Snowflake] DataGrip now supports INTO clauses in SELECT statements.
- DBE-20741: [ClickHouse] PARTITION BY clauses now support multiple expressions.
- DBE-19368: The IDE no longer displays double editor notifications.
- DBE-20947: [ClickHouse] COMMENT clauses for materialized view columns are now supported.
- DBE-19730: [PostgreSQL] Introspection for PostgreSQL 16 works as expected.

Scripted loaders
You can now import data from your tabular data files. We've implemented scripted loaders to enable importing for the following file formats: Excel, JSON, Parquet, and Shapefile.
The loaders are scripted, which means you can write and use your own custom ones. To add custom scripted loaders, place them in their specific directory in Scratches and Consoles | Extensions | Database Tools and SQL | data | loaders.
To import the data, drag your file from the Files tool window to the schema in the database explorer, and configure the import settings in the Import dialog.

Additionally, DataGrip can now display the contents of your tabular data files in the data editor. To open the files, simply click them in the Files tool window. To disable the feature, go to Settings | Advanced Settings, find the Open file as table if detected by scripted loader setting, and select None.

Related Rows in floating toolbar
Now, you can get to related rows much easier by using the table cell's floating toolbar. Just click the cell and then click the Related Rows (key) icon on the floating popup toolbar.

To remove this action from the floating toolbar, open the toolbar, click More, and then select Customize This Toolbar. In the Customize Grid Floating Toolbar dialog, select the action, and click Remove. You can restore the action by going to Settings | Appearance & Behavior | Menus and Toolbars, selecting Grid Floating Toolbar, and then clicking Add.
We have also simplified the flow of this action. Previously, its behavior options would appear in a popup window after selecting an action in a cell's context menu. We have now moved the behavior options to the Related Rows action behavior selector, which you can find under Settings | Advanced Settings. The Navigate And Select First option will select the first referenced rows and show all the rows in the table. The Navigate And Filter All option, on the other hand, will show the referenced rows only.
AI Assistant features
Generate code in editor
Ask AI Assistant to generate SQL code right in the editor. To do so, click the Generate Code with AI button on the editor toolbar and enter your prompt. An example prompt might be: "Add commands that will create a books table and populate it with three sample rows".

After AI Assistant generates the code, you can accept the generated code, regenerate it, or specify your prompt by clicking the corresponding buttons at the bottom of the suggestion pane. You can also take the generated code to the AI chat to ask AI Assistant any questions you may have about the code.

Modify tables
AI Assistant can now help you with modifying tables. In the Modify dialog, click the UI AI Assistant button to invoke the UI AI Assistant dialog. In the dialog, simply ask AI Assistant to do what you need, for example, "Switch all the VARCHAR data types to CHAR". Once AI Assistant generates the requested code, you will be able to view and edit it in the preview pane of the dialog.

Explain and fix SQL problems using intention actions
Now, you can use AI Assistant to better understand and fix SQL problems. For any problems with a severity level higher than Weak warning, AI Assistant will suggest an explanation and a fix. To get an explanation, invoke the intention actions by selecting the highlighted code and pressing Alt/Opt+Enter, selecting AI Actions, and then Explain SQL problem under caret. AI Assistant will then provide the explanation in the chat.

To fix the problem, in the AI Actions popup window, select Fix SQL problem under caret.
This feature can require attaching the database schema to suggest proper explanations and fixes.

Improved Database tab in Search Everywhere popup
We've enhanced the Database tab in the Search Everywhere popup! You can now filter search results by the database object type. Enter / followed by the object type, then type the object name. For example, entering /tables will result in a list of introspected database tables, and /tables film will find the tables that have "film" in their names.

CVE-2024-37051
Fixed security issue related to JetBrains GitHub Plugin. For more details, please refer to the blog post.

We're starting the Early Access Program for DataGrip 2024.2 and, as usual, we invite you to try the latest features and improvements ahead of the official release.
Let's take a look at what's inside the first EAP build.
Geographical data viewer for tabular data files
Our Geo viewer lets you explore the geographical data stored in CSV and XLSX files, as well as in files with other supported formats.

[Snowflake] Support for Iceberg, dynamic, and hybrid tables
Iceberg, dynamic, and hybrid Snowflake tables are now introspected and displayed in the database explorer.

IDE macros for connection startup scripts
It's now possible to use built-in macros in your connection startup scripts. To add a macro to the script, go to File | Data Sources, select your data source, and open the Options tab. Then navigate to Startup script and click Insert Macros.
For example, if you need the OS username of the user who initiates a connection, you can use the OSUser macro in your script: ALTER SESSION SET QUERY_TAG = '$OSUser$'.

Other improvements
- DBE-19185: Various SSL key types are now supported.
- DBE-20604: PAC proxies are now supported.
- AI Assistant's performance with large database schemas has been improved.

Simplification of sessions
Over the last few years, we've received tons of feedback from users who say that they don't understand the concept of sessions and that this functionality has contributed significantly to DataGrip's learning curve. Here are several examples:
- The project-first and separate-console-session model is way over the top overkill. This model makes opening and executing a simple SQL file a real chore. If I just want to open and execute a script I have to first create a project, then add the file to the project, then open a console, then open a session, and then attach the file to the session. What a gigantic PAIN.
- Coming from SQL Server Management Studio, DataGrip's UI is a lot more complex. In SSMS you basically just have servers, queries and results. In DataGrip there's sessions and consoles and scratch files, etc., etc., making the tool much less intuitive for new users.
- Some of the way the UI works is clunky and non-obvious. When I have to select a console to run a script on, it's not entirely clear to me why I have to do this or what the ramifications of the selection are. This shouldn't really be the default behavior.
In DataGrip, "session" is a technical term that refers to the container for a connection. In other words, connections can be established, stopped, and re-established within one session. For each connection, there is one session.
The ability to attach sessions is a powerful mechanism, but in the majority of cases, users just need to set the context (data source and database or schema) for the queries to be run.
Starting from version 2024.1, users will no longer need to manually choose which session to run queries in, and this will be the case for all types of queries. Sessions are still there under the hood, but you won't need to worry about them.
Let's take a deep dive into how this change affects DataGrip's main use cases.
Attaching and switching data sources
To attach a file, you now simply need to select the data source, rather than the session. After selecting the data source, you choose the schema.
Switching sessions
The Switch Session action now only appears in the client context menu in the Services tool window. It allows you to switch the session only within the current data source.
Running functions
You no longer need to select a session before launching a function. In the function launch window, a Run From option allows you to select the console or file from which the function will be launched.
Record view
You can now focus on one record in the data editor. To open a record view, use the shortcut Ctrl/Cmd+Shift+Enter or the Show Record View button on the toolbar:
A record view will open in the side panel, where the value editor and aggregate view are located:
The cells in record view are editable if they are editable in the main grid.
Code completion: custom symbols to accept suggestions
We've added to specify which symbols you will use to accept code completion suggestions, allowing you to write SQL even faster.
To make this work, you need to enable two options.
This one:
And this one:
This feature can be especially useful when using operators:

Local filter in the data editor
A long-awaited feature is finally here: you can now filter rows by values in columns.
This will obviously not send a query to the database, so it's fast, but keep in mind that the filter affects only the current page. If you want to filter more information, just change the page size or even fetch all the data.
If you want to turn off all the local filters on the current data editor, use this icon:
And don't forget about the local text search function Ctrl/Cmd+F! It has been around for decades and can still be useful, especially if you only have a rough idea of the location of the data you're searching for.
Moving columns in CSV files
Starting from 2024.1, you can move columns in the data editor of a CSV file and these changes will be applied to the file itself.
More features for UUIDs
As per requests received in our issue tracker, we've put some of our efforts toward making it easier to work with UUIDs:
- We added a new action: Generate UUID.
- It is now possible to edit any column with UUIDs, including those represented by the binary(16), blob(16), and similar types.
- [PostgreSQL] Values in UUID columns can now be validated while editing.
Aligned code style for multi-row INSERTS
You can now format multi-row INSERT statements with values aligned. The formatter will analyze the width of the values in each column and choose the most suitable width for the column.
To turn this feature on, enable the option Align multi-row VALUES.
DataGrip handles situations where certain values are much longer than others.
The formatter will detect such values and make exceptions for them, moving the remaining fields to the next row.
This behavior is managed by these three options:
Column completion for GROUP BY clause
Now DataGrip analyzes the aggregates used in the SELECT clause and offers you the appropriate column list along with the GROUP BY clause.
Warning for WHERE TRUE clauses
We expanded our unsafe query warning. It now warns you if you run the query with the WHERE TRUE condition or its variations. This can be a life-saver if you're someone who likes having this clause for debugging purposes but occasionally forgets to change it!
[Amazon Redshift] Support for shared via data catalog external databases
External databases shared via data catalogs are now supported. Their content is now introspected and available for completion.
Important fixes:
- DBE-16920: [H2] The FROM_1X option is supported for the RUNSCRIPT statement.
- DBE-19384: [Microsoft SQL Server] The parameter for OPENQUERY is no longer limited.
- DBE-19391, DBE-19941: [MySQL] Support for spatial functions has been added.
- DBE-18612: [Amazon Redshift] The QUALIFY clause is supported.
- DBE-14951: [Oracle Database] The ON CONVERSION ERROR clause is supported in converting functions.

Data visualization
Since the release of DataGrip 2023.3, it's been possible to visualize data following our integration of the Lets-Plot library, with its basic no-code data visualization possibilities. The visualization is available on all three types of grids:
- Main tab: When you open the table, view, or CSV file, the plot is displayed in split mode.
- Result tab: When you observe the result of a query in the Services tool window, the plot can be displayed instead of the grid.
- In-editor results: It's possible to display the plot instead of the grid.
Known issue: The settings for the visualization are not saved, which means that if you reopen the grid, the plot will be in its default state.
You can find more information on data visualizations in our documentation.
This feature is still under development, and we would like to hear your feedback! You can provide this using the feedback form, by creating an issue in our tracker, or by writing directly to datagrip@jetbrains.com.
New import functionality
We have spent a significant amount of time reworking our import functionality, but we believe it was worth it for the following reasons:
- It was the last chapter in the big transition to our generated Modify Object UI, which is described in detail here.
- The feature now includes the functionality to import to several targets.
- It is now possible to edit several things at once. For example, you can change formats or encode for several files, changing the schema for several targets.
Some features to highlight:
Mapping
The default target entity is called mapping. Here, you can define the target table and map the file columns with the columns of the target table. If you need to edit the table itself, press the Edit button:
The table will appear in the tree UI on the right. This UI completely repeats the Modify Object UI: here you can do any kind of manipulations with the table and its objects.
Auto-generate table names
This button automatically generates the table name from the source file. It can be useful if you rename the table and want to revert to its default name.
Simplify column names
This action can come in handy when the original column names contain spaces.
Reverting to the old UI
We understand that this rework is a huge change that may be inconvenient for some of our users. We would appreciate any feedback you can share with us to help us understand how we can improve the new UI, making it both more powerful and clearer for all use cases.
If, for any reason, you wish to revert to the old UI, you can use this option:
This option will be removed only when we have processed all the negative feedback we have received about the new UI.
DynamoDB support
We are pleased to announce that the 419 people who voted for that ticket didn't do so in vain. Support for DynamoDB is now coming to JetBrains IDEs!
What has been implemented:
- Data can be viewed via DataGrip's data viewer
- PartiQL for DynamoDB support in the code editor
- Tables with keys and indexes are now introspected
If there's anything else that you think needs to be supported as a priority, please comment on this YouTrack issue.