good_ormning/pg/query/
delete.rs

1use std::collections::HashMap;
2use crate::{
3    utils::Tokens,
4    pg::{
5        QueryResCount,
6        schema::table::Table,
7    },
8};
9use super::{
10    expr::{
11        Expr,
12        ExprType,
13        check_bool,
14        ExprValName,
15    },
16    utils::{
17        QueryBody,
18        build_returning,
19    },
20    select::Returning,
21};
22
23pub struct Delete {
24    pub(crate) table: Table,
25    pub(crate) where_: Option<Expr>,
26    pub(crate) returning: Vec<Returning>,
27}
28
29impl QueryBody for Delete {
30    fn build(
31        &self,
32        ctx: &mut super::utils::PgQueryCtx,
33        path: &rpds::Vector<String>,
34        res_count: QueryResCount,
35    ) -> (super::expr::ExprType, crate::utils::Tokens) {
36        // Prep
37        let mut scope = HashMap::new();
38        for (k, v) in match ctx.tables.get(&self.table) {
39            Some(t) => t,
40            None => {
41                ctx.errs.err(path, format!("Unknown table {} for delete", self.table));
42                return (ExprType(vec![]), Tokens::new());
43            },
44        } {
45            scope.insert(ExprValName::field(k), v.clone());
46        }
47
48        // Build query
49        let mut out = Tokens::new();
50        out.s("delete from").id(&self.table.id);
51        if let Some(where_) = &self.where_ {
52            out.s("where");
53            let path = path.push_back("Where".into());
54            let (where_t, where_tokens) = where_.build(ctx, &path, &scope);
55            check_bool(ctx, &path, &where_t);
56            out.s(&where_tokens.to_string());
57        }
58        let out_type = build_returning(ctx, path, &scope, &mut out, &self.returning, res_count);
59        (out_type, out)
60    }
61}