onesecondtrader 0.52.0__tar.gz → 0.54.0__tar.gz

{onesecondtrader-0.52.0 → onesecondtrader-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.52.0
+Version: 0.54.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 License-File: LICENSE
 Author: Nils P. Kujath

{onesecondtrader-0.52.0 → onesecondtrader-0.54.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.52.0"
+version = "0.54.0"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/__init__.py

@@ -0,0 +1,11 @@
+"""
+Provides data feed components for ingesting market data into the system.
+"""
+
+from .base import DatafeedBase
+from .simulated import SimulatedDatafeed
+
+__all__ = [
+    "DatafeedBase",
+    "SimulatedDatafeed",
+]

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/base.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import abc
+
+from onesecondtrader import events, messaging, models
+
+
+class DatafeedBase(abc.ABC):
+    """
+    Abstract base class for market data feed implementations.
+
+    A data feed is responsible for connecting to an external data source, managing symbol and bar-period subscriptions, and publishing market data events onto the system event bus.
+
+    Concrete subclasses implement the mechanics of connectivity, subscription handling, and lifecycle management for a specific data source.
+    """
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Initialize the data feed with an event bus.
+
+        parameters:
+            event_bus:
+                Event bus used to publish market data events produced by this data feed.
+        """
+        self._event_bus = event_bus
+
+    def _publish(self, event: events.EventBase) -> None:
+        """
+        Publish a market data event to the event bus.
+
+        This method is intended for use by subclasses to forward incoming data from the external source into the internal event-driven system.
+
+        parameters:
+            event:
+                Event instance to be published.
+        """
+        self._event_bus.publish(event)
+
+    @abc.abstractmethod
+    def connect(self) -> None:
+        """
+        Establish a connection to the underlying data source.
+
+        Implementations should perform any required setup, authentication, or resource allocation needed before subscriptions can be registered.
+        """
+        pass
+
+    @abc.abstractmethod
+    def disconnect(self) -> None:
+        """
+        Terminate the connection to the underlying data source.
+
+        Implementations should release resources and ensure that no further events are published after disconnection.
+        """
+        pass
+
+    @abc.abstractmethod
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Subscribe to market data for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols to subscribe to, interpreted according to the conventions of the underlying data source.
+            bar_period:
+                Bar aggregation period specifying the granularity of market data.
+        """
+        pass
+
+    @abc.abstractmethod
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Cancel existing subscriptions for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols for which subscriptions should be removed.
+            bar_period:
+                Bar aggregation period associated with the subscriptions.
+        """
+        pass
+
+    def wait_until_complete(self) -> None:
+        """
+        Block until the data feed has completed all pending work.
+
+        This method may be overridden by subclasses that perform asynchronous ingestion or background processing.
+        The default implementation does nothing.
+        """
+        pass

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/simulated.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import itertools
+import os
+import sqlite3
+import threading
+
+from onesecondtrader import events, messaging, models
+from onesecondtrader.datafeeds.base import DatafeedBase
+
+_RTYPE_MAP = {
+    models.BarPeriod.SECOND: 32,
+    models.BarPeriod.MINUTE: 33,
+    models.BarPeriod.HOUR: 34,
+    models.BarPeriod.DAY: 35,
+}
+
+_RTYPE_TO_BAR_PERIOD = {v: k for k, v in _RTYPE_MAP.items()}
+
+
+class SimulatedDatafeed(DatafeedBase):
+    """
+    Simulated market data feed backed by a secmaster SQLite database.
+
+    This datafeed replays historical OHLCV bars from a secmaster database, resolving symbols
+    via time-bounded symbology mappings. Bars are delivered in timestamp order, with all bars
+    sharing the same timestamp published before calling `wait_until_system_idle`.
+
+    Subclasses must set `publisher_name`, `dataset`, and `symbol_type` as class attributes to
+    scope the feed to a specific data source. The database must contain publishers with numeric
+    `source_instrument_id` values; symbol-only publishers (e.g., yfinance) are not supported.
+    """
+
+    db_path: str = ""
+    publisher_name: str = ""
+    dataset: str = ""
+    symbol_type: str = ""
+    price_scale: float = 1e9
+    start_ts: int | None = None
+    end_ts: int | None = None
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Parameters:
+            event_bus:
+                Event bus used to publish bar events and synchronize with subscribers.
+        """
+        super().__init__(event_bus)
+        self._db_path = self.db_path or os.environ.get(
+            "SECMASTER_DB_PATH", "secmaster.db"
+        )
+        if not self.publisher_name:
+            raise ValueError("publisher_name is required")
+        if not self.dataset:
+            raise ValueError("dataset is required")
+        if not self.symbol_type:
+            raise ValueError("symbol_type is required")
+        self._subscriptions: set[tuple[str, models.BarPeriod]] = set()
+        self._subscriptions_lock = threading.Lock()
+        self._connection: sqlite3.Connection | None = None
+        self._thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+        self._publisher_id: int | None = None
+
+    def connect(self) -> None:
+        """
+        Open a connection to the secmaster database and resolve the publisher.
+
+        If already connected, this method returns immediately.
+        """
+        if self._connection:
+            return
+        self._connection = sqlite3.connect(self._db_path, check_same_thread=False)
+        self._connection.execute("PRAGMA foreign_keys = ON")
+        self._connection.execute("PRAGMA journal_mode = WAL")
+        row = self._connection.execute(
+            "SELECT publisher_id FROM publishers WHERE name = ? AND dataset = ?",
+            (self.publisher_name, self.dataset),
+        ).fetchone()
+        if row is None:
+            raise ValueError(
+                f"Publisher not found: {self.publisher_name}/{self.dataset}"
+            )
+        self._publisher_id = row[0]
+
+    def disconnect(self) -> None:
+        """
+        Close the database connection and stop any active streaming.
+
+        If not connected, this method returns immediately.
+        """
+        if not self._connection:
+            return
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+        self._connection.close()
+        self._connection = None
+        self._publisher_id = None
+
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Register symbols for bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to subscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.update((s, bar_period) for s in symbols)
+
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Remove symbols from bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to unsubscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.difference_update((s, bar_period) for s in symbols)
+
+    def wait_until_complete(self) -> None:
+        """
+        Stream all subscribed bars and block until delivery is complete.
+
+        Bars are published in timestamp order. After each timestamp batch, the method
+        waits for all event bus subscribers to become idle before proceeding.
+        """
+        with self._subscriptions_lock:
+            has_subscriptions = bool(self._subscriptions)
+        if not has_subscriptions:
+            return
+        if self._thread is None or not self._thread.is_alive():
+            self._stop_event.clear()
+            self._thread = threading.Thread(
+                target=self._stream,
+                name=self.__class__.__name__,
+                daemon=False,
+            )
+            self._thread.start()
+        self._thread.join()
+
+    def _stream(self) -> None:
+        if not self._connection or self._publisher_id is None:
+            return
+
+        with self._subscriptions_lock:
+            subscriptions = list(self._subscriptions)
+        if not subscriptions:
+            return
+
+        symbols = list({symbol for symbol, _ in subscriptions})
+        rtypes = list({_RTYPE_MAP[bp] for _, bp in subscriptions})
+        subscription_set = {(symbol, _RTYPE_MAP[bp]) for symbol, bp in subscriptions}
+
+        params: list = [self._publisher_id, self.symbol_type]
+        params.extend(symbols)
+        params.extend(rtypes)
+        if self.start_ts is not None:
+            params.append(self.start_ts)
+        if self.end_ts is not None:
+            params.append(self.end_ts)
+
+        query = f"""
+            SELECT s.symbol, o.rtype, o.ts_event, o.open, o.high, o.low, o.close, o.volume
+            FROM ohlcv o
+            JOIN instruments i ON i.instrument_id = o.instrument_id
+            JOIN symbology s
+              ON s.publisher_ref = i.publisher_ref
+             AND s.source_instrument_id = i.source_instrument_id
+             AND date(o.ts_event / 1000000000, 'unixepoch') >= s.start_date
+             AND date(o.ts_event / 1000000000, 'unixepoch') <= s.end_date
+            WHERE i.publisher_ref = ?
+              AND s.symbol_type = ?
+              AND s.symbol IN ({",".join("?" * len(symbols))})
+              AND o.rtype IN ({",".join("?" * len(rtypes))})
+              {"AND o.ts_event >= ?" if self.start_ts is not None else ""}
+              {"AND o.ts_event <= ?" if self.end_ts is not None else ""}
+            ORDER BY o.ts_event, s.symbol
+        """
+
+        rows = self._connection.execute(query, params)
+
+        def to_bar(row):
+            symbol, rtype, ts_event, open_, high, low, close, volume = row
+            if (symbol, rtype) not in subscription_set:
+                return None
+            return events.market.BarReceived(
+                ts_event_ns=ts_event,
+                symbol=symbol,
+                bar_period=_RTYPE_TO_BAR_PERIOD[rtype],
+                open=open_ / self.price_scale,
+                high=high / self.price_scale,
+                low=low / self.price_scale,
+                close=close / self.price_scale,
+                volume=volume,
+            )
+
+        for _, group in itertools.groupby(rows, key=lambda r: r[2]):
+            if self._stop_event.is_set():
+                return
+            for bar in filter(None, map(to_bar, group)):
+                self._publish(bar)
+            self._event_bus.wait_until_system_idle()

onesecondtrader-0.54.0/src/onesecondtrader/secmaster/__init__.py

@@ -0,0 +1,15 @@
+"""
+Provides a schema for creating and utilities to populate the security master database.
+"""
+
+from .utils import (
+    create_secmaster_db,
+    ingest_databento_zip,
+    ingest_databento_dbn,
+)
+
+__all__ = [
+    "create_secmaster_db",
+    "ingest_databento_zip",
+    "ingest_databento_dbn",
+]

{onesecondtrader-0.52.0 → onesecondtrader-0.54.0}/src/onesecondtrader/secmaster/schema_versions/secmaster_schema_v1.sql

@@ -4,10 +4,16 @@
 -- Instrument identity is modeled per publisher namespace and supports either numeric upstream identifiers or symbols.
 -- Contract specifications and other static reference metadata are intentionally out of scope for this schema and should be stored separately if ingested.
 --
+-- The schema is explicitly ingestion-safe in the sense that:
+--
+-- 1) publishers are keyed by (vendor, dataset) rather than vendor alone, allowing multiple feeds per vendor;
+-- 2) symbology admits multiple mappings sharing the same start date by including the resolved instrument identifier
+--    in the primary key, preventing accidental overwrites during bulk ingestion.
+--
 -- | Table         | Description |
 -- |---------------|-------------|
--- | `publishers`  | Registry of data sources and their identifier namespaces. |
--- | `instruments` | Registry of instruments observed from market data ingestion within a publisher namespace. |
+-- | `publishers`  | Registry of vendor+dataset namespaces used for market data and instrument ingestion. |
+-- | `instruments` | Registry of instruments observed from ingestion within a publisher namespace. |
 -- | `ohlcv`       | Aggregated OHLCV bar data keyed by instrument, bar duration (`rtype`), and event timestamp (`ts_event`). |
 -- | `symbology`   | Time-bounded mappings from publisher-native symbols to publisher-native instrument identifiers. |
 
@@ -15,15 +21,24 @@
 
 -- Registry of all data sources used for market data and instrument ingestion.
 --
--- Each row represents a distinct data source.
--- A publisher establishes the provenance of instrument definitions and price data and provides the context in which raw symbols and native instrument identifiers are interpreted.
+-- Each row represents a distinct data product (feed) within a vendor namespace.
+-- A publisher record is uniquely identified by the pair (`name`, `dataset`), not by `name` alone.
+-- This allows a single vendor (e.g. Databento) to appear multiple times, once per concrete dataset/feed
+-- (e.g. `GLBX.MDP3`, `XNAS.ITCH`).
+--
+-- A publisher establishes the provenance of instrument definitions and price data and provides the context
+-- in which raw symbols and native instrument identifiers are interpreted.
 --
--- | Field           | Type      | Constraints          | Description                                                                                                                                                                     |
--- |-----------------|-----------|----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
--- | `publisher_id`  | `INTEGER` | `PRIMARY KEY`        | Internal surrogate key uniquely identifying a data source within the system.                                                                                                    |
--- | `name`          | `TEXT`    | `NOT NULL`, `UNIQUE` | Human-readable identifier for the data source or vendor (e.g. `databento`, `yfinance`).                                                                                         |
--- | `dataset`       | `TEXT`    | `NOT NULL`           | Identifier of the concrete data product or feed through which data is sourced; uses Databento dataset names (e.g. `GLBX.MDP3`) for Databento ingestion and internal identifiers for other sources (e.g. `YFINANCE`). |
--- | `venue`         | `TEXT`    |                      | Optional ISO 10383 Market Identifier Code (MIC) describing the primary trading venue; may be NULL for aggregated or multi-venue sources.                                        |
+-- | Field           | Type      | Constraints             | Description                                                                                                                                                                     |
+-- |-----------------|-----------|-------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+-- | `publisher_id`  | `INTEGER` | `PRIMARY KEY`           | Internal surrogate key uniquely identifying a publisher record within the system.                                                                                               |
+-- | `name`          | `TEXT`    | `NOT NULL`              | Human-readable vendor identifier for the data source (e.g. `databento`, `yfinance`).                                                                                            |
+-- | `dataset`       | `TEXT`    | `NOT NULL`              | Identifier of the concrete data product or feed through which data is sourced; uses Databento dataset names (e.g. `GLBX.MDP3`) for Databento ingestion and internal identifiers for other sources (e.g. `YFINANCE`). |
+-- | `venue`         | `TEXT`    |                         | Optional ISO 10383 Market Identifier Code (MIC) describing the primary trading venue; may be NULL for aggregated or multi-venue sources.                                        |
+--
+-- **Table constraints**
+--
+-- * `UNIQUE(name, dataset)` ensures that each vendor+feed combination is represented at most once.
 --
 -- **Examples**
 --
@@ -33,6 +48,12 @@
 -- *  `dataset` = `'GLBX.MDP3'`
 -- *  `venue`   = `XCME`
 --
+-- Databento NASDAQ TotalView feed:
+--
+-- *  `name`    = `'databento'`
+-- *  `dataset` = `'XNAS.ITCH'`
+-- *  `venue`   = `XNAS`
+--
 -- Yahoo Finance equity data:
 --
 -- *  `name`    = `'yfinance'`
@@ -41,14 +62,16 @@
 --
 CREATE TABLE publishers (
     publisher_id INTEGER PRIMARY KEY,
-    name TEXT NOT NULL UNIQUE,
+    name TEXT NOT NULL,
     dataset TEXT NOT NULL,
-    venue TEXT
+    venue TEXT,
+    UNIQUE (name, dataset)
 );
 
 
 
 
+
 -- Registry of instruments observed through market data ingestion.
 --
 -- Each row represents an instrument identity within a publisher namespace.
@@ -59,13 +82,13 @@ CREATE TABLE publishers (
 -- The table does not store contract specifications or other reference metadata.
 -- Such metadata must be stored separately when available.
 --
--- | Field                  | Type      | Constraints      | Description                                                                                                                                                 |
--- |------------------------|-----------|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
--- | `instrument_id`        | `INTEGER` | `PRIMARY KEY`    | Internal surrogate key identifying an instrument record within the system.                                                                                  |
--- | `publisher_ref`        | `INTEGER` | `NOT NULL`, `FK` | Foreign key reference to `publishers.publisher_id`, defining the publisher namespace in which this instrument identity is valid.                            |
+-- | Field                  | Type      | Constraints      | Description                                                                                                                                                  |
+-- |------------------------|-----------|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+-- | `instrument_id`        | `INTEGER` | `PRIMARY KEY`    | Internal surrogate key identifying an instrument record within the system.                                                                                   |
+-- | `publisher_ref`        | `INTEGER` | `NOT NULL`, `FK` | Foreign key reference to `publishers.publisher_id`, defining the publisher namespace in which this instrument identity is valid.                             |
 -- | `source_instrument_id` | `INTEGER` |                  | Publisher-native numeric instrument identifier as provided by the upstream data source (e.g. Databento instrument_id); may be `NULL` for symbol-only sources. |
--- | `symbol`               | `TEXT`    |                  | Publisher-native symbol string identifying the instrument (e.g. raw symbol, ticker); may be NULL when numeric identifiers are used.                         |
--- | `symbol_type`          | `TEXT`    |                  | Identifier describing the symbol scheme or resolution type used by the publisher (e.g. `raw_symbol`, `continuous`, `ticker`).                               |
+-- | `symbol`               | `TEXT`    |                  | Publisher-native symbol string identifying the instrument (e.g. raw symbol, ticker); may be NULL when numeric identifiers are used.                          |
+-- | `symbol_type`          | `TEXT`    |                  | Identifier describing the symbol scheme or resolution type used by the publisher (e.g. `raw_symbol`, `continuous`, `ticker`).                                |
 --
 -- Each instrument must be identifiable by at least one of `source_instrument_id` or `symbol`.
 -- Uniqueness constraints ensure that instrument identities do not collide within a publisher namespace.
@@ -78,7 +101,7 @@ CREATE TABLE instruments (
 
     source_instrument_id INTEGER,
     symbol TEXT,
-    symbol_type TEXT,
+	symbol_type TEXT,
 
     FOREIGN KEY (publisher_ref) REFERENCES publishers(publisher_id),
 
@@ -87,6 +110,8 @@ CREATE TABLE instruments (
         OR symbol IS NOT NULL
     ),
 
+	CHECK (symbol IS NULL OR symbol_type IS NOT NULL),
+
     UNIQUE (publisher_ref, source_instrument_id),
     UNIQUE (publisher_ref, symbol, symbol_type)
 );
@@ -98,16 +123,16 @@ CREATE TABLE instruments (
 
 -- Stores aggregated OHLCV bars for instruments at multiple time resolutions.
 --
--- | Field           | Type      | Constraints                                 | Description                                                                                                             |
--- |-----------------|-----------|---------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|
--- | `instrument_id` | `INTEGER` | `NOT NULL`, `FK`                            | Foreign key reference to `instruments.instrument_id`, identifying the instrument to which this bar belongs.             |
+-- | Field           | Type      | Constraints                                 | Description                                                                                                              |
+-- |-----------------|-----------|---------------------------------------------|--------------------------------------------------------------------------------------------------------------------------|
+-- | `instrument_id` | `INTEGER` | `NOT NULL`, `FK`                            | Foreign key reference to `instruments.instrument_id`, identifying the instrument to which this bar belongs.              |
 -- | `rtype`         | `INTEGER` | `NOT NULL`, `CHECK IN (32, 33, 34, 35, 36)` | Record type code encoding the bar duration using Databento OHLCV conventions (e.g. `32`=1s, `33`=1m, `34`=1h, `35`=1d). |
--- | `ts_event`      | `INTEGER` | `NOT NULL`                                  | Event timestamp of the bar as provided by the upstream source, stored as nanoseconds since the UTC Unix epoch.              |
--- | `open`          | `INTEGER` | `NOT NULL`                                  | Opening price of the bar interval, stored as a fixed-point integer using the upstream price scaling convention.         |
--- | `high`          | `INTEGER` | `NOT NULL`                                  | Highest traded price during the bar interval, stored as a fixed-point integer.                                          |
--- | `low`           | `INTEGER` | `NOT NULL`, `CHECK(low <= high)`            | Lowest traded price during the bar interval, stored as a fixed-point integer.                                           |
--- | `close`         | `INTEGER` | `NOT NULL`                                  | Closing price of the bar interval, stored as a fixed-point integer.                                                     |
--- | `volume`        | `INTEGER` | `NOT NULL`, `CHECK(volume >= 0)`            | Total traded volume during the bar interval.                                                                            |
+-- | `ts_event`      | `INTEGER` | `NOT NULL`                                  | Event timestamp of the bar as provided by the upstream source, stored as nanoseconds since the UTC Unix epoch.           |
+-- | `open`          | `INTEGER` | `NOT NULL`                                  | Opening price of the bar interval, stored as a fixed-point integer using the upstream price scaling convention.          |
+-- | `high`          | `INTEGER` | `NOT NULL`                                  | Highest traded price during the bar interval, stored as a fixed-point integer.                                           |
+-- | `low`           | `INTEGER` | `NOT NULL`, `CHECK(low <= high)`            | Lowest traded price during the bar interval, stored as a fixed-point integer.                                            |
+-- | `close`         | `INTEGER` | `NOT NULL`                                  | Closing price of the bar interval, stored as a fixed-point integer.                                                      |
+-- | `volume`        | `INTEGER` | `NOT NULL`, `CHECK(volume >= 0)`            | Total traded volume during the bar interval.                                                                             |
 --
 -- The composite primary key enforces uniqueness per instrument, bar duration, and event timestamp.
 -- Integrity constraints ensure basic OHLC consistency and prevent invalid price relationships from being stored.
@@ -135,7 +160,12 @@ CREATE TABLE ohlcv (
 
 -- Stores time-bounded mappings from publisher-native symbols to publisher-native instrument identifiers.
 --
--- The table captures symbol resolution rules as provided by upstream data sources and must be interpreted within the namespace of a specific publisher.
+-- The table captures symbol resolution rules as provided by upstream data sources and must be interpreted within the
+-- namespace of a specific publisher.
+--
+-- The schema permits multiple mappings to share the same `start_date` for a given (`publisher_ref`, `symbol`, `symbol_type`)
+-- by including `source_instrument_id` in the primary key. This prevents accidental overwrite when upstream symbology exports
+-- contain same-day corrections, backfills, or parallel resolution segments.
 --
 -- | Field                  | Type      | Constraints      | Description                                                                                                                |
 -- |------------------------|-----------|------------------|----------------------------------------------------------------------------------------------------------------------------|
@@ -146,7 +176,7 @@ CREATE TABLE ohlcv (
 -- | `start_date`           | `TEXT`    | `NOT NULL`       | First calendar date (inclusive) on which this symbol-to-instrument mapping is valid, stored in YYYY-MM-DD format.          |
 -- | `end_date`             | `TEXT`    | `NOT NULL`       | Last calendar date (inclusive) on which this symbol-to-instrument mapping is valid, stored in YYYY-MM-DD format.           |
 --
--- The primary key enforces uniqueness of symbol mappings per publisher, symbol type, and start date.
+-- The primary key enforces uniqueness of mappings at the granularity of a resolved instrument.
 -- Date bounds are interpreted as closed intervals.
 --
 CREATE TABLE symbology (
@@ -157,8 +187,9 @@ CREATE TABLE symbology (
     start_date TEXT NOT NULL,
     end_date TEXT NOT NULL,
     FOREIGN KEY (publisher_ref) REFERENCES publishers(publisher_id),
-    PRIMARY KEY (publisher_ref, symbol, symbol_type, start_date),
-    UNIQUE (publisher_ref, symbol_type, source_instrument_id, start_date),
+    FOREIGN KEY (publisher_ref, source_instrument_id)
+        REFERENCES instruments(publisher_ref, source_instrument_id),
+    PRIMARY KEY (publisher_ref, symbol, symbol_type, start_date, source_instrument_id),
     CHECK (start_date <= end_date)
 );