1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/*****************************************************************************
Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 2019, MariaDB Corporation.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
*****************************************************************************/
/**************************************************//**
@file include/row0purge.h
Purge obsolete records
Created 3/14/1997 Heikki Tuuri
*******************************************************/
#pragma once
#include "que0types.h"
#include "btr0types.h"
#include "btr0pcur.h"
#include "trx0types.h"
#include "row0types.h"
#include "row0mysql.h"
#include "mysqld.h"
#include <queue>
#include <unordered_map>
class MDL_ticket;
/** Determines if it is possible to remove a secondary index entry.
Removal is possible if the secondary index entry does not refer to any
not delete marked version of a clustered index record where DB_TRX_ID
is newer than the purge view.
NOTE: This function should only be called by the purge thread, only
while holding a latch on the leaf page of the secondary index entry
(or keeping the buffer pool watch on the page). It is possible that
this function first returns true and then false, if a user transaction
inserts a record that the secondary index entry would refer to.
However, in that case, the user transaction would also re-insert the
secondary index entry after purge has removed it and released the leaf
page latch.
@param[in,out] node row purge node
@param[in] index secondary index
@param[in] entry secondary index entry
@param[in,out] sec_pcur secondary index cursor or NULL
if it is called for purge buffering
operation.
@param[in,out] sec_mtr mini-transaction which holds
secondary index entry or NULL if it is
called for purge buffering operation.
@param[in] is_tree true=pessimistic purge,
false=optimistic (leaf-page only)
@return true if the secondary index record can be purged */
bool
row_purge_poss_sec(
purge_node_t* node,
dict_index_t* index,
const dtuple_t* entry,
btr_pcur_t* sec_pcur=NULL,
mtr_t* sec_mtr=NULL,
bool is_tree=false);
/***************************************************************
Does the purge operation.
@return query thread to run next */
que_thr_t*
row_purge_step(
/*===========*/
que_thr_t* thr) /*!< in: query thread */
MY_ATTRIBUTE((nonnull, warn_unused_result));
/** Purge worker context */
struct purge_node_t
{
/** node type: QUE_NODE_PURGE */
que_common_t common;
/** DB_TRX_ID of the undo log record */
trx_id_t trx_id;
/** DB_ROLL_PTR pointing to undo log record */
roll_ptr_t roll_ptr;
/** undo number of the record */
undo_no_t undo_no;
/** record type: TRX_UNDO_INSERT_REC, ... */
byte rec_type;
/** compiler analysis info of an update */
byte cmpl_info;
/** whether the clustered index record determined by ref was found
in the clustered index of the table, and we were able to position
pcur on it */
bool found_clust;
#ifdef UNIV_DEBUG
/** whether the operation is in progress */
bool in_progress= false;
#endif
/** table where purge is done */
dict_table_t *table= nullptr;
/** update vector for a clustered index record */
upd_t *update;
/** row reference to the next row to handle, or nullptr */
const dtuple_t *ref;
/** nullptr, or a deep copy of the indexed fields of the row to handle */
dtuple_t *row;
/** nullptr, or the next index of table whose record should be handled */
dict_index_t *index;
/** memory heap used as auxiliary storage; must be emptied between rows */
mem_heap_t *heap;
/** persistent cursor to the clustered index record */
btr_pcur_t pcur;
/** Undo recs to purge */
std::queue<trx_purge_rec_t> undo_recs;
/** map of table identifiers to table handles and meta-data locks */
std::unordered_map<table_id_t, std::pair<dict_table_t*,MDL_ticket*>> tables;
/** Constructor */
explicit purge_node_t(que_thr_t *parent) :
common(QUE_NODE_PURGE, parent), heap(mem_heap_create(256)),
tables(TRX_PURGE_TABLE_BUCKETS) {}
#ifdef UNIV_DEBUG
/** Validate the persistent cursor. The purge node has two references
to the clustered index record: ref and pcur, which must match
each other if found_clust.
@return whether pcur is consistent with ref */
bool validate_pcur();
#endif
/** Start processing an undo log record. */
inline void start();
/** Reset the state at end
@return the query graph parent */
inline que_node_t *end(THD *);
};
|
