dinoco 0.0.7

A modern Rust ORM for schema-driven queries, migrations, and database operations.
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

use dinoco_engine::{DinocoAdapter, DinocoResult, Expression, QueryBuilder, SelectStatement};

use super::{DinocoPairRow, DinocoValueRow};

pub(super) async fn query_ids<A>(
    adapter: &A,
    table_name: &str,
    select_column: Option<&str>,
    conditions: Vec<Expression>,
) -> DinocoResult<Vec<dinoco_engine::DinocoValue>>
where
    A: DinocoAdapter,
{
    let select_column = select_column.unwrap_or("id");
    let mut statement = SelectStatement::new().from(table_name).select(&[select_column]);

    for condition in conditions {
        statement = statement.condition(condition);
    }

    let (sql, params) = adapter.dialect().build_select(&statement);
    let rows = adapter.query_as::<DinocoValueRow>(&sql, &params).await?;

    Ok(rows.into_iter().map(|row| row.value).collect())
}

pub(super) async fn query_first_id<A>(
    adapter: &A,
    table_name: &str,
    select_column: &str,
    conditions: &[Expression],
) -> DinocoResult<Option<dinoco_engine::DinocoValue>>
where
    A: DinocoAdapter,
{
    let mut statement = SelectStatement::new().from(table_name).select(&[select_column]).limit(1);

    for condition in conditions {
        statement = statement.condition(condition.clone());
    }

    let (sql, params) = adapter.dialect().build_select(&statement);
    let rows = adapter.query_as::<DinocoValueRow>(&sql, &params).await?;

    Ok(rows.into_iter().next().map(|row| row.value))
}

pub(super) async fn query_pairs<A>(
    adapter: &A,
    table_name: &str,
    left_column: &str,
    right_column: &str,
    left_values: Vec<dinoco_engine::DinocoValue>,
    right_values: Vec<dinoco_engine::DinocoValue>,
) -> DinocoResult<Vec<(dinoco_engine::DinocoValue, dinoco_engine::DinocoValue)>>
where
    A: DinocoAdapter,
{
    let statement = SelectStatement::new()
        .from(table_name)
        .select(&[left_column, right_column])
        .condition(Expression::Column(left_column.to_string()).in_values(left_values))
        .condition(Expression::Column(right_column.to_string()).in_values(right_values));
    let (sql, params) = adapter.dialect().build_select(&statement);
    let rows = adapter.query_as::<DinocoPairRow>(&sql, &params).await?;

    Ok(rows.into_iter().map(|row| (row.left, row.right)).collect())
}