spg-engine 7.37.24

Execution engine for SPG: glues spg-sql parsing to spg-storage. Foreign keys, joins, vectors, cold tier.
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
111
112
113
114
115
116
117
118
119
120
121

//! v7.37.17 (17.6 siblings) — trig family sin/cos/tan/asin/acos/
//! atan/atan2 + hyperbolic sinh/cosh/tanh + degree-input variants.

use spg_engine::{Engine, QueryResult};

fn first(e: &mut Engine, sql: &str) -> spg_storage::Value<'static> {
    let r = e
        .execute(sql)
        .unwrap_or_else(|err| panic!("{sql}: {err:?}"));
    let QueryResult::Rows { rows, .. } = r else {
        panic!("expected Rows");
    };
    rows[0].values[0].clone()
}

fn as_float(v: &spg_storage::Value<'_>) -> f64 {
    match v {
        spg_storage::Value::Float(f) => *f,
        other => panic!("expected Float, got {other:?}"),
    }
}

fn assert_close(actual: f64, expected: f64, tol: f64) {
    assert!(
        (actual - expected).abs() < tol,
        "expected ~{expected}, got {actual}"
    );
}

#[test]
fn sin_cos_tan_basic_values() {
    let mut e = Engine::new();
    assert_close(as_float(&first(&mut e, "SELECT sin(0)")), 0.0, 1e-12);
    assert_close(as_float(&first(&mut e, "SELECT cos(0)")), 1.0, 1e-12);
    assert_close(as_float(&first(&mut e, "SELECT tan(0)")), 0.0, 1e-12);
    // sin(π/2) = 1
    assert_close(as_float(&first(&mut e, "SELECT sin(pi() / 2)")), 1.0, 1e-12);
    // cos(π) = -1
    assert_close(as_float(&first(&mut e, "SELECT cos(pi())")), -1.0, 1e-12);
}

#[test]
fn inverse_trig() {
    let mut e = Engine::new();
    // asin(0) = 0, asin(1) = π/2
    assert_close(as_float(&first(&mut e, "SELECT asin(0)")), 0.0, 1e-12);
    assert_close(
        as_float(&first(&mut e, "SELECT asin(1)")),
        core::f64::consts::PI / 2.0,
        1e-12,
    );
    assert_close(as_float(&first(&mut e, "SELECT acos(1)")), 0.0, 1e-12);
    assert_close(as_float(&first(&mut e, "SELECT atan(0)")), 0.0, 1e-12);
    // atan(1) = π/4
    assert_close(
        as_float(&first(&mut e, "SELECT atan(1)")),
        core::f64::consts::PI / 4.0,
        1e-12,
    );
}

#[test]
fn atan2_quadrants() {
    let mut e = Engine::new();
    // atan2(0, 1) = 0
    assert_close(as_float(&first(&mut e, "SELECT atan2(0, 1)")), 0.0, 1e-12);
    // atan2(1, 0) = π/2
    assert_close(
        as_float(&first(&mut e, "SELECT atan2(1, 0)")),
        core::f64::consts::PI / 2.0,
        1e-12,
    );
    // atan2(1, 1) = π/4
    assert_close(
        as_float(&first(&mut e, "SELECT atan2(1, 1)")),
        core::f64::consts::PI / 4.0,
        1e-12,
    );
}

#[test]
fn hyperbolic() {
    let mut e = Engine::new();
    assert_close(as_float(&first(&mut e, "SELECT sinh(0)")), 0.0, 1e-12);
    assert_close(as_float(&first(&mut e, "SELECT cosh(0)")), 1.0, 1e-12);
    assert_close(as_float(&first(&mut e, "SELECT tanh(0)")), 0.0, 1e-12);
    // asinh(sinh(1)) = 1
    let one = as_float(&first(&mut e, "SELECT asinh(sinh(1))"));
    assert_close(one, 1.0, 1e-12);
}

#[test]
fn degree_variants() {
    let mut e = Engine::new();
    // sind(90) = 1
    assert_close(as_float(&first(&mut e, "SELECT sind(90)")), 1.0, 1e-12);
    // cosd(180) = -1
    assert_close(as_float(&first(&mut e, "SELECT cosd(180)")), -1.0, 1e-12);
    // atand(1) = 45
    assert_close(as_float(&first(&mut e, "SELECT atand(1)")), 45.0, 1e-12);
    // atan2d(1, 1) = 45
    assert_close(as_float(&first(&mut e, "SELECT atan2d(1, 1)")), 45.0, 1e-12);
}

#[test]
fn trig_null_passthrough() {
    let mut e = Engine::new();
    for f in &[
        "sin(NULL::float)",
        "cos(NULL::float)",
        "atan2(NULL::float, 1)",
        "atan2(1, NULL::float)",
        "sind(NULL::float)",
    ] {
        let sql = format!("SELECT {f}");
        assert!(
            matches!(first(&mut e, &sql), spg_storage::Value::Null),
            "SELECT {f} should be NULL"
        );
    }
}