10 create end to end trade management logic

CMakeLists.txt

@@ -14,7 +14,6 @@ project(BacktestingEngine)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-
 # Configure libpqxx build
 set(PQXX_LIBRARIES_INSTALL ON)
 set(SKIP_BUILD_TEST ON)
@@ -51,8 +50,18 @@ file(GLOB_RECURSE SOURCES "source/*.cpp")
 # Create a library of your project's code
 add_library(BacktestingEngineLib STATIC ${SOURCES})
 
-# Link against pqxx
-target_link_libraries(BacktestingEngineLib pqxx)
+# Replace find_package(OpenMP REQUIRED) with this:
+if(APPLE)
+    set(OpenMP_C_FLAGS "-Xclang -fopenmp")
+    set(OpenMP_CXX_FLAGS "-Xclang -fopenmp")
+    set(OpenMP_C_LIB_NAMES "omp")
+    set(OpenMP_CXX_LIB_NAMES "omp")
+    set(OpenMP_omp_LIBRARY /opt/homebrew/opt/libomp/lib/libomp.dylib)
+    find_package(OpenMP REQUIRED)
+    target_include_directories(BacktestingEngineLib PRIVATE /opt/homebrew/opt/libomp/include)
+endif()
+
+target_link_libraries(BacktestingEngineLib PUBLIC pqxx OpenMP::OpenMP_CXX)
 
 # Main executable
 add_executable(BacktestingEngine source/main.cpp)

documents/questdb.md

@@ -0,0 +1,5 @@
+Start QuestDB (on macOS)
+
+```
+JAVA_HOME="/opt/homebrew/opt/openjdk@17" sh $HOME/dev/questdb/questdb.sh start -d $HOME/dev/questdb/data
+```

include/databaseConnection.hpp

@@ -21,6 +21,7 @@ class DatabaseConnection {
 
   void printResults(const std::vector<PriceData>& results) const;
   std::vector<PriceData> executeQuery(const std::string& query) const;
+  std::vector<PriceData> streamQuery(const std::string& query) const;
 
   const std::string& getConnectionString() const {
     return connection_string;

include/models/priceData.hpp

@@ -5,13 +5,17 @@
 // ---------------------------------------
 #pragma once
 #include <chrono>
+#include <string>
 
 struct PriceData {
-    double value1;
-    double value2;
+    double ask;
+    double bid;
     std::chrono::system_clock::time_point timestamp;
+    std::string symbol;
 
     // Constructor for easy creation
-    PriceData(double v1, double v2, const std::chrono::system_clock::time_point& ts)
-        : value1(v1), value2(v2), timestamp(ts) {}
+    PriceData(double ask, double bid, const std::chrono::system_clock::time_point& ts, const std::string& symbol)
+        : ask(ask), bid(bid), timestamp(ts), symbol(symbol) {}
+
+    PriceData() : ask(0.0), bid(0.0), timestamp{}, symbol("") {}
 };

include/operations.hpp

@@ -0,0 +1,15 @@
+// Backtesting Engine in C++
+//
+// (c) 2026 Ryan McCaffery | https://mccaffers.com
+// This code is licensed under MIT license (see LICENSE.txt for details)
+// ---------------------------------------
+
+#pragma once
+#include <vector>
+#include "models/priceData.hpp"
+
+class Operations {
+
+public:
+    static void run(const std::vector<PriceData>& priceData);
+};

include/sqlManager.hpp

@@ -11,8 +11,7 @@
 
 class SqlManager {
 public:
-    static std::vector<PriceData> getInitialPriceData(const DatabaseConnection& db);
-    static std::string getBaseQuery();
-private:
-    static constexpr int DEFAULT_LIMIT = 1000;
+    static std::vector<PriceData> streamPriceData(const DatabaseConnection& db, const std::vector<std::string>& symbols, int LAST_MONTHS = 1);
+    static std::string getBaseQuery(const std::vector<std::string>& symbols, int LAST_MONTHS = 1);
+
 };

scripts/build_dep.sh

@@ -0,0 +1,11 @@
+cd ./external/libpqxx
+
+mkdir -p build
+cd ./build
+
+export PATH="$(brew --prefix libpq)/bin:$PATH"
+export PKG_CONFIG_PATH="$(brew --prefix libpq)/lib/pkgconfig:$PKG_CONFIG_PATH"
+export PostgreSQL_ROOT="$(brew --prefix libpq)"
+
+cmake .. -DCMAKE_CXX_STANDARD=20 -DCMAKE_BUILD_TYPE=Release 
+make

scripts/run.sh

@@ -7,6 +7,10 @@ current_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 # source $current_dir/environment.sh - no longer necessary
 source $current_dir/clean.sh
 source $current_dir/build.sh
+if [ $? -ne 0 ]; then
+    echo "Error: Build failed. Aborting."
+    exit 1
+fi
 
 # Debug: Check if the executable exists
 if [ -f "$BUILD_DIR/$EXECUTABLE_NAME" ]; then
@@ -49,5 +53,9 @@ output=$(echo "$json" | base64)
 
 # Step 6: Run the tests for now (/executable) from the root directory
 # Passing two arguements, the destination of the QuestDB and the Strategy JSON (in base64)
+start_time=$(date +%s%N)
 ./"$BUILD_DIR/$EXECUTABLE_NAME" localhost "$output"
+end_time=$(date +%s%N)
+elapsed=$(( (end_time - start_time) / 1000000 ))
+echo "Execution time: ${elapsed}ms"
 

source/CMakeLists.txt

@@ -0,0 +1,68 @@
+cmake_minimum_required(VERSION 3.30)
+
+# CMAKE_OSX_SYSROOT is a macOS-specific setting that specifies the SDK path.
+# This is ignored on non-Apple platforms, so it's safe to include in cross-platform builds.
+execute_process(
+    COMMAND xcrun --show-sdk-path
+    OUTPUT_VARIABLE CMAKE_OSX_SYSROOT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+project(BacktestingEngine)
+
+# Set the C++ standard
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Configure libpqxx build
+set(PQXX_LIBRARIES_INSTALL ON)
+set(SKIP_BUILD_TEST ON)
+set(SKIP_CONFIGURE_LIBPQXX OFF)
+
+# Disable warningsfor external libraries
+set(PREV_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
+elseif(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /w")
+endif()
+
+# Quiet CMAKE output
+set(CMAKE_INSTALL_MESSAGE NEVER)
+set(CMAKE_MESSAGE_LOG_LEVEL "WARNING")
+
+# Build libpqxx from source
+add_subdirectory(external/libpqxx EXCLUDE_FROM_ALL)
+
+# Include directories
+include_directories(
+    ${CMAKE_SOURCE_DIR}/include
+    ${CMAKE_SOURCE_DIR}/include/utilities
+    ${CMAKE_SOURCE_DIR}/include/models
+    ${CMAKE_SOURCE_DIR}/include/trading
+    ${CMAKE_SOURCE_DIR}/include/trading_definitions
+    ${CMAKE_SOURCE_DIR}/external
+)
+
+# Collect all .cpp files in the src directory
+file(GLOB_RECURSE SOURCES "source/*.cpp")
+
+# Create a library of your project's code
+add_library(BacktestingEngineLib STATIC ${SOURCES})
+
+# Replace find_package(OpenMP REQUIRED) with this:
+if(APPLE)
+    set(OpenMP_C_FLAGS "-Xclang -fopenmp")
+    set(OpenMP_CXX_FLAGS "-Xclang -fopenmp")
+    set(OpenMP_C_LIB_NAMES "omp")
+    set(OpenMP_CXX_LIB_NAMES "omp")
+    set(OpenMP_omp_LIBRARY /opt/homebrew/opt/libomp/lib/libomp.dylib)
+    find_package(OpenMP REQUIRED)
+    target_include_directories(BacktestingEngineLib PRIVATE /opt/homebrew/opt/libomp/include)
+endif()
+
+target_link_libraries(BacktestingEngineLib PUBLIC pqxx OpenMP::OpenMP_CXX)
+
+# Main executable
+add_executable(BacktestingEngine source/main.cpp)
+target_link_libraries(BacktestingEngine BacktestingEngineLib)

source/databaseConnection.cpp

@@ -7,6 +7,31 @@
 #include "databaseConnection.hpp"
 #include "base64.hpp"
 #include <pqxx/pqxx>
+#include <cstdio>
+#include <charconv>
+#include <execution>
+#include <algorithm>
+
+static std::chrono::system_clock::time_point fastParseTimestamp(const char* ts) {
+    int year, month, day, hour, min, sec, usec = 0;
+    std::sscanf(ts, "%4d-%2d-%2d %2d:%2d:%2d.%d", &year, &month, &day, &hour, &min, &sec, &usec);
+
+    // Cache timegm per date — tick data is time-ordered so date changes rarely
+    static char cachedDate[11] = {};
+    static time_t cachedEpoch = 0;
+    if (std::memcmp(ts, cachedDate, 10) != 0) {
+        std::memcpy(cachedDate, ts, 10);
+        std::tm tm = {};
+        tm.tm_year = year - 1900;
+        tm.tm_mon  = month - 1;
+        tm.tm_mday = day;
+        tm.tm_isdst = 0;
+        cachedEpoch = timegm(&tm);
+    }
+
+    time_t t = cachedEpoch + hour * 3600 + min * 60 + sec;
+    return std::chrono::system_clock::from_time_t(t) + std::chrono::microseconds(usec);
+}
 
 DatabaseConnection::DatabaseConnection(const std::string& endpoint, int port,
                                      const std::string& dbname, const std::string& user,
@@ -21,37 +46,23 @@ DatabaseConnection::DatabaseConnection(const std::string& endpoint, int port,
 
 }
 
-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);
+std::vector<PriceData> DatabaseConnection::streamQuery(const std::string& query) const {
+    pqxx::connection conn(this->connection_string);
+    pqxx::nontransaction 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();
+    std::vector<PriceData> results(result.size());
 
-    } catch (const std::exception& e) {
-        std::cerr << "Error: " << e.what() << std::endl;
-    }
+    for (int i = 0; i < (int)result.size(); ++i) {
+        const auto& row = result[i];
+        double ask, bid;
+        auto symbol = row[0].view();
+        auto sv1 = row[1].view();
+        auto sv2 = row[2].view();
+        std::from_chars(sv1.data(), sv1.data() + sv1.size(), ask);
+        std::from_chars(sv2.data(), sv2.data() + sv2.size(), bid);
+        results[i] = PriceData(ask, bid, fastParseTimestamp(row[3].c_str()), std::string(symbol));
+    }  
 
     return results;
 }
@@ -70,8 +81,8 @@ void DatabaseConnection::printResults(const std::vector<PriceData>& results) con
         ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
 
         std::cout << std::fixed << std::setprecision(4)
-                 << data.value1 << "\t"
-                 << data.value2 << "\t"
+                 << data.ask << "\t"
+                 << data.bid << "\t"
                  << ss.str() << std::endl;
     }
 }

source/main.cpp

@@ -1,6 +1,6 @@
 // Backtesting Engine in C++
 //
-// (c) 2025 Ryan McCaffery | https://mccaffers.com
+// (c) 2026 Ryan McCaffery | https://mccaffers.com
 // This code is licensed under MIT license (see LICENSE.txt for details)
 // ---------------------------------------
 
@@ -23,36 +23,24 @@
 #include "tradeManager.hpp"
 #include "jsonParser.hpp"
 #include "sqlManager.hpp"
+#include "operations.hpp"
 
 using json = nlohmann::json;
 
+// Entry point. Expects two command-line arguments:
+//   argv[1] — hostname/IP of the QuestDB instance
+//   argv[2] — Base64-encoded JSON strategy configuration
 int main(int argc, const char * argv[]) {
 
-  // Connect to QuestDb argv[1]
   DatabaseConnection db(argv[1], 8812, "qdb", "admin", "quest");
 
-  // Load strategy from Base64 argv[2]
   JsonParser::parseConfigurationFromBase64(argv[2]);
 
-  std::vector<PriceData> priceData = SqlManager::getInitialPriceData(db);
-
-  // Convert timestamp to readable format for debugging
-  auto timeT = std::chrono::system_clock::to_time_t(priceData[0].timestamp);
-  std::cout << "Timestamp: " << std::put_time(std::localtime(&timeT), "%Y-%m-%d %H:%M:%S") << std::endl;
-
-  auto tradeManager = TradeManager::getInstance();
-
-  // Open a trade
-  std::string tradeId = tradeManager->openTrade(1.2345, 100000, true);
-  std::cout << "Opened trade: " << tradeId << std::endl;
-
-  // Review account
-  size_t openTrades = tradeManager->reviewAccount();
-  std::cout << "Number of open trades: " << openTrades << std::endl;
+  std::vector<std::string> symbols = {"AUSIDXAUD", "EURUSD"};
+  std::vector<PriceData> ticks = SqlManager::streamPriceData(db, symbols, 1);
+  printf("Total ticks streamed: %zu\n", ticks.size());
 
-  // Close trade
-  bool closed = tradeManager->closeTrade(tradeId);
-  std::cout << "Trade closed: " << (closed ? "yes" : "no") << std::endl;
+  Operations::run(ticks);
 
   return 0;
 

source/operations.cpp

@@ -0,0 +1,52 @@
+// Backtesting Engine in C++
+//
+// (c) 2026 Ryan McCaffery | https://mccaffers.com
+// This code is licensed under MIT license (see LICENSE.txt for details)
+// ---------------------------------------
+
+#include "operations.hpp"
+// std headers
+#include <iostream>
+#include <vector>
+#include <memory>
+#include <string>
+#include <iomanip>
+#include "tradeManager.hpp"
+
+void Operations::run(const std::vector<PriceData>& ticks) {
+
+    // Loop aroudn every tick
+    // Example output:
+    // symbol=AUSIDXAUD, ask=8602.4000, bid=8599.4000 timestamp=2026-03-12 18:39:01.076
+    // symbol=AUSIDXAUD, ask=8602.9000, bid=8599.9000 timestamp=2026-03-12 18:39:01.584
+    // symbol=EURUSD, ask=1.1513, bid=1.1512 timestamp=2026-03-12 18:39:01.644
+    // symbol=AUSIDXAUD, ask=8602.4000, bid=8599.4000 timestamp=2026-03-12 18:39:01.770
+    // symbol=AUSIDXAUD, ask=8601.9000, bid=8598.9000 timestamp=2026-03-12 18:39:01.982
+
+    for (const auto& tick : ticks) {
+        // (void)tick;
+
+        // print first tick
+        auto time_t = std::chrono::system_clock::to_time_t(tick.timestamp);
+        struct tm tm = {};
+        if (localtime_r(&time_t, &tm) == nullptr) {
+            std::cerr << "Error: failed to convert timestamp" << std::endl;
+        }
+        char buffer[20];
+        std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
+        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(tick.timestamp.time_since_epoch()) % 1000;
+        printf("symbol=%s, ask=%.4f, bid=%.4f timestamp=%s.%03lld\n", tick.symbol.c_str(), tick.ask, tick.bid, buffer,
+               static_cast<long long>(ms.count()));
+    }
+
+    auto tradeManager = TradeManager::getInstance();
+
+    // std::string tradeId = tradeManager->openTrade(ticks[0].ask, 100000, true);
+    // std::cout << "Opened trade: " << tradeId << std::endl;
+
+    // size_t openTrades = tradeManager->reviewAccount();
+    // std::cout << "Number of open trades: " << openTrades << std::endl;
+
+    // bool closed = tradeManager->closeTrade(tradeId);
+    // std::cout << "Trade closed: " << (closed ? "yes" : "no") << std::endl;
+}