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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
/*****************************************************************************
Copyright (c) 2013, 2016, Oracle and/or its affiliates. All Rights Reserved.
Copyright (c) 2017, 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, Suite 500, Boston, MA 02110-1335 USA
*****************************************************************************/
/**************************************************//**
@file include/fsp0space.h
Shared tablespace interface
Created 2013-7-26 by Kevin Lewis
*******************************************************/
#ifndef fsp0space_h
#define fsp0space_h
#include "fsp0file.h"
#include "fsp0fsp.h"
#include "fsp0types.h"
#include <vector>
/** Data structure that contains the information about shared tablespaces.
Currently this can be the system tablespace or a temporary table tablespace */
class Tablespace {
public:
typedef std::vector<Datafile, ut_allocator<Datafile> > files_t;
/** Data file information - each Datafile can be accessed globally */
files_t m_files;
/** Data file iterator */
typedef files_t::iterator iterator;
/** Data file iterator */
typedef files_t::const_iterator const_iterator;
Tablespace()
:
m_files(),
m_name(),
m_space_id(ULINT_UNDEFINED),
m_path(),
m_flags(),
m_ignore_read_only(false)
{
/* No op */
}
virtual ~Tablespace()
{
shutdown();
ut_ad(m_files.empty());
ut_ad(m_space_id == ULINT_UNDEFINED);
}
// Disable copying
Tablespace(const Tablespace&);
Tablespace& operator=(const Tablespace&);
/** Data file iterator */
const_iterator begin() const { return m_files.begin(); }
/** Data file iterator */
const_iterator end() const { return m_files.end(); }
/** Data file iterator */
iterator begin() { return m_files.begin(); }
/** Data file iterator */
iterator end() { return m_files.end(); }
void set_name(const char* name) { m_name = name; }
const char* name() const { return m_name; }
/** Set tablespace path and filename members.
@param[in] path where tablespace file(s) resides
@param[in] len length of the file path */
void set_path(const char* path, size_t len)
{
ut_ad(m_path == NULL);
m_path = mem_strdupl(path, len);
ut_ad(m_path != NULL);
os_normalize_path(m_path);
}
/** Set tablespace path and filename members.
@param[in] path where tablespace file(s) resides */
void set_path(const char* path)
{
set_path(path, strlen(path));
}
/** Get tablespace path
@return tablespace path */
const char* path() const
{
return(m_path);
}
/** Set the space id of the tablespace
@param[in] space_id tablespace ID to set */
void set_space_id(ulint space_id)
{
ut_ad(m_space_id == ULINT_UNDEFINED);
m_space_id = space_id;
}
/** Get the space id of the tablespace
@return m_space_id space id of the tablespace */
ulint space_id() const
{
return(m_space_id);
}
/** Set the tablespace flags
@param[in] fsp_flags tablespace flags */
void set_flags(ulint fsp_flags)
{
ut_ad(fil_space_t::is_valid_flags(fsp_flags, false));
m_flags = fsp_flags;
}
/** Get the tablespace flags
@return m_flags tablespace flags */
ulint flags() const
{
return(m_flags);
}
/** Get the tablespace encryption mode
@return m_mode tablespace encryption mode */
fil_encryption_t encryption_mode() const
{
return (m_mode);
}
/** Get the tablespace encryption key_id
@return m_key_id tablespace encryption key_id */
uint32_t key_id() const
{
return (m_key_id);
}
/** Set Ignore Read Only Status for tablespace.
@param[in] read_only_status read only status indicator */
void set_ignore_read_only(bool read_only_status)
{
m_ignore_read_only = read_only_status;
}
/** Free the memory allocated by the Tablespace object */
void shutdown();
/** @return the sum of the file sizes of each Datafile */
ulint get_sum_of_sizes() const
{
ulint sum = 0;
for (const_iterator it = begin(); it != end(); ++it) {
sum += it->m_size;
}
return(sum);
}
/** Open or Create the data files if they do not exist.
@param[in] is_temp whether this is a temporary tablespace
@return DB_SUCCESS or error code */
dberr_t open_or_create(bool is_temp)
MY_ATTRIBUTE((warn_unused_result));
/** Delete all the data files. */
void delete_files();
/** Check if two tablespaces have common data file names.
@param[in] other_space Tablespace to check against this.
@return true if they have the same data filenames and paths */
bool intersection(const Tablespace* other_space);
/** Use the ADD DATAFILE path to create a Datafile object and add
it to the front of m_files. Parse the datafile path into a path
and a basename with extension 'ibd'. This datafile_path provided
may be an absolute or relative path, but it must end with the
extension .ibd and have a basename of at least 1 byte.
Set tablespace m_path member and add a Datafile with the filename.
@param[in] datafile_path full path of the tablespace file. */
dberr_t add_datafile(
const char* datafile_path);
/* Return a pointer to the first Datafile for this Tablespace
@return pointer to the first Datafile for this Tablespace*/
Datafile* first_datafile()
{
ut_a(!m_files.empty());
return(&m_files.front());
}
private:
/**
@param[in] filename Name to lookup in the data files.
@return true if the filename exists in the data files */
bool find(const char* filename) const;
/** Note that the data file was found.
@param[in] file data file object */
void file_found(Datafile& file);
/* DATA MEMBERS */
/** Name of the tablespace. */
const char* m_name;
/** Tablespace ID */
ulint m_space_id;
/** Path where tablespace files will reside, not including a filename.*/
char* m_path;
/** Tablespace flags */
ulint m_flags;
/** Encryption mode and key_id */
fil_encryption_t m_mode;
uint32_t m_key_id;
protected:
/** Ignore server read only configuration for this tablespace. */
bool m_ignore_read_only;
};
#endif /* fsp0space_h */
|
