prqlc 0.13.11

PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement.
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

//! Partitioned Query
//!
//! This in an internal intermediate representation between RQ and SQL AST.
//!
//! For example, RQ does not have a separate node for DISTINCT, but uses [crate::pr::rq::Take] 1 with
//! `partition`. In [super::pq::preprocess] module, [crate::pr::rq::Transform] take is wrapped into
//! [ast::SqlTransform], which does have [`ast::SqlTransform::Distinct`].
//!
//! This module also contains the compiler from RQ to PQ.

mod anchor;
pub mod ast;
pub mod context;
mod gen_query;
mod positional_mapping;
mod postprocess;
pub mod preprocess;

pub(super) use gen_query::compile_query;

#[cfg(test)]
mod test {
    use super::ast::SqlQuery;
    use super::*;
    use crate::sql::Dialect;
    use crate::{Errors, Result};

    fn parse_and_resolve(source: &str) -> Result<SqlQuery, Errors> {
        let query = crate::semantic::test::parse_resolve_and_lower(source)?;

        let (sql, _) = compile_query(query, Some(Dialect::Generic))?;
        Ok(sql)
    }

    fn count_atomics(prql: &str) -> Result<usize, Errors> {
        let query = parse_and_resolve(prql)?;

        Ok(query.ctes.len() + 1)
    }

    #[test]
    fn test_ctes_of_pipeline() {
        // One aggregate, take at the end
        let prql: &str = r#"
        from employees
        filter country == "USA"
        aggregate {sal = average salary}
        sort sal
        take 20
        "#;

        assert!(count_atomics(prql).unwrap() == 1);

        // One aggregate, but take at the top
        let prql: &str = r#"
        from employees
        take 20
        filter country == "USA"
        aggregate {sal = average salary}
        sort sal
        "#;

        assert!(count_atomics(prql).unwrap() == 2);

        // A take, then two aggregates
        let prql: &str = r#"
        from employees
        take 20
        filter country == "USA"
        aggregate {sal = average salary}
        aggregate {sal2 = average sal}
        sort sal2
        "#;

        assert!(count_atomics(prql).unwrap() == 3);

        // A take, then a select
        let prql: &str = r###"
        from employees
        take 20
        select first_name
        "###;

        assert!(count_atomics(prql).unwrap() == 1);
    }
}