Here comes dbForge 2026.2, a new release of our ever-evolving ecosystem of AI-powered database lifecycle management solutions—and it’s packed with useful updates you definitely shouldn’t miss! These include a brand-new embedded PostgreSQL Debugger in dbForge Studio, handy visual object editors for PostgreSQL, broader context awareness in dbForge AI Assistant, enhanced SQL development and schema comparison capabilities, and a new, simplified product activation flow. It’s all here to make the daily work of developers, architects, and analysts much easier.

Without further ado, let’s get started!

What’s in the box?

Embedded PostgreSQL Debugger in dbForge Studio

First and foremost, we’re glad to introduce a brand-new PostgreSQL Debugger in dbForge Studio. With its help, you will no longer need to scrutinize your code in order to find potential performance bottlenecks and other possible issues. The Debugger will help you do the following:

• Set breakpoints in your code to pause the execution at specific lines
• Step through code line by line to see how each line is executed
• Monitor the current values of variables, expressions, and query results to analyze how data changes during the execution process
• Handle exceptions by highlighting the exact line where the error occurs

One of the best things about our new PostgreSQL Debugger is that it’s integrated into dbForge Studio, so you won’t have to deal with any extensions or manual setups at all.

New visual object editors for PostgreSQL

The same dbForge Studio for PostgreSQL has received new visual object editors for event triggers, functions, and procedures. These editors eliminate the need to manage these objects with raw code, bringing the convenience of a visual interface into your daily operations.

You can invoke them in multiple ways:

• On the Start Page, go to the Database Design tab > New Database Object
• Go to the Database menu > New Database Object
• Click the New Database Object icon on the application toolbar
• In Database Explorer, double-click the required object to open it in the editor
• In Database Explorer, create a new event trigger/function or open the existing one from the context menu

This is what the editor looks like for event triggers.

This is what the editor looks like for functions.

This is what the editor looks like for procedures.

Also note that dbForge Studio for PostgreSQL now lets you configure the default action performed when you double-click database objects in Database Explorer. Separate default actions can be set for tables and views, and for procedures and functions. You can do it in Tools > Options.

Broader context awareness in dbForge AI Assistant

Another key goal of this release was to make dbForge AI Assistant smarter and more flexible than ever, allowing you to tailor it to your workflows and standards as precisely as possible. To achieve this, your control over the context has been greatly expanded, most notably with the ability to attach files. For instance:

• You can freely select to auto-attach your currently active document to the AI chat
• You can attach ready-made files instead of manually copying SQL code into your prompts
• You can provide the Assistant with sample code to help it learn your coding style and standards—and thus generate code that consistently adheres to them
• You can attach two scripted databases and have the Assistant compare them
• You can attach multiple databases to the same chat
• Generally, you can give the Assistant any files (e.g., application code, database projects/diagrams, or custom instructions) as an additional source of context

Another useful addition to the AI Assistant is the ability to select an AI model to be used. Now you can configure it from the Tools menu > Options > AI Assistant > General. The available models include the following:

• Anthropic: Claude Haiku 4.5, Claude Sonnet 4.6, Claude Sonnet 5
• OpenAI: GPT-5.4, GPT-5.5

Free Express edition of dbForge AI Assistant

This release makes dbForge AI Assistant even more accessible by introducing a long-awaited free Express edition. It provides a limited number of tokens and 14-day storage of chat history, which is still a great way to explore the Assistant’s capabilities and try it out in your daily work.

In case you need more extensive AI assistance, with a considerably larger token allowance and unlimited chat history, you can upgrade to a paid plan at any moment.

SQL development enhancements

From now on, you can apply object and column name qualification to code that is already written. Previously, the qualification settings in Options > Text Editor > Code Completion > Advanced applied only while you typed. Now, the new refactoring command uses the same settings and qualifies names in an entire pre-written SQL document or a selected fragment of code.

We have also implemented wildcard expansion for all supported contexts, whether in the entire SQL document or in a selected fragment of code.

These enhancements have been implemented in dbForge SQL Complete and three dbForge Studios: for SQL Server, MySQL, and Oracle. And if you’re dealing with multiple database systems on different projects, you may want to try dbForge Edge, a suite of four Studios that works across a huge number of databases and cloud services.

Quick data generation from Database Explorer

If you need to generate data for a table (or several tables) quickly, just go to Database Explorer, right-click the required table(s), and select Generate Data from the shortcut menu. You will immediately proceed to configure your generation without any unnecessary steps.

New “Last modified” column in schema comparison documents and reports

Schema comparison documents, as well as all three types of comparison reports, now include a handy Last modified column.

This feature has been implemented across dbForge for SQL Server and dbForge for Oracle.

Support for MySQL 26.7 and MariaDB 13.x

Finally, all dbForge tools for MySQL are now seamlessly compatible with MySQL 26.7 and MariaDB 13.x.

Get your dbForge 2026.2 update today!

The update is already available, so you can open your dbForge product, proceed to Help > Check for Updates, and get your dbForge 2026.2 right away.

If you’re not a user of dbForge yet, we gladly invite you to download any product for a free trial and give it a go in your daily work.

For extra convenience, we have introduced product activation via a simple sign-in, now available alongside the traditional methods: entering an activation key and generating an activation request.

And, like we said previously, if you’re dealing with multiple database systems on different projects, you can try dbForge Edge, an AI-powered multidatabase solution that helps you cover the entire database lifecycle—including database design, development, management, and administration—across SQL Server, MySQL, MariaDB, Oracle, PostgreSQL, and a vast number of related database systems and cloud services.

Doltgres, the world’s first version-controlled Postgres-compatible database,
just hit 1.0, meaning that it’s ready for
production use. We want Doltgres to be a drop-in replacement for Postgres so that customers can use
the entire ecosystem of Postgres-compatible tools and libraries, or port their existing database
application to Doltgres without changing any code. This means getting all the nuanced semantics of
Postgres’s behavior correct in our emulation. And we think we’ve done pretty well here — our
compatibility tests encompass over two dozen tools and
languages.

But Doltgres shares the same SQL engine Dolt uses, which was built to emulate MySQL semantics. For
most queries this works fine, but MySQL plays famously fast and loose with the SQL standard, while
Postgres takes it much more seriously. And because we take client compatibility very, very
seriously, that means that we need an engine that reproduces all of MySQL’s wacky non-standard
behavior for Dolt and
Postgres’s dignified, correct behavior for Doltgres.

Today’s blog is a case study of one area where the engine’s behavior differs to match the emulation
target, and a look under the hood for how we manage these differences internally in our interfaces.

UPDATE with column values from the same row#

This issue was brought to our attention by an
early adopter customer: Doltgres had the wrong behavior when an UPDATE statement referenced table
columns in its update expressions.

CREATE TABLE t_seq (a int, b int);
INSERT INTO t_seq VALUES (1, 0);
UPDATE t_seq SET a = 2, b = CASE WHEN a = 1 THEN 100 ELSE -1 END;
SELECT a, b FROM t_seq;

The SQL standard says that an UPDATE statement that references column values should use the value
from the pre-update row, in all cases. So the SELECT query in the above block should return this:

 a | b
---+-----
 2 | 100 -- per the SQL standard, every assignment reads the pre-update row

But MySQL doesn’t behave this way for an UPDATE. It ignores the SQL standard and uses the new,
updated column values in every UPDATE expression as it executes them one by one, left to right, on
each row. So in MySQL, and Dolt, the above select returns this:

 a | b
---+-----
 2 | -1 -- the CASE saw the NEW value of a (=2)

And until earlier this week, Doltgres behaved this way too. But that’s wrong, and breaks client
expectations for Postgres application developers. We needed to change this behavior in the engine,
but only when running in Postgres emulation mode.

How do we do that?

Introducing engine overrides#

During development of Doltgres, we experimented with a lot of different mechanisms to vary the
engine’s behavior for Doltgres, either to reflect needed differences for Postgres compatibility or
to implement features that MySQL doesn’t have. These include new rules during query analysis, new
plan nodes that wrap or otherwise alter existing ones, as well as more hacky fixes like swapping
function pointers during program init. For something like this divergence in behavior, there wasn’t
an existing extension point in the query engine. We designed the
engine to make the database
backend swappable, as well as some of the query planning logic. But for something as fundamental as
applying updates to a row, we had not bothered to make the behavior pluggable.

Our current approach in this kind of situation is to provide the engine with a set of well-defined
behavioral extension points at construction. Unlike the interfaces that define tables, databases,
functions, etc. that allow integrators to implement a custom database storage backend, these
extension points alter the query-time behavior of the engine itself, independent of the storage
backend. They’re currently stored in a struct called EngineOverrides. To solve this particular
problem, we introduced the new UpdateExpressionApplier interface at the bottom of the struct.

type EngineOverrides struct {
	// Builder contains functions and variables that can replace, supplement, or override functionality within the builder.
	Builder BuilderOverrides
	// SchemaFormatter is the formatter for schema string creation. If nil, this will format in MySQL's style.
	SchemaFormatter SchemaFormatter
	// Hooks contain various hooks that are called within a statement's lifecycle.
	Hooks ExecutionHooks
	// CostedIndexScanExpressionFilter is used to walk expression trees in order to apply index scans based on
	// filter expressions. Some expressions may need to be modified or skipped in order to properly apply indexes
	// for all integrators.
	CostedIndexScanExpressionFilter ExpressionTreeFilter
	// UpdateExpressionApplier evaluates UPDATE assignments. If nil, the engine uses
	// MySQL's sequential assignment evaluation and IGNORE conversion handling.
	UpdateExpressionApplier UpdateExpressionApplier
}

The new interface looks like this:

// UpdateExpressionApplier evaluates the assignments for a row in an UPDATE statement.
// It does not apply to procedural SET or INSERT ON DUPLICATE KEY UPDATE statements.
type UpdateExpressionApplier interface {
	ApplyRowUpdate(ctx *Context, updateExprs *UpdateExprs, tableSchema Schema, oldRow Row, ignore bool) (Row, error)
}

For MySQL behavior, we have a simple interface that applies updates the same way it always has
(matching MySQL, not Postgres). For Doltgres, we implemented a new one that we plug in at engine
construction time.

func (UpdateExpressionApplier) ApplyRowUpdate(ctx *sql.Context, updateExprs *sql.UpdateExprs, tableSchema sql.Schema, oldRow sql.Row, _ bool) (sql.Row, error) {
	newRow := oldRow.Copy()
	for _, expr := range updateExprs.ExplicitUpdateExprs() {
	assignment, ok := expr.(*gmsexpression.SetField)
	if !ok {
	return nil, fmt.Errorf("UPDATE: expected SetField, found %T", expr)
	}
	// SetField performs assignment conversion and returns a copy of oldRow.
	// Merge only its target, so later assignments cannot undo earlier writes.
	value, err := assignment.Eval(ctx, oldRow)
	if err != nil {
	return nil, err
	}
	...
}

Now Doltgres returns the expected result, the same as Postgres.

a | b
---+-----
2 | 100 -- per the SQL standard, every assignment reads the pre-update row

Check out these two
PRs for the full details.

Conclusion#

Doltgres 1.0 already launched, but Doltgres’s compatibility story is definitely not over. Keep the
issues coming and we’ll keep knocking them down in 24
hours.

Have a divergence in Postgres behavior to report? Want to learn more about Doltgres? Visit us on the
DoltHub Discord where our engineering team hangs out all day. Hope
to see you there.

Don’t you just hate it when you’re out buying Pokémon cards, only to discover that you left your wallet at home? Well, with an exciting new life hack, you’ll never forget your wallet again.

To avoid the hassle and embarrassment that result from leaving your wallet at home, try sitting it next to your katana. You never forget to leave home without your trusty katana, so when you gear up to leave the house, your wallet will be right there waiting for you. It works every time!

All you have to do is find a nice, convenient place for your katana that also has a spot for your wallet. And for an extra tip, try engraving your katana with a helpful message. "Don’t forget your wallet!" It’s helpful for you, and for your enemies who will need that extra cash to pay the boatman for passage to cross the River Styx.

You’re always going to need your katana with you, so it just makes sense to keep all your daily essentials together. Wallet, keys, phone, Tamagotchi. If you keep everything with your katana, you’ll never be disappointed.

Start today by letting your honor for your katana protect you from leaving your wallet behind ever again.

---

The Babylon Bee finally exposes everything about the Jews in this documentary of hard-hitting investigative journalism.

The MySQL team at Oracle is excited to announce MySQL Workbench 26.7, the first of a new generation of the GUI administration and development tool for MySQL.

A New Workbench

MySQL Workbench 8 has served the community well, but it’s now old and has reached end of life. Its architecture, built on C++ and platform specific front-ends for Windows, macOS and Linux, has become increasingly difficult to extend and maintain.

MySQL Workbench 26 obsoletes MySQL Workbench 8.0. If you’re still running the old Workbench, now is the time to make the switch. MySQL Workbench 8.0 is no longer maintained and will have no new releases.

In order to better focus our efforts, the MySQL Shell for VS Code extension is discontinued as well.

Its capabilities are being carried forward into the new Workbench.

Built on MySQL Shell

The biggest change under the hood: the new Workbench is a desktop application built on top of MySQL Shell, using modern web frameworks and ElectronJS. Rather than reinventing core database functionality, Workbench now leverages the same battle-tested engine that powers MySQL Shell’s extensive scripting and admin capabilities.

From this shared foundation we get:

• Functional consistency between the CLI (MySQL Shell) and the desktop app
• Faster iteration on new features across the whole toolchain
• A modern, HTML and JavaScript based UI that’s easier to theme, extend, and maintain

Server Compatibility

MySQL Workbench 26.7 supports MySQL 8.4 LTS and newer, MySQL 9.7 LTS, the latest MySQL 26.7 and innovation releases in between.

MySQL 8.0 and older EOL versions of MySQL may work, but are not officially supported. YMMV.

As with MySQL Shell, and unlike the MySQL server, MySQL Workbench follows a single version series model. This means there is a single latest version of MySQL Workbench, which is backwards compatible and supports all currently supported versions of the MySQL server. Users are recommended to always use the latest version.

What’s New (and What’s Coming)

The new Workbench ships with many of the features you already know from Workbench 8.0, alongside new capabilities enabled by the MySQL Shell foundation.

Development

SQL Script Editor – the traditional SQL script editor, with full or step-by-step execution, syntax highlighting, code-completion, result viewer and editor view and more

SQL Notebooks — a new, notebook-style way of working with SQL, mixing queries, results, and notes in a single interactive document

Updated Visual Explain — a redesigned graphical representation of query execution plans, supporting new MySQL features like the hyper-graph optimizer and HeatWave query plans

SQL Formatter — automatically clean up and reformat SQL into a more readable format

Auto-completion – SQL completion now supports expanding table and object names, @@variable names and more

Administration

Server Status and Overview — an at-a-glance view of your server’s status and configuration

Performance Reports — including slow query analysis, memory usage, and database size reporting

User and Grants Management — create, edit, and audit users and privileges through a visual interface

MySQL Enterprise Backup integration, for creating, scheduling and restoring full and incremental MySQL backups

Client Connection Browser – view active MySQL client connections and dig down into what they’re doing. Inspect locks that they’re blocked on waiting or locks they’re holding themselves

Cloud Migration

HeatWave Migration Assistant — a guided, wizard-driven UI for migrating on-premises and cloud (AWS RDS, Aurora etc) databases to OCI, taking you step by step through the process of moving your data to MySQL HeatWave

Because this is a from-the-ground-up rebuild, the new Workbench is in active development. Some features found in Workbench 8 may not be available yet but the team is working to bring them to you as quickly as we can, along with entirely new functionality that wasn’t possible before.

In the following weeks we’ll be publishing more detailed posts on individual features. In the meantime, we encourage you to try the new Workbench, see what’s there today, and let us know what matters most to you as we prioritize the roadmap.

Open Source and Built to Extend

MySQL Workbench 26.7 is open source, and it’s been designed from the start to be easy to extend. Whether you want to add a new panel, integrate with another tool, or customize a workflow, the new architecture makes that far more approachable than it ever was in the old codebase.

Get Involved

This is a community effort, and we want you in it. Whether that means filing issues, contributing code, testing early features, or just telling us what you’d like to see next. Check out the project repository, join the discussion, and help shape where MySQL Workbench goes from here.

Downloads and More

Download MySQL Workbench 26.7 packages for Windows, macOS and Linux

Bugs and Feature Suggestions

File bugs and feature suggestions at https://bugs.mysql.com or the GitHub project issues page

Show me the code

Source code for Workbench and Shell plugins can be found at GitHub, as well as MySQL Shell sources.