toasty 0.10.0

An async ORM for Rust supporting SQL and NoSQL databases
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

use hashbrown::HashSet;
use toasty_core::{
    schema::db::ColumnId,
    stmt::{self, ExprReference},
};

use super::Normalize;

impl Normalize<'_> {
    /// Appends missing physical primary-key columns to ambiguous SQL cursor
    /// ordering.
    ///
    /// The public query retains only the user-provided ordering. Normalization
    /// runs on the cloned statement passed to the engine, making these
    /// tie-breakers internal to execution and cursor generation. Physical
    /// column references keep embedded newtype keys scalar after lowering.
    pub(super) fn normalize_cursor_order(&mut self, query: &mut stmt::Query) {
        if !self.capability.sql() || !matches!(query.limit, Some(stmt::Limit::Cursor(_))) {
            return;
        }

        let Some(order_by) = &mut query.order_by else {
            return;
        };
        if order_by.exprs.is_empty() {
            return;
        }
        let Some(select) = query.body.as_select() else {
            return;
        };
        let Some(model_id) = select.source.model_id() else {
            return;
        };

        let mapping = self.schema.mapping.model(model_id);
        let table = self.schema.db.table(mapping.table);
        let mut ordered_columns: HashSet<_> = order_by
            .exprs
            .iter()
            .filter_map(|order| resolve_order_column(mapping, &order.expr))
            .collect();

        let unambiguous = table.indices.iter().any(|index| {
            (index.unique || index.primary_key)
                && index
                    .columns
                    .iter()
                    .all(|index_column| ordered_columns.contains(&index_column.column))
                && index
                    .columns
                    .iter()
                    .all(|index_column| !table.column(index_column.column).nullable)
        });
        if unambiguous {
            return;
        }

        let direction = order_by.exprs.last().and_then(|order| order.order);
        for column in &table.primary_key.columns {
            if !ordered_columns.insert(*column) {
                continue;
            }

            order_by.exprs.push(stmt::OrderByExpr {
                expr: stmt::Expr::column(*column),
                order: direction,
            });
        }
    }
}

/// Resolves a model field path used by `order_by` to its single physical
/// column. Expressions that do not resolve to exactly one column cannot prove
/// that an order is unique.
fn resolve_order_column(
    mapping: &toasty_core::schema::mapping::Model,
    expr: &stmt::Expr,
) -> Option<ColumnId> {
    if let stmt::Expr::Reference(ExprReference::Column(column)) = expr {
        return (column.nesting == 0 && column.table == 0).then_some(ColumnId {
            table: mapping.table,
            index: column.column,
        });
    }

    let projection = field_projection(expr)?;
    let field = mapping.resolve_field_mapping(&projection)?;
    let mut columns = field.columns();
    let (column, _) = columns.next()?;
    columns.next().is_none().then_some(column)
}

fn field_projection(expr: &stmt::Expr) -> Option<stmt::Projection> {
    match expr {
        stmt::Expr::Reference(ExprReference::Field { nesting: 0, index }) => {
            Some(stmt::Projection::single(*index))
        }
        stmt::Expr::Project(project) => {
            let mut projection = field_projection(&project.base)?;
            for step in &project.projection {
                projection.push(step);
            }
            Some(projection)
        }
        _ => None,
    }
}