Skip to main content

drizzle_postgres/builder/
delete.rs

1use crate::values::PostgresValue;
2use core::marker::PhantomData;
3use drizzle_core::ToSQL;
4
5//------------------------------------------------------------------------------
6// Type State Markers
7//------------------------------------------------------------------------------
8
9pub use drizzle_core::builder::{DeleteInitial, DeleteReturningSet, DeleteWhereSet};
10
11//------------------------------------------------------------------------------
12// DeleteBuilder Definition
13//------------------------------------------------------------------------------
14
15/// Builds a DELETE query specifically for `PostgreSQL`
16pub type DeleteBuilder<'a, Schema, State, Table, Marker = (), Row = ()> =
17    super::QueryBuilder<'a, Schema, State, Table, Marker, Row>;
18
19type ReturningMarker<Table, Columns> = drizzle_core::Scoped<
20    <Columns as drizzle_core::IntoSelectTarget>::Marker,
21    drizzle_core::Cons<Table, drizzle_core::Nil>,
22>;
23
24type ReturningRow<Table, Columns> =
25    <<Columns as drizzle_core::IntoSelectTarget>::Marker as drizzle_core::ResolveRow<Table>>::Row;
26
27type ReturningBuilder<'a, S, T, Columns> = DeleteBuilder<
28    'a,
29    S,
30    DeleteReturningSet,
31    T,
32    ReturningMarker<T, Columns>,
33    ReturningRow<T, Columns>,
34>;
35
36//------------------------------------------------------------------------------
37// Initial State Implementation
38//------------------------------------------------------------------------------
39
40impl<'a, S, T> DeleteBuilder<'a, S, DeleteInitial, T> {
41    /// Adds a WHERE condition to the query
42    #[inline]
43    pub fn r#where<E>(self, condition: E) -> DeleteBuilder<'a, S, DeleteWhereSet, T>
44    where
45        E: drizzle_core::expr::Expr<'a, PostgresValue<'a>>,
46        E::SQLType: drizzle_core::types::BooleanLike,
47    {
48        let where_sql = crate::helpers::r#where(condition);
49        DeleteBuilder {
50            sql: self.sql.append(where_sql),
51            schema: PhantomData,
52            state: PhantomData,
53            table: PhantomData,
54            marker: PhantomData,
55            row: PhantomData,
56            grouped: PhantomData,
57        }
58    }
59
60    /// Adds a RETURNING clause to the query
61    #[inline]
62    pub fn returning<Columns>(self, columns: Columns) -> ReturningBuilder<'a, S, T, Columns>
63    where
64        Columns: ToSQL<'a, PostgresValue<'a>> + drizzle_core::IntoSelectTarget,
65        Columns::Marker: drizzle_core::ResolveRow<T>,
66    {
67        let returning_sql = crate::helpers::returning(columns);
68        DeleteBuilder {
69            sql: self.sql.append(returning_sql),
70            schema: PhantomData,
71            state: PhantomData,
72            table: PhantomData,
73            marker: PhantomData,
74            row: PhantomData,
75            grouped: PhantomData,
76        }
77    }
78}
79
80//------------------------------------------------------------------------------
81// Post-WHERE Implementation
82//------------------------------------------------------------------------------
83
84impl<'a, S, T> DeleteBuilder<'a, S, DeleteWhereSet, T> {
85    /// Adds a RETURNING clause after WHERE
86    #[inline]
87    pub fn returning<Columns>(self, columns: Columns) -> ReturningBuilder<'a, S, T, Columns>
88    where
89        Columns: ToSQL<'a, PostgresValue<'a>> + drizzle_core::IntoSelectTarget,
90        Columns::Marker: drizzle_core::ResolveRow<T>,
91    {
92        let returning_sql = crate::helpers::returning(columns);
93        DeleteBuilder {
94            sql: self.sql.append(returning_sql),
95            schema: PhantomData,
96            state: PhantomData,
97            table: PhantomData,
98            marker: PhantomData,
99            row: PhantomData,
100            grouped: PhantomData,
101        }
102    }
103}
104
105#[cfg(test)]
106mod tests {
107    use super::*;
108    use drizzle_core::{SQL, ToSQL};
109
110    #[test]
111    fn test_delete_builder_creation() {
112        let builder = DeleteBuilder::<(), DeleteInitial, ()> {
113            sql: SQL::raw("DELETE FROM test"),
114            schema: PhantomData,
115            state: PhantomData,
116            table: PhantomData,
117            marker: PhantomData,
118            row: PhantomData,
119            grouped: PhantomData,
120        };
121
122        assert_eq!(builder.to_sql().sql(), "DELETE FROM test");
123    }
124}