mool 0.2.0

A source-first Rust database toolkit for typed SQL queries, migrations, and model metadata
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
134
135
136
137
138
139

//! Window-function SQL rendering helpers.

use super::dialect::{self, DialectFeature};
use super::expr::{ExprNode, OrderExpr};
use super::render::{RenderMode, Renderer};
use super::window::{FrameBound, FrameBoundKind, FrameUnit, WindowFrame, WindowSpec};
use crate::QueryError;

pub(super) fn render_over(
    renderer: &mut Renderer,
    expr: &ExprNode,
    window: &WindowSpec,
    mode: RenderMode<'_>,
) -> Result<String, QueryError> {
    if matches!(mode, RenderMode::MutationRoot { .. }) {
        return Err(QueryError::BindError(
            "window functions are not allowed in mutation statements".to_string(),
        ));
    }
    validate_window_base(expr)?;
    dialect::validate_feature(renderer.dialect(), DialectFeature::WindowFunctions)?;
    let inner = renderer.render_expr(expr, mode)?;
    let spec = render_window(renderer, window, mode)?;
    Ok(format!("{inner} OVER ({spec})"))
}

fn validate_window_base(expr: &ExprNode) -> Result<(), QueryError> {
    match expr {
        ExprNode::Function { function, .. } if function.supports_window() => Ok(()),
        _ => Err(QueryError::BindError(
            "OVER requires a window-capable function".to_string(),
        )),
    }
}

fn render_window(
    renderer: &mut Renderer,
    window: &WindowSpec,
    mode: RenderMode<'_>,
) -> Result<String, QueryError> {
    let mut parts = Vec::new();
    push_partitions(renderer, window, mode, &mut parts)?;
    push_orders(renderer, window, mode, &mut parts)?;
    if let Some(frame) = &window.frame {
        parts.push(render_frame(renderer, frame, mode)?);
    }
    Ok(parts.join(" "))
}

fn push_partitions(
    renderer: &mut Renderer,
    window: &WindowSpec,
    mode: RenderMode<'_>,
    parts: &mut Vec<String>,
) -> Result<(), QueryError> {
    if window.partitions.is_empty() {
        return Ok(());
    }
    let rendered = window
        .partitions
        .iter()
        .map(|expr| renderer.render_expr(expr, mode))
        .collect::<Result<Vec<_>, _>>()?;
    parts.push(format!("PARTITION BY {}", rendered.join(", ")));
    Ok(())
}

fn push_orders(
    renderer: &mut Renderer,
    window: &WindowSpec,
    mode: RenderMode<'_>,
    parts: &mut Vec<String>,
) -> Result<(), QueryError> {
    if window.orders.is_empty() {
        return Ok(());
    }
    let mut rendered = Vec::with_capacity(window.orders.len());
    for order in &window.orders {
        rendered.push(render_order(renderer, order, mode)?);
    }
    parts.push(format!("ORDER BY {}", rendered.join(", ")));
    Ok(())
}

fn render_order(
    renderer: &mut Renderer,
    order: &OrderExpr,
    mode: RenderMode<'_>,
) -> Result<String, QueryError> {
    let direction = if order.desc { "DESC" } else { "ASC" };
    Ok(format!(
        "{} {direction}",
        renderer.render_expr(&order.expr, mode)?
    ))
}

fn render_frame(
    renderer: &mut Renderer,
    frame: &WindowFrame,
    mode: RenderMode<'_>,
) -> Result<String, QueryError> {
    let unit = match frame.unit {
        FrameUnit::Rows => "ROWS",
        FrameUnit::Range => "RANGE",
    };
    Ok(format!(
        "{unit} BETWEEN {} AND {}",
        render_bound(renderer, &frame.start, mode)?,
        render_bound(renderer, &frame.end, mode)?
    ))
}

fn render_bound(
    renderer: &mut Renderer,
    bound: &FrameBound,
    mode: RenderMode<'_>,
) -> Result<String, QueryError> {
    match bound.kind {
        FrameBoundKind::UnboundedPreceding => Ok("UNBOUNDED PRECEDING".to_string()),
        FrameBoundKind::CurrentRow => Ok("CURRENT ROW".to_string()),
        FrameBoundKind::UnboundedFollowing => Ok("UNBOUNDED FOLLOWING".to_string()),
        FrameBoundKind::Preceding => render_offset(renderer, bound, mode, "PRECEDING"),
        FrameBoundKind::Following => render_offset(renderer, bound, mode, "FOLLOWING"),
    }
}

fn render_offset(
    renderer: &mut Renderer,
    bound: &FrameBound,
    mode: RenderMode<'_>,
    suffix: &str,
) -> Result<String, QueryError> {
    let Some(expr) = bound.expr.as_ref() else {
        return Err(QueryError::BindError(format!(
            "{suffix} frame bound requires an offset"
        )));
    };
    Ok(format!("{} {suffix}", renderer.render_expr(expr, mode)?))
}