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
115
116
117
118
119
120
121
122
123
124
125

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

//! Catalog OID output preserves type-specific spelling and admitted array construction.

use super::super::conversion::{array_value_to_string_with_control, value_to_string_with_control};
use super::{casting::rebuild_array, EngineHook};
use crate::{
    ast::ColumnType,
    error::{Result, SQLError},
};
use uqa_core::{
    memory::{Produced, ProductionControl, ProductionVec},
    Value,
};

/// Format a scalar or array OID carrier using the catalog-aware output function of a `reg*` type. `None` means the declared type is not one of the supported alias types or the value is SQL NULL.
pub fn format_regtype_value(
    value: &Value,
    ty: &ColumnType,
    engine: Option<&dyn EngineHook>,
) -> Result<Option<String>> {
    format_regtype_value_with_control(value, ty, engine, &ProductionControl::uncontrolled())?
        .map(|text| {
            text.into_uncontrolled()
                .map_err(|_| SQLError::Internal("ordinary OID output owner".into()))
        })
        .transpose()
}

/// Retain a resolver's returned spelling and construct SQL-owned array and fallback text under the invoking allowance.
pub fn format_regtype_value_with_control(
    value: &Value,
    ty: &ColumnType,
    engine: Option<&dyn EngineHook>,
    control: &ProductionControl<'_>,
) -> Result<Option<Produced<String>>> {
    control.check()?;
    if matches!(value, Value::Null) {
        return Ok(None);
    }
    if let ColumnType::Array(element) = ty {
        if !is_regtype(element) {
            return Ok(None);
        }
        let Value::Array(array) = value else {
            return value_to_string_with_control(value, control).map(Some);
        };
        let elements = format_array_elements(array.elements(), element, engine, control)?;
        let formatted = rebuild_array(array, elements, control)?.ok_or_else(|| {
            SQLError::Internal("regtype array output changed the array dimensions".into())
        })?;
        return array_value_to_string_with_control(&formatted, control).map(Some);
    }
    if !is_regtype(ty) {
        return Ok(None);
    }
    let Value::Int(oid) = value else {
        return value_to_string_with_control(value, control).map(Some);
    };
    if *oid == 0 {
        return Ok(Some(control.copy_text("-")?));
    }
    let resolved = engine
        .map(|engine| engine.resolve_regtype_output(ty, *oid))
        .transpose()
        .map_err(SQLError::Internal)?
        .flatten();
    match resolved {
        Some(text) => {
            let (value, memory) = control
                .retain_external_value(Value::Str(text))?
                .into_parts();
            let Value::Str(text) = value else {
                unreachable!("external OID spelling remains text")
            };
            Ok(Some(control.finish(text, memory)?))
        }
        None => Ok(Some(control.format(format_args!("{oid}"))?)),
    }
}

fn is_regtype(ty: &ColumnType) -> bool {
    matches!(
        ty,
        ColumnType::Regproc
            | ColumnType::Regprocedure
            | ColumnType::Regclass
            | ColumnType::Regnamespace
            | ColumnType::Regrole
            | ColumnType::Regtype
    )
}

fn format_array_elements(
    values: &[Value],
    element: &ColumnType,
    engine: Option<&dyn EngineHook>,
    control: &ProductionControl<'_>,
) -> Result<Produced<Vec<Value>>> {
    let mut output = ProductionVec::new(*control);
    output.reserve(values.len())?;
    for value in values {
        let value = match value {
            Value::Null => control.finish(Value::Null, control.empty_reservation())?,
            Value::List(nested) => {
                let (nested, memory) =
                    format_array_elements(nested, element, engine, control)?.into_parts();
                control.finish(Value::List(nested), memory)?
            }
            value => match format_regtype_value_with_control(value, element, engine, control)? {
                Some(text) => {
                    let (text, memory) = text.into_parts();
                    control.finish(Value::Str(text), memory)?
                }
                None => control.copy_value(value)?,
            },
        };
        output.push_produced(value)?;
    }
    Ok(output.finish()?)
}