drizzle_postgres/builder/
delete.rs

1use crate::values::PostgresValue;
2use drizzle_core::ToSQL;
3use std::fmt::Debug;
4use std::marker::PhantomData;
5
6// Import the ExecutableState trait
7use super::ExecutableState;
8
9//------------------------------------------------------------------------------
10// Type State Markers
11//------------------------------------------------------------------------------
12
13/// Marker for the initial state of DeleteBuilder
14#[derive(Debug, Clone, Copy, Default)]
15pub struct DeleteInitial;
16
17/// Marker for the state after WHERE clause
18#[derive(Debug, Clone, Copy, Default)]
19pub struct DeleteWhereSet;
20
21/// Marker for the state after RETURNING clause
22#[derive(Debug, Clone, Copy, Default)]
23pub struct DeleteReturningSet;
24
25// Mark states that can execute delete queries
26impl ExecutableState for DeleteInitial {}
27impl ExecutableState for DeleteWhereSet {}
28impl ExecutableState for DeleteReturningSet {}
29
30//------------------------------------------------------------------------------
31// DeleteBuilder Definition
32//------------------------------------------------------------------------------
33
34/// Builds a DELETE query specifically for PostgreSQL
35pub type DeleteBuilder<'a, Schema, State, Table> = super::QueryBuilder<'a, Schema, State, Table>;
36
37//------------------------------------------------------------------------------
38// Initial State Implementation
39//------------------------------------------------------------------------------
40
41impl<'a, S, T> DeleteBuilder<'a, S, DeleteInitial, T> {
42    /// Adds a WHERE condition to the query
43    #[inline]
44    pub fn r#where(
45        self,
46        condition: impl ToSQL<'a, PostgresValue<'a>>,
47    ) -> DeleteBuilder<'a, S, DeleteWhereSet, T> {
48        let where_sql = crate::helpers::r#where(condition.to_sql());
49        DeleteBuilder {
50            sql: self.sql.append(where_sql),
51            schema: PhantomData,
52            state: PhantomData,
53            table: PhantomData,
54        }
55    }
56
57    /// Adds a RETURNING clause to the query
58    #[inline]
59    pub fn returning(
60        self,
61        columns: impl ToSQL<'a, PostgresValue<'a>>,
62    ) -> DeleteBuilder<'a, S, DeleteReturningSet, T> {
63        let returning_sql = crate::helpers::returning(columns);
64        DeleteBuilder {
65            sql: self.sql.append(returning_sql),
66            schema: PhantomData,
67            state: PhantomData,
68            table: PhantomData,
69        }
70    }
71}
72
73//------------------------------------------------------------------------------
74// Post-WHERE Implementation
75//------------------------------------------------------------------------------
76
77impl<'a, S, T> DeleteBuilder<'a, S, DeleteWhereSet, T> {
78    /// Adds a RETURNING clause after WHERE
79    #[inline]
80    pub fn returning(
81        self,
82        columns: impl ToSQL<'a, PostgresValue<'a>>,
83    ) -> DeleteBuilder<'a, S, DeleteReturningSet, T> {
84        let returning_sql = crate::helpers::returning(columns);
85        DeleteBuilder {
86            sql: self.sql.append(returning_sql),
87            schema: PhantomData,
88            state: PhantomData,
89            table: PhantomData,
90        }
91    }
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97    use drizzle_core::{SQL, ToSQL};
98
99    #[test]
100    fn test_delete_builder_creation() {
101        let builder = DeleteBuilder::<(), DeleteInitial, ()> {
102            sql: SQL::raw("DELETE FROM test"),
103            schema: PhantomData,
104            state: PhantomData,
105            table: PhantomData,
106        };
107
108        assert_eq!(builder.to_sql().sql(), "DELETE FROM test");
109    }
110}