uqa-execution 0.6.2

Volcano physical operators with row-batch pipelines
Documentation
//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

use super::*;
use std::cell::Cell;
use std::collections::HashMap;
use uqa_sql::{ast::ColumnDef, RowSchema};

mod descriptions;

#[derive(Default)]
struct Types {
    resolutions: Cell<usize>,
}
impl uqa_sql::catalog::domain::DomainCatalog for Types {
    fn domain_by_oid(&self, _: u32) -> Option<uqa_sql::catalog::domain::StoredDomain> {
        None
    }
}
impl uqa_sql::expr::EngineHook for Types {
    fn nextval(&self, _: &str) -> Result<i64, SQLError> {
        panic!("unexpected sequence")
    }
    fn currval(&self, _: &str) -> Result<i64, SQLError> {
        panic!("unexpected sequence")
    }
    fn setval(&self, _: &str, _: i64, _: bool) -> Result<i64, SQLError> {
        panic!("unexpected sequence")
    }
}
impl uqa_sql::assignment::AssignmentContext for Types {
    fn evaluate_domain_check(
        &self,
        _: &uqa_sql::ast::Expr,
        _: &dyn uqa_sql::expr::RowLookup,
        _: &RowSchema,
    ) -> Result<Value, SQLError> {
        panic!("unexpected domain check")
    }
}
impl uqa_sql::assignment::routines::RoutineValueContext for Types {
    fn catalog_column_type(&self, name: &str) -> Option<ColumnType> {
        self.resolutions.set(self.resolutions.get() + 1);
        ColumnType::from_sql_name(name).ok()
    }
}

fn record_schema() -> RowSchema {
    let columns = ["c", "p", "plain", "n"]
        .iter()
        .enumerate()
        .map(|(i, name)| {
            let mut column = ColumnDef::nullable(
                *name,
                if i == 3 {
                    ColumnType::Integer
                } else {
                    ColumnType::Text
                },
            );
            column.collation_oid = [Some(950), Some(951), None, None][i];
            column
        })
        .collect::<Vec<_>>();
    RowSchema::with_column_definitions(None, &columns)
}

#[test]
fn routine_record_fields_preserve_postgresql_declared_collations() {
    let types = Types::default();
    let names = ["c", "p", "plain", "n"];
    let schema = record_schema();
    let schemas = HashMap::from([(0, schema.clone().into()), (1, schema.into())]);
    let datums = [
        PLpgSQLDatum::Rec { name: "old".into() },
        PLpgSQLDatum::Rec { name: "new".into() },
        PLpgSQLDatum::RecField {
            parent: 1,
            field: "c".into(),
        },
    ];
    let bindings = HashMap::from([("old".into(), vec![0]), ("new".into(), vec![1])]);
    let reference: serde_json::Value = serde_json::from_str(include_str!(
        "../../mutation/triggers/tests/collations.json"
    ))
    .unwrap();
    for null in [false, true] {
        let fields = names
            .iter()
            .enumerate()
            .map(|(i, name)| {
                (
                    (*name).into(),
                    if null {
                        Value::Null
                    } else if i == 3 {
                        Value::Int(7)
                    } else {
                        Value::Str((*name).into())
                    },
                )
            })
            .collect::<Vec<_>>();
        let record = Value::Record(fields.into());
        let values = [record.clone(), record, Value::Null];
        let mut resolver = DatumResolver {
            descriptions: None,
            types: &types,
            datums: &datums,
            values: &values,
            record_descriptors: &schemas,
            bindings: &bindings,
            error: None,
            param_count: 0,
        };
        let mut observed = 0;
        for case in reference.as_array().unwrap() {
            for variable in case["variables"].as_array().unwrap() {
                let relation = if variable["relation"] == 1 {
                    "old"
                } else {
                    "new"
                };
                let position =
                    usize::try_from(variable["attribute"].as_u64().unwrap()).unwrap() - 1;
                let resolved = resolver
                    .resolve_qualified(relation, names[position])
                    .unwrap()
                    .unwrap();
                let ty =
                    ColumnType::from_sql_name(resolved.declared_type.as_deref().unwrap()).unwrap();
                assert_eq!(
                    uqa_sql::catalog::type_metadata::pg_type_oid(&ty),
                    variable["type"].as_i64().unwrap()
                );
                assert_eq!(
                    resolved.collation_oid.map(u64::from),
                    variable["collation"].as_u64()
                );
                assert_eq!(
                    resolved.value,
                    if null {
                        Value::Null
                    } else if position == 3 {
                        Value::Int(7)
                    } else {
                        Value::Str(names[position].into())
                    }
                );
                observed += 1;
            }
        }
        assert_eq!(observed, 16);
        assert_eq!(resolver.resolved_datum(2).unwrap().collation_oid, Some(950));
        assert_eq!(
            resolver
                .resolve_qualified("new", "missing")
                .unwrap_err()
                .sqlstate(),
            Some("42703")
        );
    }
}

#[test]
fn prepared_record_parameters_preserve_selected_types_without_text_resolution() {
    let types = Types::default();
    let datums = [PLpgSQLDatum::Rec { name: "row".into() }];
    let bindings = HashMap::from([("row".into(), vec![0])]);
    let reference = uqa_sql::plpgsql::PLpgSQLVariableReference::Qualified {
        qualifier: "row".into(),
        column: "value".into(),
    };
    for (ty, text) in [(ColumnType::SmallInteger, false), (ColumnType::Text, true)] {
        let schema =
            RowSchema::with_column_definitions(None, &[ColumnDef::nullable("value", ty.clone())]);
        let schemas = HashMap::from([(0, schema.into())]);
        for index in 0..256 {
            let value = if index % 3 == 0 {
                Value::Null
            } else if text {
                Value::Str(index.to_string())
            } else {
                Value::Int(index)
            };
            let values = [Value::Record(vec![("value".into(), value.clone())].into())];
            let mut resolver = DatumResolver {
                descriptions: None,
                types: &types,
                datums: &datums,
                values: &values,
                record_descriptors: &schemas,
                bindings: &bindings,
                error: None,
                param_count: 0,
            };
            let parameter = reference.read(&mut resolver).unwrap();
            assert_eq!(parameter.scalar_value(), Some(&value));
            assert_eq!(parameter.declared_scalar_type(), Some(&ty));
        }
    }
    assert_eq!(
        types.resolutions.get(),
        0,
        "a record parameter already owns its selected field type"
    );
}

#[test]
fn prepared_scalar_parameters_do_not_resolve_the_selected_type_twice() {
    let types = Types::default();
    let datums = [PLpgSQLDatum::Var(Box::new(uqa_sql::plpgsql::PLpgSQLVar {
        name: "value".into(),
        type_oid: Some(21),
        type_name: "smallint".into(),
        type_reference: None,
        default: None,
        constant: false,
        not_null: false,
        cursor: None,
        lineno: None,
    }))];
    let bindings = HashMap::from([("value".into(), vec![0])]);
    let schemas = HashMap::new();
    for index in 0..512 {
        let value = if index % 3 == 0 {
            Value::Null
        } else {
            Value::Int(index)
        };
        let values = [value.clone()];
        let mut resolver = DatumResolver {
            descriptions: None,
            types: &types,
            datums: &datums,
            values: &values,
            record_descriptors: &schemas,
            bindings: &bindings,
            error: None,
            param_count: 1,
        };
        let parameter = uqa_sql::plpgsql::PLpgSQLVariableReference::Parameter(1)
            .read(&mut resolver)
            .unwrap();
        assert_eq!(parameter.scalar_value(), Some(&value));
        assert_eq!(
            parameter.declared_scalar_type(),
            Some(&ColumnType::SmallInteger)
        );
    }
    assert_eq!(types.resolutions.get(), 512);
}