Skip to main content

uqa_sql/catalog/index/
operator_classes.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Default B-tree capability of resolved SQL types, independently of the carrier's total order.
8
9use crate::{ColumnType, SQLError};
10
11mod btree;
12pub use btree::{
13    builtin_btree_operator_class, builtin_btree_operator_classes, default_btree_operator_class,
14    BoundBTreeOperatorClass, BuiltinBTreeComparison, BuiltinBTreeOperatorClass,
15};
16
17/// Resolve default B-tree capability using the shared class identities. Domains use their base class; generic arrays and records do not require a scalar class for every element or field. UQA vectors and tensors retain their native ordering capability.
18pub fn has_default_btree_operator_class(ty: &ColumnType) -> bool {
19    match ty {
20        ColumnType::Domain { base, .. } => has_default_btree_operator_class(base),
21        ColumnType::Vector(_) | ColumnType::Tensor(_) => true,
22        _ => default_btree_operator_class(ty).is_some(),
23    }
24}
25
26/// Validate default B-tree selection while retaining the declared type's visible name in diagnostics, including a domain whose base has no class.
27pub fn require_default_btree_operator_class(ty: &ColumnType) -> Result<(), SQLError> {
28    if has_default_btree_operator_class(ty) {
29        Ok(())
30    } else {
31        Err(missing_operator_class(&ty.display_name(), "btree"))
32    }
33}
34
35pub(crate) fn missing_operator_class(type_name: &str, access_method: &str) -> SQLError {
36    SQLError::Diagnostic {
37        sqlstate: "42704".into(),
38        message: format!(
39            "data type {type_name} has no default operator class for access method \"{access_method}\""
40        ),
41        detail: None,
42        hint: Some(
43            "You must specify an operator class for the index or define a default operator class for the data type."
44                .into(),
45        ),
46    }
47}
48
49#[cfg(test)]
50mod tests {
51    use super::*;
52
53    fn domain(base: ColumnType) -> ColumnType {
54        ColumnType::Domain {
55            schema: "opclass299".into(),
56            name: "json_domain".into(),
57            oid: 80_001,
58            array_oid: Some(80_002),
59            collation_oid: None,
60            base: Box::new(base),
61        }
62    }
63
64    #[test]
65    fn default_btree_classes_match_independent_pg18_key_declarations() {
66        let reference: serde_json::Value = serde_json::from_str(include_str!(
67            "../../../../../tests/parity/pg18/default_btree_operator_class_oracle.expected.json"
68        ))
69        .unwrap();
70        let _scope = crate::ast::TypeDisplayScope::enter(&["opclass299".into()]);
71        for (id, ty) in [
72            ("json_unique", ColumnType::Json),
73            ("domain_unique", domain(ColumnType::Json)),
74            ("xid_table", ColumnType::Xid),
75            ("refcursor_table", ColumnType::RefCursor),
76            ("aclitem_table", ColumnType::AclItem),
77            ("jsonb_index", ColumnType::JsonB),
78            ("array_index", ColumnType::Array(Box::new(ColumnType::Json))),
79            ("composite_index", ColumnType::Record),
80            ("int2vector_table", ColumnType::Int2Vector),
81            ("oidvector_table", ColumnType::OidVector),
82            ("alias_table", ColumnType::Regclass),
83            ("character_table", ColumnType::InternalChar),
84        ] {
85            let expected = &reference["cases"]
86                .as_array()
87                .unwrap()
88                .iter()
89                .find(|case| case["id"] == id)
90                .unwrap()["error"];
91            let actual = require_default_btree_operator_class(&ty)
92                .err()
93                .map(|error| {
94                    serde_json::json!({
95                        "sqlstate": error.sqlstate(),
96                        "message": error.to_string(),
97                        "detail": error.detail(),
98                        "hint": error.hint(),
99                    })
100                });
101            assert_eq!(serde_json::to_value(actual).unwrap(), *expected, "{id}");
102        }
103    }
104
105    #[test]
106    fn missing_base_class_keeps_the_visible_domain_identity() {
107        let ty = domain(domain(ColumnType::Json));
108        let _scope = crate::ast::TypeDisplayScope::enter(&["public".into()]);
109        assert_eq!(
110            require_default_btree_operator_class(&ty).unwrap_err().to_string(),
111            "data type opclass299.json_domain has no default operator class for access method \"btree\""
112        );
113        for ty in [ColumnType::Vector(3), ColumnType::Tensor(3)] {
114            require_default_btree_operator_class(&ty).unwrap();
115        }
116    }
117}