← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/trx0undo.h

  • Committer: Monty Taylor
  • Date: 2008-10-30 19:42:06 UTC
  • mto: (520.4.38 devel)
  • mto: This revision was merged to the branch mainline in revision 572.
  • Revision ID: monty@inaugust.com-20081030194206-fzus6yqlw1ekru65
Removed handler from common_includes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/trx0undo.h
 
1
/******************************************************
 
2
Transaction undo log
 
3
 
 
4
(c) 1996 Innobase Oy
 
5
 
 
6
Created 3/26/1996 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#ifndef trx0undo_h
 
10
#define trx0undo_h
 
11
 
 
12
#include "univ.i"
 
13
#include "trx0types.h"
 
14
#include "mtr0mtr.h"
 
15
#include "trx0sys.h"
 
16
#include "page0types.h"
 
17
#include "trx0xa.h"
 
18
 
 
19
/***************************************************************************
 
20
Builds a roll pointer dulint. */
 
21
UNIV_INLINE
 
22
dulint
 
23
trx_undo_build_roll_ptr(
 
24
/*====================*/
 
25
                                /* out: roll pointer */
 
26
        ibool   is_insert,      /* in: TRUE if insert undo log */
 
27
        ulint   rseg_id,        /* in: rollback segment id */
 
28
        ulint   page_no,        /* in: page number */
 
29
        ulint   offset);        /* in: offset of the undo entry within page */
 
30
/***************************************************************************
 
31
Decodes a roll pointer dulint. */
 
32
UNIV_INLINE
 
33
void
 
34
trx_undo_decode_roll_ptr(
 
35
/*=====================*/
 
36
        dulint  roll_ptr,       /* in: roll pointer */
 
37
        ibool*  is_insert,      /* out: TRUE if insert undo log */
 
38
        ulint*  rseg_id,        /* out: rollback segment id */
 
39
        ulint*  page_no,        /* out: page number */
 
40
        ulint*  offset);        /* out: offset of the undo entry within page */
 
41
/***************************************************************************
 
42
Returns TRUE if the roll pointer is of the insert type. */
 
43
UNIV_INLINE
 
44
ibool
 
45
trx_undo_roll_ptr_is_insert(
 
46
/*========================*/
 
47
                                /* out: TRUE if insert undo log */
 
48
        dulint  roll_ptr);      /* in: roll pointer */
 
49
/*********************************************************************
 
50
Writes a roll ptr to an index page. In case that the size changes in
 
51
some future version, this function should be used instead of
 
52
mach_write_... */
 
53
UNIV_INLINE
 
54
void
 
55
trx_write_roll_ptr(
 
56
/*===============*/
 
57
        byte*   ptr,            /* in: pointer to memory where written */
 
58
        dulint  roll_ptr);      /* in: roll ptr */
 
59
/*********************************************************************
 
60
Reads a roll ptr from an index page. In case that the roll ptr size
 
61
changes in some future version, this function should be used instead of
 
62
mach_read_... */
 
63
UNIV_INLINE
 
64
dulint
 
65
trx_read_roll_ptr(
 
66
/*==============*/
 
67
                                /* out: roll ptr */
 
68
        const byte*     ptr);   /* in: pointer to memory from where to read */
 
69
/**********************************************************************
 
70
Gets an undo log page and x-latches it. */
 
71
UNIV_INLINE
 
72
page_t*
 
73
trx_undo_page_get(
 
74
/*==============*/
 
75
                                /* out: pointer to page x-latched */
 
76
        ulint   space,          /* in: space where placed */
 
77
        ulint   zip_size,       /* in: compressed page size in bytes
 
78
                                or 0 for uncompressed pages */
 
79
        ulint   page_no,        /* in: page number */
 
80
        mtr_t*  mtr);           /* in: mtr */
 
81
/**********************************************************************
 
82
Gets an undo log page and s-latches it. */
 
83
UNIV_INLINE
 
84
page_t*
 
85
trx_undo_page_get_s_latched(
 
86
/*========================*/
 
87
                                /* out: pointer to page s-latched */
 
88
        ulint   space,          /* in: space where placed */
 
89
        ulint   zip_size,       /* in: compressed page size in bytes
 
90
                                or 0 for uncompressed pages */
 
91
        ulint   page_no,        /* in: page number */
 
92
        mtr_t*  mtr);           /* in: mtr */
 
93
/**********************************************************************
 
94
Returns the previous undo record on the page in the specified log, or
 
95
NULL if none exists. */
 
96
UNIV_INLINE
 
97
trx_undo_rec_t*
 
98
trx_undo_page_get_prev_rec(
 
99
/*=======================*/
 
100
                                /* out: pointer to record, NULL if none */
 
101
        trx_undo_rec_t* rec,    /* in: undo log record */
 
102
        ulint           page_no,/* in: undo log header page number */
 
103
        ulint           offset);/* in: undo log header offset on page */
 
104
/**********************************************************************
 
105
Returns the next undo log record on the page in the specified log, or
 
106
NULL if none exists. */
 
107
UNIV_INLINE
 
108
trx_undo_rec_t*
 
109
trx_undo_page_get_next_rec(
 
110
/*=======================*/
 
111
                                /* out: pointer to record, NULL if none */
 
112
        trx_undo_rec_t* rec,    /* in: undo log record */
 
113
        ulint           page_no,/* in: undo log header page number */
 
114
        ulint           offset);/* in: undo log header offset on page */
 
115
/**********************************************************************
 
116
Returns the last undo record on the page in the specified undo log, or
 
117
NULL if none exists. */
 
118
UNIV_INLINE
 
119
trx_undo_rec_t*
 
120
trx_undo_page_get_last_rec(
 
121
/*=======================*/
 
122
                        /* out: pointer to record, NULL if none */
 
123
        page_t* undo_page,/* in: undo log page */
 
124
        ulint   page_no,/* in: undo log header page number */
 
125
        ulint   offset);        /* in: undo log header offset on page */
 
126
/**********************************************************************
 
127
Returns the first undo record on the page in the specified undo log, or
 
128
NULL if none exists. */
 
129
UNIV_INLINE
 
130
trx_undo_rec_t*
 
131
trx_undo_page_get_first_rec(
 
132
/*========================*/
 
133
                        /* out: pointer to record, NULL if none */
 
134
        page_t* undo_page,/* in: undo log page */
 
135
        ulint   page_no,/* in: undo log header page number */
 
136
        ulint   offset);/* in: undo log header offset on page */
 
137
/***************************************************************************
 
138
Gets the previous record in an undo log. */
 
139
UNIV_INTERN
 
140
trx_undo_rec_t*
 
141
trx_undo_get_prev_rec(
 
142
/*==================*/
 
143
                                /* out: undo log record, the page s-latched,
 
144
                                NULL if none */
 
145
        trx_undo_rec_t* rec,    /* in: undo record */
 
146
        ulint           page_no,/* in: undo log header page number */
 
147
        ulint           offset, /* in: undo log header offset on page */
 
148
        mtr_t*          mtr);   /* in: mtr */
 
149
/***************************************************************************
 
150
Gets the next record in an undo log. */
 
151
UNIV_INTERN
 
152
trx_undo_rec_t*
 
153
trx_undo_get_next_rec(
 
154
/*==================*/
 
155
                                /* out: undo log record, the page s-latched,
 
156
                                NULL if none */
 
157
        trx_undo_rec_t* rec,    /* in: undo record */
 
158
        ulint           page_no,/* in: undo log header page number */
 
159
        ulint           offset, /* in: undo log header offset on page */
 
160
        mtr_t*          mtr);   /* in: mtr */
 
161
/***************************************************************************
 
162
Gets the first record in an undo log. */
 
163
UNIV_INTERN
 
164
trx_undo_rec_t*
 
165
trx_undo_get_first_rec(
 
166
/*===================*/
 
167
                        /* out: undo log record, the page latched, NULL if
 
168
                        none */
 
169
        ulint   space,  /* in: undo log header space */
 
170
        ulint   zip_size,/* in: compressed page size in bytes
 
171
                        or 0 for uncompressed pages */
 
172
        ulint   page_no,/* in: undo log header page number */
 
173
        ulint   offset, /* in: undo log header offset on page */
 
174
        ulint   mode,   /* in: latching mode: RW_S_LATCH or RW_X_LATCH */
 
175
        mtr_t*  mtr);   /* in: mtr */
 
176
/************************************************************************
 
177
Tries to add a page to the undo log segment where the undo log is placed. */
 
178
UNIV_INTERN
 
179
ulint
 
180
trx_undo_add_page(
 
181
/*==============*/
 
182
                                /* out: page number if success, else
 
183
                                FIL_NULL */
 
184
        trx_t*          trx,    /* in: transaction */
 
185
        trx_undo_t*     undo,   /* in: undo log memory object */
 
186
        mtr_t*          mtr);   /* in: mtr which does not have a latch to any
 
187
                                undo log page; the caller must have reserved
 
188
                                the rollback segment mutex */
 
189
/***************************************************************************
 
190
Truncates an undo log from the end. This function is used during a rollback
 
191
to free space from an undo log. */
 
192
UNIV_INTERN
 
193
void
 
194
trx_undo_truncate_end(
 
195
/*==================*/
 
196
        trx_t*          trx,    /* in: transaction whose undo log it is */
 
197
        trx_undo_t*     undo,   /* in: undo log */
 
198
        dulint          limit); /* in: all undo records with undo number
 
199
                                >= this value should be truncated */
 
200
/***************************************************************************
 
201
Truncates an undo log from the start. This function is used during a purge
 
202
operation. */
 
203
UNIV_INTERN
 
204
void
 
205
trx_undo_truncate_start(
 
206
/*====================*/
 
207
        trx_rseg_t* rseg,       /* in: rollback segment */
 
208
        ulint   space,          /* in: space id of the log */
 
209
        ulint   hdr_page_no,    /* in: header page number */
 
210
        ulint   hdr_offset,     /* in: header offset on the page */
 
211
        dulint  limit);         /* in: all undo pages with undo numbers <
 
212
                                this value should be truncated; NOTE that
 
213
                                the function only frees whole pages; the
 
214
                                header page is not freed, but emptied, if
 
215
                                all the records there are < limit */
 
216
/************************************************************************
 
217
Initializes the undo log lists for a rollback segment memory copy.
 
218
This function is only called when the database is started or a new
 
219
rollback segment created. */
 
220
UNIV_INTERN
 
221
ulint
 
222
trx_undo_lists_init(
 
223
/*================*/
 
224
                                /* out: the combined size of undo log segments
 
225
                                in pages */
 
226
        trx_rseg_t*     rseg);  /* in: rollback segment memory object */
 
227
/**************************************************************************
 
228
Assigns an undo log for a transaction. A new undo log is created or a cached
 
229
undo log reused. */
 
230
UNIV_INTERN
 
231
ulint
 
232
trx_undo_assign_undo(
 
233
/*=================*/
 
234
                                /* out: DB_SUCCESS if undo log assign
 
235
                                 * successful, possible error codes are:
 
236
                                 * ER_TOO_MANY_CONCURRENT_TRXS
 
237
                                 * DB_OUT_OF_FILE_SPAC
 
238
                                 * DB_OUT_OF_MEMORY */
 
239
        trx_t*          trx,    /* in: transaction */
 
240
        ulint           type);  /* in: TRX_UNDO_INSERT or TRX_UNDO_UPDATE */
 
241
/**********************************************************************
 
242
Sets the state of the undo log segment at a transaction finish. */
 
243
UNIV_INTERN
 
244
page_t*
 
245
trx_undo_set_state_at_finish(
 
246
/*=========================*/
 
247
                                /* out: undo log segment header page,
 
248
                                x-latched */
 
249
        trx_rseg_t*     rseg,   /* in: rollback segment memory object */
 
250
        trx_t*          trx,    /* in: transaction */
 
251
        trx_undo_t*     undo,   /* in: undo log memory copy */
 
252
        mtr_t*          mtr);   /* in: mtr */
 
253
/**********************************************************************
 
254
Sets the state of the undo log segment at a transaction prepare. */
 
255
UNIV_INTERN
 
256
page_t*
 
257
trx_undo_set_state_at_prepare(
 
258
/*==========================*/
 
259
                                /* out: undo log segment header page,
 
260
                                x-latched */
 
261
        trx_t*          trx,    /* in: transaction */
 
262
        trx_undo_t*     undo,   /* in: undo log memory copy */
 
263
        mtr_t*          mtr);   /* in: mtr */
 
264
 
 
265
/**************************************************************************
 
266
Adds the update undo log header as the first in the history list, and
 
267
frees the memory object, or puts it to the list of cached update undo log
 
268
segments. */
 
269
UNIV_INTERN
 
270
void
 
271
trx_undo_update_cleanup(
 
272
/*====================*/
 
273
        trx_t*  trx,            /* in: trx owning the update undo log */
 
274
        page_t* undo_page,      /* in: update undo log header page,
 
275
                                x-latched */
 
276
        mtr_t*  mtr);           /* in: mtr */
 
277
/**********************************************************************
 
278
Frees or caches an insert undo log after a transaction commit or rollback.
 
279
Knowledge of inserts is not needed after a commit or rollback, therefore
 
280
the data can be discarded. */
 
281
UNIV_INTERN
 
282
void
 
283
trx_undo_insert_cleanup(
 
284
/*====================*/
 
285
        trx_t*  trx);   /* in: transaction handle */
 
286
/***************************************************************
 
287
Parses the redo log entry of an undo log page initialization. */
 
288
UNIV_INTERN
 
289
byte*
 
290
trx_undo_parse_page_init(
 
291
/*=====================*/
 
292
                        /* out: end of log record or NULL */
 
293
        byte*   ptr,    /* in: buffer */
 
294
        byte*   end_ptr,/* in: buffer end */
 
295
        page_t* page,   /* in: page or NULL */
 
296
        mtr_t*  mtr);   /* in: mtr or NULL */
 
297
/***************************************************************
 
298
Parses the redo log entry of an undo log page header create or reuse. */
 
299
UNIV_INTERN
 
300
byte*
 
301
trx_undo_parse_page_header(
 
302
/*=======================*/
 
303
                        /* out: end of log record or NULL */
 
304
        ulint   type,   /* in: MLOG_UNDO_HDR_CREATE or MLOG_UNDO_HDR_REUSE */
 
305
        byte*   ptr,    /* in: buffer */
 
306
        byte*   end_ptr,/* in: buffer end */
 
307
        page_t* page,   /* in: page or NULL */
 
308
        mtr_t*  mtr);   /* in: mtr or NULL */
 
309
/***************************************************************
 
310
Parses the redo log entry of an undo log page header discard. */
 
311
UNIV_INTERN
 
312
byte*
 
313
trx_undo_parse_discard_latest(
 
314
/*==========================*/
 
315
                        /* out: end of log record or NULL */
 
316
        byte*   ptr,    /* in: buffer */
 
317
        byte*   end_ptr,/* in: buffer end */
 
318
        page_t* page,   /* in: page or NULL */
 
319
        mtr_t*  mtr);   /* in: mtr or NULL */
 
320
 
 
321
/* Types of an undo log segment */
 
322
#define TRX_UNDO_INSERT         1       /* contains undo entries for inserts */
 
323
#define TRX_UNDO_UPDATE         2       /* contains undo entries for updates
 
324
                                        and delete markings: in short,
 
325
                                        modifys (the name 'UPDATE' is a
 
326
                                        historical relic) */
 
327
/* States of an undo log segment */
 
328
#define TRX_UNDO_ACTIVE         1       /* contains an undo log of an active
 
329
                                        transaction */
 
330
#define TRX_UNDO_CACHED         2       /* cached for quick reuse */
 
331
#define TRX_UNDO_TO_FREE        3       /* insert undo segment can be freed */
 
332
#define TRX_UNDO_TO_PURGE       4       /* update undo segment will not be
 
333
                                        reused: it can be freed in purge when
 
334
                                        all undo data in it is removed */
 
335
#define TRX_UNDO_PREPARED       5       /* contains an undo log of an
 
336
                                        prepared transaction */
 
337
 
 
338
/* Transaction undo log memory object; this is protected by the undo_mutex
 
339
in the corresponding transaction object */
 
340
 
 
341
struct trx_undo_struct{
 
342
        /*-----------------------------*/
 
343
        ulint           id;             /* undo log slot number within the
 
344
                                        rollback segment */
 
345
        ulint           type;           /* TRX_UNDO_INSERT or
 
346
                                        TRX_UNDO_UPDATE */
 
347
        ulint           state;          /* state of the corresponding undo log
 
348
                                        segment */
 
349
        ibool           del_marks;      /* relevant only in an update undo log:
 
350
                                        this is TRUE if the transaction may
 
351
                                        have delete marked records, because of
 
352
                                        a delete of a row or an update of an
 
353
                                        indexed field; purge is then
 
354
                                        necessary; also TRUE if the transaction
 
355
                                        has updated an externally stored
 
356
                                        field */
 
357
        dulint          trx_id;         /* id of the trx assigned to the undo
 
358
                                        log */
 
359
        XID             xid;            /* X/Open XA transaction
 
360
                                        identification */
 
361
        ibool           dict_operation; /* TRUE if a dict operation trx */
 
362
        dulint          table_id;       /* if a dict operation, then the table
 
363
                                        id */
 
364
        trx_rseg_t*     rseg;           /* rseg where the undo log belongs */
 
365
        /*-----------------------------*/
 
366
        ulint           space;          /* space id where the undo log
 
367
                                        placed */
 
368
        ulint           zip_size;       /* in: compressed page size of space
 
369
                                        in bytes, or 0 for uncompressed */
 
370
        ulint           hdr_page_no;    /* page number of the header page in
 
371
                                        the undo log */
 
372
        ulint           hdr_offset;     /* header offset of the undo log on the
 
373
                                        page */
 
374
        ulint           last_page_no;   /* page number of the last page in the
 
375
                                        undo log; this may differ from
 
376
                                        top_page_no during a rollback */
 
377
        ulint           size;           /* current size in pages */
 
378
        /*-----------------------------*/
 
379
        ulint           empty;          /* TRUE if the stack of undo log
 
380
                                        records is currently empty */
 
381
        ulint           top_page_no;    /* page number where the latest undo
 
382
                                        log record was catenated; during
 
383
                                        rollback the page from which the latest
 
384
                                        undo record was chosen */
 
385
        ulint           top_offset;     /* offset of the latest undo record,
 
386
                                        i.e., the topmost element in the undo
 
387
                                        log if we think of it as a stack */
 
388
        dulint          top_undo_no;    /* undo number of the latest record */
 
389
        buf_block_t*    guess_block;    /* guess for the buffer block where
 
390
                                        the top page might reside */
 
391
        /*-----------------------------*/
 
392
        UT_LIST_NODE_T(trx_undo_t) undo_list;
 
393
                                        /* undo log objects in the rollback
 
394
                                        segment are chained into lists */
 
395
};
 
396
 
 
397
/* The offset of the undo log page header on pages of the undo log */
 
398
#define TRX_UNDO_PAGE_HDR       FSEG_PAGE_DATA
 
399
/*-------------------------------------------------------------*/
 
400
/* Transaction undo log page header offsets */
 
401
#define TRX_UNDO_PAGE_TYPE      0       /* TRX_UNDO_INSERT or
 
402
                                        TRX_UNDO_UPDATE */
 
403
#define TRX_UNDO_PAGE_START     2       /* Byte offset where the undo log
 
404
                                        records for the LATEST transaction
 
405
                                        start on this page (remember that
 
406
                                        in an update undo log, the first page
 
407
                                        can contain several undo logs) */
 
408
#define TRX_UNDO_PAGE_FREE      4       /* On each page of the undo log this
 
409
                                        field contains the byte offset of the
 
410
                                        first free byte on the page */
 
411
#define TRX_UNDO_PAGE_NODE      6       /* The file list node in the chain
 
412
                                        of undo log pages */
 
413
/*-------------------------------------------------------------*/
 
414
#define TRX_UNDO_PAGE_HDR_SIZE  (6 + FLST_NODE_SIZE)
 
415
 
 
416
/* An update undo segment with just one page can be reused if it has
 
417
< this number bytes used; we must leave space at least for one new undo
 
418
log header on the page */
 
419
 
 
420
#define TRX_UNDO_PAGE_REUSE_LIMIT       (3 * UNIV_PAGE_SIZE / 4)
 
421
 
 
422
/* An update undo log segment may contain several undo logs on its first page
 
423
if the undo logs took so little space that the segment could be cached and
 
424
reused. All the undo log headers are then on the first page, and the last one
 
425
owns the undo log records on subsequent pages if the segment is bigger than
 
426
one page. If an undo log is stored in a segment, then on the first page it is
 
427
allowed to have zero undo records, but if the segment extends to several
 
428
pages, then all the rest of the pages must contain at least one undo log
 
429
record. */
 
430
 
 
431
/* The offset of the undo log segment header on the first page of the undo
 
432
log segment */
 
433
 
 
434
#define TRX_UNDO_SEG_HDR        (TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_HDR_SIZE)
 
435
/*-------------------------------------------------------------*/
 
436
#define TRX_UNDO_STATE          0       /* TRX_UNDO_ACTIVE, ... */
 
437
#define TRX_UNDO_LAST_LOG       2       /* Offset of the last undo log header
 
438
                                        on the segment header page, 0 if
 
439
                                        none */
 
440
#define TRX_UNDO_FSEG_HEADER    4       /* Header for the file segment which
 
441
                                        the undo log segment occupies */
 
442
#define TRX_UNDO_PAGE_LIST      (4 + FSEG_HEADER_SIZE)
 
443
                                        /* Base node for the list of pages in
 
444
                                        the undo log segment; defined only on
 
445
                                        the undo log segment's first page */
 
446
/*-------------------------------------------------------------*/
 
447
/* Size of the undo log segment header */
 
448
#define TRX_UNDO_SEG_HDR_SIZE   (4 + FSEG_HEADER_SIZE + FLST_BASE_NODE_SIZE)
 
449
 
 
450
 
 
451
/* The undo log header. There can be several undo log headers on the first
 
452
page of an update undo log segment. */
 
453
/*-------------------------------------------------------------*/
 
454
#define TRX_UNDO_TRX_ID         0       /* Transaction id */
 
455
#define TRX_UNDO_TRX_NO         8       /* Transaction number of the
 
456
                                        transaction; defined only if the log
 
457
                                        is in a history list */
 
458
#define TRX_UNDO_DEL_MARKS      16      /* Defined only in an update undo
 
459
                                        log: TRUE if the transaction may have
 
460
                                        done delete markings of records, and
 
461
                                        thus purge is necessary */
 
462
#define TRX_UNDO_LOG_START      18      /* Offset of the first undo log record
 
463
                                        of this log on the header page; purge
 
464
                                        may remove undo log record from the
 
465
                                        log start, and therefore this is not
 
466
                                        necessarily the same as this log
 
467
                                        header end offset */
 
468
#define TRX_UNDO_XID_EXISTS     20      /* TRUE if undo log header includes
 
469
                                        X/Open XA transaction identification
 
470
                                        XID */
 
471
#define TRX_UNDO_DICT_TRANS     21      /* TRUE if the transaction is a table
 
472
                                        create, index create, or drop
 
473
                                        transaction: in recovery
 
474
                                        the transaction cannot be rolled back
 
475
                                        in the usual way: a 'rollback' rather
 
476
                                        means dropping the created or dropped
 
477
                                        table, if it still exists */
 
478
#define TRX_UNDO_TABLE_ID       22      /* Id of the table if the preceding
 
479
                                        field is TRUE */
 
480
#define TRX_UNDO_NEXT_LOG       30      /* Offset of the next undo log header
 
481
                                        on this page, 0 if none */
 
482
#define TRX_UNDO_PREV_LOG       32      /* Offset of the previous undo log
 
483
                                        header on this page, 0 if none */
 
484
#define TRX_UNDO_HISTORY_NODE   34      /* If the log is put to the history
 
485
                                        list, the file list node is here */
 
486
/*-------------------------------------------------------------*/
 
487
#define TRX_UNDO_LOG_OLD_HDR_SIZE (34 + FLST_NODE_SIZE)
 
488
 
 
489
/* Note: the writing of the undo log old header is coded by a log record
 
490
MLOG_UNDO_HDR_CREATE or MLOG_UNDO_HDR_REUSE. The appending of an XID to the
 
491
header is logged separately. In this sense, the XID is not really a member
 
492
of the undo log header. TODO: do not append the XID to the log header if XA
 
493
is not needed by the user. The XID wastes about 150 bytes of space in every
 
494
undo log. In the history list we may have millions of undo logs, which means
 
495
quite a large overhead. */
 
496
 
 
497
/* X/Open XA Transaction Identification (XID) */
 
498
 
 
499
#define TRX_UNDO_XA_FORMAT      (TRX_UNDO_LOG_OLD_HDR_SIZE)
 
500
#define TRX_UNDO_XA_TRID_LEN    (TRX_UNDO_XA_FORMAT + 4)
 
501
#define TRX_UNDO_XA_BQUAL_LEN   (TRX_UNDO_XA_TRID_LEN + 4)
 
502
#define TRX_UNDO_XA_XID         (TRX_UNDO_XA_BQUAL_LEN + 4)
 
503
/*--------------------------------------------------------------*/
 
504
#define TRX_UNDO_LOG_XA_HDR_SIZE (TRX_UNDO_XA_XID + XIDDATASIZE)
 
505
                                /* Total size of the header with the XA XID */
 
506
 
 
507
#ifndef UNIV_NONINL
 
508
#include "trx0undo.ic"
 
509
#endif
 
510
 
 
511
#endif