Struct mz_adapter::session::GroupCommitWriteLocks

pub(crate) struct GroupCommitWriteLocks {
    locks: BTreeMap<CatalogItemId, OwnedMutexGuard<()>>,
}

Collection of WriteLocks gathered during group_commit.

Note: This struct should never be used outside of group commit because it attempts to merge together several collections of WriteLocks which if not done carefully can cause deadlocks or consistency violations.

We must prevent writes from occurring to tables during read then write plans (e.g. UPDATE) but we can allow blind writes (e.g. INSERT) to get committed concurrently at the same timestamp when submitting the updates from a read then write plan.

Naively it would seem as though we could allow blind writes to occur whenever as blind writes could never cause invalid retractions, but it could cause us to violate serializability because there is no total order we could define for the transactions. Consider the following scenario:

table: foo

 a | b
--------
 x   2
 y   3
 z   4

-- Session(A)
-- read then write plan, reads at t0, writes at t3, transaction Ta
DELETE FROM foo WHERE b % 2 = 0;


-- Session(B)
-- blind write into foo, writes at t1, transaction Tb
INSERT INTO foo VALUES ('q', 6);
-- select from foo, reads at t2, transaction Tc
SELECT * FROM foo;


The times these operations occur at are ordered:
t0 < t1 < t2 < t3

Given the timing of the operations, the transactions must have the following order:

* Ta does not observe ('q', 6), so Ta < Tb
* Tc does observe ('q', 6), so Tb < Tc
* Tc does not observe the retractions from Ta, so Tc < Ta

For total order to exist, Ta < Tb < Tc < Ta, which is impossible.

Fields

locks: BTreeMap<CatalogItemId, OwnedMutexGuard<()>>

Implementations

impl GroupCommitWriteLocks

pub fn merge(&mut self, locks: WriteLocks)

Merge a set of WriteLocks into this collection for group commit.

pub fn missing_locks( &self, writes: impl Iterator<Item = CatalogItemId>, ) -> BTreeSet<CatalogItemId>

Returns the collections we’re missing locks for, if any.

Trait Implementations

impl Debug for GroupCommitWriteLocks

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for GroupCommitWriteLocks

fn default() -> GroupCommitWriteLocks

Returns the “default value” for a type.

impl Drop for GroupCommitWriteLocks

fn drop(&mut self)

Executes the destructor for this type.