First cut at implementing float8array serializer

Author: dsmyth

src/oatpp-postgresql/mapping/Deserializer.cpp

@@ -339,19 +339,18 @@ oatpp::Void Deserializer::deserializeArray(const Deserializer* _this, const InDa
 
         // everything is in network order!!!
         // only handle 1d array for now
-        if (ntohl(pgArray->ndim) > 1) {
+        if (ntohl(pgArray->header.ndim) > 1) {
             throw std::runtime_error("[oatpp::postgresql::mapping::Deserializer::deserializeArray()]: Dimension > 1");
         }
 
         // make sure data is the right type
-        if (ntohl(pgArray->oid) == FLOAT8OID) {
+        if (ntohl(pgArray->header.oid) == FLOAT8OID) {
             // build the array
             auto vec = oatpp::Vector<Float64>::createShared();
-            auto pElem = &pgArray->elem;
-            auto nElem = ntohl(*pElem);
+            auto nElem = ntohl(pgArray->header.size);
             for (int i = 0; i < nElem; i++) {
                 // get element size, point to element data
-                auto elemSize = ntohl(*pElem++);
+                auto elemSize = ntohl(pgArray->elem[i].size);
                 // quit if we get an empty element
                 if (elemSize == 0) {
                     break;
@@ -363,8 +362,8 @@ oatpp::Void Deserializer::deserializeArray(const Deserializer* _this, const InDa
                 }
                 // get the 64 bit host order data, pointing to next element
                 // TODO: make sure this matches element size
-                v_int64 l1 = ntohl(*pElem++);
-                v_int64 l2 = ntohl(*pElem++);
+                v_int64 l1 = ntohl(pgArray->elem[i].value[0]);
+                v_int64 l2 = ntohl(pgArray->elem[i].value[1]);
                 v_int64 intVal = (l1 << 32) | l2 ;
                 v_float64 val = *reinterpret_cast<p_float64>(&intVal);
                 vec->push_back(val);

src/oatpp-postgresql/mapping/PgArray.hpp

@@ -5,16 +5,26 @@
 #ifndef oatpp_postgresql_mapping_PgArray_hpp
 #define oatpp_postgresql_mapping_PgArray_hpp
 
+// TODO: Assumes 64 bits for each element -- only valid for float64 and int64!
+struct PgElem {
+    v_int32 size;
+    v_int32 value[2];
+};
+
 // after https://stackoverflow.com/questions/4016412/postgresqls-libpq-encoding-for-binary-transport-of-array-data
-struct PgArray {
-    int32_t ndim;   // Number of dimensions
-    int32_t _ign;   // offset for data, removed by libpq
+struct PgArrayHeader {
+    v_int32 ndim;   // Number of dimensions
+    v_int32 _ign;   // offset for data, removed by libpq
     Oid oid;        // type of element in the array
 
     // Start of array (1st dimension)
-    int32_t size;   // Number of elements
-    int32_t index;  // Index of first element
-    int32_t elem;   // Beginning of (size, value) elements
+    v_int32 size;   // Number of elements
+    v_int32 index;  // Index of first element
+};
+
+struct PgArray {
+    PgArrayHeader header;
+    PgElem elem[1]; // Beginning of (size, value) elements
 };
 
 #endif // oatpp_postgresql_mapping_PgArray_hpp

src/oatpp-postgresql/mapping/Serializer.cpp

@@ -25,6 +25,7 @@
 #include "Serializer.hpp"
 
 #include "Oid.hpp"
+#include "PgArray.hpp"
 #include "oatpp-postgresql/Types.hpp"
 
 #if defined(WIN32) || defined(_WIN32)
@@ -397,10 +398,33 @@ void Serializer::serializeArray(const Serializer* _this, OutputData& outData, co
 
     if(polymorph) {
         auto v = polymorph.staticCast<oatpp::Vector<Float64>>();
-        outData.data = nullptr;
-        outData.dataSize = 0;
+
+        // get size of header + vector size * sizeof each element (size + data)
+        auto dataSize = sizeof(PgArrayHeader) + v->size() * sizeof(PgElem);
+        outData.dataBuffer.reset(new char[dataSize]);
+        outData.dataSize = dataSize;
         outData.dataFormat = 1;
         outData.oid = FLOAT8ARRAYOID;
+        outData.data = outData.dataBuffer.get();
+        auto buffer = outData.data;
+
+        // load the data in to the pgArray
+        auto *pgArray = reinterpret_cast<PgArray *>(buffer);
+        // only support 1d float8 arrays for now
+        pgArray->header.ndim = htonl(1);
+        pgArray->header._ign = 0;
+        pgArray->header.oid = htonl(FLOAT8OID);
+        pgArray->header.size = htonl(v->size());
+        pgArray->header.index = 0;
+
+        // stuff in the elements in network order
+        for (int i=0; i < v->size(); i++) {
+            pgArray->elem[i].size = htonl(sizeof(v_float64));
+            v_float64 fValue = v->at(i);
+            auto pVal = reinterpret_cast<p_int64>(&fValue);
+            pgArray->elem[i].value[0] = htonl(*pVal >> 32);
+            pgArray->elem[i].value[1] = htonl(*pVal & 0xFFFFFFFF);
+        }
     } else{
         serNull(outData);
     }