Create record locks. More...

#include <lock0priv.h>

Public Member Functions
	RecLock (que_thr_t thr, dict_index_t index, const RecID &rec_id, ulint mode)

	RecLock (que_thr_t thr, dict_index_t index, const buf_block_t *block, ulint heap_no, ulint mode)

	RecLock (dict_index_t *index, const RecID &rec_id, ulint mode)

	RecLock (dict_index_t index, const buf_block_t block, ulint heap_no, ulint mode)

dberr_t	add_to_waitq (const lock_t wait_for, const lock_prdt_t prdt=nullptr)
	Enqueue a lock wait for a transaction. More...

lock_t *	create (trx_t trx, const lock_prdt_t prdt=nullptr)
	Create a lock for a transaction and initialise it. More...

Static Public Member Functions
static lock_t *	lock_alloc (trx_t trx, dict_index_t index, ulint mode, const RecID &rec_id, ulint size)
	Create the lock instance. More...

Private Member Functions
size_t	lock_size () const

void	prepare () const
	Do some checks and prepare for creating a new record lock. More...

void	set_wait_state (lock_t *lock)
	Setup the requesting transaction state for lock grant. More...

void	lock_add (lock_t *lock)
	Add the lock to the record lock hash and the transaction's lock list. More...

void	init (const page_t *page)
	Setup the context from the requirements. More...

Static Private Member Functions
static size_t	lock_size (ulint mode)
	Calculate the record lock physical size required for a predicate lock. More...

static size_t	lock_size (const page_t *page)
	Calculate the record lock physical size required, non-predicate lock. More...

static bool	is_predicate_lock (ulint mode)

Private Attributes
que_thr_t *	m_thr
	The query thread of the transaction. More...

trx_t *	m_trx
	Transaction requesting the record lock. More...

ulint	m_mode
	Lock mode requested. More...

size_t	m_size
	Size of the record lock in bytes. More...

dict_index_t *	m_index
	Index on which the record lock is required. More...

RecID	m_rec_id
	The record lock tuple {space, page_no, heap_no}. More...

Detailed Description

Create record locks.

Constructor & Destructor Documentation

◆ RecLock() [1/4]

RecLock::RecLock	(	que_thr_t *	thr,
		dict_index_t *	index,
		const RecID &	rec_id,
		ulint	mode
	)

inline

Parameters

[in,out]	thr	Transaction query thread requesting the record lock
[in]	index	Index on which record lock requested
[in]	rec_id	Record lock tuple {space, page_no, heap_no}
[in]	mode	The lock mode

◆ RecLock() [2/4]

RecLock::RecLock	(	que_thr_t *	thr,
		dict_index_t *	index,
		const buf_block_t *	block,
		ulint	heap_no,
		ulint	mode
	)

inline

Parameters

[in,out]	thr	Transaction query thread requesting the record lock
[in]	index	Index on which record lock requested
[in]	block	Buffer page containing record
[in]	heap_no	Heap number within the block
[in]	mode	The lock mode

◆ RecLock() [3/4]

RecLock::RecLock	(	dict_index_t *	index,
		const RecID &	rec_id,
		ulint	mode
	)

inline

Parameters

[in]	index	Index on which record lock requested
[in]	rec_id	Record lock tuple {space, page_no, heap_no}
[in]	mode	The lock mode

◆ RecLock() [4/4]

RecLock::RecLock	(	dict_index_t *	index,
		const buf_block_t *	block,
		ulint	heap_no,
		ulint	mode
	)

inline

Parameters

[in]	index	Index on which record lock requested
[in]	block	Buffer page containing record
[in]	heap_no	Heap number within block
[in]	mode	The lock mode

Member Function Documentation

◆ add_to_waitq()

dberr_t RecLock::add_to_waitq	(	const lock_t *	wait_for,
		const lock_prdt_t *	prdt = `nullptr`
	)

Enqueue a lock wait for a transaction.

If it is a high priority transaction (cannot rollback) then try to jump ahead in the record lock wait queue. Also check if async rollback was request for our trx.

Parameters

[in,out]	wait_for	The lock that the the joining transaction is waiting for
[in]	prdt	Predicate [optional]

Returns: DB_LOCK_WAIT, DB_DEADLOCK, or DB_SUCCESS_LOCKED_REC

Return values

DB_DEADLOCK	means that async rollback was requested for our trx
DB_SUCCESS_LOCKED_REC	means that we are High Priority transaction and we've managed to jump in front of other waiting transactions and got the lock granted, so there is no need to wait.

◆ create()

lock_t * RecLock::create	(	trx_t *	trx,
		const lock_prdt_t *	prdt = `nullptr`
	)

Create a lock for a transaction and initialise it.

Parameters

[in,out]	trx	Transaction requesting the new lock
[in]	prdt	Predicate lock (optional)

Returns: new lock instance

◆ init()

void RecLock::init ( const page_t * page )

inlineprivate

Setup the context from the requirements.

If rec is the supremum record, then we reset the gap and LOCK_REC_NOT_GAP bits, as all locks on the supremum are automatically of the gap type

◆ is_predicate_lock()

static bool RecLock::is_predicate_lock ( ulint mode )

inlinestaticprivate

Returns: true if the requested lock mode is for a predicate or page lock

◆ lock_add()

void RecLock::lock_add ( lock_t * lock )

private

Add the lock to the record lock hash and the transaction's lock list.

Parameters

[in,out] lock Newly created record lock to add to the rec hash and the transaction lock list

◆ lock_alloc()

lock_t * RecLock::lock_alloc	(	trx_t *	trx,
		dict_index_t *	index,
		ulint	mode,
		const RecID &	rec_id,
		ulint	size
	)

static

Create the lock instance.

Parameters

[in,out]	trx	The transaction requesting the lock
[in,out]	index	Index on which record lock is required
[in]	mode	The lock mode desired
[in]	rec_id	The record id
[in]	size	Size of the lock + bitmap requested

Returns: a record lock instance

◆ lock_size() [1/3]

size_t RecLock::lock_size ( ) const

inlineprivate

◆ lock_size() [2/3]

static size_t RecLock::lock_size ( const page_t * page )

inlinestaticprivate

Calculate the record lock physical size required, non-predicate lock.

Parameters

[in] page For non-predicate locks the buffer page

Returns: the size of the lock data structure required in bytes

◆ lock_size() [3/3]

static size_t RecLock::lock_size ( ulint mode )

inlinestaticprivate

Calculate the record lock physical size required for a predicate lock.

Parameters

[in] mode For predicate locks the lock mode

Returns: the size of the lock data structure required in bytes

◆ prepare()

void RecLock::prepare ( ) const

private

Do some checks and prepare for creating a new record lock.

◆ set_wait_state()

void RecLock::set_wait_state ( lock_t * lock )

private

Setup the requesting transaction state for lock grant.

Parameters

[in,out] lock Lock for which to change state

Member Data Documentation

◆ m_index

dict_index_t* RecLock::m_index

private

Index on which the record lock is required.

◆ m_mode

ulint RecLock::m_mode

private

Lock mode requested.

◆ m_rec_id

RecID RecLock::m_rec_id

private

The record lock tuple {space, page_no, heap_no}.

◆ m_size

size_t RecLock::m_size

private

Size of the record lock in bytes.

◆ m_thr

que_thr_t* RecLock::m_thr

private

The query thread of the transaction.

◆ m_trx

trx_t* RecLock::m_trx

private

Transaction requesting the record lock.

The documentation for this class was generated from the following files:

storage/innobase/include/lock0priv.h
storage/innobase/lock/lock0lock.cc

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RecLock() [1/4]

◆ RecLock() [2/4]

◆ RecLock() [3/4]

◆ RecLock() [4/4]

Member Function Documentation

◆ add_to_waitq()

◆ create()

◆ init()

◆ is_predicate_lock()

◆ lock_add()

◆ lock_alloc()

◆ lock_size() [1/3]

◆ lock_size() [2/3]

◆ lock_size() [3/3]

◆ prepare()

◆ set_wait_state()

Member Data Documentation

◆ m_index

◆ m_mode

◆ m_rec_id

◆ m_size

◆ m_thr

◆ m_trx