Struct DatabentoHistorical 

pub struct DatabentoHistorical { /* private fields */ }

Historical data fetcher for Databento.

Wraps HistoricalClient for fetching historical market data older than 24 hours.

Implementations

impl DatabentoHistorical

pub fn from_env() -> Result<Self, DataError>

Create a new historical client using API key from environment.

Reads DATABENTO_API_KEY from environment variables.

Errors

Returns error if DATABENTO_API_KEY is not set or client construction fails.

pub fn new(api_key: &str) -> Result<Self, DataError>

Create a new historical client with an explicit API key.

Errors

Returns error if client construction fails.

pub async fn fetch_trades<K: Clone>( &mut self, params: &GetRangeParams, exchange: ExchangeId, instrument: K, ) -> Result<Vec<MarketEvent<K, PublicTrade>>, DataError>

Fetch historical trades for the given parameters.

Collects all records into memory before returning. For large queries (millions of records), consider fetch_trades_stream to process records incrementally.

Arguments

• params - Query parameters (dataset, symbols, time range)
• exchange - ExchangeId to tag events with (should match dataset)
• instrument - Instrument key to tag events with

Performance

The instrument key is cloned for each record. For high-frequency data, use Arc<K> to avoid per-record heap allocations:

let instrument = Arc::new("ES".to_string());
let trades = client.fetch_trades(&params, exchange, instrument).await?;

Returns

Vector of trades converted to PublicTrade events. Each event’s time_received is stamped at decode time on the local machine.

pub async fn fetch_quotes<K: Clone>( &mut self, params: &GetRangeParams, exchange: ExchangeId, instrument: K, ) -> Result<Vec<MarketEvent<K, Quote>>, DataError>

Fetch historical quotes (top-of-book) for the given parameters.

Uses MBP-1 (Market By Price level 1) schema. Collects all records into memory before returning. For large queries, consider fetch_quotes_stream.

Arguments

• params - Query parameters (dataset, symbols, time range). Schema should be Mbp1.
• exchange - ExchangeId to tag events with
• instrument - Instrument key to tag events with

Performance

The instrument key is cloned for each record. For high-frequency data, use Arc<K> to avoid per-record heap allocations.

Each event’s time_received is stamped at decode time on the local machine.

pub async fn fetch_candles<K: Clone>( &mut self, params: &DatabentoOhlcvParams, exchange: ExchangeId, instrument: K, ) -> Result<Vec<MarketEvent<K, Candle>>, DataError>

Fetch historical OHLCV candles for the given parameters.

Collects all records into memory before returning. For large queries, consider fetch_candles_stream.

Schema derivation

The DBN schema is derived internally from DatabentoOhlcvParams::interval via the crate-internal ensure_databento_ohlcv_supports, so the interval and schema cannot diverge — the caller never supplies a Schema. The interval is also load-bearing for each candle’s close_time (see Candle::close_time).

Time range

DatabentoOhlcvParams::time_range is (start, end) with inclusive start and exclusive end, filtering on the bar’s ts_event — i.e. the bar open instant, Databento’s native OHLCV filter field — not the normalised close_time. (Unlike the Hyperliquid path, no close-time range-widening/trimming is applied; the range is passed through to Databento’s native open-time filter.)

Arguments

• params - Typed OHLCV query parameters (dataset, symbols, range, interval)
• exchange - ExchangeId to tag events with (should match dataset)
• instrument - Instrument key to tag events with (use Arc<K> for efficiency)

Errors

Returns DataError::UnsupportedInterval if params.interval is not one of Databento’s native intervals (1s/1m/1h/1d); DataError::Databento if the request fails, a record fails to decode, a price field carries the UNDEF_PRICE sentinel, or a candle’s close_time overflows. A conversion failure is propagated, never silently skipped (native OHLCV bars have no skippable-malformed mode).

pub async fn fetch_candles_stream<K: Clone + Send + 'static>( &mut self, params: &DatabentoOhlcvParams, exchange: ExchangeId, instrument: K, ) -> Result<impl Stream<Item = Result<MarketEvent<K, Candle>, DataError>>, DataError>

Stream historical OHLCV candles without collecting into memory.

Unlike fetch_candles, this returns a stream that yields records as they’re decoded, avoiding memory spikes for large queries.

See fetch_candles for schema-derivation and time-range semantics.

Errors

Returns DataError::UnsupportedInterval up front if params.interval is unsupported, or DataError::Databento if the initial get_range request fails. Per-item errors are yielded as Err items: a DBN decode failure (the decoder is then in an unspecified state — drop the stream), an rtype/schema contract violation (assert_ohlcv_rtype_matches; the stream keeps polling but every record is likely to fail the same way — drop the stream), or a candle conversion failure (an UNDEF_PRICE sentinel or close_time overflow — surfaced, never skipped).

pub async fn fetch_trades_stream<K: Clone + Send + 'static>( &mut self, params: &GetRangeParams, exchange: ExchangeId, instrument: K, ) -> Result<impl Stream<Item = Result<MarketEvent<K, PublicTrade>, DataError>>, DataError>

Stream historical trades without collecting into memory.

Unlike fetch_trades, this returns a stream that yields records as they’re decoded, avoiding memory spikes for large queries.

Arguments

• params - Query parameters (dataset, symbols, time range)
• exchange - ExchangeId to tag events with
• instrument - Instrument key to tag events with (use Arc<K> for efficiency)

Errors

The outer Result returns DataError::Databento if the initial get_range request fails (e.g. authentication, network, or invalid params).

Per-item errors are yielded as Err items on the stream and indicate a DBN decode failure. After a decode error the underlying decoder is in an unspecified state; callers should drop the stream rather than continue polling for more records. Records that successfully decode but fail conversion to PublicTrade are logged at debug and skipped silently.

pub async fn fetch_quotes_stream<K: Clone + Send + 'static>( &mut self, params: &GetRangeParams, exchange: ExchangeId, instrument: K, ) -> Result<impl Stream<Item = Result<MarketEvent<K, Quote>, DataError>>, DataError>

Stream historical quotes without collecting into memory.

Unlike fetch_quotes, this returns a stream that yields records as they’re decoded, avoiding memory spikes for large queries.

Arguments

• params - Query parameters (dataset, symbols, time range). Schema should be Mbp1.
• exchange - ExchangeId to tag events with
• instrument - Instrument key to tag events with (use Arc<K> for efficiency)

Errors

The outer Result returns DataError::Databento if the initial get_range request fails (e.g. authentication, network, or invalid params).

Per-item errors are yielded as Err items on the stream and indicate a DBN decode failure. After a decode error the underlying decoder is in an unspecified state; callers should drop the stream rather than continue polling for more records. Records that successfully decode but fail conversion to Quote are logged at debug and skipped silently.

pub fn client(&self) -> &HistoricalClient

Returns the underlying client for advanced use cases.

pub fn client_mut(&mut self) -> &mut HistoricalClient

Returns a mutable reference to the underlying client.

Trait Implementations

impl Debug for DatabentoHistorical

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.