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<AHashMap<String, Bytes>>

Loads raw key-value data from the database.

fn load_currencies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<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<AHashMap<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<AHashMap<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<AHashMap<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<AHashMap<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<AHashMap<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<AHashMap<ClientOrderId, Position>>

Loads mapping from order IDs to position IDs.

fn load_index_order_client(&self) -> Result<AHashMap<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<AHashMap<String, Bytes>>

Loads actor state by component ID.

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

Deletes actor state from the cache.

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

Loads strategy state by strategy ID.

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

Deletes strategy state from the cache.

fn delete_order(&self, client_order_id: &ClientOrderId) -> Result<()>

Deletes an order from the cache.

fn delete_position(&self, position_id: &PositionId) -> Result<()>

Deletes a position from the cache.

fn delete_account_event( &self, account_id: &AccountId, event_id: &str, ) -> Result<()>

Deletes an account event from the cache.

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

Adds a generic key-value pair to the cache.

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

Adds a currency to the cache.

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

Adds an instrument to the cache.

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

Adds a synthetic instrument to the cache.

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

Adds an account to the cache.

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

Adds an order to the cache.

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

Adds an order snapshot to the cache.

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

Adds a position to the cache.

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

Adds a position snapshot to the cache.

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

Adds an order book to the cache.

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

Adds a quote tick to the cache.

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

Loads quote ticks by instrument ID.

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

Adds a trade tick to the cache.

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

Loads trade ticks by instrument ID.

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

Adds a bar to the cache.

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

Loads bars by instrument ID.

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

Adds a signal to the cache.

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

Loads signals by name.

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

Adds custom data to the cache.

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<()>

Indexes a venue order ID with its client order ID.

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

Indexes an order-position mapping.

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

Updates actor state in the cache.

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

Updates strategy state in the cache.

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

Updates an account in the cache.

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

Updates an order in the cache with an order event.

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

Updates a position in the cache.

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

Creates a snapshot of order state.

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

Creates a snapshot of position state.

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

Records a heartbeat timestamp.

fn load_greeks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<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<AHashMap<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>

Adds greeks data to the cache.

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

Adds yield curve data to the cache.

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