float/double to string - match Postgres behaviour more closely, and fix PG11 compatibility.

Follow-up to #4 and #5.

Author: mpartel

postgres_utils.cpp

@@ -1,8 +1,18 @@
 
 #include "postgres_utils.hpp"
 
+#include <algorithm>
+#include <cfloat>
+#include <cmath>
+
 extern "C" {
+#include <pg_config.h>
 #include <postgres.h>
+#include <utils/builtins.h>
+#if PG_VERSION_NUM >= 120000
+#include <common/shortest_dec.h>
+#include <utils/float.h>
+#endif
 }
 
 namespace postgres_protobuf {
@@ -16,5 +26,54 @@ void* palloc0_or_throw_bad_alloc(size_t size) {
   return p;
 }
 
+std::string float_to_string(float x) {
+  // Matches behaviour of `float4out`
+#if PG_VERSION_NUM >= 120000
+  char buf[32];
+  static_assert(32 >= FLOAT_SHORTEST_DECIMAL_LEN);
+  if (extra_float_digits > 0) {
+    float_to_shortest_decimal_buf(x, buf);
+  } else {
+    pg_strfromd(buf, 32, FLT_DIG + extra_float_digits, x);
+  }
+  return std::string(buf);
+#else
+  if (std::isnan(x)) {
+    return "NaN";
+  }
+  int inf = std::isinf(x);
+  if (inf == 1) {
+    return "Infinity";
+  } else if (inf == -1) {
+    return "-Infinity";
+  } else {
+    int digits = std::max(1, FLT_DIG + extra_float_digits);
+    char* buf = psprintf("%.*g", digits, x);
+    std::string s(buf);
+    pfree(buf);
+    return s;
+  }
+#endif
+}
+
+std::string double_to_string(double x) {
+  // Matches behaviour of `float8out`
+#if PG_VERSION_NUM >= 120000
+  char buf[32];
+  static_assert(32 >= DOUBLE_SHORTEST_DECIMAL_LEN);
+  if (extra_float_digits > 0) {
+    double_to_shortest_decimal_buf(x, buf);
+  } else {
+    pg_strfromd(buf, 32, DBL_DIG + extra_float_digits, x);
+  }
+  return std::string(buf);
+#else
+  char* buf = float8out_internal(x);
+  std::string s(buf);
+  pfree(buf);
+  return s;
+#endif
+}
+
 }  // namespace postgres_utils
 }  // namespace postgres_protobuf

postgres_utils.hpp

@@ -46,6 +46,9 @@ void pdelete(T* p) {
   pfree(p);
 }
 
+std::string float_to_string(float x);
+std::string double_to_string(double x);
+
 // TODO: pass memory context explicitly?
 template <typename T>
 class PostgresAllocator : public std::allocator<T> {

querying.cpp

@@ -1,8 +1,5 @@
 #include "querying.hpp"
 
-#include "descriptor_db.hpp"
-#include "postgres_protobuf_common.hpp"
-
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
@@ -14,6 +11,10 @@
 #include <utility>
 #include <vector>
 
+#include "descriptor_db.hpp"
+#include "postgres_protobuf_common.hpp"
+#include "postgres_utils.hpp"
+
 // Protobuf headers must be included before any Postgres headers because
 // the latter pollute names like 'FATAL' used by macros in the former.
 #include <google/protobuf/descriptor.h>
@@ -27,7 +28,6 @@
 extern "C" {
 // Must be included before other Postgres headers
 #include <postgres.h>
-#include <common/shortest_dec.h>
 }
 
 namespace pb = ::google::protobuf;
@@ -464,18 +464,12 @@ class PrimitiveEmitter : public Emitter {
                   field.wire_type, ty_);
     switch (ty_) {
       case T::TYPE_DOUBLE:
-        {
-          char buf[DOUBLE_SHORTEST_DECIMAL_LEN];
-          double_to_shortest_decimal_buf(WFL::DecodeDouble(field.value.as_uint64), buf);
-          EmitStr(std::move(std::string(buf)));
-        }
+        EmitStr(std::move(postgres_utils::double_to_string(
+            WFL::DecodeDouble(field.value.as_uint64))));
         break;
       case T::TYPE_FLOAT:
-        {
-          char buf[FLOAT_SHORTEST_DECIMAL_LEN];
-          float_to_shortest_decimal_buf(WFL::DecodeFloat(field.value.as_uint32), buf);
-          EmitStr(std::move(std::string(buf)));
-        }
+        EmitStr(std::move(postgres_utils::float_to_string(
+            WFL::DecodeFloat(field.value.as_uint32))));
         break;
       case T::TYPE_INT64:
       case T::TYPE_SFIXED64: