uqa-sql 0.5.4

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//
// 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::{TemporalInfinity, TemporalValue};

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

pub(crate) fn encode(value: &TemporalValue, oid: i64) -> Result<Vec<u8>, SQLError> {
    let bytes = match (value, oid) {
        (TemporalValue::Date { days }, 1082) => {
            let days = if value.is_finite() {
                days.checked_sub(EPOCH_DAYS)
                    .ok_or_else(|| invalid("date Datum overflow"))?
            } else {
                *days
            };
            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) => (match value.infinity() {
            Some(TemporalInfinity::Negative) => i64::MIN,
            Some(TemporalInfinity::Positive) => i64::MAX,
            None => 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 => {
            let value = TemporalValue::Date { days: integer(0)? };
            if !value.is_finite() {
                return Ok(value);
            }
            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()?;
            let infinity = match micros {
                i64::MIN => Some(TemporalInfinity::Negative),
                i64::MAX => Some(TemporalInfinity::Positive),
                _ => None,
            };
            if let Some(infinity) = infinity {
                return Ok(if oid == 1114 {
                    infinity.timestamp()
                } else {
                    infinity.timestamp_tz()
                });
            }
            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")),
    })
}