Skip to main content

uqa_execution/row_locks/
batch.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Bounded acquisition of already evaluated reservations without intervening observations.
8
9use super::{
10    remove_inactive_versions, rollback_grant, row_byte_claims, try_grant, GrantAttempt,
11    LockAcquire, LockRequest, RowLockManager, SQLError,
12};
13
14impl RowLockManager {
15    /// Acquire pre-evaluated reservations in their original order. A group with no conflicting holder publishes all its grants under one claim-table lock. A conflict leaves that attempt unchanged and uses ordinary single-request waits, preserving prefix retention, wait diagnostics and deadlock detection. Callers must not put observable work between requests and must refresh their data view unconditionally after the batch; preliminary conflicts need not cause a later individual wait.
16    pub fn acquire_batch(
17        &self,
18        requests: &[LockRequest<'_>],
19    ) -> Result<Vec<LockAcquire>, SQLError> {
20        let mut results = Vec::with_capacity(requests.len());
21        for chunk in requests.chunks(64) {
22            if let Some(granted) = self.try_grant_batch(chunk)? {
23                results.extend(granted);
24            } else {
25                for request in chunk {
26                    results.push(self.acquire(request)?);
27                }
28            }
29        }
30        Ok(results)
31    }
32
33    fn try_grant_batch(
34        &self,
35        requests: &[LockRequest<'_>],
36    ) -> Result<Option<Vec<LockAcquire>>, SQLError> {
37        let session = requests[0].session_id;
38        if requests.len() == 1 || requests.iter().any(|request| request.session_id != session) {
39            return Ok(None);
40        }
41        let coordinator = self.coordinator()?;
42        let retained = requests
43            .iter()
44            .map(|request| self.identities.retain(request.key.table))
45            .collect::<Vec<_>>();
46        let relations = requests
47            .iter()
48            .map(|request| self.relation_bytes(request.key.table))
49            .collect::<Vec<_>>();
50        let mut identities = Vec::with_capacity(requests.len());
51        for (request, relation) in requests.iter().zip(&relations) {
52            request.cancel.check()?;
53            identities.push(
54                coordinator
55                    .map(|coordinator| {
56                        coordinator.pin_row(relation, request.key.doc_id, request.cancel)
57                    })
58                    .transpose()?,
59            );
60        }
61        let mut state = self.state.lock();
62        let mut acquisitions = Vec::with_capacity(requests.len());
63        let mut claims = Vec::with_capacity(requests.len() * 2);
64        let attempt = (|| {
65            for ((request, identity), retained) in requests.iter().zip(&identities).zip(&retained) {
66                request.cancel.check()?;
67                match try_grant(
68                    &mut state,
69                    request,
70                    &self.next_acquisition,
71                    retained.as_ref(),
72                ) {
73                    GrantAttempt::Conflict => return Ok(false),
74                    GrantAttempt::Granted(acquisition) => {
75                        if acquisition.is_some() {
76                            if let Some(identity) = identity {
77                                claims
78                                    .extend(row_byte_claims(identity.identity(), request.strength));
79                            }
80                        }
81                        acquisitions.push(acquisition);
82                    }
83                }
84            }
85            if let Some(coordinator) = coordinator.filter(|_| !claims.is_empty()) {
86                return coordinator
87                    .try_claim(session, &claims)
88                    .map(|result| result.is_ok())
89                    .map_err(SQLError::Internal);
90            }
91            Ok(true)
92        })();
93        if !matches!(attempt, Ok(true)) {
94            for acquisition in acquisitions.into_iter().rev().flatten() {
95                rollback_grant(&mut state, acquisition);
96            }
97            return attempt.map(|_| None);
98        }
99        for (identity, acquisition) in identities.iter_mut().zip(&acquisitions) {
100            if acquisition.is_some() {
101                if let Some(identity) = identity {
102                    identity.retain();
103                }
104            }
105        }
106        state.waiting.remove(&session);
107        remove_inactive_versions(&mut state);
108        Ok(Some(
109            acquisitions
110                .into_iter()
111                .map(|acquisition| LockAcquire::Granted {
112                    waited: false,
113                    foreign_waited: false,
114                    acquisition,
115                })
116                .collect(),
117        ))
118    }
119}
120
121#[cfg(test)]
122mod tests;