Struct PostgresCacheDatabase

pub struct PostgresCacheDatabase {
    pub pool: PgPool,
    /* private fields */
}

Fields

pool: PgPool

Implementations

impl PostgresCacheDatabase

pub async fn connect( host: Option<String>, port: Option<u16>, username: Option<String>, password: Option<String>, database: Option<String>, ) -> Result<Self, Error>

Connects to the Postgres cache database using the provided connection parameters.

Errors

Returns an error if establishing the database connection fails.

Panics

Panics if the internal Postgres pool connection attempt (connect_pg) unwraps on error.

Trait Implementations

impl CacheDatabaseAdapter for PostgresCacheDatabase

fn close(&mut self) -> Result<()>

Closes the cache database connection.

fn flush(&mut self) -> Result<()>

Flushes any pending changes to the database.

fn load_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CacheMap>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all cached data into memory.

fn load(&self) -> Result<HashMap<String, Bytes>>

Loads raw key-value data from the database.

fn load_currencies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<Ustr, Currency>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all currencies from the cache.

fn load_instruments<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<InstrumentId, InstrumentAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all instruments from the cache.

fn load_synthetics<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<InstrumentId, SyntheticInstrument>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all synthetic instruments from the cache.

fn load_accounts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<AccountId, AccountAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all accounts from the cache.

fn load_orders<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<ClientOrderId, OrderAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all orders from the cache.

fn load_positions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<PositionId, Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all positions from the cache.

fn load_index_order_position(&self) -> Result<HashMap<ClientOrderId, Position>>

Loads mapping from order IDs to position IDs.

fn load_index_order_client(&self) -> Result<HashMap<ClientOrderId, ClientId>>

Loads mapping from order IDs to client IDs.

fn load_currency<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 Ustr, ) -> Pin<Box<dyn Future<Output = Result<Option<Currency>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single currency by code.

fn load_instrument<'life0, 'life1, 'async_trait>( &'life0 self, instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<Option<InstrumentAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single instrument by ID.

fn load_synthetic<'life0, 'life1, 'async_trait>( &'life0 self, instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<Option<SyntheticInstrument>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single synthetic instrument by ID.

fn load_account<'life0, 'life1, 'async_trait>( &'life0 self, account_id: &'life1 AccountId, ) -> Pin<Box<dyn Future<Output = Result<Option<AccountAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single account by ID.

fn load_order<'life0, 'life1, 'async_trait>( &'life0 self, client_order_id: &'life1 ClientOrderId, ) -> Pin<Box<dyn Future<Output = Result<Option<OrderAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single order by client order ID.

fn load_position<'life0, 'life1, 'async_trait>( &'life0 self, position_id: &'life1 PositionId, ) -> Pin<Box<dyn Future<Output = Result<Option<Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single position by position ID.

fn load_actor( &self, component_id: &ComponentId, ) -> Result<HashMap<String, Bytes>>

Loads actor state by component ID.

fn delete_actor(&self, component_id: &ComponentId) -> Result<()>

Errors

fn load_strategy( &self, strategy_id: &StrategyId, ) -> Result<HashMap<String, Bytes>>

Loads strategy state by strategy ID.

fn delete_strategy(&self, component_id: &StrategyId) -> Result<()>

Errors

fn add(&self, key: String, value: Bytes) -> Result<()>

Errors

fn add_currency(&self, currency: &Currency) -> Result<()>

Errors

fn add_instrument(&self, instrument: &InstrumentAny) -> Result<()>

Errors

fn add_synthetic(&self, synthetic: &SyntheticInstrument) -> Result<()>

Errors

fn add_account(&self, account: &AccountAny) -> Result<()>

Errors

fn add_order(&self, order: &OrderAny, client_id: Option<ClientId>) -> Result<()>

Errors

fn add_order_snapshot(&self, snapshot: &OrderSnapshot) -> Result<()>

Errors

fn add_position(&self, position: &Position) -> Result<()>

Errors

fn add_position_snapshot(&self, snapshot: &PositionSnapshot) -> Result<()>

Errors

fn add_order_book(&self, order_book: &OrderBook) -> Result<()>

Errors

fn add_quote(&self, quote: &QuoteTick) -> Result<()>

Errors

fn load_quotes(&self, instrument_id: &InstrumentId) -> Result<Vec<QuoteTick>>

Loads quote ticks by instrument ID.

fn add_trade(&self, trade: &TradeTick) -> Result<()>

Errors

fn load_trades(&self, instrument_id: &InstrumentId) -> Result<Vec<TradeTick>>

Loads trade ticks by instrument ID.

fn add_bar(&self, bar: &Bar) -> Result<()>

Errors

fn load_bars(&self, instrument_id: &InstrumentId) -> Result<Vec<Bar>>

Loads bars by instrument ID.

fn add_signal(&self, signal: &Signal) -> Result<()>

Errors

fn load_signals(&self, name: &str) -> Result<Vec<Signal>>

Loads signals by name.

fn add_custom_data(&self, data: &CustomData) -> Result<()>

Errors

fn load_custom_data(&self, data_type: &DataType) -> Result<Vec<CustomData>>

Loads custom data by data type.

fn load_order_snapshot( &self, client_order_id: &ClientOrderId, ) -> Result<Option<OrderSnapshot>>

Loads an order snapshot by client order ID.

fn load_position_snapshot( &self, position_id: &PositionId, ) -> Result<Option<PositionSnapshot>>

Loads a position snapshot by position ID.

fn index_venue_order_id( &self, client_order_id: ClientOrderId, venue_order_id: VenueOrderId, ) -> Result<()>

Errors

fn index_order_position( &self, client_order_id: ClientOrderId, position_id: PositionId, ) -> Result<()>

Errors

fn update_actor(&self) -> Result<()>

Errors

fn update_strategy(&self) -> Result<()>

Errors

fn update_account(&self, account: &AccountAny) -> Result<()>

Errors

fn update_order(&self, event: &OrderEventAny) -> Result<()>

Errors

fn update_position(&self, position: &Position) -> Result<()>

Errors

fn snapshot_order_state(&self, order: &OrderAny) -> Result<()>

Errors

fn snapshot_position_state(&self, position: &Position) -> Result<()>

Errors

fn heartbeat(&self, timestamp: UnixNanos) -> Result<()>

Errors

fn load_greeks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<InstrumentId, GreeksData>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Loads all [GreeksData] from the cache.

fn load_yield_curves<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, YieldCurveData>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Loads all [YieldCurveData] from the cache.

fn add_greeks(&self, greeks: &GreeksData) -> Result<(), Error>

Errors

fn add_yield_curve(&self, yield_curve: &YieldCurveData) -> Result<(), Error>

Errors

impl Debug for PostgresCacheDatabase

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

Formats the value using the given formatter.

impl<'py> IntoPyObject<'py> for PostgresCacheDatabase

type Target = PostgresCacheDatabase

The Python output type

type Output = Bound<'py, <PostgresCacheDatabase as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PostgresCacheDatabase

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PostgresCacheDatabase

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PostgresCacheDatabase>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a PostgresCacheDatabase

type Holder = Option<PyRef<'py, PostgresCacheDatabase>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py, false> for &'a mut PostgresCacheDatabase

type Holder = Option<PyRefMut<'py, PostgresCacheDatabase>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'a mut Self::Holder, ) -> PyResult<Self>

impl PyMethods<PostgresCacheDatabase> for PyClassImplCollector<PostgresCacheDatabase>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for PostgresCacheDatabase

const NAME: &'static str = "PostgresCacheDatabase"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for PostgresCacheDatabase