holocron 0.4.0

Declarative schema & query compiler — one YAML as the source of truth for SQL schema and a type-checked query catalog.
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

use crate::ast::{SelectItem, View};
use crate::catalog::CatalogColumn;
use crate::error::HolocronError;
use crate::resolve::scope::Scope;

/// Resolve a view's select list into catalog columns, flowing each source
/// column's type up to the view column.
pub(crate) fn resolve_columns(
    view: &View,
    scope: &Scope,
) -> Result<Vec<CatalogColumn>, HolocronError> {
    let mut columns = Vec::with_capacity(view.select.len());
    for item in &view.select {
        columns.push(resolve_item(view, item, scope)?);
    }
    Ok(columns)
}

fn resolve_item(
    view: &View,
    item: &SelectItem,
    scope: &Scope,
) -> Result<CatalogColumn, HolocronError> {
    let select = match item {
        SelectItem::Column(select) => select,
        SelectItem::Expression(expression) => {
            return Err(HolocronError::unsupported(
                "expression select items are not yet supported",
                expression.span,
            ));
        }
    };

    // Resolve the source relation: the named alias, or the sole source if omitted.
    let relation = match &select.from {
        Some(alias) => scope.relation(&alias.value).ok_or_else(|| {
            HolocronError::unknown_alias(
                &view.name.value,
                &alias.value,
                scope.alias_names(),
                alias.span,
            )
        })?,
        None => scope.sole_relation().ok_or_else(|| {
            HolocronError::ambiguous_source(
                &view.name.value,
                &select.column.value,
                scope.alias_names(),
                select.column.span,
            )
        })?,
    };

    let source = relation.column(&select.column.value).ok_or_else(|| {
        let candidates = relation
            .columns
            .iter()
            .map(|column| column.name.clone())
            .collect();
        HolocronError::unknown_column(
            &relation.name,
            &select.column.value,
            candidates,
            select.column.span,
        )
    })?;

    let name = select
        .r#as
        .clone()
        .unwrap_or_else(|| select.column.value.clone());
    Ok(CatalogColumn {
        name,
        data_type: source.data_type.clone(),
        nullable: source.nullable,
        // The view declares the per-column query policy explicitly; defaults
        // come from the AST (filterable=true, searchable=false).
        filterable: select.filterable,
        searchable: select.searchable,
    })
}