ores.marketdata.series_classification_rule

The taxonomy rule for a market series, one row per identity the runtime classifies. The runtime reads the whole table once, builds a classifier from it, and asks that classifier for the asset classes and the series subclass of every series it creates.

The table replaces a compiled C++ map, so the taxonomy is managed like every other catalogue: an instrument a corpus adds later, or one a user brings, is an inserted row rather than a rebuild. This matters because an ingest that cannot classify a series it must create aborts on it, so a compiled table makes every new instrument a code change.

The key is the oresmd identity and not an ORE key. Two kinds of identity reach this table, and key_kind says which a row is keyed by:

• datum, keyed by instrument – the text the URI writes under instrument, such as ir_swap or discount – and by quote, the text it writes under quote, or the empty string for a rule that applies to every quote of its instrument. Most instruments classify the same way whatever their quote carries, so their row holds the empty string; a lookup tries the exact quote first and falls back to the empty one.
• index, keyed by instrument too, which for this kind holds the index family's oresmd name or the empty string for every family. A fixing series is an index and not a datum, so it is keyed by the index's own vocabulary.

asset_class_source says where a row's classes come from:

• literal names its class in asset_class_code.
• correlation_operands reads the classes from the two operand fields of a correlation datum, because a pairwise correlation belongs to the two classes it relates and to no class of its own.
• index_authority reads the class from the index family's schema row, whose asset authority names the market-data namespace the index is written in, and ores.refdata.asset_class_catalogue maps that authority onto a refdata class. One row serves every index family, and a family the catalogue maps to no class leaves the class list empty rather than mis-classing the series.

The class codes name rows in refdata.asset_class_code and the subclass codes name rows in refdata.series_subclass_code, and the insert trigger checks both against those catalogues.

The reader rejects an empty table, because an empty table aborts the first ingest that reads it and the message should name the table rather than the first series it met.

std::string("ir_swap")

std::string("rate")

std::string("datum")

std::string("literal")

[idx]{
    constexpr auto count = sizeof(domain::asset_class_codes) /
                           sizeof(domain::asset_class_codes[0]);
    return std::string(domain::asset_class_codes[static_cast<std::size_t>(idx) % count]);
}()

[idx]{
    static constexpr std::string_view subclasses[] = {
        "spot",    "forward", "volatility", "yield",       "basis",
        "fra",     "xccy",    "spread",     "index_credit", "recovery",
        "swap",    "capfloor", "seasonality", "price",     "correlation",
        "prepayment", "transition_probability", "index_fixing"};
    return std::string(subclasses[static_cast<std::size_t>(idx) % std::size(subclasses)]);
}()

#include "ores.marketdata.api/domain/asset_class_authorities.hpp"
#include <optional>
#include <string>

#include <optional>
#include <string>