datasources 0.1.55

Async datasource interfaces, middleware, registry, and test doubles
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::*;

fn contact_graph() -> NestedSelectType {
    let source = NestedSelectType::new("ContactSource", "Id", vec!["Id".into(), "Name".into()], vec![]);
    let type_def = NestedSelectType::new("ContactType", "Id", vec!["Id".into(), "Name".into()], vec![]);
    let address_type = NestedSelectType::new("AddressType", "Id", vec!["Id".into(), "Name".into()], vec![]);
    let phone_type = NestedSelectType::new("PhoneType", "Id", vec!["Id".into(), "Name".into()], vec![]);
    let address = NestedSelectType::new(
        "Address",
        "Id",
        vec!["Id".into(), "Line1".into(), "City".into()],
        vec![NestedSelectRelation::new(
            "AddressType",
            NestedSelectRelationKind::Object,
            "AddressTypeId",
            "Id",
            address_type,
        )],
    );
    let phone = NestedSelectType::new(
        "Phone",
        "Id",
        vec!["Id".into(), "Number".into()],
        vec![NestedSelectRelation::new(
            "PhoneType",
            NestedSelectRelationKind::Object,
            "PhoneTypeId",
            "Id",
            phone_type,
        )],
    );
    NestedSelectType::new(
        "Contact",
        "Id",
        vec!["Id".into(), "FirstName".into(), "LastName".into(), "Email".into()],
        vec![
            NestedSelectRelation::new(
                "ContactSource",
                NestedSelectRelationKind::Object,
                "ContactSourceId",
                "Id",
                source,
            ),
            NestedSelectRelation::new(
                "ContactType",
                NestedSelectRelationKind::Object,
                "ContactTypeId",
                "Id",
                type_def,
            ),
            NestedSelectRelation::new("Addresses", NestedSelectRelationKind::List, "Id", "ContactId", address),
            NestedSelectRelation::new("Phones", NestedSelectRelationKind::List, "Id", "ContactId", phone),
        ],
    )
}

#[test]
fn builds_contact_joins_and_map() {
    let nested = NestedSelectBuilder::build(&contact_graph(), NestedSelectBuilderOptions::default());
    assert_eq!(nested.select.table, "Contact");
    assert_eq!(nested.select.fields.len(), 17);
    assert_eq!(nested.select.joins.len(), 6);
    assert_eq!(nested.map.key, "Id");
    assert!(nested.map.fields.iter().any(|(name, field)| {
        name == "Addresses"
            && matches!(field, TypeMapField::Group(group) if group.key == "AddressId")
    }));
}

#[test]
fn stop_at_drops_phones() {
    let nested = NestedSelectBuilder::build(
        &contact_graph(),
        NestedSelectBuilderOptions {
            stop_at: vec!["Phones".into()],
            ..NestedSelectBuilderOptions::default()
        },
    );
    assert!(nested.select.fields.iter().all(|field| !field.contains("Phone")));
    assert!(nested.select.joins.iter().all(|join| !join.table.contains("Phone")));
    assert!(nested.map.fields.iter().all(|(name, _)| name != "Phones"));
}

#[test]
fn procedure_adds_where_argument() {
    let procedure = CreateNestedReadStoredProcedureStatement::new(
        "ReadContactsByEmail",
        NestedSelectBuilder::build(
            &contact_graph(),
            NestedSelectBuilderOptions {
                stop_at: vec!["Phones".into()],
                ..NestedSelectBuilderOptions::default()
            },
        ),
        vec![NestedWhereArgument::new(
            "Contact.Email",
            RoutineParameter {
                name: "email".into(),
                r#type: "varchar".into(),
                field: None,
            },
        )],
    );
    let sql = DefaultStatementTextRenderer::instance().render(&procedure.select());
    assert!(sql.contains("Contact.Email"));
    assert!(!sql.contains("Phone"));
}

#[test]
fn procedure_ands_onto_existing_where() {
    let where_clause = Where::new(Operator::equals("Contact.Id", 1));
    let nested = NestedSelectBuilder::build(
        &contact_graph(),
        NestedSelectBuilderOptions {
            stop_at: vec!["Phones".into()],
            where_clause: Some(&where_clause),
        },
    );
    let procedure = CreateNestedReadStoredProcedureStatement::new(
        "ReadContactsByEmail",
        nested,
        vec![NestedWhereArgument::new(
            "Contact.Email",
            RoutineParameter {
                name: "email".into(),
                r#type: "varchar".into(),
                field: None,
            },
        )],
    );
    let sql = DefaultStatementTextRenderer::instance().render(&procedure.select());
    assert!(sql.contains(" AND "));
}