Refactoring the QuestDB/Postgres flow

Author: mccaffers

backtesting-engine-cpp.xcodeproj/project.pbxproj

@@ -53,6 +53,7 @@
 		941B549C2D3BBFB900E3BF64 /* trading_definitions.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = trading_definitions.hpp; sourceTree = "<group>"; };
 		94280BA12D2FC00200F1CF56 /* base64.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = base64.hpp; sourceTree = "<group>"; };
 		94280BA22D2FC00200F1CF56 /* base64.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = base64.cpp; sourceTree = "<group>"; };
+		942966D82D48E84A00532862 /* priceData.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = priceData.hpp; sourceTree = "<group>"; };
 		94364CB52D416D8000F35B55 /* db.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = db.mm; sourceTree = "<group>"; };
 		944D0DC82C8C3704004DD0FC /* LICENSE.MD */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; path = LICENSE.MD; sourceTree = "<group>"; };
 		944D0DC92C8C3704004DD0FC /* build.sh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.sh; path = build.sh; sourceTree = "<group>"; };
@@ -1285,6 +1286,14 @@
 			path = utilities;
 			sourceTree = "<group>";
 		};
+		942966D72D48E84100532862 /* models */ = {
+			isa = PBXGroup;
+			children = (
+				942966D82D48E84A00532862 /* priceData.hpp */,
+			);
+			path = models;
+			sourceTree = "<group>";
+		};
 		944D0DB52C8C36C0004DD0FC = {
 			isa = PBXGroup;
 			children = (
@@ -3455,6 +3464,7 @@
 		94DE4F772C8C3E7C00FE48FF /* include */ = {
 			isa = PBXGroup;
 			children = (
+				942966D72D48E84100532862 /* models */,
 				94B8C7932D3D770800E17EB6 /* utilities */,
 				941B548F2D3BBA3B00E3BF64 /* trading_definitions */,
 				941B549C2D3BBFB900E3BF64 /* trading_definitions.hpp */,

source/databaseConnection.cpp

@@ -5,6 +5,7 @@
 // ---------------------------------------
 
 #include "databaseConnection.hpp"
+#include "base64.hpp"
 #include <pqxx/pqxx>
 
 DatabaseConnection::DatabaseConnection(const std::string& endpoint, int port,
@@ -20,41 +21,53 @@ DatabaseConnection::DatabaseConnection(const std::string& endpoint, int port,
 
 }
 
-void DatabaseConnection::executeQuery(const std::string& query) const {
-  try {
-      // Establish connection
-      pqxx::connection conn(this->connection_string);
-
-      // Rest of your code remains the same
-      if (!conn.is_open()) {
-          throw std::invalid_argument("Failed to open database connection");
-      }
-
-      std::cout << "Connected to database successfully!" << std::endl;
-
-      // Create a transaction
-      pqxx::work txn(conn);
-
-      // Execute query
-      pqxx::result result = txn.exec(query);
-
-      // Print results
-      for (const auto& row : result) {
-          for (const auto& field : row) {
-              std::cout << field.c_str() << "\t";
-          }
-          std::cout << std::endl;
-      }
-
-      // Commit transaction
-      txn.commit();
-
-  } catch (const pqxx::broken_connection& e) {
-        std::cerr << "Connection error: " << e.what() << std::endl;
-    } catch (const pqxx::sql_error& e) {
-        std::cerr << "SQL error: " << e.what() << std::endl;
-        std::cerr << "Query was: " << e.query() << std::endl;
-    } catch (const pqxx::usage_error& e) {
-        std::cerr << "Usage error: " << e.what() << std::endl;
+std::vector<PriceData> DatabaseConnection::executeQuery(const std::string& query) const {
+    std::vector<PriceData> results;
+    
+    try {
+        pqxx::connection conn(this->connection_string);
+
+        if (!conn.is_open()) {
+            throw std::invalid_argument("Failed to open database connection");
+        }
+
+        std::cout << "Connected to database successfully!" << std::endl;
+
+        pqxx::work txn(conn);
+        pqxx::result result = txn.exec(query);
+
+        // Convert results to PriceData objects
+        for (const auto& row : result) {
+            double value1 = row[0].as<double>();
+            double value2 = row[1].as<double>();
+            std::string timestamp_str = row[2].as<std::string>();
+            
+            auto timestamp = Utilities::parseTimestamp(timestamp_str);
+            
+            results.emplace_back(value1, value2, timestamp);
+        }
+
+        txn.commit();
+
+    } catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
+    }
+
+    return results;
+}
+
+// Example usage function to demonstrate how to work with the results
+void DatabaseConnection::printResults(const std::vector<PriceData>& results) const {
+    for (const auto& data : results) {
+        // Convert timestamp back to string for display
+        auto time_t = std::chrono::system_clock::to_time_t(data.timestamp);
+        auto tm = *std::localtime(&time_t);
+        std::stringstream ss;
+        ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
+        
+        std::cout << std::fixed << std::setprecision(4)
+                 << data.value1 << "\t"
+                 << data.value2 << "\t"
+                 << ss.str() << std::endl;
     }
 }

source/include/databaseConnection.hpp

@@ -6,6 +6,7 @@
 #pragma once
 #include <iostream>
 #include <pqxx/pqxx>
+#include "models/priceData.hpp"
 
 class DatabaseConnection {
 private:
@@ -18,7 +19,8 @@ class DatabaseConnection {
                         const std::string& user = "admin",
                         const std::string& password = "");
 
-  void executeQuery(const std::string& query) const;
+  void printResults(const std::vector<PriceData>& results) const;
+  std::vector<PriceData> executeQuery(const std::string& query) const;
 
   const std::string& getConnectionString() const {
     return connection_string;

source/include/models/priceData.hpp

@@ -0,0 +1,16 @@
+// Backtesting Engine in C++
+//
+// (c) 2025 Ryan McCaffery | https://mccaffers.com
+// This code is licensed under MIT license (see LICENSE.txt for details)
+// ---------------------------------------
+#pragma once
+
+struct PriceData {
+    double value1;
+    double value2;
+    std::chrono::system_clock::time_point timestamp;
+
+    // Constructor for easy creation
+    PriceData(double v1, double v2, const std::chrono::system_clock::time_point& ts)
+        : value1(v1), value2(v2), timestamp(ts) {}
+};

source/include/utilities/base64.hpp

@@ -20,3 +20,9 @@ class Base64 {
   static bool isValidBase64(const std::string& input);
   static std::string checkInput(const std::string& base64_input);
 };
+
+class Utilities {
+public:
+  static std::chrono::system_clock::time_point parseTimestamp(const std::string& ts);
+};
+

source/utilities/base64.cpp

@@ -4,6 +4,9 @@
 // This code is licensed under MIT license (see LICENSE.txt for details)
 // ---------------------------------------
 
+#include <iomanip>  // Add this header for std::get_time
+#include <sstream>
+#include <chrono>
 #include "base64.hpp"
 
 static const char* const B64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -111,3 +114,21 @@ bool Base64::isValidBase64(const std::string& input) {
             return strchr(valid, c) != nullptr;
         });
 }
+
+std::chrono::system_clock::time_point Utilities::parseTimestamp(const std::string& ts) {
+    std::tm tm = {};
+    std::istringstream ss(ts);
+    ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
+    
+    auto timePoint = std::chrono::system_clock::from_time_t(std::mktime(&tm));
+    
+    // Parse milliseconds if present
+    if (ss.peek() == '.') {
+        ss.ignore(); // Skip the dot
+        int milliseconds;
+        ss >> milliseconds;
+        timePoint += std::chrono::milliseconds(milliseconds / 1000); // Convert microseconds to milliseconds
+    }
+    
+    return timePoint;
+}