Initial report

Author: anarthal

_posts/2026-04-06-Ruben2026Q1Update.md

@@ -0,0 +1,231 @@
+---
+layout: post
+nav-class: dark
+categories: ruben
+title: "A postgres library for Boost"
+author-id: ruben
+author-name: Rubén Pérez Hidalgo
+---
+
+## The road to `import boost`: a talk in a wonderful conference
+
+- C++20 modules have been in the standard for 6 years already, but we're not seeing widespread adoption.
+- At the moment, the ecosystem is still getting ready. As a quick example, `import std`, an absolute blessing
+  for compile times, requires build system support, and this is still experimental as of CMake 4.3.1.
+  Just an instance of what it is.
+
+- Something I've realized is that writing module-native applications is really enjoyable. The system is well-thought and allows for better encapsulation,
+  just as you'd write in a modern programming language. (TODO: example).
+- I've been using my Servertech Chat project (a webserver that uses Boost.Asio and companion libraries) to have a taste of what modules really look like in real code.
+  In case you're curious: https://github.com/anarthal/servertech-chat/tree/feature/cxx20-modules
+- When writing this, I saw clearly that having big dependencies that can't be consumed via import is a big problem.
+  With the scheme I used, compile times got 66% worse instead of improving. This is because when writing modules, you tend to have
+  a bigger number of translation units. These are supposed to be much more lightweight, but if you're relying on includes
+  for third-party libraries, they're not!
+
+For example:
+
+```cpp
+//
+// File: redis_client.cppm. Contains only the interface declaration (somehow like headers do)
+//
+module;
+
+// No import boost yet - must be in the global module fragment
+#include <boost/asio/awaitable.hpp>
+#include <boost/system/result.hpp>
+
+module servertech_chat:redis_client;
+import std;
+
+namespace chat {
+
+class redis_client
+{
+public:
+    virtual ~redis_client() {}
+    virtual boost::asio::awaitable<boost::system::result<std::int64_t>> get_int_key(std::string_view key) = 0;
+    // ...
+};
+
+}
+
+//
+// File: redis_client.cpp. Contains the implementation
+//
+module;
+
+#include <boost/redis/connection.hpp>
+
+module servertech_chat;
+import :redis_client;
+import std;
+
+namespace {
+
+class redis_client_impl final : public redis_client { /* ... */ };
+
+}
+
+```
+
+I analyze this in much more depth in the talk I've had the pleasure to give at using std::cpp this March in Madrid.
+https://youtu.be/hD9JHkt7e2Y for the entire talk.
+
+The TL;DR is that supporting `import boost` natively is very important for any serious usage of Boost in the modules world.
+
+## `import boost` is upon us
+
+As you may know, I prefer doing to saying, and I've been writing a prototype to support
+`import boost` natively while keeping today's header code as is. This prototype has
+seen substantial advancements during these months.
+
+I've developed a systematic approach for modularization, which I summarize here: https://github.com/anarthal/boost-cmake/blob/feature/cxx20-modules/modules.md.
+We've settled for the ABI-breaking style, with compatibility headers.
+I've added support for the remaining compiler, gcc, to the core libraries that we used to support (Config, Mp11, Core, Assert, ThrowException, Charconv).
+And I've added modular bindings for (variant2, compat, endian, system, type_traits, optional, container_hash, io and asio).
+These are only tested under clang yet - it's part of a discovery process. Idea is modularizing the flagship libraries
+to verify that the approach works, and to measure compile time improvements.
+
+Still lots to do before things become functional. I've received helpful feedback from many community
+members.
+
+## Redis meets Capy
+
+If you're a user of Boost.Asio and coroutines, you probably know that there's a new player
+in town - Capy and Corosio. They're a coroutines-native Asio replacement which promise
+a range of benefits, from improved expressiveness, saner compile times, without performance loss.
+
+Since I maintain Boost.MySQL and co-maintain Boost.Redis, I know the pain of writing
+operations using the universal Asio model. Lifetime management is difficult to follow,
+testing is complex, things must be remained header-only (and usually heavily templatized).
+Coroutine code is much simpler to write and understand, and it's what I use whenever I can.
+So obviously I'm interested in this project.
+
+My long-term idea is creating a v2 version of MySQL and Redis that exposes a Capy/Corosio
+interface. As a proof-of-concept, I migrated Boost.Redis and some of its tests.
+Still some polishment needed, but - it works!
+You can see the full report: https://lists.boost.org/archives/list/boost@lists.boost.org/thread/FSX5H3MDQSLO3VZFEOUINUZPYQFCIASB/
+
+Some sample code as an appetizer:
+
+```cpp
+
+capy::task<void> run_request(connection& conn)
+{
+    // A request containing only a ping command.
+    request req;
+    req.push("PING", "Hello world");
+
+    // Response where the PONG response will be stored.
+    response<std::string> resp;
+
+    // Executes the request.
+    auto [ec] = co_await conn.exec(req, resp);
+    if (ec)
+        co_return;
+    std::cout << "PING value: " << std::get<0>(resp).value() << std::endl;
+}
+
+capy::task<void> co_main()
+{
+    connection conn{(co_await capy::this_coro::executor).context()};
+    co_await capy::when_any(
+        // Sends the request
+        run_request(conn),
+
+        // Performs connection establishment, re-connection, pings...
+        conn.run(config{})
+    );
+}
+
+```
+
+## Redis PubSub
+
+Working with PubSub messages in Boost.Redis has always been more involved than in other libraries.
+For example, we support transparent reconnection, but (before 1.91), the user had to explicitly
+re-establish subscriptions:
+
+```cpp
+request req;
+req.push("SUBSCRIBE", "channel");
+while (conn->will_reconnect()) {
+    // Reconnect to the channels.
+    co_await conn->async_exec(req, ignore);
+
+    // ...
+}
+```
+
+Boost 1.91 has added pubsub state restoration. A fancy name but an easy feature.
+Established subscriptions are recorded. When a reconnection happens,
+the subscription is re-established:
+
+```cpp
+// Subscribe to the channel 'mychannel'. If a re-connection happens,
+// an appropriate SUBSCRIBE command is issued to re-establish the subscription.
+request req;
+req.subscribe({"mychannel"});
+co_await conn->async_exec(req);
+```
+
+Boost 1.91 also adds `flat_tree`, a specialized container for Redis messages
+with an emphasis in memory-reuse, performance and usability.
+This container is specially appropriate for using when dealing with PubSub.
+We've also added `connection::async_receive2()`, a higher-performance
+replacement for `connection::async_receive()` that consumes messages in batches,
+rather than one-by-one, eliminating re-scheduling overhead.
+And `push_parser`, a view to transform raw RESP3 nodes into user-friendly structures.
+
+With these improvements, code goes from
+
+```cpp
+// Loop while reconnection is enabled
+while (conn->will_reconnect()) {
+
+    // Reconnect to channels.
+    co_await conn->async_exec(req, ignore);
+
+    // Loop reading Redis pushs messages.
+    for (error_code ec;;) {
+        // First try to read any buffered pushes.
+        conn->receive(ec);
+        if (ec == error::sync_receive_push_failed) {
+            ec = {};
+
+            // Wait for pushes
+            co_await conn->async_receive(asio::redirect_error(asio::use_awaitable, ec));
+        }
+
+        if (ec)
+            break;  // Connection lost, break so we can reconnect to channels.
+
+        // Left to the user: resp contains raw RESP3 nodes, which need to be parsed manually!
+
+        // Remove the nodes corresponding to one message
+        consume_one(resp);
+    }
+}
+
+```
+
+To:
+
+```cpp
+// Loop to read Redis push messages.
+while (conn->will_reconnect()) {
+    // No need to reconnect, we now have PubSub state restoration
+    // Wait for pushes
+    auto [ec] = co_await conn->async_receive2(asio::as_tuple);
+    if (ec)
+        break; // Cancelled
+
+    // Consume the messages
+    for (push_view elem : push_parser(resp.value()))
+        std::cout << "Received message from channel " << elem.channel << ": " << elem.payload << "\n";
+
+    // Clear all the batch
+    resp.value().clear();
+}
+```