pylon-db-core 0.2.0

The Pylon compiler: PyQL parsing, IR, SQL emission, schema export and migration diffing
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

//
// This source file is part of the Pylon open source project.
//
// Copyright (c) 2026 Jaldis B.V.
//
// Licensed under the MIT OR Apache-2.0 license (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://opensource.org/licenses/MIT
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

use super::{B, E, NamedDefault, f, p, pn, set_of};
use super::{Decimal, Float64, FnDescriptor, Int64};

pub(super) fn build() -> Vec<FnDescriptor> {
    vec![
        f("math", "pi", vec![], Float64, E("pi()")),
        f("math", "e", vec![], Float64, E("exp(1.0)")),
        f("math", "exp", vec![p("n", Float64)], Float64, B("exp")),
        f("math", "ln", vec![p("n", Float64)], Float64, B("ln")),
        f("math", "ln", vec![p("n", Decimal)], Decimal, B("ln")),
        f("math", "log", vec![p("n", Float64)], Float64, B("log")),
        // `log(base, x)` in PostgreSQL — the arguments are swapped — and it is
        // numeric-only, which is why the base has no float64 form.
        f(
            "math",
            "log",
            vec![p("n", Decimal), pn("base", Decimal, NamedDefault::Required)],
            Decimal,
            E("log($2, $1)"),
        ),
        f("math", "log2", vec![p("n", Float64)], Float64, E("log(2.0, $1)")),
        f("math", "log10", vec![p("n", Float64)], Float64, B("log")),
        // math::lg is exactly a base-10 log; kept as a thin alias alongside
        // the clearer std::log10 name (which Pylon deliberately favors — see
        // stdlib-intentional-divergences memory).
        f("math", "lg", vec![p("n", Int64)], Float64, E("log($1::float8)")),
        f("math", "lg", vec![p("n", Float64)], Float64, B("log")),
        f("math", "lg", vec![p("n", Decimal)], Decimal, B("log")),
        f("math", "sin", vec![p("n", Float64)], Float64, B("sin")),
        f("math", "cos", vec![p("n", Float64)], Float64, B("cos")),
        f("math", "tan", vec![p("n", Float64)], Float64, B("tan")),
        f("math", "cot", vec![p("n", Float64)], Float64, B("cot")),
        f("math", "asin", vec![p("n", Float64)], Float64, B("asin")),
        f("math", "acos", vec![p("n", Float64)], Float64, B("acos")),
        f("math", "atan", vec![p("n", Float64)], Float64, B("atan")),
        f(
            "math",
            "atan2",
            vec![p("y", Float64), p("x", Float64)],
            Float64,
            B("atan2"),
        ),
        f(
            "math",
            "stddev",
            vec![p("s", set_of(Float64))],
            Float64,
            B("stddev_samp"),
        ),
        f(
            "math",
            "stddev",
            vec![p("s", set_of(Decimal))],
            Decimal,
            B("stddev_samp"),
        ),
        f(
            "math",
            "stddev_pop",
            vec![p("s", set_of(Float64))],
            Float64,
            B("stddev_pop"),
        ),
        f(
            "math",
            "stddev_pop",
            vec![p("s", set_of(Decimal))],
            Decimal,
            B("stddev_pop"),
        ),
        f("math", "var", vec![p("s", set_of(Float64))], Float64, B("var_samp")),
        f("math", "var", vec![p("s", set_of(Decimal))], Decimal, B("var_samp")),
        f("math", "var_pop", vec![p("s", set_of(Float64))], Float64, B("var_pop")),
        f("math", "var_pop", vec![p("s", set_of(Decimal))], Decimal, B("var_pop")),
        // These belong in `math::`, not `std::` — `std::ceil` alone would
        // leave `math::ceil(…)` reading as a function that does not exist.
        f("math", "abs", vec![p("x", Int64)], Int64, B("abs")),
        f("math", "abs", vec![p("x", Float64)], Float64, B("abs")),
        f("math", "abs", vec![p("x", Decimal)], Decimal, B("abs")),
        f("math", "ceil", vec![p("x", Int64)], Int64, B("ceil")),
        f("math", "ceil", vec![p("x", Float64)], Float64, B("ceil")),
        f("math", "ceil", vec![p("x", Decimal)], Decimal, B("ceil")),
        f("math", "floor", vec![p("x", Int64)], Int64, B("floor")),
        f("math", "floor", vec![p("x", Float64)], Float64, B("floor")),
        f("math", "floor", vec![p("x", Decimal)], Decimal, B("floor")),
        f("math", "sqrt", vec![p("x", Int64)], Float64, E("sqrt($1::float8)")),
        f("math", "sqrt", vec![p("x", Float64)], Float64, B("sqrt")),
        f("math", "sqrt", vec![p("x", Decimal)], Decimal, B("sqrt")),
        f(
            "math",
            "mean",
            vec![p("vals", set_of(Int64))],
            Float64,
            E("avg($1)::float8"),
        ),
        f("math", "mean", vec![p("vals", set_of(Float64))], Float64, B("avg")),
        f("math", "mean", vec![p("vals", set_of(Decimal))], Decimal, B("avg")),
    ]
}