Skip to main content

uqa_execution/row_locks/
cleanup.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Release of session, savepoint-marked, and provisional lock ownership.
8
9use super::{remove_inactive_versions, RowLockAcquisition, RowLockManager};
10
11impl RowLockManager {
12    pub fn release_mark_above(&self, session_id: u64, mark: u32) {
13        let mut released_rows = Vec::new();
14        let mut retained_identities = Vec::new();
15        let mut released_relations = Vec::new();
16        let mut state = self.state.lock();
17        state.rows.retain(|key, grants| {
18            grants.retain_mut(|grant| {
19                if grant.session_id == session_id {
20                    retained_identities.extend(grant.identity.clone());
21                    grant.acquisitions.retain(|acquisition| {
22                        let keep = acquisition.mark <= mark;
23                        if !keep {
24                            released_rows.push((*key, acquisition.strength));
25                        }
26                        keep
27                    });
28                }
29                !grant.acquisitions.is_empty()
30            });
31            !grants.is_empty()
32        });
33        state.relations.retain(|table, grants| {
34            grants.retain_mut(|grant| {
35                if grant.session_id == session_id {
36                    grant.acquisitions.retain(|acquisition| {
37                        let keep = acquisition.mark <= mark;
38                        if !keep {
39                            released_relations.push((*table, acquisition.mode));
40                        }
41                        keep
42                    });
43                }
44                !grant.acquisitions.is_empty()
45            });
46            !grants.is_empty()
47        });
48        state.waiting.remove(&session_id);
49        state.waiting_relations.remove(&session_id);
50        state.advertised_waits.remove(&session_id);
51        remove_inactive_versions(&mut state);
52        drop(state);
53        self.release_row_claims(session_id, &released_rows);
54        drop(retained_identities);
55        for (table, mode) in released_relations {
56            self.release_relation_claims(session_id, table, mode);
57        }
58        self.wake.notify_all();
59    }
60
61    pub fn release_session(&self, session_id: u64) {
62        let mut released_rows = Vec::new();
63        let mut retained_identities = Vec::new();
64        let mut released_relations = Vec::new();
65        let mut state = self.state.lock();
66        state.rows.retain(|key, grants| {
67            grants.retain(|grant| {
68                if grant.session_id == session_id {
69                    retained_identities.extend(grant.identity.clone());
70                    for acquisition in &grant.acquisitions {
71                        released_rows.push((*key, acquisition.strength));
72                    }
73                    return false;
74                }
75                true
76            });
77            !grants.is_empty()
78        });
79        state.relations.retain(|table, grants| {
80            grants.retain(|grant| {
81                if grant.session_id == session_id {
82                    for acquisition in &grant.acquisitions {
83                        released_relations.push((*table, acquisition.mode));
84                    }
85                    return false;
86                }
87                true
88            });
89            !grants.is_empty()
90        });
91        state.waiting.remove(&session_id);
92        state.waiting_relations.remove(&session_id);
93        state.advertised_waits.remove(&session_id);
94        remove_inactive_versions(&mut state);
95        drop(state);
96        self.release_row_claims(session_id, &released_rows);
97        drop(retained_identities);
98        for (table, mode) in released_relations {
99            self.release_relation_claims(session_id, table, mode);
100        }
101        self.wake.notify_all();
102    }
103
104    pub fn rollback_acquisition(&self, acquisition: RowLockAcquisition) {
105        let mut released = None;
106        let mut retained_identity = None;
107        let mut state = self.state.lock();
108        let Some(grants) = state.rows.get_mut(&acquisition.key) else {
109            return;
110        };
111        grants.retain_mut(|grant| {
112            if grant.session_id == acquisition.session_id {
113                retained_identity.clone_from(&grant.identity);
114                grant.acquisitions.retain(|marked| {
115                    let keep = marked.acquisition_id != acquisition.acquisition_id;
116                    if !keep {
117                        released = Some(marked.strength);
118                    }
119                    keep
120                });
121            }
122            !grant.acquisitions.is_empty()
123        });
124        if grants.is_empty() {
125            state.rows.remove(&acquisition.key);
126        }
127        remove_inactive_versions(&mut state);
128        drop(state);
129        if let Some(strength) = released {
130            self.release_row_claims(acquisition.session_id, &[(acquisition.key, strength)]);
131        }
132        drop(retained_identity);
133        self.wake.notify_all();
134    }
135}