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
150
151
152
|
/* Copyright (c) 2014, 2025, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License, version 2.0,
as published by the Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
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, version 2.0, 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 St, Fifth Floor, Boston, MA 02110-1301 USA */
#ifndef RPL_TABLE_ACCESS_H_
#define RPL_TABLE_ACCESS_H_
#include <sys/types.h>
#include "lex_string.h"
#include "thr_lock.h" // thr_lock_type
class Open_tables_backup;
class THD;
struct TABLE;
/**
A base class for accessing a system table.
*/
class System_table_access {
public:
virtual ~System_table_access() = default;
/**
Opens and locks a system table.
It's assumed that the caller knows what they are doing:
- whether it was necessary to reset-and-backup the open tables state
- whether the requested lock does not lead to a deadlock
- whether this open mode would work under LOCK TABLES, or inside a
stored function or trigger.
Note that if the table can't be locked successfully this operation will
close it. Therefore it provides guarantee that it either opens and locks
table or fails without leaving any tables open.
@param[in] thd Thread requesting to open the table
@param[in] dbstr Database where the table resides
@param[in] tbstr Table to be opened
@param[in] max_num_field Maximum number of fields
@param[in] lock_type How to lock the table
@param[out] table We will store the open table here
@param[out] backup Save the lock info. here
@retval true open and lock failed - an error message is pushed into the
stack
@retval false success
*/
bool open_table(THD *thd, const LEX_CSTRING dbstr, const LEX_CSTRING tbstr,
uint max_num_field, enum thr_lock_type lock_type,
TABLE **table, Open_tables_backup *backup);
/**
Opens and locks a system table.
It's assumed that the caller knows what they are doing:
- whether it was necessary to reset-and-backup the open tables state
- whether the requested lock does not lead to a deadlock
- whether this open mode would work under LOCK TABLES, or inside a
stored function or trigger.
Note that if the table can't be locked successfully this operation will
close it. Therefore it provides guarantee that it either opens and locks
table or fails without leaving any tables open.
@param[in] thd Thread requesting to open the table
@param[in] dbstr Database where the table resides
@param[in] tbstr Table to be opened
@param[in] max_num_field Maximum number of fields
@param[in] lock_type How to lock the table
@param[out] table We will store the open table here
@param[out] backup Save the lock info. here
@retval true open and lock failed - an error message is pushed into the
stack
@retval false success
*/
bool open_table(THD *thd, std::string dbstr, std::string tbstr,
uint max_num_field, enum thr_lock_type lock_type,
TABLE **table, Open_tables_backup *backup);
/**
Prepares before opening table.
@param[in] thd Thread requesting to open the table
*/
virtual void before_open(THD *thd) = 0;
/**
Commits the changes, unlocks the table and closes it. This method
needs to be called even if the open_table fails, in order to ensure
the lock info is properly restored.
@param[in] thd Thread requesting to close the table
@param[in] table Table to be closed
@param[in] backup Restore the lock info from here
@param[in] error If there was an error while updating
the table
@param[in] need_commit Need to commit current transaction
if it is true.
@retval true failed
@retval false success
If there is an error, rolls back the current statement. Otherwise,
commits it. However, if a new thread was created and there is an
error, the transaction must be rolled back. Otherwise, it must be
committed. In this case, the changes were not done on behalf of
any user transaction and if not finished, there would be pending
changes.
*/
bool close_table(THD *thd, TABLE *table, Open_tables_backup *backup,
bool error, bool need_commit);
/**
Creates a new thread in the bootstrap process or in the mysqld startup,
a thread is created in order to be able to access a table.
@return THD* Pointer to thread structure
*/
THD *create_thd();
/**
Destroys the created thread and restores the
system_thread information.
@param thd Thread requesting to be destroyed
*/
void drop_thd(THD *thd);
/* Flags for opening table */
uint m_flags;
};
#endif /* RPL_TABLE_ACCESS_H_ */
|
