← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/mtr0mtr.h

  • Committer: Brian Aker
  • Date: 2010-09-22 22:25:29 UTC
  • mto: (1791.1.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 1792.
  • Revision ID: brian@tangent.org-20100922222529-geo4wggmu5ntqa5k
Current boost work (more conversion).

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/mtr0mtr.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/mtr0mtr.h
21
 
Mini-transaction buffer
22
 
 
23
 
Created 11/26/1995 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef mtr0mtr_h
27
 
#define mtr0mtr_h
28
 
 
29
 
#include "univ.i"
30
 
#include "mem0mem.h"
31
 
#include "dyn0dyn.h"
32
 
#include "buf0types.h"
33
 
#include "sync0rw.h"
34
 
#include "ut0byte.h"
35
 
#include "mtr0types.h"
36
 
#include "page0types.h"
37
 
 
38
 
/* Logging modes for a mini-transaction */
39
 
#define MTR_LOG_ALL             21      /* default mode: log all operations
40
 
                                        modifying disk-based data */
41
 
#define MTR_LOG_NONE            22      /* log no operations */
42
 
/*#define       MTR_LOG_SPACE   23 */   /* log only operations modifying
43
 
                                        file space page allocation data
44
 
                                        (operations in fsp0fsp.* ) */
45
 
#define MTR_LOG_SHORT_INSERTS   24      /* inserts are logged in a shorter
46
 
                                        form */
47
 
 
48
 
/* Types for the mlock objects to store in the mtr memo; NOTE that the
49
 
first 3 values must be RW_S_LATCH, RW_X_LATCH, RW_NO_LATCH */
50
 
#define MTR_MEMO_PAGE_S_FIX     RW_S_LATCH
51
 
#define MTR_MEMO_PAGE_X_FIX     RW_X_LATCH
52
 
#define MTR_MEMO_BUF_FIX        RW_NO_LATCH
53
 
#define MTR_MEMO_MODIFY         54
54
 
#define MTR_MEMO_S_LOCK         55
55
 
#define MTR_MEMO_X_LOCK         56
56
 
 
57
 
/** @name Log item types
58
 
The log items are declared 'byte' so that the compiler can warn if val
59
 
and type parameters are switched in a call to mlog_write_ulint. NOTE!
60
 
For 1 - 8 bytes, the flag value must give the length also! @{ */
61
 
#define MLOG_SINGLE_REC_FLAG    128             /*!< if the mtr contains only
62
 
                                                one log record for one page,
63
 
                                                i.e., write_initial_log_record
64
 
                                                has been called only once,
65
 
                                                this flag is ORed to the type
66
 
                                                of that first log record */
67
 
#define MLOG_1BYTE              (1)             /*!< one byte is written */
68
 
#define MLOG_2BYTES             (2)             /*!< 2 bytes ... */
69
 
#define MLOG_4BYTES             (4)             /*!< 4 bytes ... */
70
 
#define MLOG_8BYTES             (8)             /*!< 8 bytes ... */
71
 
#define MLOG_REC_INSERT         ((byte)9)       /*!< record insert */
72
 
#define MLOG_REC_CLUST_DELETE_MARK ((byte)10)   /*!< mark clustered index record
73
 
                                                deleted */
74
 
#define MLOG_REC_SEC_DELETE_MARK ((byte)11)     /*!< mark secondary index record
75
 
                                                deleted */
76
 
#define MLOG_REC_UPDATE_IN_PLACE ((byte)13)     /*!< update of a record,
77
 
                                                preserves record field sizes */
78
 
#define MLOG_REC_DELETE         ((byte)14)      /*!< delete a record from a
79
 
                                                page */
80
 
#define MLOG_LIST_END_DELETE    ((byte)15)      /*!< delete record list end on
81
 
                                                index page */
82
 
#define MLOG_LIST_START_DELETE  ((byte)16)      /*!< delete record list start on
83
 
                                                index page */
84
 
#define MLOG_LIST_END_COPY_CREATED ((byte)17)   /*!< copy record list end to a
85
 
                                                new created index page */
86
 
#define MLOG_PAGE_REORGANIZE    ((byte)18)      /*!< reorganize an
87
 
                                                index page in
88
 
                                                ROW_FORMAT=REDUNDANT */
89
 
#define MLOG_PAGE_CREATE        ((byte)19)      /*!< create an index page */
90
 
#define MLOG_UNDO_INSERT        ((byte)20)      /*!< insert entry in an undo
91
 
                                                log */
92
 
#define MLOG_UNDO_ERASE_END     ((byte)21)      /*!< erase an undo log
93
 
                                                page end */
94
 
#define MLOG_UNDO_INIT          ((byte)22)      /*!< initialize a page in an
95
 
                                                undo log */
96
 
#define MLOG_UNDO_HDR_DISCARD   ((byte)23)      /*!< discard an update undo log
97
 
                                                header */
98
 
#define MLOG_UNDO_HDR_REUSE     ((byte)24)      /*!< reuse an insert undo log
99
 
                                                header */
100
 
#define MLOG_UNDO_HDR_CREATE    ((byte)25)      /*!< create an undo
101
 
                                                log header */
102
 
#define MLOG_REC_MIN_MARK       ((byte)26)      /*!< mark an index
103
 
                                                record as the
104
 
                                                predefined minimum
105
 
                                                record */
106
 
#define MLOG_IBUF_BITMAP_INIT   ((byte)27)      /*!< initialize an
107
 
                                                ibuf bitmap page */
108
 
/*#define       MLOG_FULL_PAGE  ((byte)28)      full contents of a page */
109
 
#ifdef UNIV_LOG_LSN_DEBUG
110
 
# define MLOG_LSN               ((byte)28)      /* current LSN */
111
 
#endif
112
 
#define MLOG_INIT_FILE_PAGE     ((byte)29)      /*!< this means that a
113
 
                                                file page is taken
114
 
                                                into use and the prior
115
 
                                                contents of the page
116
 
                                                should be ignored: in
117
 
                                                recovery we must not
118
 
                                                trust the lsn values
119
 
                                                stored to the file
120
 
                                                page */
121
 
#define MLOG_WRITE_STRING       ((byte)30)      /*!< write a string to
122
 
                                                a page */
123
 
#define MLOG_MULTI_REC_END      ((byte)31)      /*!< if a single mtr writes
124
 
                                                several log records,
125
 
                                                this log record ends the
126
 
                                                sequence of these records */
127
 
#define MLOG_DUMMY_RECORD       ((byte)32)      /*!< dummy log record used to
128
 
                                                pad a log block full */
129
 
#define MLOG_FILE_CREATE        ((byte)33)      /*!< log record about an .ibd
130
 
                                                file creation */
131
 
#define MLOG_FILE_RENAME        ((byte)34)      /*!< log record about an .ibd
132
 
                                                file rename */
133
 
#define MLOG_FILE_DELETE        ((byte)35)      /*!< log record about an .ibd
134
 
                                                file deletion */
135
 
#define MLOG_COMP_REC_MIN_MARK  ((byte)36)      /*!< mark a compact
136
 
                                                index record as the
137
 
                                                predefined minimum
138
 
                                                record */
139
 
#define MLOG_COMP_PAGE_CREATE   ((byte)37)      /*!< create a compact
140
 
                                                index page */
141
 
#define MLOG_COMP_REC_INSERT    ((byte)38)      /*!< compact record insert */
142
 
#define MLOG_COMP_REC_CLUST_DELETE_MARK ((byte)39)
143
 
                                                /*!< mark compact
144
 
                                                clustered index record
145
 
                                                deleted */
146
 
#define MLOG_COMP_REC_SEC_DELETE_MARK ((byte)40)/*!< mark compact
147
 
                                                secondary index record
148
 
                                                deleted; this log
149
 
                                                record type is
150
 
                                                redundant, as
151
 
                                                MLOG_REC_SEC_DELETE_MARK
152
 
                                                is independent of the
153
 
                                                record format. */
154
 
#define MLOG_COMP_REC_UPDATE_IN_PLACE ((byte)41)/*!< update of a
155
 
                                                compact record,
156
 
                                                preserves record field
157
 
                                                sizes */
158
 
#define MLOG_COMP_REC_DELETE    ((byte)42)      /*!< delete a compact record
159
 
                                                from a page */
160
 
#define MLOG_COMP_LIST_END_DELETE ((byte)43)    /*!< delete compact record list
161
 
                                                end on index page */
162
 
#define MLOG_COMP_LIST_START_DELETE ((byte)44)  /*!< delete compact record list
163
 
                                                start on index page */
164
 
#define MLOG_COMP_LIST_END_COPY_CREATED ((byte)45)
165
 
                                                /*!< copy compact
166
 
                                                record list end to a
167
 
                                                new created index
168
 
                                                page */
169
 
#define MLOG_COMP_PAGE_REORGANIZE ((byte)46)    /*!< reorganize an index page */
170
 
#define MLOG_FILE_CREATE2       ((byte)47)      /*!< log record about creating
171
 
                                                an .ibd file, with format */
172
 
#define MLOG_ZIP_WRITE_NODE_PTR ((byte)48)      /*!< write the node pointer of
173
 
                                                a record on a compressed
174
 
                                                non-leaf B-tree page */
175
 
#define MLOG_ZIP_WRITE_BLOB_PTR ((byte)49)      /*!< write the BLOB pointer
176
 
                                                of an externally stored column
177
 
                                                on a compressed page */
178
 
#define MLOG_ZIP_WRITE_HEADER   ((byte)50)      /*!< write to compressed page
179
 
                                                header */
180
 
#define MLOG_ZIP_PAGE_COMPRESS  ((byte)51)      /*!< compress an index page */
181
 
#define MLOG_BIGGEST_TYPE       ((byte)51)      /*!< biggest value (used in
182
 
                                                assertions) */
183
 
/* @} */
184
 
 
185
 
/** @name Flags for MLOG_FILE operations
186
 
(stored in the page number parameter, called log_flags in the
187
 
functions).  The page number parameter was originally written as 0. @{ */
188
 
#define MLOG_FILE_FLAG_TEMP     1       /*!< identifies TEMPORARY TABLE in
189
 
                                        MLOG_FILE_CREATE, MLOG_FILE_CREATE2 */
190
 
/* @} */
191
 
 
192
 
/***************************************************************//**
193
 
Starts a mini-transaction and creates a mini-transaction handle
194
 
and buffer in the memory buffer given by the caller.
195
 
@return mtr buffer which also acts as the mtr handle */
196
 
UNIV_INLINE
197
 
mtr_t*
198
 
mtr_start(
199
 
/*======*/
200
 
        mtr_t*  mtr);   /*!< in: memory buffer for the mtr buffer */
201
 
/***************************************************************//**
202
 
Commits a mini-transaction. */
203
 
UNIV_INTERN
204
 
void
205
 
mtr_commit(
206
 
/*=======*/
207
 
        mtr_t*  mtr);   /*!< in: mini-transaction */
208
 
/**********************************************************//**
209
 
Sets and returns a savepoint in mtr.
210
 
@return savepoint */
211
 
UNIV_INLINE
212
 
ulint
213
 
mtr_set_savepoint(
214
 
/*==============*/
215
 
        mtr_t*  mtr);   /*!< in: mtr */
216
 
/**********************************************************//**
217
 
Releases the latches stored in an mtr memo down to a savepoint.
218
 
NOTE! The mtr must not have made changes to buffer pages after the
219
 
savepoint, as these can be handled only by mtr_commit. */
220
 
UNIV_INTERN
221
 
void
222
 
mtr_rollback_to_savepoint(
223
 
/*======================*/
224
 
        mtr_t*  mtr,            /*!< in: mtr */
225
 
        ulint   savepoint);     /*!< in: savepoint */
226
 
#ifndef UNIV_HOTBACKUP
227
 
/**********************************************************//**
228
 
Releases the (index tree) s-latch stored in an mtr memo after a
229
 
savepoint. */
230
 
UNIV_INLINE
231
 
void
232
 
mtr_release_s_latch_at_savepoint(
233
 
/*=============================*/
234
 
        mtr_t*          mtr,            /*!< in: mtr */
235
 
        ulint           savepoint,      /*!< in: savepoint */
236
 
        rw_lock_t*      lock);          /*!< in: latch to release */
237
 
#else /* !UNIV_HOTBACKUP */
238
 
# define mtr_release_s_latch_at_savepoint(mtr,savepoint,lock) ((void) 0)
239
 
#endif /* !UNIV_HOTBACKUP */
240
 
/***************************************************************//**
241
 
Gets the logging mode of a mini-transaction.
242
 
@return logging mode: MTR_LOG_NONE, ... */
243
 
UNIV_INLINE
244
 
ulint
245
 
mtr_get_log_mode(
246
 
/*=============*/
247
 
        mtr_t*  mtr);   /*!< in: mtr */
248
 
/***************************************************************//**
249
 
Changes the logging mode of a mini-transaction.
250
 
@return old mode */
251
 
UNIV_INLINE
252
 
ulint
253
 
mtr_set_log_mode(
254
 
/*=============*/
255
 
        mtr_t*  mtr,    /*!< in: mtr */
256
 
        ulint   mode);  /*!< in: logging mode: MTR_LOG_NONE, ... */
257
 
/********************************************************//**
258
 
Reads 1 - 4 bytes from a file page buffered in the buffer pool.
259
 
@return value read */
260
 
UNIV_INTERN
261
 
ulint
262
 
mtr_read_ulint(
263
 
/*===========*/
264
 
        const byte*     ptr,    /*!< in: pointer from where to read */
265
 
        ulint           type,   /*!< in: MLOG_1BYTE, MLOG_2BYTES, MLOG_4BYTES */
266
 
        mtr_t*          mtr);   /*!< in: mini-transaction handle */
267
 
#ifndef UNIV_HOTBACKUP
268
 
/*********************************************************************//**
269
 
This macro locks an rw-lock in s-mode. */
270
 
#define mtr_s_lock(B, MTR)      mtr_s_lock_func((B), __FILE__, __LINE__,\
271
 
                                                (MTR))
272
 
/*********************************************************************//**
273
 
This macro locks an rw-lock in x-mode. */
274
 
#define mtr_x_lock(B, MTR)      mtr_x_lock_func((B), __FILE__, __LINE__,\
275
 
                                                (MTR))
276
 
/*********************************************************************//**
277
 
NOTE! Use the macro above!
278
 
Locks a lock in s-mode. */
279
 
UNIV_INLINE
280
 
void
281
 
mtr_s_lock_func(
282
 
/*============*/
283
 
        rw_lock_t*      lock,   /*!< in: rw-lock */
284
 
        const char*     file,   /*!< in: file name */
285
 
        ulint           line,   /*!< in: line number */
286
 
        mtr_t*          mtr);   /*!< in: mtr */
287
 
/*********************************************************************//**
288
 
NOTE! Use the macro above!
289
 
Locks a lock in x-mode. */
290
 
UNIV_INLINE
291
 
void
292
 
mtr_x_lock_func(
293
 
/*============*/
294
 
        rw_lock_t*      lock,   /*!< in: rw-lock */
295
 
        const char*     file,   /*!< in: file name */
296
 
        ulint           line,   /*!< in: line number */
297
 
        mtr_t*          mtr);   /*!< in: mtr */
298
 
#endif /* !UNIV_HOTBACKUP */
299
 
 
300
 
/***************************************************//**
301
 
Releases an object in the memo stack. */
302
 
UNIV_INTERN
303
 
void
304
 
mtr_memo_release(
305
 
/*=============*/
306
 
        mtr_t*  mtr,    /*!< in: mtr */
307
 
        void*   object, /*!< in: object */
308
 
        ulint   type);  /*!< in: object type: MTR_MEMO_S_LOCK, ... */
309
 
#ifdef UNIV_DEBUG
310
 
# ifndef UNIV_HOTBACKUP
311
 
/**********************************************************//**
312
 
Checks if memo contains the given item.
313
 
@return TRUE if contains */
314
 
UNIV_INLINE
315
 
ibool
316
 
mtr_memo_contains(
317
 
/*==============*/
318
 
        mtr_t*          mtr,    /*!< in: mtr */
319
 
        const void*     object, /*!< in: object to search */
320
 
        ulint           type);  /*!< in: type of object */
321
 
 
322
 
/**********************************************************//**
323
 
Checks if memo contains the given page.
324
 
@return TRUE if contains */
325
 
UNIV_INTERN
326
 
ibool
327
 
mtr_memo_contains_page(
328
 
/*===================*/
329
 
        mtr_t*          mtr,    /*!< in: mtr */
330
 
        const byte*     ptr,    /*!< in: pointer to buffer frame */
331
 
        ulint           type);  /*!< in: type of object */
332
 
/*********************************************************//**
333
 
Prints info of an mtr handle. */
334
 
UNIV_INTERN
335
 
void
336
 
mtr_print(
337
 
/*======*/
338
 
        mtr_t*  mtr);   /*!< in: mtr */
339
 
# else /* !UNIV_HOTBACKUP */
340
 
#  define mtr_memo_contains(mtr, object, type)          TRUE
341
 
#  define mtr_memo_contains_page(mtr, ptr, type)        TRUE
342
 
# endif /* !UNIV_HOTBACKUP */
343
 
#endif /* UNIV_DEBUG */
344
 
/*######################################################################*/
345
 
 
346
 
#define MTR_BUF_MEMO_SIZE       200     /* number of slots in memo */
347
 
 
348
 
/***************************************************************//**
349
 
Returns the log object of a mini-transaction buffer.
350
 
@return log */
351
 
UNIV_INLINE
352
 
dyn_array_t*
353
 
mtr_get_log(
354
 
/*========*/
355
 
        mtr_t*  mtr);   /*!< in: mini-transaction */
356
 
/***************************************************//**
357
 
Pushes an object to an mtr memo stack. */
358
 
UNIV_INLINE
359
 
void
360
 
mtr_memo_push(
361
 
/*==========*/
362
 
        mtr_t*  mtr,    /*!< in: mtr */
363
 
        void*   object, /*!< in: object */
364
 
        ulint   type);  /*!< in: object type: MTR_MEMO_S_LOCK, ... */
365
 
 
366
 
 
367
 
/* Type definition of a mini-transaction memo stack slot. */
368
 
typedef struct mtr_memo_slot_struct     mtr_memo_slot_t;
369
 
struct mtr_memo_slot_struct{
370
 
        ulint   type;   /*!< type of the stored object (MTR_MEMO_S_LOCK, ...) */
371
 
        void*   object; /*!< pointer to the object */
372
 
};
373
 
 
374
 
/* Mini-transaction handle and buffer */
375
 
struct mtr_struct{
376
 
#ifdef UNIV_DEBUG
377
 
        ulint           state;  /*!< MTR_ACTIVE, MTR_COMMITTING, MTR_COMMITTED */
378
 
#endif
379
 
        dyn_array_t     memo;   /*!< memo stack for locks etc. */
380
 
        dyn_array_t     log;    /*!< mini-transaction log */
381
 
        ibool           modifications;
382
 
                                /* TRUE if the mtr made modifications to
383
 
                                buffer pool pages */
384
 
        ulint           n_log_recs;
385
 
                                /* count of how many page initial log records
386
 
                                have been written to the mtr log */
387
 
        ulint           log_mode; /* specifies which operations should be
388
 
                                logged; default value MTR_LOG_ALL */
389
 
        ib_uint64_t     start_lsn;/* start lsn of the possible log entry for
390
 
                                this mtr */
391
 
        ib_uint64_t     end_lsn;/* end lsn of the possible log entry for
392
 
                                this mtr */
393
 
#ifdef UNIV_DEBUG
394
 
        ulint           magic_n;
395
 
#endif /* UNIV_DEBUG */
396
 
};
397
 
 
398
 
#ifdef UNIV_DEBUG
399
 
# define MTR_MAGIC_N            54551
400
 
#endif /* UNIV_DEBUG */
401
 
 
402
 
#define MTR_ACTIVE              12231
403
 
#define MTR_COMMITTING          56456
404
 
#define MTR_COMMITTED           34676
405
 
 
406
 
#ifndef UNIV_NONINL
407
 
#include "mtr0mtr.ic"
408
 
#endif
409
 
 
410
 
#endif