use core::future::poll_fn;
use core::num::NonZeroUsize;
use happenstance_core::{AppendCondition, SequencePosition};
use happenstance_sync::write_group::{GroupPageBuilder, decode_guard, encode_guard};
use happenstance_sync::{GroupPage, ReplicatedEvent, SendWriteGroupStore, Waiting};
use sqlx::postgres::{PgArguments, PgRow};
use sqlx::query::Query;
use sqlx::{PgPool, Postgres, Row as _, Transaction};
use super::{PostgresEventStore, Visibility, as_i64, position_from_row};
use crate::error::PostgresEventStoreError;
pub(super) const STAMP_SQL: &str = "UPDATE event \
SET write_group = $1, group_guard = CASE WHEN position = $1 THEN $2::bytea END \
WHERE position = ANY($3)";
const GROUPS_SQL: &str = "WITH scan AS (\
SELECT position AS p, coalesce(write_group, position) AS g FROM event \
WHERE position > $1 AND coalesce(write_group, position) > $1 AND {frontier} \
ORDER BY position LIMIT $3), \
ids AS (SELECT DISTINCT g FROM (SELECT g FROM scan ORDER BY p LIMIT $2) AS head), \
counted AS (SELECT count(*) AS n FROM scan) \
SELECT e.position, e.event_type, e.data, e.metadata, e.tags, e.origin_store, \
e.origin_position, e.recorded_at, ids.g AS write_group_first, e.group_guard, \
(SELECT n FROM counted) AS scanned \
FROM ids JOIN event AS e ON e.write_group = ids.g \
WHERE {frontier} \
UNION ALL \
SELECT e.position, e.event_type, e.data, e.metadata, e.tags, e.origin_store, \
e.origin_position, e.recorded_at, ids.g AS write_group_first, e.group_guard, \
(SELECT n FROM counted) AS scanned \
FROM ids JOIN event AS e ON e.position = ids.g \
WHERE e.write_group IS NULL AND {frontier} \
ORDER BY write_group_first, position";
pub(super) fn groups_query(
sql: &str,
after: i64,
max_events: NonZeroUsize,
) -> Query<'_, Postgres, PgArguments> {
sqlx::query(sql)
.bind(after)
.bind(budget(max_events))
.bind(probe(max_events))
}
fn budget(max_events: NonZeroUsize) -> i64 {
i64::try_from(max_events.get()).unwrap_or(i64::MAX)
}
fn probe(max_events: NonZeroUsize) -> i64 {
budget(max_events).saturating_add(1)
}
pub(super) fn groups_sql(visibility: Visibility) -> String {
GROUPS_SQL.replace("{frontier}", visibility.predicate())
}
pub(super) async fn stamp(
transaction: &mut Transaction<'static, Postgres>,
first: i64,
landed: &[i64],
guard: Option<&AppendCondition>,
) -> Result<(), PostgresEventStoreError> {
let stored = match guard.map(encode_guard).transpose() {
Ok(stored) => stored,
Err(source) => {
return Err(PostgresEventStoreError::StoredGuard {
first: position_from_row(first)?,
source,
});
}
};
sqlx::query(STAMP_SQL)
.bind(first)
.bind(stored)
.bind(landed)
.execute(&mut **transaction)
.await?;
Ok(())
}
impl PostgresEventStore {
async fn read_write_groups(
&self,
after: Option<SequencePosition>,
max_events: NonZeroUsize,
) -> Result<GroupPage, PostgresEventStoreError> {
let pool = self.pool.clone();
let sql = groups_sql(self.visibility);
let after = after.map_or(0, as_i64);
self.on_runtime(async move { page_of_groups(&pool, &sql, after, max_events).await })
.await
}
}
async fn page_of_groups(
pool: &PgPool,
sql: &str,
after: i64,
max_events: NonZeroUsize,
) -> Result<GroupPage, PostgresEventStoreError> {
let mut rows = groups_query(sql, after, max_events).fetch(pool);
let mut page = GroupPageBuilder::new(max_events);
let mut scanned = 0;
while let Some(row) = poll_fn(|cx| rows.as_mut().poll_next(cx)).await {
let row = row?;
scanned = row.try_get::<i64, _>("scanned")?;
let (first, guard, event) = decode_group_row(&row)?;
if page.offer(first, guard, event).is_break() {
return Ok(page.finish(Waiting::Unknown)?);
}
}
let past = if scanned < probe(max_events) {
Waiting::Nothing
} else {
Waiting::Unknown
};
Ok(page.finish(past)?)
}
fn decode_group_row(
row: &PgRow,
) -> Result<(SequencePosition, Option<AppendCondition>, ReplicatedEvent), PostgresEventStoreError> {
let stored = crate::read_stream::decode_row(row)?;
let first = position_from_row(row.try_get::<i64, _>("write_group_first")?)?;
let guard = match row.try_get::<Option<Vec<u8>>, _>("group_guard")? {
Some(bytes) if stored.position == first => Some(
decode_guard(&bytes)
.map_err(|source| PostgresEventStoreError::StoredGuard { first, source })?,
),
_ => None,
};
let event = ReplicatedEvent::new(stored.id, stored.recorded_at, stored.event);
Ok((first, guard, event))
}
#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
impl SendWriteGroupStore for PostgresEventStore {
type Error = PostgresEventStoreError;
async fn read_groups(
&self,
after: Option<SequencePosition>,
max_events: NonZeroUsize,
) -> Result<GroupPage, Self::Error> {
self.read_write_groups(after, max_events).await
}
}
#[cfg(test)]
mod tests {
use super::{GROUPS_SQL, STAMP_SQL, groups_sql};
use crate::event_store::Visibility;
#[test]
fn the_group_read_carries_the_frontier_in_every_read_of_the_table() {
let sql = groups_sql(Visibility::Frontier);
assert_eq!(
sql.matches(Visibility::Frontier.predicate()).count(),
3,
"{sql}"
);
assert!(!sql.contains("{frontier}"), "a placeholder survived: {sql}");
}
#[test]
fn the_group_read_joins_by_key_and_orders_by_group_first() {
assert!(
GROUPS_SQL.ends_with("ORDER BY write_group_first, position"),
"{GROUPS_SQL}"
);
assert!(
GROUPS_SQL.contains("JOIN event AS e ON e.write_group = ids.g")
&& GROUPS_SQL.contains("JOIN event AS e ON e.position = ids.g")
&& GROUPS_SQL.contains(" UNION ALL "),
"{GROUPS_SQL}"
);
assert!(!GROUPS_SQL.contains(" OR "), "{GROUPS_SQL}");
}
#[test]
fn the_stamp_touches_only_the_landed_rows() {
assert!(
STAMP_SQL.ends_with("WHERE position = ANY($3)"),
"{STAMP_SQL}"
);
assert!(!STAMP_SQL.contains(">="), "{STAMP_SQL}");
}
}