Enum NamedTime 

#[non_exhaustive]
pub enum NamedTime {
    Chrono(DateTime<Utc>),
    Time(OffsetDateTime),
}

A time a by-name subscription binds, in the type its column holds: the current time, a delayed retry’s, or in the lease form a lease’s expiry.

A dialect binds it in ByName::bind_time. Each variant comes with the feature of its time type, so a match keeps a wildcard arm.

Examples

use ruststream::HeaderMap;
use ruststream_sqlx::prelude::*;
use ruststream_sqlx::{BuiltIn, ByName, NamedTime};
use serde::Deserialize;
use sqlx::error::BoxDynError;
use sqlx::postgres::{PgArguments, PgValueRef};
use sqlx::{Arguments, PgPool, Postgres};

/// A dialect of the service's own over Postgres, whose tables keep `chrono` times.
#[derive(Debug)]
pub struct Audited;

impl ByName<Postgres> for Audited {
    fn headers(value: PgValueRef<'_>) -> Result<HeaderMap, BoxDynError> {
        <BuiltIn<Postgres> as ByName<Postgres>>::headers(value)
    }

    fn bind_time(arguments: &mut PgArguments, time: NamedTime) -> Result<(), sqlx::Error> {
        match time {
            NamedTime::Chrono(at) => arguments.add(at).map_err(sqlx::Error::Encode),
            _ => Err(sqlx::Error::Configuration("these tables keep `chrono` times".into())),
        }
    }
}

#[derive(Inbox, sqlx::FromRow)]
#[inbox(table = "email_jobs")]
pub struct SendEmail {
    #[field(id, generated)]
    job_id: i64,
    #[field(group)]
    name: String,
    #[field(payload)]
    payload: Vec<u8>,
}

#[derive(Deserialize)]
struct Email {
    to: String,
}

#[subscriber("emails")]
async fn send(email: &Email) -> HandlerOutcome {
    tracing::info!(to = %email.to, "sending");
    HandlerOutcome::ack()
}

pub fn app(pool: PgPool) -> RustStream {
    let broker = SqlxBroker::with_dialect(pool, Audited).route::<SendEmail>("emails");
    RustStream::new(AppInfo::new("mailer", "0.1.0")).with_broker(broker, |b| {
        b.include(send);
    })
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Chrono(DateTime<Utc>)

A chrono column.

Time(OffsetDateTime)

A time column.

Trait Implementations

impl Clone for NamedTime

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NamedTime

impl Debug for NamedTime

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

Formats the value using the given formatter.

impl Eq for NamedTime

impl PartialEq for NamedTime

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for NamedTime