uqa_execution/row_locks/
batch.rs1use super::{
10 remove_inactive_versions, rollback_grant, row_byte_claims, try_grant, GrantAttempt,
11 LockAcquire, LockRequest, RowLockManager, SQLError,
12};
13
14impl RowLockManager {
15 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;