alopex-sql 0.6.0

SQL parser components for the Alopex DB dialect
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

use alopex_sql::{
    Assignment, CreateIndex, CreateTable, Delete, FromItem, Insert, OrderByExpr, Select,
    SelectItem, Span, Spanned, Statement, StatementKind, Update,
};

fn span(line: u64, col: u64) -> Span {
    Span::new(
        alopex_sql::Location::new(line, col),
        alopex_sql::Location::new(line, col + 1),
    )
}

#[cfg_attr(not(feature = "lane_ci"), ignore)]
#[test]
fn ddl_nodes_carry_spans() {
    let tbl = CreateTable {
        if_not_exists: true,
        name: "t".into(),
        columns: vec![],
        constraints: vec![],
        with_options: vec![],
        span: span(1, 1),
    };
    assert_eq!(tbl.span().start.line, 1);

    let idx = CreateIndex {
        if_not_exists: false,
        name: "idx".into(),
        table: "t".into(),
        column: "c".into(),
        method: None,
        options: vec![],
        span: span(2, 1),
    };
    assert_eq!(idx.span().start.line, 2);
}

#[cfg_attr(not(feature = "lane_ci"), ignore)]
#[test]
fn dml_nodes_carry_spans() {
    let select = Select {
        distinct: false,
        projection: vec![SelectItem::Wildcard { span: span(1, 1) }],
        from: vec![FromItem::Table {
            name: "t".into(),
            alias: None,
            span: span(1, 10),
        }],
        selection: None,
        group_by: None,
        having: None,
        order_by: vec![OrderByExpr {
            expr: alopex_sql::Expr::new(
                alopex_sql::ExprKind::Literal {
                    literal: alopex_sql::Literal::Number("1".into()),
                },
                span(1, 20),
            ),
            asc: Some(true),
            nulls_first: None,
            span: span(1, 20),
        }],
        limit: None,
        offset: None,
        span: span(1, 1),
    };
    assert_eq!(select.span().start.column, 1);

    let insert = Insert {
        table: "t".into(),
        columns: None,
        values: vec![],
        span: span(2, 1),
    };
    assert_eq!(insert.span().start.line, 2);

    let update = Update {
        table: "t".into(),
        assignments: vec![Assignment {
            column: "c".into(),
            value: alopex_sql::Expr::new(
                alopex_sql::ExprKind::Literal {
                    literal: alopex_sql::Literal::Null,
                },
                span(3, 10),
            ),
            span: span(3, 5),
        }],
        selection: None,
        span: span(3, 1),
    };
    assert_eq!(update.span().start.line, 3);

    let delete = Delete {
        table: "t".into(),
        selection: None,
        span: span(4, 1),
    };
    assert_eq!(delete.span().start.line, 4);

    let stmt = Statement {
        kind: StatementKind::Select(select),
        span: span(1, 1),
    };
    assert_eq!(stmt.span().start.line, 1);
}