uqa-sql 0.6.3

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::*;
use crate::{
    expr::{composites::CompositeTypeDescriptor, enums::EnumTypeLabels},
    ColumnType,
};
use std::sync::Arc;
use uqa_core::{memory::MemoryBudget, CancellationToken, DatumValue, RecordFieldType, RowValue};

struct Catalog(Option<Arc<CompositeTypeDescriptor>>);

impl SQLValueCatalog for Catalog {
    fn value_type_by_oid(&self, oid: u32) -> Result<Option<ColumnType>, SQLError> {
        if let Some(descriptor) = self
            .0
            .as_ref()
            .filter(|descriptor| descriptor.type_oid == oid)
        {
            return Ok(Some(ColumnType::Composite(
                crate::ast::CompositeTypeReference {
                    schema: "public".into(),
                    name: "image_record".into(),
                    oid,
                    array_oid: oid + 1,
                    relation_oid: descriptor.relation_oid,
                },
            )));
        }
        Ok(type_metadata::builtin_array_element(oid)
            .map(|element| ColumnType::Array(Box::new(element.clone()))))
    }
    fn value_composite_type(
        &self,
        oid: u32,
    ) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError> {
        Ok(self
            .0
            .as_ref()
            .filter(|descriptor| descriptor.type_oid == oid)
            .cloned())
    }
    fn enum_type_labels(&self, _: u32) -> Result<Option<Arc<EnumTypeLabels>>, SQLError> {
        Ok(None)
    }
    fn enum_label_uncommitted(&self, _: u32) -> bool {
        false
    }
    fn enum_type_name(&self, _: u32) -> Result<Option<String>, SQLError> {
        Ok(None)
    }
    fn has_enum_types(&self) -> bool {
        false
    }
}

fn row(values: Vec<Value>, types: &[ColumnType]) -> Value {
    Value::Row(
        RowValue::typed(
            values,
            types
                .iter()
                .map(|ty| RecordFieldType {
                    collation_oid: None,
                    oid: type_metadata::pg_type_oid(ty) as u32,
                    type_modifier: type_metadata::pg_type_modifier(ty) as i32,
                })
                .collect(),
        )
        .unwrap(),
    )
}

fn physical(value: &Value, ty: &ColumnType, catalog: Option<&dyn SQLValueCatalog>) -> Value {
    if matches!(value, Value::Null) {
        return Value::Null;
    }
    let composites = super::super::support::ValueCompositeCatalog(catalog);
    let encoded = datums::encoding::encode(
        value,
        ty,
        Some(&composites),
        &ProductionControl::uncontrolled(),
    )
    .unwrap();
    let mut bytes = Vec::new();
    if type_metadata::pg_type_len(ty) == -1 {
        bytes.extend_from_slice(&datums::encoding::header(encoded.len()).unwrap());
    }
    bytes.extend_from_slice(&encoded);
    Value::Datum(DatumValue::new(
        type_metadata::pg_type_oid(ty) as u32,
        0,
        bytes,
    ))
}

#[test]
fn record_image_comparison_matches_postgresql_for_logical_and_physical_fields() {
    let reference: serde_json::Value =
        serde_json::from_str(include_str!("postgresql.json")).unwrap();
    let memory = MemoryBudget::new(1024 * 1024);
    let token = CancellationToken::new();
    let control = ProductionControl::new(&memory, &token, &token);
    for case in reference["cases"].as_array().unwrap() {
        let name = case["type"].as_str().unwrap();
        let ty = ColumnType::from_sql_name(name).unwrap();
        let values = ["left", "right"].map(|field| {
            case[field].as_str().map_or(Value::Null, |text| {
                crate::expr::cast_value(&Value::Str(text.into()), name).unwrap()
            })
        });
        for (value, field) in values.iter().zip(["left_payload_hex", "right_payload_hex"]) {
            if let Some(hex) = case[field].as_str() {
                let expected = (0..hex.len())
                    .step_by(2)
                    .map(|index| u8::from_str_radix(&hex[index..index + 2], 16).unwrap())
                    .collect::<Vec<_>>();
                let encoded = datums::encoding::encode(value, &ty, None, &control).unwrap();
                assert_eq!(&*encoded, expected, "{case}");
            }
        }
        let expected = case["order"].as_i64().unwrap().cmp(&0);
        for left in [&values[0], &physical(&values[0], &ty, None)] {
            for right in [&values[1], &physical(&values[1], &ty, None)] {
                let left = row(vec![left.clone()], std::slice::from_ref(&ty));
                let right = row(vec![right.clone()], std::slice::from_ref(&ty));
                assert_eq!(
                    compare_record_images_with_catalog(
                        &left,
                        &right,
                        Some(&Catalog(None)),
                        &control
                    )
                    .unwrap(),
                    expected,
                    "{case}"
                );
                assert_eq!(
                    compare_record_images_with_catalog(
                        &right,
                        &left,
                        Some(&Catalog(None)),
                        &control
                    )
                    .unwrap(),
                    expected.reverse(),
                    "{case}"
                );
                assert_eq!(memory.used(), 0);
            }
        }
    }
}

#[test]
fn record_image_comparison_keeps_reached_type_and_byte_errors_lazy() {
    let broken = Value::Datum(DatumValue::new(25, 0, vec![0]));
    let types = [ColumnType::Integer, ColumnType::Text];
    let left = row(vec![Value::Int(1), broken.clone()], &types);
    let right = row(vec![Value::Int(2), broken.clone()], &types);
    let control = ProductionControl::uncontrolled();
    assert!(
        compare_record_images_with_catalog(&left, &right, None, &control)
            .unwrap()
            .is_lt()
    );
    let error = compare_record_images_with_catalog(&left, &left, None, &control).unwrap_err();
    assert_eq!(error.sqlstate(), Some("XX001"));
    let mismatched = row(
        vec![Value::Int(1), Value::Null],
        &[ColumnType::Integer, ColumnType::Json],
    );
    let error = compare_record_images_with_catalog(&left, &mismatched, None, &control).unwrap_err();
    assert_eq!(error.sqlstate(), Some("42804"));
    assert_eq!(
        error.to_string(),
        "cannot compare dissimilar column types text and json at record column 2"
    );
    let shorter = row(vec![Value::Int(1)], &[ColumnType::Integer]);
    let error = compare_record_images_with_catalog(&shorter, &left, None, &control).unwrap_err();
    assert_eq!(error.sqlstate(), Some("42804"));
}

#[test]
fn record_image_comparison_shares_the_callers_allowance_and_cancellation() {
    let ty = ColumnType::Numeric {
        precision: None,
        scale: None,
    };
    let value = row(
        vec![crate::expr::cast_value(&Value::Str("1.00".into()), "numeric").unwrap()],
        &[ty],
    );
    let memory = MemoryBudget::new(0);
    let statement = CancellationToken::new();
    let session = CancellationToken::new();
    let control = ProductionControl::new(&memory, &statement, &session);
    let error = compare_record_images_with_catalog(&value, &value, None, &control).unwrap_err();
    assert_eq!(error.sqlstate(), Some("53200"));
    assert_eq!(memory.used(), 0);
    for cancel_statement in [false, true] {
        let statement = CancellationToken::new();
        let session = CancellationToken::new();
        if cancel_statement {
            statement.cancel();
        } else {
            session.cancel();
        }
        let control = ProductionControl::new(&memory, &statement, &session);
        let error = compare_record_images_with_catalog(&value, &value, None, &control).unwrap_err();
        assert_eq!(error.sqlstate(), Some("57014"));
        assert_eq!(memory.used(), 0);
    }
}

#[test]
fn record_image_comparison_retains_named_tuple_field_images() {
    use crate::expr::composites::CompositeAttribute;
    let ty = ColumnType::Numeric {
        precision: None,
        scale: None,
    };
    let catalog = Catalog(Some(Arc::new(CompositeTypeDescriptor {
        type_oid: 80_001,
        relation_oid: 80_003,
        dropped: Vec::new(),
        attributes: vec![CompositeAttribute {
            name: "n".into(),
            ty,
            number: 1,
            collation_oid: None,
        }],
    })));
    let ty = catalog.value_type_by_oid(80_001).unwrap().unwrap();
    let values = ["1.0", "1.00"].map(|text| {
        Value::Record(uqa_core::RecordValue::from_parts(
            vec![(
                "n".into(),
                crate::expr::cast_value(&Value::Str(text.into()), "numeric").unwrap(),
            )],
            Some(80_001),
        ))
    });
    let memory = MemoryBudget::new(16 * 1024);
    let token = CancellationToken::new();
    let control = ProductionControl::new(&memory, &token, &token);
    for left in [&values[0], &physical(&values[0], &ty, Some(&catalog))] {
        for right in [&values[1], &physical(&values[1], &ty, Some(&catalog))] {
            assert_eq!(
                compare_record_images_with_catalog(left, right, Some(&catalog), &control).unwrap(),
                Ordering::Greater,
            );
            assert_eq!(
                compare_record_images_with_catalog(right, left, Some(&catalog), &control).unwrap(),
                Ordering::Less,
            );
            assert_eq!(memory.used(), 0);
        }
    }
}

#[test]
fn record_image_observation_borrows_fields_and_checks_callback_cancellation() {
    let text = "image".repeat(32 * 1024);
    let source = text.as_ptr();
    let value = row(
        vec![Value::Str(text), Value::Null],
        &[ColumnType::Text, ColumnType::Text],
    );
    for cancellation in [0, 1, 2] {
        let memory = MemoryBudget::new(0);
        let statement = CancellationToken::new();
        let session = CancellationToken::new();
        let control = ProductionControl::new(&memory, &statement, &session);
        let result =
            visit_record_image_fields_with_catalog(&value, None, &control, |oid, image| {
                assert_eq!(oid, Some(25));
                if let Some(image) = image {
                    assert_eq!(image.as_ptr(), source);
                }
                if cancellation == 1 {
                    statement.cancel();
                }
                if cancellation == 2 {
                    session.cancel();
                }
                Ok(())
            });
        if cancellation == 0 {
            assert_eq!(result.unwrap(), 2);
        } else {
            assert_eq!(result.unwrap_err().sqlstate(), Some("57014"));
        }
        assert_eq!(memory.used(), 0);
        assert_eq!(memory.peak(), 0);
    }
}