icydb_core/db/query/
delete.rs

1use crate::{
2    db::{
3        primitives::{FilterExpr, FilterExt, FilterSlot, LimitExpr, LimitSlot},
4        query::{QueryError, QueryValidate},
5    },
6    traits::{EntityKind, FieldValue},
7};
8use candid::CandidType;
9use serde::Deserialize;
10use serde::Serialize;
11
12///
13/// DeleteQuery
14///
15
16#[derive(CandidType, Clone, Debug, Default, Deserialize, Serialize)]
17pub struct DeleteQuery {
18    pub filter: Option<FilterExpr>,
19    pub limit: Option<LimitExpr>,
20}
21
22impl DeleteQuery {
23    #[must_use]
24    /// Construct an empty delete query.
25    pub fn new() -> Self {
26        Self::default()
27    }
28
29    #[must_use]
30    /// Delete a single row by primary key value.
31    pub fn one<E: EntityKind>(self, value: impl FieldValue) -> Self {
32        self.filter(|f| f.eq(E::PRIMARY_KEY, value))
33    }
34
35    #[must_use]
36    /// Delete a single row where the primary key is unit.
37    pub fn only<E: EntityKind>(self) -> Self {
38        self.filter(|f| f.eq(E::PRIMARY_KEY, ()))
39    }
40
41    #[must_use]
42    /// Delete multiple rows by primary key values.
43    pub fn many<E: EntityKind>(self, values: impl IntoIterator<Item = impl FieldValue>) -> Self {
44        self.filter(move |f| f.in_iter(E::PRIMARY_KEY, values))
45    }
46}
47
48impl FilterSlot for DeleteQuery {
49    fn filter_slot(&mut self) -> &mut Option<FilterExpr> {
50        &mut self.filter
51    }
52}
53
54impl LimitSlot for DeleteQuery {
55    fn limit_slot(&mut self) -> &mut Option<LimitExpr> {
56        &mut self.limit
57    }
58}
59
60impl<E: EntityKind> QueryValidate<E> for DeleteQuery {
61    fn validate(&self) -> Result<(), QueryError> {
62        if let Some(filter) = &self.filter {
63            QueryValidate::<E>::validate(filter)?;
64        }
65
66        if let Some(limit) = &self.limit {
67            QueryValidate::<E>::validate(limit)?;
68        }
69
70        Ok(())
71    }
72}