use super::{
atomic, select_rows_tx_with_related, ExecError, FetcherPool, LoadRelated, MaybeMyFromRow,
MaybeMyLoadRelated, MaybePgFromRow, MaybeSqliteFromRow, MaybeSqliteLoadRelated, PoolTx,
};
use crate::core::{Model, SelectQuery};
use crate::sql::Pool;
pub async fn get_or_create<T, F, Fut>(
qs: crate::query::QuerySet<T>,
create_fn: F,
pool: &Pool,
) -> Result<(T, bool), ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
F: FnOnce(Pool) -> Fut,
Fut: std::future::Future<Output = Result<T, ExecError>>,
{
match fetch_at_most_one(qs.clone(), "get_or_create", pool).await? {
Some(row) => Ok((row, false)),
None => match create(create_fn, pool).await {
Ok(row) => Ok((row, true)),
Err(e) => Ok((lost_race(qs, e, "get_or_create", pool, true).await?, false)),
},
}
}
pub async fn get_or_create_tx<'t, T, F>(
qs: crate::query::QuerySet<T>,
create_fn: F,
tx: &mut PoolTx<'t>,
) -> Result<(T, bool), ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
F: for<'a> FnOnce(
&'a mut PoolTx<'t>,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'a>,
>,
{
let select = qs.compile()?;
match at_most_one(
select_rows_tx_with_related(tx, &select).await?,
"get_or_create",
)? {
Some(row) => Ok((row, false)),
None => create_or_winner_tx(select, create_fn, tx, "get_or_create", true).await,
}
}
pub async fn update_or_create_tx<'t, T, UF, CF>(
qs: crate::query::QuerySet<T>,
update_fn: UF,
create_fn: CF,
tx: &mut PoolTx<'t>,
) -> Result<(T, bool), ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
UF: for<'a> FnOnce(
&'a mut PoolTx<'t>,
T,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'a>,
>,
CF: for<'a> FnOnce(
&'a mut PoolTx<'t>,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'a>,
>,
{
let select = qs.compile()?;
let found = select_rows_tx_with_related(tx, &select).await?;
let existing = match at_most_one(found, "update_or_create")? {
Some(row) => row,
None => {
match create_or_winner_tx(select, create_fn, tx, "update_or_create", false).await? {
(row, true) => return Ok((row, true)),
(row, false) => row,
}
}
};
Ok((update_fn(tx, existing).await?, false))
}
async fn create_or_winner_tx<'t, T, F>(
select: SelectQuery,
create_fn: F,
tx: &mut PoolTx<'t>,
op: &'static str,
share: bool,
) -> Result<(T, bool), ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
F: for<'a> FnOnce(
&'a mut PoolTx<'t>,
) -> std::pin::Pin<
Box<dyn std::future::Future<Output = Result<T, ExecError>> + Send + 'a>,
>,
{
let point = tx.next_savepoint("rustango_create");
tx.execute_unprepared(&format!("SAVEPOINT {point}")).await?;
let err = match create_fn(tx).await {
Ok(row) => {
tx.execute_unprepared(&format!("RELEASE SAVEPOINT {point}"))
.await?;
return Ok((row, true));
}
Err(e) => e,
};
let undo = format!("ROLLBACK TO SAVEPOINT {point}; RELEASE SAVEPOINT {point}");
if tx.execute_unprepared(&undo).await.is_err() || !err.is_unique_violation() {
return Err(err);
}
let select = winner_read(select, tx.dialect(), share);
let row = at_most_one(select_rows_tx_with_related(tx, &select).await?, op)?.ok_or(err)?;
Ok((row, false))
}
fn winner_read(mut select: SelectQuery, dialect: &dyn super::Dialect, share: bool) -> SelectQuery {
if dialect.name() == "mysql" && select.lock_mode.is_none() {
let mut lock = crate::core::LockMode::default();
lock.share = share;
lock.of = vec![select.model.table];
lock.silent_on_sqlite = true;
select.lock_mode = Some(lock);
}
select
}
async fn create<T, F, Fut>(create_fn: F, pool: &Pool) -> Result<T, ExecError>
where
F: FnOnce(Pool) -> Fut,
Fut: std::future::Future<Output = Result<T, ExecError>>,
{
atomic::caught(pool, create_fn(pool.clone())).await
}
async fn fetch_at_most_one<T>(
qs: crate::query::QuerySet<T>,
op: &'static str,
pool: &Pool,
) -> Result<Option<T>, ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
{
at_most_one(qs.fetch(pool).await?, op)
}
fn at_most_one<T: Model>(mut rows: Vec<T>, op: &'static str) -> Result<Option<T>, ExecError> {
match rows.len() {
0 => Ok(None),
1 => Ok(Some(rows.remove(0))),
n => Err(ExecError::MultipleRowsReturned {
op,
table: T::SCHEMA.table,
count: n,
}),
}
}
async fn lost_race<T>(
qs: crate::query::QuerySet<T>,
err: ExecError,
op: &'static str,
pool: &Pool,
share: bool,
) -> Result<T, ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
{
if !err.is_unique_violation() {
return Err(err);
}
let mut select = qs.compile()?;
if atomic::in_block(pool) {
select = winner_read(select, pool.dialect(), share);
}
at_most_one(
super::select_rows_pool_with_related(pool, &select).await?,
op,
)?
.ok_or(err)
}
pub async fn update_or_create<T, UF, UFut, CF, CFut>(
qs: crate::query::QuerySet<T>,
update_fn: UF,
create_fn: CF,
pool: &Pool,
) -> Result<(T, bool), ExecError>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
UF: FnOnce(Pool, T) -> UFut,
UFut: std::future::Future<Output = Result<T, ExecError>>,
CF: FnOnce(Pool) -> CFut,
CFut: std::future::Future<Output = Result<T, ExecError>>,
{
let existing = match fetch_at_most_one(qs.clone(), "update_or_create", pool).await? {
Some(row) => row,
None => match create(create_fn, pool).await {
Ok(row) => return Ok((row, true)),
Err(e) => lost_race(qs, e, "update_or_create", pool, false).await?,
},
};
Ok((update_fn(pool.clone(), existing).await?, false))
}
impl<T> crate::query::QuerySet<T>
where
T: Model
+ MaybePgFromRow
+ MaybeMyFromRow
+ MaybeSqliteFromRow
+ LoadRelated
+ MaybeMyLoadRelated
+ MaybeSqliteLoadRelated
+ Send
+ Unpin,
{
pub async fn get_or_create<F, Fut>(
self,
create_fn: F,
pool: &Pool,
) -> Result<(T, bool), ExecError>
where
F: FnOnce(Pool) -> Fut,
Fut: std::future::Future<Output = Result<T, ExecError>>,
{
get_or_create(self, create_fn, pool).await
}
pub async fn first_or_create<F, Fut>(
self,
create_fn: F,
pool: &Pool,
) -> Result<(T, bool), ExecError>
where
F: FnOnce(Pool) -> Fut,
Fut: std::future::Future<Output = Result<T, ExecError>>,
{
self.get_or_create(create_fn, pool).await
}
pub async fn update_or_create<UF, UFut, CF, CFut>(
self,
update_fn: UF,
create_fn: CF,
pool: &Pool,
) -> Result<(T, bool), ExecError>
where
UF: FnOnce(Pool, T) -> UFut,
UFut: std::future::Future<Output = Result<T, ExecError>>,
CF: FnOnce(Pool) -> CFut,
CFut: std::future::Future<Output = Result<T, ExecError>>,
{
update_or_create(self, update_fn, create_fn, pool).await
}
}