uqa-sql 0.4.0

PostgreSQL-compatible SQL compiler built on libpg_query
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//
// Unified Query Algebra
//
// Copyright (c) 2023-2026 Cognica, Inc.
//

//! Resolve materialized foreign keys by name initially and by durable identity after a wait.

use super::{find_constraint, ConstraintLocation};
use crate::{
    ast::{ColumnDef, TableConstraintSet},
    SQLError,
};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ForeignKeyTarget<'a> {
    pub location: ConstraintLocation,
    pub name: &'a str,
    pub object_id: [u8; 16],
    pub referenced_table: &'a str,
}

impl<'a> ForeignKeyTarget<'a> {
    pub fn by_name(
        columns: &'a [ColumnDef],
        constraints: &'a TableConstraintSet,
        name: &str,
    ) -> Result<Option<Self>, SQLError> {
        find_constraint(columns, constraints, name).map_or(Ok(None), |location| {
            Self::at(columns, constraints, location)
        })
    }

    pub fn by_id(
        columns: &'a [ColumnDef],
        constraints: &'a TableConstraintSet,
        object_id: [u8; 16],
    ) -> Result<Option<Self>, SQLError> {
        let location = columns
            .iter()
            .position(|column| {
                column
                    .references
                    .as_ref()
                    .is_some_and(|reference| reference.object_id == Some(object_id))
            })
            .map(ConstraintLocation::ColumnForeignKey)
            .or_else(|| {
                constraints
                    .foreign_keys
                    .iter()
                    .position(|reference| reference.object_id == Some(object_id))
                    .map(ConstraintLocation::TableForeignKey)
            });
        location.map_or(Ok(None), |location| {
            Self::at(columns, constraints, location)
        })
    }

    fn at(
        columns: &'a [ColumnDef],
        constraints: &'a TableConstraintSet,
        location: ConstraintLocation,
    ) -> Result<Option<Self>, SQLError> {
        let (name, object_id, referenced_table) = match location {
            ConstraintLocation::ColumnForeignKey(index) => {
                let reference = columns[index]
                    .references
                    .as_ref()
                    .ok_or_else(|| SQLError::Internal("column FOREIGN KEY disappeared".into()))?;
                (
                    reference.name.as_deref(),
                    reference.object_id,
                    reference.table.as_str(),
                )
            }
            ConstraintLocation::TableForeignKey(index) => {
                let reference = &constraints.foreign_keys[index];
                (
                    reference.name.as_deref(),
                    reference.object_id,
                    reference.ref_table.as_str(),
                )
            }
            _ => return Ok(None),
        };
        Ok(Some(Self {
            location,
            name: name
                .ok_or_else(|| SQLError::Internal("FOREIGN KEY has no durable name".into()))?,
            object_id: object_id
                .ok_or_else(|| SQLError::Internal("FOREIGN KEY has no durable identity".into()))?,
            referenced_table,
        }))
    }
}

/// Retire the selected local catalog row and its attachment provenance together.
pub fn remove_foreign_key(
    columns: &mut [ColumnDef],
    constraints: &mut TableConstraintSet,
    object_id: [u8; 16],
) -> Result<bool, SQLError> {
    let Some(target) = ForeignKeyTarget::by_id(columns, constraints, object_id)? else {
        return Ok(false);
    };
    match target.location {
        ConstraintLocation::ColumnForeignKey(index) => columns[index].references = None,
        ConstraintLocation::TableForeignKey(index) => {
            constraints.foreign_keys.remove(index);
        }
        _ => unreachable!("a foreign-key target has a foreign-key location"),
    }
    constraints
        .hierarchy
        .partition_inherited_foreign_keys
        .retain(|key| key.object_id != Some(object_id));
    Ok(true)
}

#[cfg(test)]
mod tests;