PGConf.Russia 2025

Last year, we introduced built-in fault tolerance support in Postgres Pro Enterprise through BiHA. Our solution allows you to deploy a fault-tolerant Postgres cluster where, in the event of a failure of the primary node, a new primary node (leader) is automatically selected.

However, this brings up the issue of redirecting traffic to the new leader. This can be solved using our Proxima extension or an external TCP proxy server. Both solutions needed to periodically query the BiHA cluster to determine the primary node.

As an alternative, the latest version of BiHA introduced the ability to register custom functions that will be triggered by events such as leader change, node addition/removal, and others. We call this mechanism user callbacks. In this presentation, we’ll explain how the callbacks are implemented and discuss their usage.

This talk explores the challenges we encountered — and solved — while migrating massive databases from Oracle to PostgreSQL.

One of the most complex aspects of this process was rebuilding foreign keys (FKs). To overcome these challenges, we had to dive deep into the internal workings of FK creation and validation.

Key topics include:

Does ALTER TABLE ... ADD CONSTRAINT ... FOREIGN KEY have an execution plan?

Can an ordinary user influence this process?

What locks are applied during FK creation and validation?

Also, we’ll introduce a first-principles method for investigating performance issues, applying it to a real-world FK creation bottleneck.

What does a modern application developer need to transition from familiar cloud-based solutions to SQL databases?

This talk is a practical report on how we transformed an SQL database into a NoSQL-like solution with a developer-friendly interface. We’ll discuss:

What application developers expect from a data framework

How to implement declarative DDL, access control, and automation for reading and writing data

Simplified DML operations, pagination, and other essential features for application development

Many developers often face performance issues in the systems they develop. One common solution for optimizing slow business processes is parallelization. But what do you do if the bottleneck is the data insertion into the database, which needs to maintain atomicity?

In this talk, I’ll explain how to speed up data insertion by parallelizing the process in Spring, while ensuring the atomicity of the entire operation. We'll cover batch updates in Spring and PostgreSQL, discuss why updates are heavy operations, and explore ways to speed up the process in the current tech stack. Additionally, I will present other approaches to maintaining atomicity and demonstrate their differences in benchmarks.

This will be useful for practicing engineers.