oxide-sql-core 0.2.0

Type-safe SQL parser and builder with compile-time validation
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

//! Tests for SELECT column selection: wildcards, named columns,
//! qualified columns, aliases, DISTINCT, ALL, and no-FROM selects.

mod common;
use common::*;

use oxide_sql_core::ast::{BinaryOp, Expr};

#[test]
fn select_star() {
    let s = parse_select("SELECT * FROM users");
    assert_eq!(s.columns.len(), 1);
    assert!(matches!(s.columns[0].expr, Expr::Wildcard { table: None }));
    round_trip("SELECT * FROM users");
}

#[test]
fn select_qualified_star() {
    let s = parse_select("SELECT u.* FROM users u");
    assert_eq!(s.columns.len(), 1);
    assert!(matches!(
        &s.columns[0].expr,
        Expr::Wildcard { table: Some(t) } if t == "u"
    ));
    round_trip("SELECT u.* FROM users AS u");
}

#[test]
fn select_named_columns() {
    let s = parse_select("SELECT id, name, email FROM users");
    assert_eq!(s.columns.len(), 3);
    assert!(matches!(
        &s.columns[0].expr,
        Expr::Column { name, table: None, .. } if name == "id"
    ));
    assert!(matches!(
        &s.columns[2].expr,
        Expr::Column { name, table: None, .. } if name == "email"
    ));
    round_trip("SELECT id, name, email FROM users");
}

#[test]
fn select_qualified_columns() {
    let s = parse_select("SELECT u.id, u.name FROM users u");
    assert_eq!(s.columns.len(), 2);
    assert!(matches!(
        &s.columns[0].expr,
        Expr::Column { table: Some(t), name, .. }
            if t == "u" && name == "id"
    ));
    round_trip("SELECT u.id, u.name FROM users AS u");
}

#[test]
fn select_alias_with_as() {
    let s = parse_select("SELECT id AS user_id FROM users");
    assert_eq!(s.columns[0].alias.as_deref(), Some("user_id"));
    round_trip("SELECT id AS user_id FROM users");
}

#[test]
fn select_bare_alias() {
    let s = parse_select("SELECT id uid FROM users");
    assert_eq!(s.columns[0].alias.as_deref(), Some("uid"));
    round_trip("SELECT id AS uid FROM users");
}

#[test]
fn select_expression_alias() {
    let s = parse_select("SELECT 1 + 2 AS total");
    assert_eq!(s.columns[0].alias.as_deref(), Some("total"));
    assert!(matches!(
        &s.columns[0].expr,
        Expr::Binary {
            op: BinaryOp::Add,
            ..
        }
    ));
    round_trip("SELECT 1 + 2 AS total");
}

#[test]
fn select_distinct() {
    let s = parse_select("SELECT DISTINCT status FROM orders");
    assert!(s.distinct);
    assert_eq!(s.columns.len(), 1);
    round_trip("SELECT DISTINCT status FROM orders");
}

#[test]
fn select_all() {
    let s = parse_select("SELECT ALL status FROM orders");
    assert!(!s.distinct);
    round_trip("SELECT status FROM orders");
}

#[test]
fn select_without_from() {
    let s = parse_select("SELECT 1 + 1");
    assert!(s.from.is_none());
    assert!(matches!(
        &s.columns[0].expr,
        Expr::Binary {
            op: BinaryOp::Add,
            ..
        }
    ));
    round_trip("SELECT 1 + 1");
}