JetBrains DataGrip database management tool

Developers and data analysts often face various challenges when working with databases. These challenges can include writing and debugging SQL queries, managing multiple database connections, and maintaining large SQL scripts. To address these challenges, many choose to use database IDEs designed specifically for SQL developers, such as DataGrip. So, what is DataGrip? What are its features? And why should you choose it?

What is DataGrip?

DataGrip is a multi-engine database environment developed by JetBrains. If your database management system (DBMS) has a JDBC driver, you can connect to it through DataGrip. DataGrip is widely praised for its powerful features, especially its strong support for SQL.

Download

https://www.jetbrains.com/datagrip/download

The updates of JetBrains DataGrip For Mac v2024.3.5 mainly include the following points:

1. Performance Improvement : The database connection speed and query processing performance have been optimized to make the overall user experience smoother.
2. Bug fixes : Fixed some known errors and vulnerabilities to improve the stability and security of the software. For example, the issue where GitHub access tokens could be leaked to third-party websites in some cases was fixed.
3. New features : Added support for a new SQL formatter and enhanced stored procedure execution. These features are designed to improve user efficiency and convenience when writing and managing SQL code.
4. 4. User interface improvements : The user interface has been improved to make it more friendly and easy to use, and support for different database types has also been enhanced.

DataGrip 2024.1 new features

DataGrip 2024.1 has been released! This is the first major upgrade of 2024 and brings many improvements and new features. Let’s take a look at all the new features and updates in detail!

AI Assistant: with mode options (supports DataGrip only)

AI Assistant now supports improving the quality of generated SQL queries by including your database schema in chat. Currently, only table and column names can be included, and a maximum of 50 tables can be included. To use this feature, you must authorize AI Assistant to search for database objects in your project.

Each time you attach a new schema, you can choose to authorize your AI assistant, or you can choose to remember your selection in the Attach Schema pop-up to automatically enable the Enable Database Context setting in the future.

Context menu functions in the editor (such as Explain Code) are now aware of the current mode when called from the Database Console.

The AI Assistant has learned your patterns, so you can now generate queries based on natural language requests, get insights about your patterns, perform more complex searches, and more. This is just a small sampling of what it can do; the possibilities are endless!

Data processing

Local filters in the Data Editor

Here’s a feature everyone’s been asking for: you can now filter rows by column values. This operation is very fast because it doesn’t involve sending a query to the database. However, it’s important to note that filters only affect the current page of data. So, if you want to filter more data, just change the page size or fetch all data.

If you want to turn off all local filters in the current Data Editor, uncheck the Enable local filters button.

Also, don’t forget about the local text search feature (Ctrl/Cmd+F)! It’s still very useful, especially when you only have a rough idea of the data location.

Single record view

You can now focus on a single record in the Data Editor. To open the single record view, use Ctrl/Cmd+Shift+Enterthe shortcut key or click the Show Record View button on the toolbar.

If cells in the main grid are editable, they will also be editable in the single record view.

You can also change the layout to two columns if applicable to your use case:

Ability to move columns in CSV files

Starting with version 2024.1, you can move columns in CSV files in the Data Editor and the changes will be applied directly to the file itself.

More UUID Features

In response to various requests from users in the issue tracker, we have further improved the UUID handling function:

• Added a new operation: Generate UUID.
• Now, you can edit any column that uses a UUID, including columns represented by types such as binary(16), blob(16), etc.
• Validation now works when editing values in UUID columns.

Simplify conversations

Over the years, we’ve received a lot of feedback from users who say they don’t understand the concept of sessions and that this makes DataGrip more complicated. Here are some examples:

“The project-first, separate console and session model was too complex. To open and execute a simple SQL script, I had to create a project, add the file to the project, open the console, then open the session, and finally attach the file to the session. It was a real hassle.”

“The transition from SQL Server Management Studio to DataGrip has a more complex user interface. In SQL Server Management Studio, you only need to focus on the server, the query, and the results. In DataGrip, there are sessions, consoles, scratch files, and so on, which is not very intuitive for new users.”

“The way parts of the UI work is a bit clunky and unintuitive. Every time I run a script, I have to select a console. It’s not super clear why I have to do that and what the impact of my choices will be. This shouldn’t be the default behavior.”

In DataGrip, a “session” is a container that refers to connections. In other words, connections can be established, stopped, and re-established within a session. For each connection, there is a session.

While attaching sessions is a powerful mechanism, in most cases users only need to set up the context (data source and database or schema) in which to run queries.

Starting with version 2024.1, users no longer need to manually select the session to use before running a query, for all types of queries. Sessions still exist, but you don’t need to worry about using them. Let’s take a deeper look at how this change affects the main use cases of DataGrip.

Connecting and switching data sources

Now, to attach a file, you only need to select the data source to use instead of the session. After selecting the data source, you can select the mode to use.

Switching Sessions

The Switch Session action is now visible only in the context menu of the Services tool window. It allows you to switch sessions only within the current data source.

Run the function

You do not need to select a session before launching a function. In the Execute Routine window, from the Run from option, you can select which console or file to launch the function from.

Coding

Align code format for multi-line INSERT statements

You can now align values in multi-row INSERT statements for clearer display. The formatter analyzes the width of the values in each column and chooses the best alignment width.

To turn on this feature, enable the Align multi-row VALUES option.

DataGrip can even adapt to cases where some values are longer than others. The formatter will detect these cases and move the other columns to the next line to maintain alignment.

This behavior is controlled by the following three options:

• align: Align all columns.
• align_padding: Aligns all columns and adds the same amount of space to each column when aligning.
• align_padding_individual: Aligns the columns according to the length of their values and provides a different amount of space for each column.

Automatic completion of GROUP BY clause columns

DataGrip now analyzes aggregate functions used in the SELECT clause and provides the corresponding column list in the GROUP BY clause.

Warning about WHERE TRUE clauses

We’ve expanded the “Unsafe Query” warning. Now, if you run a query with a WHERE TRUE condition or one of its variants, DataGrip will warn you. This is very useful for those who are used to debugging with a WHERE TRUE condition but sometimes forget to change it!

Customize the character to accept code completion suggestions

We’ve added a feature that allows you to specify which characters receive code completion suggestions, making it easier to write SQL. To enable this, you need to enable two options:

• Accepts code completion on:: Specifies which characters will trigger code completion.
• Code completion triggers on:: Specifies in which scenarios code completion can be triggered.

This feature is particularly useful when using operators:

• For example, you can configure parentheses or equal signs to trigger code completion to quickly get relevant code suggestions.

Fixed lines in the editor

To simplify working with large files, we’ve introduced a fixed-line editor feature. This feature pins structural elements, such as CREATE statements, to the top of the editor, keeping them visible while scrolling. This allows you to quickly navigate the code by clicking on the fixed line at any time.

This feature is enabled by default , and you can turn it off via the checkbox in Settings/Preferences – Editor – General – Appearance. You can also set the maximum number of fixed lines as needed.

Other Features

• Support for Redis Stack module commands: DataGrip now supports the four main modules of the Redis Stack: RedisJSON, RediSearch, RedisBloom, and RedisTimeSeries. This support also requires a new version of the driver: v1.5. This includes the following:
  • You can send commands to these modules and view the results.
  • Commands for these modules are now highlighted correctly.
  • The keys provided by these modules will be displayed in the Database Explorer.
• JSON Documents: JSON documents are now displayed as separate folders. You can view them in the data viewer and specify the JSON path.
• Other Data Types: Keys of types provided by the RedisTimeSeries and RedisBloom modules will appear in the Data Structures folder.
• Support for external databases shared via data catalogs: External databases shared via data catalogs are now supported, and their contents can be automatically viewed and completed for them. This feature improves the convenience of data processing.

That concludes our introduction to the new features and improvements in DataGrip 2024.1. We hope these new features will improve your productivity and data processing experience!

Key Features of DataGrip

Smart Query Console

DataGrip provides the Smart Query Console, a tool that can execute queries in different modes, and a local history that records all your actions to prevent you from losing your work.

Efficient architecture navigation

DataGrip’s schema navigation feature allows you to jump to any table, view, or procedure by name. You can jump to it using the corresponding action or directly through its use case in the SQL code.

Explanation plan

DataGrip’s Explain Schema feature allows you to gain a deeper understanding of how queries work and the behavior of the database engine, thereby improving query efficiency.

Smart code completion

DataGrip’s smart code completion is context-aware and helps you write SQL code faster. It automatically recognizes table structures, foreign keys, and even database objects you create in your code.

Real-time analysis and quick fixes

DataGrip detects possible errors in your code in real time and suggests the best possible fixes. It immediately alerts you to unresolved objects, keywords used as identifiers, and always suggests fixes.

Refactorings used in SQL files and schemas

DataGrip can correctly resolve all references in your SQL code and refactor them. When you rename a variable or alias, all uses of that variable or alias in the entire file are also updated.

Version control integration

DataGrip provides support for all major version control systems including Git, SVN, and Mercurial.

Why DataGrip?

DataGrip’s powerful features make it an ideal choice for database developers. Here are some reasons to choose DataGrip:

• Powerful code editing and refactoring tools : DataGrip provides powerful code editing and refactoring tools, such as smart code completion, real-time code analysis and quick fixes, and refactorings for SQL files and schemas.
• Efficient database management : DataGrip can handle all database operations, including creating, modifying, deleting, and querying database objects. You can easily navigate and manage your database schema.
• Multiple database support : DataGrip supports all major database systems, including MySQL, PostgreSQL, SQLite, Oracle, DB2, SQL Server, and other JDBC-compliant databases.
• Integrated version control : DataGrip integrates with all major version control systems such as Git, SVN, and Mercurial, making version control more convenient during database development.
• Powerful data import/export tools : DataGrip provides powerful data import and export tools. You can easily import data from CSV files or export data to CSV, JSON, HTML, Markdown and other formats.
• Localized UI : DataGrip supports multiple languages, including Chinese, Japanese, and Korean, making it more convenient for users to use.

In general, DataGrip is a powerful and easy-to-use database IDE. Whether you are a database administrator, developer or data analyst, it can help you improve your work efficiency and better manage and process your data.

In modern development environments, managing and operating databases has become a crucial task. Data is the cornerstone of our applications, so we need a tool that can help us easily operate and manage databases. This is where JetBrains’ DataGrip comes in. DataGrip is an integrated development environment (IDE) designed specifically for SQL developers. It provides a range of powerful tools and features that make operating and managing databases a breeze.

A tour of DataGrip’s powerful features

Smart Query Console

DataGrip’s intelligent query console is one of the core features of this IDE. This console allows you to execute queries in different modes and provides a local history feature that records all your activities to ensure that your work is never lost.

Efficient architecture navigation

DataGrip’s schema navigation feature allows you to quickly jump to any specified table, view, or procedure. Whether you jump by direct name or by reference in SQL code, DataGrip provides convenient and fast navigation.

Explain the implementation plan

DataGrip’s Explained Execution Plan feature gives you detailed insights into how your query works and the database engine’s behavior. This not only helps you improve your query efficiency but also helps you better understand the inner workings of your database engine.

Smart code completion

DataGrip’s smart code completion feature is context-aware and automatically completes the SQL code you’re writing. Whether it’s the table structure, foreign keys, or database objects you create in your code, DataGrip can automatically identify and complete them.

Real-time analysis and quick fixes

DataGrip’s live analysis feature detects potential errors in your code in real time and suggests the best possible fixes. Whether it’s unresolved objects, keywords used as identifiers, or other issues, DataGrip provides timely reminders and suggested fixes.

Refactoring and version control integration

Not only does DataGrip correctly resolve all references in your SQL code and refactor them, but it also supports all major version control systems like Git, SVN, and Mercurial, providing a unified version control experience.

A good helper for database operations

DataGrip provides a range of powerful tools to help you easily manipulate and manage your database. Whether importing data from a CSV file or exporting data to CSV, JSON, HTML, or Markdown, DataGrip can do it with ease. Furthermore, DataGrip provides powerful data import and export tools, making working with large amounts of data a breeze.

Essential tools for writing SQL

DataGrip not only provides powerful code editing and refactoring tools, but also offers a range of features specifically designed for SQL writing, such as smart code completion, real-time code analysis, and quick fixes. These features not only improve your writing efficiency, but also help you write higher-quality SQL code.

The magic tool for running queries

DataGrip’s query console is a must-have for any SQL developer. You can create multiple consoles, each with its own schema context and query options. Furthermore, DataGrip provides a local history feature that records all your actions, preventing you from losing your work.

In daily database management and operations, improving efficiency, ensuring data accuracy, and ensuring smooth workflows are key challenges. DataGrip, a database IDE developed by JetBrains, was created to address these challenges.

1. DataGrip: Intelligent Database IDE

DataGrip is a powerful multi-engine database environment that supports JDBC drivers for various DBMSs, allowing you to easily connect to and manage your databases. DataGrip offers a rich set of features, including an intelligent query console, efficient schema navigation, detailed query explanations, and smart code completion.

1.1 Smart Query Console

DataGrip’s smart query console allows you to execute queries in different modes and provides a local history feature to record all your operations to prevent your work from being lost.

1.2 Efficient Architecture Navigation

Whether by operation or use case in SQL code, DataGrip’s efficient schema navigation lets you quickly jump to any table, view, or procedure by name.

1.3 Detailed query explanation

DataGrip’s Explain Query feature gives you detailed insights into how queries work and the database engine’s behavior, allowing you to improve your query efficiency.

1.4 Intelligent Code Completion

DataGrip’s smart code completion feature is context-aware and helps you write SQL code faster. It automatically recognizes table structures, foreign keys, and even database objects created in the code you are editing.

2. Advanced Data Processing Technology

DataGrip is more than just an ordinary database IDE; it’s a powerful data processing tool. Whether it’s real-time analysis, quick fixes, code refactoring, or version control integration, DataGrip can handle it with ease.

2.1 Real-time analysis and quick fixes

DataGrip detects possible errors in your code in real time and suggests the best possible fixes. It immediately alerts you to unresolved objects, keywords used as identifiers, and always offers fix suggestions.

2.2 Code Refactoring

DataGrip can correctly resolve all references in your SQL code and refactor them. When you rename a variable or alias, all usages of that variable or alias in the entire file will be updated as well.

2.3 Version Control Integration

DataGrip provides unified support for all major version control systems such as Git, SVN, Mercurial, etc., making it easier for you to manage and collaborate on versions.

3. In-depth exploration of the database

DataGrip not only provides powerful data processing capabilities, but also provides in-depth database exploration tools. Whether it is grouping data sources, duplicating data sources, or generating SQL files for selected objects, DataGrip can help you better understand and master your database.

3.1 Data Source Grouping and Replication

DataGrip allows you to group data sources by type, such as database vendor. You can also easily copy and share the same data source across different projects or different IntelliJ-based IDEs.

3.2 Generate SQL file for selected objects

DataGrip can use the SQL generator to generate SQL files for database objects, helping you better manage and maintain your database objects.

4. A good companion for SQL writing

The power of DataGrip is also reflected in its support for SQL programming. Whether it is code completion, code generation, code analysis and quick repair, or refactoring and finding usage, DataGrip is involved, greatly improving the efficiency of SQL programming.

4.1 Code Completion

DataGrip provides intelligent code completion that is context-aware and schema-aware, making writing code faster and more accurate. It recognizes table structures, foreign keys, and database objects created in the code you edit.

4.2 Code Generation

DataGrip’s code generation feature can help us generate typical code snippets, freeing our hands. It can generate code based on changing objects such as tables and columns, and even help us get the DDL of any object and provide DML queries.

4.3 Code Analysis and Quick Fixes

DataGrip detects possible errors in your SQL code in real time and suggests the best possible fixes. It immediately alerts you to unresolved objects, keywords used as identifiers, and always suggests fixes.

4.4 Refactoring and Finding Usages

DataGrip correctly resolves all references in SQL files and refactors them. When we rename database objects in SQL, they are also renamed in the database. We can quickly find in which stored procedures, functions, and views our tables are used.

5. Query Tool

DataGrip’s query console is a must-have tool for all SQL developers. We can create multiple consoles, each with its own independent schema context and query options.

5.1 Query Console

We can specify how the console behaves when running queries by selecting what to execute. Available modes include read-only, results in editor, and manual transaction commit.

5.2 Query History

Every query we run is saved in a log file. Each file also has a local history, which means that everything we enter is saved immediately after entering so that we don’t lose any work.

5.3 User Parameters

DataGrip supports running parameterized SQL queries. We can add our own parameter patterns using regular expressions and choose the SQL dialect to which these parameters will be applied.

6. A powerful tool for file processing

DataGrip provides a range of features for working with files, such as DDL data sources, version control system (VCS) support, and run configurations.

6.1 DDL Data Source

SQL files containing schema DDL statements can be used as data sources. This allows us to reference all tables, columns, and other objects defined in such files. We can also map a DDL data source to a real data source and migrate between the two.

6.2 VCS Support

DataGrip provides a unified interface for most popular version control systems, such as Git and others, ensuring a consistent user experience. DataGrip also supports GitHub integration.

6.3 Runtime Configuration

Run configurations allow us to run scripts without opening them. Each configuration can contain multiple script files in the required order, multiple target architectures, and a list of tasks to be completed before the actual run.

7. User experience considerations

DataGrip also takes user experience into consideration, providing localized UI, customizable appearance, and customizable key mapping.

7.1 Localized UI

DataGrip supports multiple languages, including Chinese, Japanese, and Korean, making it more convenient for users to use.

7.2 Customizable Appearance

DataGrip comes with two themes: light and dark. Each theme is fully customizable, allowing you to change any color. You can even create your own color themes; our plugin library offers countless options.

7.3 Customizable key mapping

The power of DataGrip lies in its rich shortcut function. You can change the shortcut keys that are inconvenient for you and assign your own shortcut keys to any operation in the IDE.

Conclusion

DataGrip is a powerful and easy-to-use database IDE. Whether you’re a database administrator, developer, or data analyst, it helps you improve your productivity and better manage and work with your data. DataGrip’s powerful features, flexibility, and ease of use make it a standout in the database IDE market. Choose DataGrip to make your database operations more efficient and your development work smoother.