Skip to main content

uqa_sql/expr/range/
observation.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Structural observation borrows admitted bounds and encodes members without construction effects.
8
9use super::{CanonicalRange, RangeComparisonValue};
10use crate::{expr::SQLValueCatalog, SQLError};
11use uqa_core::{
12    memory::{Produced, ProductionControl},
13    Value,
14};
15
16pub struct RangeBoundValues<'a> {
17    pub lower: Option<&'a Value>,
18    pub upper: Option<&'a Value>,
19    pub lower_inclusive: bool,
20    pub upper_inclusive: bool,
21    pub empty: bool,
22}
23
24impl<'a> RangeBoundValues<'a> {
25    fn from_range<I>(range: &'a CanonicalRange<I>) -> Self {
26        Self {
27            lower: range.lower(),
28            upper: range.upper(),
29            lower_inclusive: range.lower_inclusive(),
30            upper_inclusive: range.upper_inclusive(),
31            empty: range.is_empty(),
32        }
33    }
34}
35
36impl RangeComparisonValue {
37    #[must_use]
38    pub fn bounds(&self) -> Option<RangeBoundValues<'_>> {
39        match self {
40            Self::Range(range) => Some(RangeBoundValues::from_range(range)),
41            Self::DeclaredRange(range) => Some(RangeBoundValues::from_range(range)),
42            _ => None,
43        }
44    }
45
46    #[must_use]
47    pub fn member_count(&self) -> Option<usize> {
48        match self {
49            Self::Multirange(ranges) => Some(ranges.ranges().len()),
50            Self::DeclaredMultirange(ranges) => Some(ranges.ranges().len()),
51            _ => None,
52        }
53    }
54
55    /// Copy one normalized member through its native carrier encoder. No type input, comparison or canonical function executes.
56    pub fn member_value_with_control(
57        &self,
58        index: usize,
59        catalog: Option<&dyn SQLValueCatalog>,
60        control: &ProductionControl<'_>,
61    ) -> Result<Option<Produced<Value>>, SQLError> {
62        control.check()?;
63        match self {
64            Self::Multirange(ranges) => {
65                let Some(range) = ranges.ranges().get(index) else {
66                    return Ok(None);
67                };
68                let (text, memory) = range.to_text_with_control(control)?.into_parts();
69                Ok(Some(control.finish(Value::Str(text), memory)?))
70            }
71            Self::DeclaredMultirange(ranges) => {
72                let Some(range) = ranges.ranges().get(index) else {
73                    return Ok(None);
74                };
75                let descriptor = catalog
76                    .map(|catalog| catalog.value_range_type(*range.identity()))
77                    .transpose()?
78                    .flatten()
79                    .ok_or_else(|| SQLError::Routine {
80                        sqlstate: "42704".into(),
81                        message: format!("type with OID {} does not exist", range.identity()),
82                    })?;
83                let adapter = crate::expr::value_catalog::ValueCompositeCatalog(catalog);
84                Ok(Some(super::declared_range_datum_with_control(
85                    range,
86                    &descriptor,
87                    Some(&adapter),
88                    control,
89                )?))
90            }
91            _ => Ok(None),
92        }
93    }
94}