Better Serializer

Author: lganzzzo

src/oatpp-postgresql/Executor.cpp

@@ -28,6 +28,8 @@
 #include "ql_template/TemplateValueProvider.hpp"
 #include "oatpp/core/data/stream/ChunkedBuffer.hpp"
 
+#include <vector>
+
 namespace oatpp { namespace postgresql {
 
 std::unique_ptr<Oid[]> Executor::getParamTypes(const StringTemplate& queryTemplate, const ParamsTypeMap& paramsTypeMap) {
@@ -81,6 +83,8 @@ void Executor::executeQuery(const StringTemplate& queryTemplate,
 
   v_uint32 paramsNumber = queryTemplate.getTemplateVariables().size();
 
+  std::vector<mapping::Serializer::OutputData> outData(paramsNumber);
+
   std::unique_ptr<const char* []> paramValues(new const char*[paramsNumber]);
   std::unique_ptr<int[]> paramLengths(new int[paramsNumber]);
   std::unique_ptr<int[]> paramFormats(new int[paramsNumber]);
@@ -91,8 +95,13 @@ void Executor::executeQuery(const StringTemplate& queryTemplate,
     if(it == params.end()) {
       throw std::runtime_error("param not found");
     }
-    paramLengths[i] = m_serializer.serialize(&paramValues[i], it->second);
-    paramFormats[i] = 1;
+
+    auto& data = outData[i];
+    m_serializer.serialize(data, it->second);
+
+    paramValues[i] = data.data;
+    paramLengths[i] = data.dataSize;
+    paramFormats[i] = data.dataFormat;
   }
 
   PGresult *qres = PQexecPrepared(pgConnection,

src/oatpp-postgresql/mapping/Serializer.cpp

@@ -70,22 +70,23 @@ void Serializer::setSerializerMethod(const data::mapping::type::ClassId& classId
   }
 }
 
-int Serializer::serialize(const char** outData, const oatpp::Void& polymorph) const {
-
+void Serializer::serialize(OutputData& outData, const oatpp::Void& polymorph) const {
   auto id = polymorph.valueType->classId.id;
   auto& method = m_methods[id];
   if(method) {
-    return (*method)(outData, polymorph);
+    (*method)(outData, polymorph);
+  } else {
+    throw std::runtime_error("[oatpp::postgresql::mapping::Serializer::serialize()]: "
+                             "Error. No serialize method for type '" + std::string(polymorph.valueType->classId.name) +
+                             "'");
   }
-
-  throw std::runtime_error("[oatpp::postgresql::mapping::Serializer::serialize()]: "
-                           "Error. No serialize method for type '" + std::string(polymorph.valueType->classId.name) + "'");
 }
 
-int Serializer::serializeString(const char** outData, const oatpp::Void& polymorph) {
+void Serializer::serializeString(OutputData& outData, const oatpp::Void& polymorph) {
   base::StrBuffer* buff = static_cast<base::StrBuffer*>(polymorph.get());
-  *outData = buff->c_str();
-  return buff->getSize();
+  outData.data = buff->c_str();
+  outData.dataSize = buff->getSize();
+  outData.dataFormat = 1;
 }
 
 }}}

src/oatpp-postgresql/mapping/Serializer.hpp

@@ -31,7 +31,16 @@ namespace oatpp { namespace postgresql { namespace mapping {
 
 class Serializer {
 public:
-  typedef int (*SerializerMethod)(const char**, const oatpp::Void&);
+
+  struct OutputData {
+    std::unique_ptr<char[]> dataBuffer;
+    const char* data;
+    int dataSize;
+    int dataFormat;
+  };
+
+public:
+  typedef void (*SerializerMethod)(OutputData&, const oatpp::Void&);
 private:
   std::vector<SerializerMethod> m_methods;
 public:
@@ -40,11 +49,11 @@ class Serializer {
 
   void setSerializerMethod(const data::mapping::type::ClassId& classId, SerializerMethod method);
 
-  int serialize(const char** outData, const oatpp::Void& polymorph) const;
+  void serialize(OutputData& outData, const oatpp::Void& polymorph) const;
 
 public:
 
-  static int serializeString(const char** outData, const oatpp::Void& polymorph);
+  static void serializeString(OutputData& outData, const oatpp::Void& polymorph);
 
 };
 

src/oatpp-postgresql/mapping/TypeMapper.cpp

@@ -47,9 +47,9 @@ TypeMapper::TypeMapper() {
   setTypeOid(data::mapping::type::__class::Int64::CLASS_ID, INT8OID);
   setTypeOid(data::mapping::type::__class::UInt64::CLASS_ID, 0);
 
-  setTypeOid(data::mapping::type::__class::Float32::CLASS_ID, 0);
-  setTypeOid(data::mapping::type::__class::Float64::CLASS_ID, 0);
-  setTypeOid(data::mapping::type::__class::Boolean::CLASS_ID, 0);
+  setTypeOid(data::mapping::type::__class::Float32::CLASS_ID, FLOAT4OID);
+  setTypeOid(data::mapping::type::__class::Float64::CLASS_ID, FLOAT8OID);
+  setTypeOid(data::mapping::type::__class::Boolean::CLASS_ID, BOOLOID);
 
   setTypeOid(data::mapping::type::__class::AbstractObject::CLASS_ID, 0);
   setTypeOid(data::mapping::type::__class::AbstractEnum::CLASS_ID, 0);