Struct cqrs_postgres::PostgresStore

pub struct PostgresStore<'conn, A, E, M, S = NeverSnapshot> where
    A: Aggregate,
    E: AggregateEvent<A>,
    S: SnapshotStrategy,  { /* fields omitted */ }

A PostgreSQL storage backend.

Methods

impl<'conn, A, E, M, S> PostgresStore<'conn, A, E, M, S> where
    A: Aggregate,
    E: AggregateEvent<A>,
    S: SnapshotStrategy + Default, 

pub fn new(conn: &'conn Connection) -> Self

Constructs a transient store based on a provided PostgreSQL connection using the default snapshot strategy.

pub fn with_snapshot_strategy(
    conn: &'conn Connection,
    snapshot_strategy: S
) -> Self

Constructs a transient store based on a provided PostgreSQL connection and snapshot strategy.

pub fn create_tables(&self) -> Result<(), Error>

Creates the base set of tables required to support the CQRS system.

pub fn is_latest(&self) -> Result<bool, Error>

Checks to see if the database is the latest version as seen by the current executable..

pub fn is_compatible(&self) -> Result<bool, Error>

Checks to see if the database is compatible with the current executable.

pub fn get_entity_count(&self) -> Result<u64, Error>

Gets the total number of entities of this type in the store.

pub fn get_entity_ids(
    &self,
    offset: u32,
    limit: u32
) -> Result<Vec<String>, Error>

Loads a page of entity IDs.

pub fn get_entity_count_matching_pattern(
    &self,
    pattern: &str
) -> Result<u64, Error>

Gets the total number of entities of this type matching a particular PostgreSQL pattern in the store.

PostgreSQL pattern matching rules:

• _ matches any single character.
• % matches any number of characters.

See the PostgreSQL documentation on pattern matching

pub fn get_entity_ids_matching_pattern(
    &self,
    pattern: &str,
    offset: u32,
    limit: u32
) -> Result<Vec<String>, Error>

Loads a page of entity IDs matching a particular PostgreSQL pattern.

PostgreSQL pattern matching rules:

• _ matches any single character.
• % matches any number of characters.

See the PostgreSQL documentation on pattern matching

pub fn get_entity_count_matching_sql_regex(
    &self,
    regex: &str
) -> Result<u64, Error>

Gets the total number of entities of this type matching a particular PostgreSQL regular expression in the store.

See the PostgreSQL documentation on pattern matching

pub fn get_entity_ids_matching_sql_regex(
    &self,
    regex: &str,
    offset: u32,
    limit: u32
) -> Result<Vec<String>, Error>

Loads a page of entity IDs matching a particular PostgreSQL regular expression.

See the PostgreSQL documentation on pattern matching

pub fn get_entity_count_matching_posix_regex(
    &self,
    regex: &str
) -> Result<u64, Error>

Gets the total number of entities of this type matching a particular POSIX regular expression in the store.

See the PostgreSQL documentation on pattern matching

pub fn get_entity_ids_matching_posix_regex(
    &self,
    regex: &str,
    offset: u32,
    limit: u32
) -> Result<Vec<String>, Error>

Loads a page of entity IDs matching a particular POSIX regular expression.

See the PostgreSQL documentation on pattern matching

pub fn read_events_with_metadata<I>(
    &self,
    id: &I,
    since: Since,
    max_count: Option<u64>
) -> Result<Option<Vec<Result<VersionedEventWithMetadata<E, M>, LoadError<E::Error>>>>, LoadError<E::Error>> where
    I: AggregateId<A>,
    E: DeserializableEvent,
    M: for<'de> Deserialize<'de>, 

Reads events and associated metadata from the event source for a given identifier.

Only loads events after the event number provided in since (See Since), and will only load a maximum of max_count events, if given. If not given, will read all remaining events.

Trait Implementations

impl<'conn, A: Clone, E: Clone, M: Clone, S: Clone> Clone for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate,
    E: AggregateEvent<A>,
    S: SnapshotStrategy, 

fn clone(&self) -> PostgresStore<'conn, A, E, M, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'conn, A, E, M, S> Debug for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate,
    E: AggregateEvent<A>,
    S: SnapshotStrategy + Debug, 

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

Formats the value using the given formatter.

impl<'conn, A, E, M, S> EventSource<A, E> for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate,
    E: AggregateEvent<A> + DeserializableEvent,
    S: SnapshotStrategy, 

type Error = LoadError<<E as DeserializableEvent>::Error>

The error type.

type Events = Vec<VersionedEvent<E>>

Represents the sequence of events read from the event source.

fn read_events<I>(
    &self,
    id: &I,
    since: Since,
    max_count: Option<u64>
) -> Result<Option<Self::Events>, Self::Error> where
    I: AggregateId<A>, 

Reads events from the event source for a given identifier.

impl<'conn, A, E, M, S> EventSink<A, E, M> for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate,
    E: AggregateEvent<A> + SerializableEvent + Debug,
    M: Serialize + Debug,
    S: SnapshotStrategy, 

type Error = PersistError<<E as SerializableEvent>::Error>

The error type.

fn append_events<I>(
    &self,
    id: &I,
    events: &[E],
    precondition: Option<Precondition>,
    metadata: M
) -> Result<EventNumber, Self::Error> where
    I: AggregateId<A>, 

Appends events to a given source, with an optional precondition, and associated metadata.

impl<'conn, A, E, M, S> SnapshotSource<A> for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate + DeserializeOwned,
    E: AggregateEvent<A>,
    S: SnapshotStrategy, 

type Error = Error

The error type.

fn get_snapshot<I>(
    &self,
    id: &I
) -> Result<Option<VersionedAggregate<A>>, Self::Error> where
    I: AggregateId<A>, 

Loads a versioned aggregate from the snapshot source.

impl<'conn, A, E, M, S> SnapshotSink<A> for PostgresStore<'conn, A, E, M, S> where
    A: Aggregate + Serialize + Debug,
    E: AggregateEvent<A>,
    S: SnapshotStrategy, 

type Error = PersistError<Error>

The error type.

fn persist_snapshot<I>(
    &self,
    id: &I,
    aggregate: &A,
    version: Version,
    last_snapshot_version: Option<Version>
) -> Result<Version, Self::Error> where
    I: AggregateId<A>, 

Writes an aggregate with its version to the sink. Returns the version number of the latest snapshot.