use std::collections::VecDeque;
use std::fmt;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use futures_core::Stream;
use happenstance_core::{
Event, EventId, Query, ReadOptions, RecordedAt, SequencePosition, SequencedEvent, StoreId, Tag,
Tags,
};
use sqlx::Row as _;
use sqlx::postgres::PgRow;
use sqlx::{PgPool, Postgres, Transaction};
use tokio::runtime::Handle;
use crate::error::PostgresEventStoreError;
use crate::event_store::{Visibility, position_from_row};
use crate::query_sql::Param;
const FETCH_CHUNK: u32 = 1024;
const CURSOR_NAME: &str = "happenstance_read";
type Step<T> = Pin<Box<dyn Future<Output = T> + Send>>;
type Spawned<T> = Pin<Box<tokio::task::JoinHandle<T>>>;
type Opened = Result<(Box<PgCursor>, Vec<PgRow>), PostgresEventStoreError>;
type Fetched = (Box<PgCursor>, Result<Vec<PgRow>, sqlx::Error>);
#[derive(Debug)]
struct CursorPlan {
pool: PgPool,
runtime: Option<Handle>,
visibility: Visibility,
query: Query,
options: ReadOptions,
}
struct PgCursor {
tx: Option<Transaction<'static, Postgres>>,
runtime: Option<Handle>,
}
impl PgCursor {
fn transaction(&mut self) -> &mut Transaction<'static, Postgres> {
self.tx
.as_mut()
.expect("the cursor's transaction is taken only by `Drop`")
}
}
impl Drop for PgCursor {
fn drop(&mut self) {
let Some(tx) = self.tx.take() else {
return;
};
let Some(handle) = self.runtime.clone().or_else(|| Handle::try_current().ok()) else {
std::mem::forget(tx);
return;
};
handle.spawn(async move {
let _ = tx.rollback().await;
});
}
}
enum ReadState {
Unstarted(Box<CursorPlan>),
Opening(Spawned<Opened>),
Fetching(Step<Fetched>),
Draining {
cursor: Box<PgCursor>,
rows: VecDeque<PgRow>,
},
Done,
}
pub struct PgReadStream {
state: ReadState,
}
impl fmt::Debug for PgReadStream {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let state = match self.state {
ReadState::Unstarted(_) => "Unstarted",
ReadState::Opening(_) => "Opening",
ReadState::Fetching(_) => "Fetching",
ReadState::Draining { .. } => "Draining",
ReadState::Done => "Done",
};
f.debug_struct("PgReadStream")
.field("state", &state)
.finish()
}
}
impl PgReadStream {
pub(crate) fn new(
pool: PgPool,
runtime: Option<Handle>,
visibility: Visibility,
query: &Query,
options: ReadOptions,
) -> Self {
Self {
state: ReadState::Unstarted(Box::new(CursorPlan {
pool,
runtime,
visibility,
query: query.clone(),
options,
})),
}
}
}
impl Stream for PgReadStream {
type Item = Result<SequencedEvent, PostgresEventStoreError>;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
loop {
match std::mem::replace(&mut this.state, ReadState::Done) {
ReadState::Unstarted(plan) => {
let handle = plan.runtime.clone().or_else(|| Handle::try_current().ok());
let Some(handle) = handle else {
this.state = ReadState::Done;
return Poll::Ready(Some(Err(PostgresEventStoreError::NoRuntime)));
};
this.state = ReadState::Opening(Box::pin(handle.spawn(open_cursor(*plan))));
}
ReadState::Opening(mut step) => match step.as_mut().poll(cx) {
Poll::Pending => {
this.state = ReadState::Opening(step);
return Poll::Pending;
}
Poll::Ready(Err(join)) => {
this.state = ReadState::Done;
return Poll::Ready(Some(Err(PostgresEventStoreError::Worker(join))));
}
Poll::Ready(Ok(Ok((cursor, rows)))) => {
this.state = ReadState::Draining {
cursor,
rows: rows.into(),
};
}
Poll::Ready(Ok(Err(error))) => {
this.state = ReadState::Done;
return Poll::Ready(Some(Err(error)));
}
},
ReadState::Fetching(mut step) => match step.as_mut().poll(cx) {
Poll::Pending => {
this.state = ReadState::Fetching(step);
return Poll::Pending;
}
Poll::Ready((_, Err(err))) => {
return Poll::Ready(Some(Err(PostgresEventStoreError::Driver(err))));
}
Poll::Ready((cursor, Ok(rows))) => {
if rows.is_empty() {
return Poll::Ready(None);
}
this.state = ReadState::Draining {
cursor,
rows: rows.into(),
};
}
},
ReadState::Draining { cursor, mut rows } => match rows.pop_front() {
Some(row) => {
this.state = ReadState::Draining { cursor, rows };
return Poll::Ready(Some(decode_row(&row)));
}
None => {
this.state = ReadState::Fetching(Box::pin(fetch_chunk(cursor)));
}
},
ReadState::Done => return Poll::Ready(None),
}
}
}
}
async fn open_cursor(plan: CursorPlan) -> Opened {
let runtime = Handle::try_current().ok().or_else(|| plan.runtime.clone());
let mut tx = plan
.pool
.begin_with("BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY")
.await?;
let (declare, params) = declare_sql(&plan.query, plan.options, plan.visibility);
let mut statement = sqlx::query(&declare);
for param in ¶ms {
statement = match param {
Param::EventType(value) => statement.bind(value.clone()),
Param::Tags(values) => statement.bind(values.clone()),
};
}
statement.execute(&mut *tx).await?;
let rows = sqlx::query(&fetch_sql()).fetch_all(&mut *tx).await?;
Ok((
Box::new(PgCursor {
tx: Some(tx),
runtime,
}),
rows,
))
}
async fn fetch_chunk(mut cursor: Box<PgCursor>) -> Fetched {
let rows = sqlx::query(&fetch_sql())
.fetch_all(&mut **cursor.transaction())
.await;
(cursor, rows)
}
const SELECTED_COLUMNS: &str = "position, event_type, data, metadata, tags, \
origin_store, origin_position, recorded_at";
fn declare_sql(
query: &Query,
options: ReadOptions,
visibility: Visibility,
) -> (String, Vec<Param>) {
let mut next = 1;
let predicate = crate::query_sql::predicate(query, &mut next);
let mut clauses = vec![
predicate.sql().to_owned(),
visibility.predicate().to_owned(),
];
let (start_op, stop_op) = if options.backwards {
("<=", ">=")
} else {
(">=", "<=")
};
if let Some(from) = options.from {
clauses.push(format!("position {start_op} {}", as_i64(from)));
}
if let Some(to) = options.to {
clauses.push(format!("position {stop_op} {}", as_i64(to)));
}
let order = if options.backwards { "DESC" } else { "ASC" };
let limit = options
.limit
.map_or_else(String::new, |limit| format!(" LIMIT {limit}"));
let sql = format!(
"DECLARE {CURSOR_NAME} NO SCROLL CURSOR FOR \
SELECT {SELECTED_COLUMNS} FROM event \
WHERE {} \
ORDER BY position {order}{limit}",
clauses.join(" AND ")
);
(sql, predicate.params().to_vec())
}
fn fetch_sql() -> String {
format!("FETCH FORWARD {FETCH_CHUNK} FROM {CURSOR_NAME}")
}
fn as_i64(position: SequencePosition) -> i64 {
i64::try_from(position.get()).unwrap_or(i64::MAX)
}
fn decode_row(row: &PgRow) -> Result<SequencedEvent, PostgresEventStoreError> {
let position = position_from_row(row.try_get::<i64, _>("position")?)?;
let event_type: String = row.try_get("event_type")?;
let data: Vec<u8> = row.try_get("data")?;
let metadata: Option<Vec<u8>> = row.try_get("metadata")?;
let stored_tags: Vec<String> = row.try_get("tags")?;
let mut event =
Event::new(event_type.as_str(), data).map_err(PostgresEventStoreError::EventType)?;
if !stored_tags.is_empty() {
let tags = stored_tags
.iter()
.map(|tag| Tag::new(tag.as_str()))
.collect::<Result<Tags, _>>()
.map_err(PostgresEventStoreError::Tag)?;
event = event.with_tags(tags);
}
if let Some(metadata) = metadata {
event = event.with_metadata(metadata);
}
let origin_store: Option<Vec<u8>> = row.try_get("origin_store")?;
let origin_position: Option<i64> = row.try_get("origin_position")?;
let id = match (origin_store, origin_position) {
(Some(store), Some(origin)) => {
let bytes: [u8; 16] = store
.as_slice()
.try_into()
.map_err(|_| PostgresEventStoreError::MalformedIdentity { len: store.len() })?;
EventId::new(StoreId::from_bytes(bytes), position_from_row(origin)?)
}
_ => return Err(PostgresEventStoreError::UnstampedEvent { position }),
};
let recorded_at = RecordedAt::from_millis(row.try_get::<i64, _>("recorded_at")?);
Ok(SequencedEvent::new(position, id, recorded_at, event))
}
#[cfg(test)]
mod tests {
use super::{PgReadStream, Postgres, Transaction};
use sqlx::PgPool;
async fn begin_borrows_nothing_from_the_pool(
pool: PgPool,
) -> Result<Transaction<'static, Postgres>, sqlx::Error> {
let batch = {
let borrowed: &PgPool = &pool;
borrowed.begin().await?
};
drop(pool);
Ok(batch)
}
#[test]
fn pool_begin_yields_an_owned_transaction() {
let _ = begin_borrows_nothing_from_the_pool;
}
#[test]
fn read_stream_is_send() {
fn assert_send<T: Send>() {}
assert_send::<PgReadStream>();
}
}