uqa_sql/assignment/
conversion.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Declared-column assignment coercion for scalar, array, vector, and temporal values.
8
9use super::AssignmentContext;
10use crate::{ColumnType, SQLError};
11use uqa_core::{ArrayValue, DecimalValue, TemporalValue, Value};
12
13mod carrier;
14pub(super) use carrier::normalize_existing;
15pub use carrier::{contains_legacy_vectors, normalize_legacy_vector_carrier_with_control};
16
17pub fn coerce_assignment_value(
18    context: &dyn AssignmentContext,
19    value: Value,
20    target: &ColumnType,
21    source: Option<&ColumnType>,
22) -> Result<Value, SQLError> {
23    if source.is_some_and(|source| same_catalog_value_type(source, target)) {
24        return normalize_existing(value, target);
25    }
26    if matches!(target, ColumnType::Domain { .. }) {
27        let source = source.map(ColumnType::catalog_name);
28        if let Some(value) =
29            super::domain::assign_domain_value_from(context, &value, source.as_deref(), target)?
30        {
31            return Ok(value);
32        }
33    }
34    let value = if target.is_character_string() {
35        source
36            .map(|source| crate::expr::format_regtype_value(&value, source, Some(context)))
37            .transpose()?
38            .flatten()
39            .map(Value::Str)
40            .unwrap_or(value)
41    } else {
42        value
43    };
44    convert_value_to_column_type_with_context(context, value, target)
45}
46
47fn same_catalog_value_type(source: &ColumnType, target: &ColumnType) -> bool {
48    match (source, target) {
49        (ColumnType::Domain { oid: source, .. }, ColumnType::Domain { oid: target, .. }) => {
50            source == target
51        }
52        (ColumnType::Composite(source), ColumnType::Composite(target)) => source.oid == target.oid,
53        (ColumnType::Domain { base, .. }, ColumnType::Composite(_)) => {
54            same_catalog_value_type(base, target)
55        }
56        (ColumnType::Array(source), ColumnType::Array(target)) => {
57            same_catalog_value_type(source, target)
58        }
59        _ => false,
60    }
61}
62
63pub fn coerce_json_value(value: Value, jsonb: bool) -> Result<Value, SQLError> {
64    crate::expr::cast_value(&value, if jsonb { "jsonb" } else { "json" })
65}
66
67pub fn convert_declared_value_to_column_type(
68    context: &dyn AssignmentContext,
69    value: Value,
70    source_ty: &ColumnType,
71    target_ty: &ColumnType,
72) -> Result<Value, SQLError> {
73    match (source_ty, target_ty) {
74        (ColumnType::Domain { base, .. }, target) => {
75            convert_declared_value_to_column_type(context, value, base, target)
76        }
77        (source, ColumnType::Domain { base, .. }) => {
78            convert_declared_value_to_column_type(context, value, source, base)
79        }
80        (ColumnType::Array(source), ColumnType::Array(target)) => {
81            let Value::Array(array) = value else {
82                return Err(SQLError::TypeMismatch(format!(
83                    "cannot cast a non-array value to {}[]",
84                    column_type_name(target)
85                )));
86            };
87            let source = array_scalar_type(source);
88            let target = array_scalar_type(target);
89            let converted =
90                convert_declared_array_elements(context, array.elements(), source, target)?;
91            ArrayValue::with_lower_bounds(converted, array.lower_bounds().to_vec())
92                .map(Value::Array)
93                .ok_or_else(|| {
94                    SQLError::TypeMismatch(
95                        "multidimensional arrays must have matching dimensions".into(),
96                    )
97                })
98        }
99        (ColumnType::Range(source), ColumnType::Range(target)) if source == target => {
100            crate::expr::cast_value_from(&value, target.range_name(), Some(source.range_name()))
101        }
102        (ColumnType::Range(source), ColumnType::Multirange(target)) if source == target => {
103            crate::expr::cast_value_from(
104                &value,
105                target.multirange_name(),
106                Some(source.range_name()),
107            )
108        }
109        (ColumnType::Multirange(source), ColumnType::Multirange(target)) if source == target => {
110            crate::expr::cast_value_from(
111                &value,
112                target.multirange_name(),
113                Some(source.multirange_name()),
114            )
115        }
116        (_, ColumnType::Range(_) | ColumnType::Multirange(_)) => {
117            Err(SQLError::TypeMismatch(format!(
118                "column cannot be cast automatically from type {} to type {}",
119                column_type_name(source_ty),
120                column_type_name(target_ty)
121            )))
122        }
123        (source, ColumnType::Oid)
124            if matches!(
125                source,
126                ColumnType::SmallInteger
127                    | ColumnType::Integer
128                    | ColumnType::BigInteger
129                    | ColumnType::Oid
130                    | ColumnType::Regproc
131                    | ColumnType::Regprocedure
132                    | ColumnType::Regclass
133                    | ColumnType::Regnamespace
134                    | ColumnType::Regrole
135                    | ColumnType::Regtype
136            ) =>
137        {
138            crate::expr::cast_value_from(&value, "oid", Some(column_type_name(source)))
139        }
140        (ColumnType::Xid, ColumnType::Xid) => Ok(value),
141        (ColumnType::Bytea, ColumnType::Bytea) => Ok(value),
142        (_, ColumnType::Oid | ColumnType::Xid | ColumnType::Bytea) => {
143            Err(SQLError::TypeMismatch(format!(
144                "column cannot be cast automatically from type {} to type {}",
145                column_type_name(source_ty),
146                column_type_name(target_ty)
147            )))
148        }
149        _ => convert_value_to_column_type_with_context(context, value, target_ty),
150    }
151}
152
153/// Whether converting a value to `ty` needs the statement's catalog or session: enum labels, domain constraints, composite attributes, role names or the current time zone.
154pub(crate) fn type_requires_catalog_resolution(ty: &ColumnType) -> bool {
155    match ty {
156        // The OID alias types read a name through the catalog, so an assigned text value becomes the object's OID, as `regclassin` and its siblings read it.
157        ColumnType::Regrole
158        | ColumnType::Regclass
159        | ColumnType::Regtype
160        | ColumnType::Regproc
161        | ColumnType::Regprocedure
162        | ColumnType::Regnamespace
163        | ColumnType::Domain { .. }
164        | ColumnType::Enum(_)
165        | ColumnType::Composite(_)
166        | ColumnType::TimestampTz
167        | ColumnType::TimestampTzPrecision(_) => true,
168        ColumnType::Array(element) => type_requires_catalog_resolution(element),
169        _ => false,
170    }
171}
172
173pub fn convert_value_to_column_type_with_context(
174    context: &dyn AssignmentContext,
175    value: Value,
176    ty: &ColumnType,
177) -> Result<Value, SQLError> {
178    // Assignment to a string type calls the enum output function, which reads the current label.
179    let value = if textual_target(ty) && crate::expr::enums::contains_enum_carrier(&value) {
180        crate::expr::enums::render_enum_labels(
181            crate::expr::EngineHook::enum_labels(context),
182            &value,
183        )?
184    } else {
185        value
186    };
187    if let Some(value) = super::domain::assign_domain_value(context, &value, ty)? {
188        return Ok(value);
189    }
190    if matches!(value, Value::Null) {
191        return Ok(Value::Null);
192    }
193    if let ColumnType::Array(element) = ty {
194        if type_requires_catalog_resolution(element) {
195            return convert_catalog_array(context, value, element);
196        }
197    }
198    if type_requires_catalog_resolution(ty) {
199        return crate::expr::cast_value_with_type_resolution(
200            &value,
201            None,
202            &ty.catalog_name(),
203            Some(context),
204        );
205    }
206    convert_value_to_column_type(value, ty)
207}
208
209fn textual_target(ty: &ColumnType) -> bool {
210    match ty {
211        ColumnType::Array(element) => textual_target(element),
212        other => other.is_character_string(),
213    }
214}
215
216fn convert_catalog_array(
217    context: &dyn AssignmentContext,
218    value: Value,
219    element: &ColumnType,
220) -> Result<Value, SQLError> {
221    let array = match value {
222        Value::Array(array) => array,
223        Value::Str(text) => crate::expr::parse_pg_array_literal(&text)?,
224        other => {
225            return Err(SQLError::TypeMismatch(format!(
226                "expected an array, got {other:?}"
227            )))
228        }
229    };
230    let values = convert_catalog_array_elements(context, array.elements(), element)?;
231    ArrayValue::with_lower_bounds(values, array.lower_bounds().to_vec())
232        .map(Value::Array)
233        .ok_or_else(|| {
234            SQLError::TypeMismatch("multidimensional arrays must have matching dimensions".into())
235        })
236}
237
238fn convert_catalog_array_elements(
239    context: &dyn AssignmentContext,
240    values: &[Value],
241    element: &ColumnType,
242) -> Result<Vec<Value>, SQLError> {
243    let mut element = element;
244    while let ColumnType::Array(nested) = element {
245        element = nested;
246    }
247    values
248        .iter()
249        .map(|value| match value {
250            Value::List(values) => {
251                convert_catalog_array_elements(context, values, element).map(Value::List)
252            }
253            value => convert_value_to_column_type_with_context(context, value.clone(), element),
254        })
255        .collect()
256}
257
258mod production;
259pub use production::{convert_value_to_column_type_with_control, numeric_field_overflow};
260
261pub fn convert_value_to_column_type(value: Value, ty: &ColumnType) -> Result<Value, SQLError> {
262    let control = uqa_core::memory::ProductionControl::uncontrolled();
263    convert_value_to_column_type_with_control(control.finish(value, None)?, ty, &control)?
264        .into_uncontrolled()
265        .map_err(|_| SQLError::Internal("ordinary assignment production owner".into()))
266}
267
268fn convert_declared_array_elements(
269    context: &dyn AssignmentContext,
270    elements: &[Value],
271    source_type: &ColumnType,
272    target_type: &ColumnType,
273) -> Result<Vec<Value>, SQLError> {
274    elements
275        .iter()
276        .cloned()
277        .map(|element| match element {
278            Value::List(nested) => {
279                convert_declared_array_elements(context, &nested, source_type, target_type)
280                    .map(Value::List)
281            }
282            scalar => {
283                convert_declared_value_to_column_type(context, scalar, source_type, target_type)
284            }
285        })
286        .collect()
287}
288
289fn array_scalar_type(mut ty: &ColumnType) -> &ColumnType {
290    while let ColumnType::Array(element) = ty {
291        ty = element;
292    }
293    ty
294}
295
296pub fn validate_vector_dimensions(expected: u32, actual: usize) -> Result<(), SQLError> {
297    let expected = usize::try_from(expected).map_err(|_| {
298        SQLError::TypeMismatch(format!(
299            "declared vector dimension {expected} exceeds the platform usize range"
300        ))
301    })?;
302    if actual == expected {
303        Ok(())
304    } else {
305        Err(SQLError::VectorDimMismatch { expected, actual })
306    }
307}
308
309pub use crate::catalog::type_metadata::column_type_name;
310
311pub use crate::expr::value_to_text;
312
313pub fn json_to_core_value(json: serde_json::Value) -> Value {
314    match json {
315        serde_json::Value::Null => Value::Null,
316        serde_json::Value::Bool(b) => Value::Bool(b),
317        serde_json::Value::Number(n) => {
318            if let Some(i) = n.as_i64() {
319                Value::Int(i)
320            } else if let Some(d) = DecimalValue::parse(&n.to_string()) {
321                Value::Decimal(d)
322            } else if let Some(f) = n.as_f64() {
323                Value::Float(f)
324            } else {
325                Value::Null
326            }
327        }
328        serde_json::Value::String(s) => Value::Str(s),
329        serde_json::Value::Array(items) => {
330            Value::List(items.into_iter().map(json_to_core_value).collect())
331        }
332        serde_json::Value::Object(obj) => {
333            if let Ok(temporal) =
334                serde_json::from_value::<TemporalValue>(serde_json::Value::Object(obj.clone()))
335            {
336                return Value::Temporal(temporal);
337            }
338            Value::Map(
339                obj.into_iter()
340                    .map(|(k, v)| (k, json_to_core_value(v)))
341                    .collect(),
342            )
343        }
344    }
345}
346
347pub use crate::expr::core_value_to_json;
348
349pub fn json_table_value_to_text(value: &serde_json::Value) -> Value {
350    match value {
351        serde_json::Value::Null => Value::Null,
352        serde_json::Value::String(s) => Value::Str(s.clone()),
353        serde_json::Value::Bool(b) => Value::Str(b.to_string()),
354        serde_json::Value::Number(n) => Value::Str(n.to_string()),
355        serde_json::Value::Array(_) | serde_json::Value::Object(_) => Value::Str(value.to_string()),
356    }
357}
358
359pub fn json_table_arg(value: &Value, name: &str) -> Result<serde_json::Value, SQLError> {
360    match value {
361        Value::Json(s) | Value::JsonB(s) | Value::Str(s) => {
362            serde_json::from_str::<serde_json::Value>(s)
363                .map_err(|e| SQLError::TypeMismatch(format!("{name}: invalid JSON: {e}")))
364        }
365        other => core_value_to_json(other),
366    }
367}
uqa_sql/assignment/conversion.rs

uqa_sql/assignment/
conversion.rs
