welds 0.5.0

An async ORM for (postgres, mssql, mysql, sqlite)
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

use welds::prelude::*;

/// Define a struct the maps to the products table in the databases
#[derive(Debug, WeldsModel)]
#[welds(table = "products")]
#[welds(HasMany(orders, Order, "product_id"))]
pub struct Product {
    #[welds(primary_key)]
    #[welds(rename = "product_id")]
    pub id: i32,
    pub name: String,
    pub description: Option<String>,
    #[welds(rename = "price1")]
    pub price: Option<f32>,
    pub active: bool,
}

/// Define a Struct the maps to the Orders table in the databases
#[derive(Debug, WeldsModel)]
#[welds(table = "orders")]
#[welds(BelongsTo(product, Product, "product_id"))]
pub struct Order {
    #[welds(primary_key)]
    pub id: i32,
    pub product_id: Option<i32>,
    #[welds(rename = "price")]
    pub sell_price: Option<f32>,
}

#[async_std::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let connection_string = "sqlite::memory:";
    let client = welds::connections::connect(connection_string).await?;
    let client = client.as_ref();

    // Build an in memory DB with a schema (Product Table, Orders Table)
    let schema = include_str!("../../tests/testlib/databases/sqlite/01_create_tables.sql");
    client.execute(schema, &[]).await?;

    // Create a bunch of products to play with
    create_products(client).await?;
    println!();

    // Bulk update Orders and assign to first product
    Order::all().set(|x| x.product_id, 1).run(client).await?;
    //verify Change
    let order_count = Product::where_col(|p| p.id.equal(1))
        .map_query(|p| p.orders)
        .count(client)
        .await?;
    println!("Product:1 orders: {}", order_count);

    // Bulk update Orders selecting through the product with order filter
    Product::where_col(|p| p.id.equal(1))
        .map_query(|p| p.orders)
        .where_col(|o| o.id.gt(400))
        .set(|o| o.sell_price, 3.50)
        .run(client)
        .await?;
    //verify change
    let order_count = Order::where_col(|o| o.sell_price.gt(3.0))
        .count(client)
        .await?;
    println!("Updated orders: {}", order_count);

    // Bulk Delete
    let query = Product::where_col(|p| p.id.equal(1))
        .map_query(|p| p.orders)
        .where_col(|o| o.sell_price.equal(None));
    println!("To Delete orders: {}", query.count(client).await?);
    query.delete(client).await?;

    //verify deletion
    let order_count = Order::where_col(|o| o.sell_price.not_equal(None))
        .count(client)
        .await?;
    println!("Remaining orders: {}", order_count);

    Ok(())
}

async fn create_products(client: &dyn Client) -> Result<(), Box<dyn std::error::Error>> {
    let products: Vec<_> = (0..1000)
        .map(|i| Product {
            id: 0,
            name: format!("product #{}", i),
            description: None,
            price: None,
            active: true,
        })
        .collect();
    println!("Products::new()");
    welds::query::insert::bulk_insert(client, &products).await?;
    println!("Products::inserted()");

    let orders: Vec<_> = (0..1000)
        .map(|i| Order {
            id: 0,
            product_id: Some(i + 1),
            sell_price: None,
        })
        .collect();
    welds::query::insert::bulk_insert(client, &orders).await?;

    let total_p = Product::all().count(client).await?;
    let total_o = Order::all().count(client).await?;
    println!();
    println!("Created Products: {}", total_p);
    println!("Created Products: {}", total_o);
    Ok(())
}