ADD: Add statistics schema to C++ client

Author: threecgreen

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## 0.7.0 - TBD
 - Added initial support for live data with `LiveBlocking` and `LiveThreaded` clients
+- Added support for statistics schema
 - Added `SystemMsg` and `ErrorMsg` records for use in live data
 - Added `strike_price`, `strike_price_currency`, and `instrument_class` to `InstrumentDefMsg`
 - Renamed `BatchJob.cost` to `cost_usd` and value now expressed as US dollars
@@ -16,6 +17,7 @@
 - Renamed `InstrumentDefMsg::symbol` to `raw_symbol`
 - Renamed `SymbolMapping::native_symbol` to `raw_symbol`
 - Deprecated `SType::Smart` to split into `SType::Parent` and `SType::Continuous`
+- Changed `expiration` and `action` type to `UnixNanos`
 - Changed some fields to enums in `InstrumentDefMsg`
 - Added optional `compression` parameter to `BatchSubmitJob`
 - Fixed parsing of `BatchSubmitJob` response

include/databento/enums.hpp

@@ -116,6 +116,7 @@ enum RType : std::uint8_t {
   Error = 0x15,
   SymbolMapping = 0x16,
   System = 0x17,
+  Statistics = 0x18,
   Mbo = 0xA0,
 };
 }  // namespace rtype
@@ -194,6 +195,49 @@ enum class UserDefinedInstrument : char {
   Yes = 'Y',
 };
 
+namespace stat_type {
+// The type of statistic contained in a StatMsg.
+enum StatType : std::uint16_t {
+  // The price of the first trade of an instrument. `price` will be set.
+  OpeningPrice = 1,
+  // The probable price of the first trade of an instrument published during
+  // pre-open. Both `price` and `quantity` will be set.
+  IndicativeOpeningPrice = 2,
+  // The settlement price of an instrument. `price` will be set and `flags`
+  // indicate whether the price is final or preliminary and actual or
+  // theoretical.
+  SettlementPrice = 3,
+  // The lowest trade price of an instrument during the trading session.
+  // `price` will be set.
+  TradingSessionLowPrice = 4,
+  // The highest trade price of an instrument during the trading session.
+  // `price` will be set.
+  TradingSessionHighPrice = 5,
+  // The number of contracts cleared for an instrument on the previous trading
+  // date. `quantity` will be set.
+  ClearedVolume = 6,
+  // The lowest offer price for an instrument during the trading session.
+  // `price` will be set.
+  LowestOffer = 7,
+  // The highest bid price for an instrument during the trading session.
+  // `price` will be set.
+  HighestBid = 8,
+  // The current number of outstanding contracts of an instrument. `quantity`
+  // will be set.
+  OpenInterest = 9,
+  // The volume-weighted average price (VWAP) for a fixing period. `price` will
+  // be set.
+  FixingPrice = 10,
+};
+}  // namespace stat_type
+using stat_type::StatType;
+
+// The type of StatMsg update.
+enum class StatUpdateAction : std::uint8_t {
+  New = 1,
+  Delete = 2,
+};
+
 // Convert a HistoricalGateway to a URL.
 const char* UrlFromGateway(HistoricalGateway gateway);
 
@@ -214,6 +258,8 @@ const char* ToString(InstrumentClass instrument_class);
 const char* ToString(MatchAlgorithm match_algorithm);
 const char* ToString(SecurityUpdateAction update_action);
 const char* ToString(UserDefinedInstrument user_def_instr);
+const char* ToString(StatType stat_type);
+const char* ToString(StatUpdateAction stat_update_action);
 
 std::ostream& operator<<(std::ostream& out, Schema schema);
 std::ostream& operator<<(std::ostream& out, Encoding encoding);
@@ -233,6 +279,9 @@ std::ostream& operator<<(std::ostream& out, MatchAlgorithm match_algorithm);
 std::ostream& operator<<(std::ostream& out, SecurityUpdateAction update_action);
 std::ostream& operator<<(std::ostream& out,
                          UserDefinedInstrument user_def_instr);
+std::ostream& operator<<(std::ostream& out, StatType stat_type);
+std::ostream& operator<<(std::ostream& out,
+                         StatUpdateAction stat_update_action);
 
 template <typename T>
 T FromString(const std::string& str);

include/databento/record.hpp

@@ -6,6 +6,7 @@
 #include <cstdint>
 #include <cstring>  // strncmp
 #include <string>
+#include <tuple>  // tie
 
 #include "databento/datetime.hpp"  // UnixNanos
 #include "databento/enums.hpp"
@@ -171,8 +172,8 @@ struct InstrumentDefMsg {
   UnixNanos ts_recv;
   std::int64_t min_price_increment;
   std::int64_t display_factor;
-  std::uint64_t expiration;
-  std::uint64_t activation;
+  UnixNanos expiration;
+  UnixNanos activation;
   std::int64_t high_limit_price;
   std::int64_t low_limit_price;
   std::int64_t max_price_variation;
@@ -265,11 +266,33 @@ struct ImbalanceMsg {
   Side unpaired_side;
   char significant_imbalance;
   // padding for alignment
-  std::array<char, 1> dummy[1];
+  std::array<char, 1> dummy;
 };
 
 static_assert(sizeof(ImbalanceMsg) == 112, "ImbalanceMsg size must match C");
 
+/// A statistics message. A catchall for various data disseminated by
+/// publishers. The `stat_type` indicates the statistic contained in the
+/// message.
+struct StatMsg {
+  static bool HasRType(RType rtype) { return rtype == RType::Statistics; }
+
+  RecordHeader hd;
+  UnixNanos ts_recv;
+  UnixNanos ts_ref;
+  std::int64_t price;
+  std::int32_t quantity;
+  std::uint32_t sequence;
+  TimeDeltaNanos ts_in_delta;
+  StatType stat_type;
+  std::uint16_t channel_id;
+  StatUpdateAction update_action;
+  std::uint8_t stat_flags;
+  std::array<char, 6> dummy;
+};
+
+static_assert(sizeof(StatMsg) == 64, "StatMsg size must match C");
+
 // An error message from the Live Subscription Gateway (LSG). This will never
 // be present in historical data.
 struct ErrorMsg {
@@ -396,13 +419,32 @@ inline bool operator!=(const ImbalanceMsg& lhs, const ImbalanceMsg& rhs) {
   return !(lhs == rhs);
 }
 
+inline bool operator==(const StatMsg& lhs, const StatMsg& rhs) {
+  return std::tie(lhs.hd, lhs.ts_recv, lhs.ts_ref, lhs.price, lhs.quantity,
+                  lhs.sequence, lhs.ts_in_delta, lhs.stat_type, lhs.channel_id,
+                  lhs.update_action, lhs.stat_flags) ==
+         std::tie(rhs.hd, rhs.ts_recv, rhs.ts_ref, rhs.price, rhs.quantity,
+                  rhs.sequence, rhs.ts_in_delta, rhs.stat_type, rhs.channel_id,
+                  rhs.update_action, rhs.stat_flags);
+}
+inline bool operator!=(const StatMsg& lhs, const StatMsg& rhs) {
+  return !(lhs == rhs);
+}
+
 inline bool operator==(const ErrorMsg& lhs, const ErrorMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.err == rhs.err;
 }
 inline bool operator!=(const ErrorMsg& lhs, const ErrorMsg& rhs) {
   return !(lhs == rhs);
 }
 
+inline bool operator==(const SystemMsg& lhs, const SystemMsg& rhs) {
+  return lhs.hd == rhs.hd && lhs.msg == rhs.msg;
+}
+inline bool operator!=(const SystemMsg& lhs, const SystemMsg& rhs) {
+  return !(lhs == rhs);
+}
+
 inline bool operator==(const SymbolMappingMsg& lhs,
                        const SymbolMappingMsg& rhs) {
   return lhs.hd == rhs.hd && lhs.stype_in_symbol == rhs.stype_in_symbol &&
@@ -430,8 +472,12 @@ std::ostream& operator<<(std::ostream& stream,
 std::string ToString(const ImbalanceMsg& imbalance_msg);
 std::ostream& operator<<(std::ostream& stream,
                          const ImbalanceMsg& imbalance_msg);
+std::string ToString(const StatMsg& stat_msg);
+std::ostream& operator<<(std::ostream& stream, const StatMsg& stat_msg);
 std::string ToString(const ErrorMsg& err_msg);
 std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg);
+std::string ToString(const SystemMsg& system_msg);
+std::ostream& operator<<(std::ostream& stream, const SystemMsg& system_msg);
 std::string ToString(const SymbolMappingMsg& symbol_mapping_msg);
 std::ostream& operator<<(std::ostream& stream,
                          const SymbolMappingMsg& symbol_mapping_msg);

src/enums.cpp

@@ -280,6 +280,9 @@ const char* ToString(RType rtype) {
     case RType::System: {
       return "System";
     }
+    case RType::Statistics: {
+      return "Statistics";
+    }
     case RType::Mbo: {
       return "Mbo";
     }
@@ -430,6 +433,58 @@ const char* ToString(UserDefinedInstrument user_def_instr) {
   }
 }
 
+const char* ToString(StatType stat_type) {
+  switch (stat_type) {
+    case StatType::OpeningPrice: {
+      return "OpeningPrice";
+    }
+    case StatType::IndicativeOpeningPrice: {
+      return "IndicativeOpeningPrice";
+    }
+    case StatType::SettlementPrice: {
+      return "SettlementPrice";
+    }
+    case StatType::TradingSessionLowPrice: {
+      return "TradingSessionLowPrice";
+    }
+    case StatType::TradingSessionHighPrice: {
+      return "TradingSessionHighPrice";
+    }
+    case StatType::ClearedVolume: {
+      return "ClearedVolume";
+    }
+    case StatType::LowestOffer: {
+      return "LowestOffer";
+    }
+    case StatType::HighestBid: {
+      return "HighestBid";
+    }
+    case StatType::OpenInterest: {
+      return "OpenInterest";
+    }
+    case StatType::FixingPrice: {
+      return "FixingPrice";
+    }
+    default: {
+      return "Unknown";
+    }
+  }
+}
+
+const char* ToString(StatUpdateAction stat_update_action) {
+  switch (stat_update_action) {
+    case StatUpdateAction::New: {
+      return "New";
+    }
+    case StatUpdateAction::Delete: {
+      return "Delete";
+    }
+    default: {
+      return "Unknown";
+    }
+  }
+}
+
 std::ostream& operator<<(std::ostream& out, Schema schema) {
   out << ToString(schema);
   return out;
@@ -517,6 +572,17 @@ std::ostream& operator<<(std::ostream& out,
   return out;
 }
 
+std::ostream& operator<<(std::ostream& out, StatType stat_type) {
+  out << ToString(stat_type);
+  return out;
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         StatUpdateAction stat_update_action) {
+  out << ToString(stat_update_action);
+  return out;
+}
+
 template <>
 Schema FromString(const std::string& str) {
   if (str == "mbo") {

src/record.cpp

@@ -43,6 +43,12 @@ std::size_t Record::SizeOfSchema(const Schema schema) {
     case Schema::Definition: {
       return sizeof(InstrumentDefMsg);
     }
+    case Schema::Statistics: {
+      return sizeof(StatMsg);
+    }
+    case Schema::Imbalance: {
+      return sizeof(ImbalanceMsg);
+    }
     default: {
       throw InvalidArgumentError{
           "Record::SizeOfSchema", "schema",
@@ -84,6 +90,12 @@ RType Record::RTypeFromSchema(const Schema schema) {
     case Schema::Definition: {
       return RType::InstrumentDef;
     }
+    case Schema::Statistics: {
+      return RType::Statistics;
+    }
+    case Schema::Imbalance: {
+      return RType::Imbalance;
+    }
     default: {
       throw InvalidArgumentError{
           "Record::RTypeFromSchema", "schema",
@@ -430,6 +442,26 @@ std::ostream& operator<<(std::ostream& stream,
       .Finish();
 }
 
+std::string ToString(const StatMsg& stat_msg) { return MakeString(stat_msg); }
+std::ostream& operator<<(std::ostream& stream, const StatMsg& stat_msg) {
+  return StreamOpBuilder{stream}
+      .SetSpacer("\n    ")
+      .SetTypeName("StatMsg")
+      .Build()
+      .AddField("hd", stat_msg.hd)
+      .AddField("ts_recv", stat_msg.ts_recv)
+      .AddField("ts_ref", stat_msg.ts_ref)
+      .AddField("price", FixPx{stat_msg.price})
+      .AddField("quantity", stat_msg.quantity)
+      .AddField("sequence", stat_msg.sequence)
+      .AddField("ts_in_delta", stat_msg.ts_in_delta)
+      .AddField("stat_type", stat_msg.stat_type)
+      .AddField("channel_id", stat_msg.channel_id)
+      .AddField("update_action", stat_msg.update_action)
+      .AddField("stat_flags", stat_msg.stat_flags)
+      .Finish();
+}
+
 std::string ToString(const ErrorMsg& err_msg) { return MakeString(err_msg); }
 std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg) {
   return StreamOpBuilder{stream}
@@ -441,6 +473,19 @@ std::ostream& operator<<(std::ostream& stream, const ErrorMsg& err_msg) {
       .Finish();
 }
 
+std::string ToString(const SystemMsg& system_msg) {
+  return MakeString(system_msg);
+}
+std::ostream& operator<<(std::ostream& stream, const SystemMsg& system_msg) {
+  return StreamOpBuilder{stream}
+      .SetSpacer("\n    ")
+      .SetTypeName("SystemMsg")
+      .Build()
+      .AddField("hd", system_msg.hd)
+      .AddField("msg", system_msg.msg)
+      .Finish();
+}
+
 std::string ToString(const SymbolMappingMsg& symbol_mapping_msg) {
   return MakeString(symbol_mapping_msg);
 }

test/src/record_tests.cpp

@@ -66,8 +66,8 @@ TEST(RecordTests, TestInstrumentDefMsgToString) {
       UnixNanos{},
       1,
       2,
-      3,
-      4,
+      UnixNanos{},
+      UnixNanos{},
       5,
       6,
       7,
@@ -134,8 +134,8 @@ TEST(RecordTests, TestInstrumentDefMsgToString) {
     ts_recv = 0,
     min_price_increment = 0.000000001,
     display_factor = 2,
-    expiration = 3,
-    activation = 4,
+    expiration = 0,
+    activation = 0,
     high_limit_price = 0.000000005,
     low_limit_price = 0.000000006,
     max_price_variation = 0.000000007,