6.3.4: Build fix for statement parameters

This is a minor update to 6.3, the previous stable release. It fixes the handling of const in smart-pointer-like arguments to prepared/parameterised statements.

6.4.4: Build improvements

Fixes some puzzling CMake build errors. Turns out the problem was, sometimes there are still autoconf-generated config headers in the source tree, and the CMake build would prefer those over the ones which CMake itself had generated in the binary tree. Bad things would happen if the two contained incompatible configuration.

Also, uses pkg-config if the pg_config script is not available. Expect pkg-config to become the default over time.

6.4.3: Install new stream headers

This release fixes two omissions with the new stream_from and stream_to headers:

1. The native automake-based build did not include them in the install.
2. They were not included in the pqxx/pqxx header.

The old tablereader and tablewriter headers are no longer included from pqxx/pqxx. They're still there, but you won't automatically include them when you include pqxx/pqxx. The stream_from/stream_to headers replace the tablereader/tablewriter ones, and the old headers will be gone completely in 7.0.

6.4.2: Fix the fix.

Well, that fix for a memory leak in 6.4.1 wasn't quite perfect. Yes, the memory got freed. But not in quite the right way for Windows, where you can't allocate memory in one DLL (in this case libpq) and free it in another (here, libpqxx). If you are using Windows, unescaping binary data in 6.4.1 will probably crash, and 6.4.2 should fix it. If you are not on Windows, or are not calling esc_raw, you shouldn't notice any difference.

Thanks @egorpugin for spotting the problem and pointing it out so quickly!

6.4.1: Memory bugs fixed

It's been ages since I ran libpqxx through some solid memory checking tools. In this case, I enabled all gcc instrumentation I could find, and it turned up a few small leaks and a use-after-free!

Those are fixed now, so I recommend that you upgrade.

6.4.0: Object lifetime bug fixed

This release addresses (but does not fully prevent) a subtle lifetime bug. Due to an unexpected subtlety in how libpq and libpqxx interact, an application would access invalid memory if the following things all happened together:

1. The application receives a result object from a connection.
2. It destroys the connection, but keeps the result.
3. And, it continues using the result.
4. Then, it does something on the result which causes the underlying C driver, libpq, to issue an error or warning message.

Today's update can't prevent this, but it further limits the circumstances under which this can happen. Now, the bug will only happen if the connection has an errorhandler registered on it at the time it produces the result.

Documentation has been updated to mention this as a hazard of registering an error handler. If you need to register an errorhandler on a connection, you will need to keep the connection object alive until you stop using the result you got from that connection.

6.3.3: Just a little more of the same.

Another exception change: if a connection's client encoding can't be read, the attempt will throw an exception.

Also, a few more CMake build problems are fixed.

6.3.2: Fixes but also some real changes

It's mostly small fixes, but some of these changes may affect your application. So test carefully.

• Conversion errors no longer throw pqxx::failure; always conversion_error!
• Use C++17's built-in numeric string conversions, if available.
• Query numeric precision in a more sensible, standard way.
• Avoid "dead code" warning.
• Replace obsolete autoconf macros.
• Remove all using namespace std.
• CMake build fixes.

6.3.1: Windows compile fixes

This is a minor update to 6.3.0, fixing a few build problems on Windows.

See the 6.3.0 release for the really interesting stuff!

6.3.0: Encodings, new stream classes, deprecations, and more.

This is a big release, with lots of changes. It paves the way for some even more drastic changes to come in 7.0.

First let me tell you what's new in 6.3, and then I'll go into my plans for 7.0.

What's new in 6.3

Thanks to some major contributions from Joseph "JadeMatrix" Durel, we now have:

Type-safe replacements for tablereader and tablewriter: stream_from and stream_to. They support tuples (or tuple-like types) to represent database rows on the client side, so you could stream a std::tuple or std::vector straight into a database row, or vice versa.

Broader support for variable-width multibyte client encodings. UTF-8 has always worked, but other encodings such as SJIS might confuse the code by embedding bytes that looked like ASCII quotes or backslashes and such inside a multibyte character. From now on, the library should work properly with all client encodings that PostgreSQL supports.

In other news:

• libpqxx lets you assign names to some types of objects, such as cursors or transactions. These names are now more tolerant of "special" characters such as embedded quotes or non-ASCII letters.
• The CMake build has been overhauled. There may be teething problems, so please report anything you run into.
• Copying result objects for long SQL queries is now faster.

For the really big changes though, we're going to have to break stuff. Many items have also been deprecated. See the section on my 7.0 plans below.

Also, many items which had been documented as being deprecated are now actually marked deprecated, using the C++ deprecated attribute if your compiler supports it. This means that you may start seeing warnings where your code has been using deprecated features. Those features really will start disappearing in 7.0.

Preparing for 7.0

We'll see some profound change in libpqxx 7.0. Some of details still have to be worked out, but in 6.3 you'll start seeing deprecation warnings for features that will no longer work as before.

What can you expect from 7.0? What will you need to be ready for? Read on.

C++ upgrade

C++11 has been great, but now I want more. There are some wonderful things we can do if we bump the minimum requirement to C++17. Is your compiler ready for them?

The C++17 features I'd particularly like to use are:

• std::optional as, eventually, the one standard way to accommodate null values.
• Nested namespaces. It'll make pqxx::internal easier for me to manage.
• std::string_view support in places where we already accept std::string or C-style strings.
• std::to_chars and std::from_chars could replace a lot of libpqxx code.

If your compiler is not ready for any of these new features, please file a bug on the ​Github page so I can avoid breaking your build.

Connection classes

The connection class hierarchy is going to change drastically. If you have defined your own custom connection classes, these will no longer work, and you will start to see deprecation warnings in libpqxx 6.3. The new design is not final, but it will be a lot simpler than what we have now. Some esoteric features are going to disappear, and in return you'll get a move constructor and a much easier class hierarchy to work with.

The plan is to fold essentially the entire class hierarchy into one single class. It will support the current built-in connection types, but it won't be extensible. We have always had an API for defining your own connection policies, and the library uses it to implement different types of connections, but I've never heard of anyone else using this API to define their own connection types. The existing built-in connection types will just be thin wrappers for the single connection class, and eventually the single connection class should replace them all.

Replacing lazyconnection and asyncconnection

If you're using lazyconnection or asyncconnection, the API will change. You'll have to do a bit of extra work.

In older libpqxx versions, you got a connection object which looks just like a regular connection but only completes its actual connection to the database once you actually start using it. Your code will have to go through an explicit check-or-wait step before using the connection. It may end up looking similar to std::future, or it may just be a member function. I'm not sure yet.

No more connection reactivation

It's just a fact of life: network connections to the database can break. It could happen because of a network problem, or the database may have been restarted. The existing connection classes hide this from you. They notice that the connection is broken and quietly try to re-establish it for you. This feature is going to be removed.

That may sound like a problem. But your application already knows how to deal with a broken connection, right? It may simply happen slightly more often.

I believe doing it this way will make the application design issues clearer, eliminate a duplication of effort between libpqxx and your application, and clear out some dark corners where bugs might hide. It will also remove an enormous source of complexity inside the connection classes.

As a bonus, several operations on connection objects can finally get the const qualifier. That's because they will no longer try to re-establish a broken connection, or finalise an incomplete lazy or asynchronous connection. It will be a lot more obvious which operations make changes to your connection and which ones will not. Some references in your code that don't look like they modify the connection may even become const.