drizzle 0.1.10

A type-safe SQL query builder for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#![cfg(any(feature = "rusqlite", feature = "turso", feature = "libsql"))]
#[cfg(feature = "uuid")]
use crate::common::schema::sqlite::{InsertComplex, Role, SimpleComplexSchema};
use crate::common::schema::sqlite::{InsertSimple, SelectSimple, Simple, SimpleSchema};
use drizzle::core::expr::*;
use drizzle::sqlite::prelude::*;
#[cfg(feature = "uuid")]
use uuid::Uuid;

#[cfg(feature = "uuid")]
#[allow(dead_code)]
#[derive(Debug, SQLiteFromRow)]
struct ComplexResult {
    id: Uuid,
    name: String,
    email: Option<String>,
    age: Option<i32>,
}

#[drizzle::test]
fn simple_delete(db: &mut TestDb<SimpleSchema>) {
    let SimpleSchema { simple } = schema;

    // Insert test records
    let test_data = vec![
        InsertSimple::new("delete_me"),
        InsertSimple::new("keep_me"),
        InsertSimple::new("delete_me"),
    ];

    let insert_result = db.insert(simple).values(test_data).execute();
    assert_eq!(insert_result, 3);

    // Verify initial state
    let initial_results: Vec<SelectSimple> = db.select((simple.id, simple.name)).from(simple).all();
    assert_eq!(initial_results.len(), 3);

    // Delete records with specific condition
    let delete_result = db
        .delete(simple)
        .r#where(eq(simple.name, "delete_me"))
        .execute();

    assert_eq!(delete_result, 2); // Should delete 2 records

    // Verify deletion - should only have "keep_me" left
    let remaining_results: Vec<SelectSimple> =
        db.select((simple.id, simple.name)).from(simple).all();

    assert_eq!(remaining_results.len(), 1);
    assert_eq!(remaining_results[0].name, "keep_me");

    // Verify deleted records are gone
    let deleted_results: Vec<SelectSimple> = db
        .select((simple.id, simple.name))
        .from(simple)
        .r#where(eq(Simple::name, "delete_me"))
        .all();

    assert_eq!(deleted_results.len(), 0);
}

#[cfg(feature = "uuid")]
#[drizzle::test]
fn feature_gated_delete(db: &mut TestDb<SimpleComplexSchema>) {
    let SimpleComplexSchema { complex, .. } = schema;

    // Insert test records with UUIDs
    let test_id_1 = uuid::Uuid::new_v4();
    let test_id_2 = uuid::Uuid::new_v4();

    let test_data = vec![
        InsertComplex::new("delete_user", true, Role::User)
            .with_id(test_id_1)
            .with_email("delete@example.com".to_string())
            .with_age(25),
        InsertComplex::new("keep_user", true, Role::User)
            .with_id(test_id_2)
            .with_email("keep@example.com".to_string())
            .with_age(35),
    ];

    let insert_result = db.insert(complex).values(test_data).execute();
    assert_eq!(insert_result, 2);

    // Verify initial state
    let initial_results: Vec<ComplexResult> = db
        .select((complex.id, complex.name, complex.email, complex.age))
        .from(complex)
        .all();
    assert_eq!(2, initial_results.len());

    // Delete specific record using UUID primary key
    let delete_result = db
        .delete(complex)
        .r#where(eq(complex.id, test_id_1))
        .execute();
    assert_eq!(1, delete_result);

    // Verify deletion - should only have keep_user left
    let remaining_results: Vec<ComplexResult> = db
        .select((complex.id, complex.name, complex.email, complex.age))
        .from(complex)
        .all();

    assert_eq!(1, remaining_results.len());
    assert_eq!("keep_user", remaining_results[0].name.as_str());
    assert_eq!(test_id_2, remaining_results[0].id);

    // Verify specific UUID record is gone
    let deleted_results: Vec<ComplexResult> = db
        .select((complex.id, complex.name, complex.email, complex.age))
        .from(complex)
        .r#where(eq(complex.id, test_id_1.to_string()))
        .all();

    assert_eq!(0, deleted_results.len());
}