uqa-sql 0.4.0

PostgreSQL-compatible SQL compiler built on libpg_query
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

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Convert `PostgreSQL`'s 2000 epoch Datums to shared temporal values.

use crate::catalog::node_tree::invalid;
use crate::SQLError;
use uqa_core::TemporalValue;

const EPOCH_DAYS: i32 = 10_957;
const EPOCH_MICROS: i64 = 946_684_800_000_000;

pub(super) fn encode(value: &TemporalValue, oid: i64) -> Result<Vec<u8>, SQLError> {
    let bytes = match (value, oid) {
        (TemporalValue::Date { days }, 1082) => {
            let days = days
                .checked_sub(EPOCH_DAYS)
                .ok_or_else(|| invalid("date Datum overflow"))?;
            i64::from(days).to_le_bytes().to_vec()
        }
        (TemporalValue::Time { micros }, 1083) => micros.to_le_bytes().to_vec(),
        (TemporalValue::Timestamp { micros }, 1114)
        | (TemporalValue::TimestampTz { micros }, 1184) => micros
            .checked_sub(EPOCH_MICROS)
            .ok_or_else(|| invalid("timestamp Datum overflow"))?
            .to_le_bytes()
            .to_vec(),
        (
            TemporalValue::TimeTz {
                micros,
                offset_minutes,
            },
            1266,
        ) => {
            let offset = offset_minutes
                .checked_mul(-60)
                .ok_or_else(|| invalid("time zone Datum overflow"))?;
            micros
                .to_le_bytes()
                .into_iter()
                .chain(offset.to_le_bytes())
                .collect()
        }
        (
            TemporalValue::Interval {
                months,
                days,
                micros,
            },
            1186,
        ) => micros
            .to_le_bytes()
            .into_iter()
            .chain(days.to_le_bytes())
            .chain(months.to_le_bytes())
            .collect(),
        _ => return Err(invalid("temporal Datum differs from its declared type")),
    };
    Ok(bytes)
}

pub(crate) fn decode(bytes: &[u8], oid: i64) -> Result<TemporalValue, SQLError> {
    let integer = |offset: usize| -> Result<i32, SQLError> {
        bytes
            .get(offset..offset + 4)
            .and_then(|bytes| bytes.try_into().ok())
            .map(i32::from_le_bytes)
            .ok_or_else(|| invalid("truncated temporal Datum"))
    };
    let micros = || -> Result<i64, SQLError> {
        bytes
            .get(..8)
            .and_then(|bytes| bytes.try_into().ok())
            .map(i64::from_le_bytes)
            .ok_or_else(|| invalid("truncated temporal Datum"))
    };
    Ok(match oid {
        1082 => TemporalValue::Date {
            days: integer(0)?
                .checked_add(EPOCH_DAYS)
                .ok_or_else(|| invalid("date Datum overflow"))?,
        },
        1083 => TemporalValue::Time { micros: micros()? },
        1114 | 1184 => {
            let micros = micros()?
                .checked_add(EPOCH_MICROS)
                .ok_or_else(|| invalid("timestamp Datum overflow"))?;
            if oid == 1114 {
                TemporalValue::Timestamp { micros }
            } else {
                TemporalValue::TimestampTz { micros }
            }
        }
        1266 => {
            let seconds = integer(8)?;
            if seconds % 60 != 0 {
                return Err(invalid("time zone offset is not a whole minute"));
            }
            TemporalValue::TimeTz {
                micros: micros()?,
                offset_minutes: seconds / -60,
            }
        }
        1186 => TemporalValue::Interval {
            months: integer(12)?,
            days: integer(8)?,
            micros: micros()?,
        },
        _ => return Err(invalid("unknown temporal Datum type")),
    })
}