PGConf.Russia 2025

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.

As part of the import substitution process, we encountered the need to find a reliable alternative to Oracle. PostgreSQL was considered the primary candidate for replacement, but during the research, the "vanilla" version revealed a number of critical limitations that hindered a successful transition.

These issues included support for autonomous transactions, batch variables, and several other specifics. What is special about pg_settings? Why do we need autonomous transactions, and how do HOLD cursors relate to this? These and other topics will be discussed in our presentation, where we will also share our experience of implementing Postgres Pro Enterprise.

This talk will explore different approaches to storing files in PostgreSQL, including:

• Simple table-based storage

• Large objects with pg_largeobject

• pgpro_sfile – a large object (pgpro_bfile) storage solution

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.