PGConf.Russia 2025

In this talk, I will challenge architectural stereotypes about the impossibility of communication with external systems directly from a DBMS. PostgreSQL offers vast communication capabilities; you just need to know which extensions to use.

And when extensions aren't enough, you can create your own. For the Luxms BI project, we needed communication with NATS, so we developed our own extension in Rust. I’ll share the GitHub link and my experience of developing PostgreSQL extensions in Rust during this talk.

Not a PgBouncer, But a Connection Pooler. Not Odyssey, But with Coroutines

If you’ve ever set up a high-availability PostgreSQL cluster, you’ve likely faced the challenge of redirecting traffic to the primary node after a failover.

Typically, this requires additional software to monitor cluster status and reroute traffic accordingly. To avoid a single point of failure, you may have had to implement failover handling within that layer. Additionally, you might have encountered PostgreSQL’s limitations on handling large numbers of concurrent client sessions, necessitating query pooling.

To solve these issues, we developed Proxima — a scalable, fault-tolerant proxy and connection pooler. Proxima automatically redirects traffic to the primary node and, in BiHA setups, seamlessly switches to a new primary in case of failure.

In this talk, I’ll cover why and how we built Proxima, the key architectural decisions behind the extension, and the

implementation details that enable it to handle 10,000+ concurrent client sessions.

We’ll also explore use cases and answer your questions.

So much has been said about PostgreSQL as the result of its program code. But Postgres is not just code. It’s the people who create it, develop it, and... leave a piece of themselves through comments.

What stories can we uncover from the comments in PostgreSQL’s code? We’ll discover what the most popular word is, which comments have been in the code since the very first public commit, how the style of communication has evolved with the product, and how we can see the human side behind the lines of code and comments.

I’ll talk about the challenges you’ll face if you decide to implement a new TableAM. What to choose: Generic XLog or Custom RMGR? Why use a Custom SMGR? How to integrate PostgreSQL allocators into third-party libraries, even if they don't officially support it? What’s missing for a columnar engine (including vectorization and late materialization), and how can we work around those limitations?

In the second part, I’ll dive into the internals of pgpro_tam — a new native table engine for OLAP that supports standard data formats, various SMGRs, and, if needed, third-party schedulers and execution engines, all while adhering to ACID principles. This is designed to achieve the fastest analytics on PostgreSQL (not just plugging in DuckDB).