Struct ThreadLocker 

pub struct ThreadLocker { /* private fields */ }

A thread-based locker that shares locks with other ThreadLockers on the same thread.

ThreadLocker extends BasicLocker to track which thread created it. All ThreadLockers on the same thread share locks with each other, which allows multiple cursors to operate without lock conflicts.

This is used for auto-commit operations where a transaction context is not explicitly provided.

Implementations

impl ThreadLocker

pub fn new(id: i64, lock_manager: Arc<LockManager>) -> Self

Creates a new ThreadLocker for the current thread.

Registers this locker’s thread ID in the LockManager’s sharing registry so that LockImpl::try_lock() can bypass conflict detection for co-owning ThreadLockers on the same thread.

Arguments

• id - Unique locker ID
• lock_manager - Shared lock manager

pub fn with_timeout( id: i64, lock_manager: Arc<LockManager>, timeout_ms: u64, ) -> Self

Creates a ThreadLocker with a specified timeout.

pub fn get_thread_id(&self) -> u64

Returns the thread ID that created this locker.

pub fn release_all_locks(&mut self) -> Result<(), TxnError>

Release all locks held by this locker.

pub fn set_lock_timeout(&mut self, timeout_ms: u64)

Sets the lock timeout.

Trait Implementations

impl Drop for ThreadLocker

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Locker for ThreadLocker

fn shares_locks_with(&self, other_id: i64) -> bool

Returns true if the other locker was created on the same thread.

Both lockers must be ThreadLockers and have the same originating thread for sharing. We check via the LockManager’s sharing registry (locker_id → thread_id).

fn id(&self) -> i64

Returns the unique ID of this locker.

fn lock( &mut self, lsn: u64, lock_type: LockType, non_blocking: bool, ) -> Result<LockResult, TxnError>

Acquires a lock on the given LSN.

fn release_lock(&mut self, lsn: u64) -> Result<(), TxnError>

Releases a lock on the given LSN.

fn owns_write_lock(&self, lsn: u64) -> bool

Returns true if this locker owns a write lock on the given LSN.

fn is_transactional(&self) -> bool

Returns true if this locker is transactional (supports commit/abort).

fn lock_timeout_ms(&self) -> u64

Returns the timeout for lock attempts in milliseconds.

fn default_no_wait(&self) -> bool

Returns true if this locker uses non-blocking lock requests by default.

fn close(&mut self)

Marks this locker as closed. After close, no operations should occur.

fn is_open(&self) -> bool

Returns true if this locker is still open.

fn owns_any_lock(&self, lsn: u64) -> bool

Returns true if this locker owns ANY lock (read or write) on the given LSN.

fn retains_locks_on_commit(&self) -> bool

Returns true if locks should be retained on commit (serializable isolation).

fn is_preemptable(&self) -> bool

Returns true if this locker’s locks can be preempted/stolen.

fn is_importunate(&self) -> bool

Returns true if this locker can steal other lockers’ locks.

fn is_read_uncommitted_default(&self) -> bool

Returns true if this locker allows read-uncommitted by default.

fn locking_required(&self) -> bool

Returns true if locking is required for this locker’s current context.

fn txn_timeout_ms(&self) -> u64

Returns the transaction-level timeout in milliseconds.

fn is_timed_out(&self) -> bool

Returns true if the transaction-level timeout has expired.

fn lock_after_lsn_change( &mut self, _old_lsn: u64, _new_lsn: u64, ) -> Result<(), TxnError>

Called by the lock manager when an LN is moved to a new LSN without first acquiring a write lock (e.g. during eviction or cleaning).

fn operation_end(&mut self) -> Result<(), TxnError>

Called at the end of a non-transactional operation to release locks.

fn release_non_txn_locks(&mut self) -> Result<(), TxnError>

Releases all non-transactional locks held by this locker.

fn non_txn_operation_end(&mut self) -> Result<(), TxnError>

Called after a non-transactional operation ends, releasing locks and closing the locker.

fn is_serializable_isolation(&self) -> bool

Returns true if this locker uses serializable (repeatable-read) isolation.

fn is_read_committed_isolation(&self) -> bool

Returns true if this locker uses read-committed isolation.

fn get_txn_locker_id(&self) -> Option<i64>

Returns the transaction ID if this locker is or owns a Txn, else None.