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

//! Write-value and upsert rendering.

use super::super::binds::upsert_update_columns;
use super::super::dialect::DialectFeature;
use super::super::expr::ColumnRef;
use super::super::scope::QueryScope;
use super::super::values::WriteSlot;
use super::{RenderMode, Renderer};
use crate::QueryError;

impl Renderer {
    pub(super) fn render_values_grid(&self, rows: usize, cols: usize, sql: &mut String) {
        for row in 0..rows {
            if row > 0 {
                sql.push_str(", ");
            }
            sql.push('(');
            self.render_value_row(row, cols, sql);
            sql.push(')');
        }
    }

    pub(super) fn render_write_slots(
        &mut self,
        scope: &QueryScope,
        slots: &[WriteSlot],
        sql: &mut String,
    ) -> Result<(), QueryError> {
        for (idx, slot) in slots.iter().enumerate() {
            if idx > 0 {
                sql.push_str(", ");
            }
            sql.push_str(&self.render_write_slot(scope, slot)?);
        }
        Ok(())
    }

    pub(super) fn render_write_slot(
        &mut self,
        scope: &QueryScope,
        slot: &WriteSlot,
    ) -> Result<String, QueryError> {
        match slot {
            WriteSlot::Prebound(position) => Ok(self.placeholder(*position)),
            WriteSlot::Expr(expr) => self.render_expr(
                expr,
                RenderMode::MutationRoot {
                    source: &scope.source,
                },
            ),
        }
    }

    pub(super) fn render_upsert(
        &self,
        columns: &[String],
        conflict: &[ColumnRef],
        sql: &mut String,
    ) -> Result<(), QueryError> {
        let update_columns = upsert_update_columns(columns, conflict)?;
        self.dialect_renderer
            .validate_feature(DialectFeature::Upsert)?;
        sql.push_str(
            &self
                .dialect_renderer
                .render_upsert(conflict, &update_columns)?,
        );
        Ok(())
    }

    fn render_value_row(&self, row: usize, cols: usize, sql: &mut String) {
        for col in 0..cols {
            if col > 0 {
                sql.push_str(", ");
            }
            let position = row * cols + col + 1;
            sql.push_str(&self.placeholder(position));
        }
    }
}