← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/trx/trx0undo.c

  • Committer: Monty Taylor
  • Date: 2008-09-15 17:24:04 UTC
  • Revision ID: monty@inaugust.com-20080915172404-ygh6hiyu0q7qpa9x
Removed strndup calls.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/trx/trx0undo.c
98
98
                                TRX_UNDO_UPDATE */
99
99
        dulint          trx_id, /* in: id of the trx for which the undo log
100
100
                                is created */
101
 
        const XID*      xid,    /* in: X/Open XA transaction identification*/
 
101
        XID*            xid,    /* in: X/Open XA transaction identification*/
102
102
        ulint           page_no,/* in: undo log header page number */
103
103
        ulint           offset);/* in: undo log header byte offset on page */
104
104
/*******************************************************************
138
138
        ulint           offset, /* in: undo log header offset on page */
139
139
        mtr_t*          mtr)    /* in: mtr */
140
140
{
141
 
        ulint   space;
142
 
        ulint   zip_size;
143
141
        ulint   prev_page_no;
144
142
        page_t* prev_page;
145
143
        page_t* undo_page;
146
144
 
147
 
        undo_page = page_align(rec);
 
145
        undo_page = buf_frame_align(rec);
148
146
 
149
147
        prev_page_no = flst_get_prev_addr(undo_page + TRX_UNDO_PAGE_HDR
150
148
                                          + TRX_UNDO_PAGE_NODE, mtr)
155
153
                return(NULL);
156
154
        }
157
155
 
158
 
        space = page_get_space_id(undo_page);
159
 
        zip_size = fil_space_get_zip_size(space);
160
 
 
161
 
        prev_page = trx_undo_page_get_s_latched(space, zip_size,
162
 
                                                prev_page_no, mtr);
 
156
        prev_page = trx_undo_page_get_s_latched(
 
157
                buf_frame_get_space_id(undo_page), prev_page_no, mtr);
163
158
 
164
159
        return(trx_undo_page_get_last_rec(prev_page, page_no, offset));
165
160
}
166
161
 
167
162
/***************************************************************************
168
163
Gets the previous record in an undo log. */
169
 
UNIV_INTERN
 
164
 
170
165
trx_undo_rec_t*
171
166
trx_undo_get_prev_rec(
172
167
/*==================*/
201
196
/*=================================*/
202
197
                        /* out: undo log record, the page latched, NULL if
203
198
                        none */
204
 
        ulint   space,  /* in: undo log header space */
205
 
        ulint   zip_size,/* in: compressed page size in bytes
206
 
                        or 0 for uncompressed pages */
207
199
        page_t* undo_page, /* in: undo log page */
208
200
        ulint   page_no,/* in: undo log header page number */
209
201
        ulint   offset, /* in: undo log header offset on page */
213
205
        trx_ulogf_t*    log_hdr;
214
206
        ulint           next_page_no;
215
207
        page_t*         next_page;
 
208
        ulint           space;
216
209
        ulint           next;
217
210
 
218
 
        if (page_no == page_get_page_no(undo_page)) {
 
211
        if (page_no == buf_frame_get_page_no(undo_page)) {
219
212
 
220
213
                log_hdr = undo_page + offset;
221
214
                next = mach_read_from_2(log_hdr + TRX_UNDO_NEXT_LOG);
226
219
                }
227
220
        }
228
221
 
 
222
        space = buf_frame_get_space_id(undo_page);
 
223
 
229
224
        next_page_no = flst_get_next_addr(undo_page + TRX_UNDO_PAGE_HDR
230
225
                                          + TRX_UNDO_PAGE_NODE, mtr)
231
226
                .page;
235
230
        }
236
231
 
237
232
        if (mode == RW_S_LATCH) {
238
 
                next_page = trx_undo_page_get_s_latched(space, zip_size,
239
 
                                                        next_page_no, mtr);
 
233
                next_page = trx_undo_page_get_s_latched(space, next_page_no,
 
234
                                                        mtr);
240
235
        } else {
241
236
                ut_ad(mode == RW_X_LATCH);
242
 
                next_page = trx_undo_page_get(space, zip_size,
243
 
                                              next_page_no, mtr);
 
237
                next_page = trx_undo_page_get(space, next_page_no, mtr);
244
238
        }
245
239
 
246
240
        return(trx_undo_page_get_first_rec(next_page, page_no, offset));
248
242
 
249
243
/***************************************************************************
250
244
Gets the next record in an undo log. */
251
 
UNIV_INTERN
 
245
 
252
246
trx_undo_rec_t*
253
247
trx_undo_get_next_rec(
254
248
/*==================*/
259
253
        ulint           offset, /* in: undo log header offset on page */
260
254
        mtr_t*          mtr)    /* in: mtr */
261
255
{
262
 
        ulint           space;
263
 
        ulint           zip_size;
264
256
        trx_undo_rec_t* next_rec;
265
257
 
266
258
        next_rec = trx_undo_page_get_next_rec(rec, page_no, offset);
269
261
                return(next_rec);
270
262
        }
271
263
 
272
 
        space = page_get_space_id(page_align(rec));
273
 
        zip_size = fil_space_get_zip_size(space);
274
 
 
275
 
        return(trx_undo_get_next_rec_from_next_page(space, zip_size,
276
 
                                                    page_align(rec),
 
264
        return(trx_undo_get_next_rec_from_next_page(buf_frame_align(rec),
277
265
                                                    page_no, offset,
278
266
                                                    RW_S_LATCH, mtr));
279
267
}
280
268
 
281
269
/***************************************************************************
282
270
Gets the first record in an undo log. */
283
 
UNIV_INTERN
 
271
 
284
272
trx_undo_rec_t*
285
273
trx_undo_get_first_rec(
286
274
/*===================*/
287
275
                        /* out: undo log record, the page latched, NULL if
288
276
                        none */
289
277
        ulint   space,  /* in: undo log header space */
290
 
        ulint   zip_size,/* in: compressed page size in bytes
291
 
                        or 0 for uncompressed pages */
292
278
        ulint   page_no,/* in: undo log header page number */
293
279
        ulint   offset, /* in: undo log header offset on page */
294
280
        ulint   mode,   /* in: latching mode: RW_S_LATCH or RW_X_LATCH */
298
284
        trx_undo_rec_t* rec;
299
285
 
300
286
        if (mode == RW_S_LATCH) {
301
 
                undo_page = trx_undo_page_get_s_latched(space, zip_size,
302
 
                                                        page_no, mtr);
 
287
                undo_page = trx_undo_page_get_s_latched(space, page_no, mtr);
303
288
        } else {
304
 
                undo_page = trx_undo_page_get(space, zip_size, page_no, mtr);
 
289
                undo_page = trx_undo_page_get(space, page_no, mtr);
305
290
        }
306
291
 
307
292
        rec = trx_undo_page_get_first_rec(undo_page, page_no, offset);
310
295
                return(rec);
311
296
        }
312
297
 
313
 
        return(trx_undo_get_next_rec_from_next_page(space, zip_size,
314
 
                                                    undo_page, page_no, offset,
 
298
        return(trx_undo_get_next_rec_from_next_page(undo_page, page_no, offset,
315
299
                                                    mode, mtr));
316
300
}
317
301
 
334
318
 
335
319
/***************************************************************
336
320
Parses the redo log entry of an undo log page initialization. */
337
 
UNIV_INTERN
 
321
 
338
322
byte*
339
323
trx_undo_parse_page_init(
340
324
/*=====================*/
409
393
{
410
394
        ulint           slot_no;
411
395
        ulint           space;
412
 
        buf_block_t*    block;
413
396
        trx_upagef_t*   page_hdr;
414
397
        trx_usegf_t*    seg_hdr;
415
398
        ulint           n_reserved;
435
418
                return(DB_TOO_MANY_CONCURRENT_TRXS);
436
419
        }
437
420
 
438
 
        space = page_get_space_id(page_align(rseg_hdr));
 
421
        space = buf_frame_get_space_id(rseg_hdr);
439
422
 
440
423
        success = fsp_reserve_free_extents(&n_reserved, space, 2, FSP_UNDO,
441
424
                                           mtr);
445
428
        }
446
429
 
447
430
        /* Allocate a new file segment for the undo log */
448
 
        block = fseg_create_general(space, 0,
449
 
                                    TRX_UNDO_SEG_HDR
450
 
                                    + TRX_UNDO_FSEG_HEADER, TRUE, mtr);
 
431
        *undo_page = fseg_create_general(space, 0,
 
432
                                        TRX_UNDO_SEG_HDR
 
433
                                        + TRX_UNDO_FSEG_HEADER, TRUE, mtr);
451
434
 
452
435
        fil_space_release_free_extents(space, n_reserved);
453
436
 
454
 
        if (block == NULL) {
 
437
        if (*undo_page == NULL) {
455
438
                /* No space left */
456
439
 
457
440
                return(DB_OUT_OF_FILE_SPACE);
458
441
        }
459
442
 
460
443
#ifdef UNIV_SYNC_DEBUG
461
 
        buf_block_dbg_add_level(block, SYNC_TRX_UNDO_PAGE);
 
444
        buf_page_dbg_add_level(*undo_page, SYNC_TRX_UNDO_PAGE);
462
445
#endif /* UNIV_SYNC_DEBUG */
463
 
        *undo_page = buf_block_get_frame(block);
464
446
 
465
447
        page_hdr = *undo_page + TRX_UNDO_PAGE_HDR;
466
448
        seg_hdr = *undo_page + TRX_UNDO_SEG_HDR;
479
461
                      page_hdr + TRX_UNDO_PAGE_NODE, mtr);
480
462
 
481
463
        trx_rsegf_set_nth_undo(rseg_hdr, slot_no,
482
 
                               page_get_page_no(*undo_page), mtr);
 
464
                                buf_frame_get_page_no(*undo_page), mtr);
 
465
 
483
466
        *id = slot_no;
484
467
 
485
468
        return(err);
669
652
 
670
653
/***************************************************************
671
654
Parses the redo log entry of an undo log page header create or reuse. */
672
 
UNIV_INTERN
 
655
 
673
656
byte*
674
657
trx_undo_parse_page_header(
675
658
/*=======================*/
775
758
 
776
759
/***************************************************************
777
760
Parses the redo log entry of an undo log page header discard. */
778
 
UNIV_INTERN
 
761
 
779
762
byte*
780
763
trx_undo_parse_discard_latest(
781
764
/*==========================*/
838
821
 
839
822
/************************************************************************
840
823
Tries to add a page to the undo log segment where the undo log is placed. */
841
 
UNIV_INTERN
 
824
 
842
825
ulint
843
826
trx_undo_add_page(
844
827
/*==============*/
868
851
                return(FIL_NULL);
869
852
        }
870
853
 
871
 
        header_page = trx_undo_page_get(undo->space, undo->zip_size,
872
 
                                        undo->hdr_page_no, mtr);
 
854
        header_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
873
855
 
874
856
        success = fsp_reserve_free_extents(&n_reserved, undo->space, 1,
875
857
                                           FSP_UNDO, mtr);
894
876
 
895
877
        undo->last_page_no = page_no;
896
878
 
897
 
        new_page = trx_undo_page_get(undo->space, undo->zip_size,
898
 
                                     page_no, mtr);
 
879
        new_page = trx_undo_page_get(undo->space, page_no, mtr);
899
880
 
900
881
        trx_undo_page_init(new_page, undo->type, mtr);
901
882
 
930
911
        fil_addr_t      last_addr;
931
912
        trx_rsegf_t*    rseg_header;
932
913
        ulint           hist_size;
933
 
        ulint           zip_size;
934
914
 
935
915
        ut_a(hdr_page_no != page_no);
936
916
        ut_ad(!mutex_own(&kernel_mutex));
937
917
        ut_ad(mutex_own(&(rseg->mutex)));
938
918
 
939
 
        zip_size = rseg->zip_size;
940
 
 
941
 
        undo_page = trx_undo_page_get(space, zip_size, page_no, mtr);
942
 
 
943
 
        header_page = trx_undo_page_get(space, zip_size, hdr_page_no, mtr);
 
919
        undo_page = trx_undo_page_get(space, page_no, mtr);
 
920
 
 
921
        header_page = trx_undo_page_get(space, hdr_page_no, mtr);
944
922
 
945
923
        flst_remove(header_page + TRX_UNDO_SEG_HDR + TRX_UNDO_PAGE_LIST,
946
924
                    undo_page + TRX_UNDO_PAGE_HDR + TRX_UNDO_PAGE_NODE, mtr);
953
931
        rseg->curr_size--;
954
932
 
955
933
        if (in_history) {
956
 
                rseg_header = trx_rsegf_get(space, zip_size,
957
 
                                            rseg->page_no, mtr);
 
934
                rseg_header = trx_rsegf_get(space, rseg->page_no, mtr);
958
935
 
959
936
                hist_size = mtr_read_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
960
937
                                           MLOG_4BYTES, mtr);
1001
978
trx_undo_empty_header_page(
1002
979
/*=======================*/
1003
980
        ulint   space,          /* in: space */
1004
 
        ulint   zip_size,       /* in: compressed page size in bytes
1005
 
                                or 0 for uncompressed pages */
1006
981
        ulint   hdr_page_no,    /* in: header page number */
1007
982
        ulint   hdr_offset,     /* in: header offset */
1008
983
        mtr_t*  mtr)            /* in: mtr */
1011
986
        trx_ulogf_t*    log_hdr;
1012
987
        ulint           end;
1013
988
 
1014
 
        header_page = trx_undo_page_get(space, zip_size, hdr_page_no, mtr);
 
989
        header_page = trx_undo_page_get(space, hdr_page_no, mtr);
1015
990
 
1016
991
        log_hdr = header_page + hdr_offset;
1017
992
 
1023
998
/***************************************************************************
1024
999
Truncates an undo log from the end. This function is used during a rollback
1025
1000
to free space from an undo log. */
1026
 
UNIV_INTERN
 
1001
 
1027
1002
void
1028
1003
trx_undo_truncate_end(
1029
1004
/*==================*/
1051
1026
 
1052
1027
                last_page_no = undo->last_page_no;
1053
1028
 
1054
 
                undo_page = trx_undo_page_get(undo->space, undo->zip_size,
1055
 
                                              last_page_no, &mtr);
 
1029
                undo_page = trx_undo_page_get(undo->space, last_page_no, &mtr);
1056
1030
 
1057
1031
                rec = trx_undo_page_get_last_rec(undo_page, undo->hdr_page_no,
1058
1032
                                                 undo->hdr_offset);
1098
1072
/***************************************************************************
1099
1073
Truncates an undo log from the start. This function is used during a purge
1100
1074
operation. */
1101
 
UNIV_INTERN
 
1075
 
1102
1076
void
1103
1077
trx_undo_truncate_start(
1104
1078
/*====================*/
1120
1094
 
1121
1095
        ut_ad(mutex_own(&(rseg->mutex)));
1122
1096
 
1123
 
        if (ut_dulint_is_zero(limit)) {
 
1097
        if (0 == ut_dulint_cmp(limit, ut_dulint_zero)) {
1124
1098
 
1125
1099
                return;
1126
1100
        }
1127
1101
loop:
1128
1102
        mtr_start(&mtr);
1129
1103
 
1130
 
        rec = trx_undo_get_first_rec(space, rseg->zip_size,
1131
 
                                     hdr_page_no, hdr_offset,
 
1104
        rec = trx_undo_get_first_rec(space, hdr_page_no, hdr_offset,
1132
1105
                                     RW_X_LATCH, &mtr);
1133
1106
        if (rec == NULL) {
1134
1107
                /* Already empty */
1138
1111
                return;
1139
1112
        }
1140
1113
 
1141
 
        undo_page = page_align(rec);
 
1114
        undo_page = buf_frame_align(rec);
1142
1115
 
1143
1116
        last_rec = trx_undo_page_get_last_rec(undo_page, hdr_page_no,
1144
1117
                                              hdr_offset);
1149
1122
                return;
1150
1123
        }
1151
1124
 
1152
 
        page_no = page_get_page_no(undo_page);
 
1125
        page_no = buf_frame_get_page_no(undo_page);
1153
1126
 
1154
1127
        if (page_no == hdr_page_no) {
1155
 
                trx_undo_empty_header_page(space, rseg->zip_size,
1156
 
                                           hdr_page_no, hdr_offset,
 
1128
                trx_undo_empty_header_page(space, hdr_page_no, hdr_offset,
1157
1129
                                           &mtr);
1158
1130
        } else {
1159
1131
                trx_undo_free_page(rseg, TRUE, space, hdr_page_no,
1180
1152
        ibool           finished;
1181
1153
        mtr_t           mtr;
1182
1154
 
 
1155
        finished = FALSE;
1183
1156
        rseg = undo->rseg;
1184
1157
 
1185
 
        do {
 
1158
        while (!finished) {
1186
1159
 
1187
1160
                mtr_start(&mtr);
1188
1161
 
1190
1163
 
1191
1164
                mutex_enter(&(rseg->mutex));
1192
1165
 
1193
 
                seg_header = trx_undo_page_get(undo->space, undo->zip_size,
1194
 
                                               undo->hdr_page_no,
 
1166
                seg_header = trx_undo_page_get(undo->space, undo->hdr_page_no,
1195
1167
                                               &mtr) + TRX_UNDO_SEG_HDR;
1196
1168
 
1197
1169
                file_seg = seg_header + TRX_UNDO_FSEG_HEADER;
1200
1172
 
1201
1173
                if (finished) {
1202
1174
                        /* Update the rseg header */
1203
 
                        rseg_header = trx_rsegf_get(
1204
 
                                rseg->space, rseg->zip_size, rseg->page_no,
1205
 
                                &mtr);
 
1175
                        rseg_header = trx_rsegf_get(rseg->space, rseg->page_no,
 
1176
                                                    &mtr);
1206
1177
                        trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL,
1207
1178
                                               &mtr);
1208
1179
                }
1209
1180
 
1210
1181
                mutex_exit(&(rseg->mutex));
1211
1182
                mtr_commit(&mtr);
1212
 
        } while (!finished);
 
1183
        }
1213
1184
}
1214
1185
 
1215
1186
/*========== UNDO LOG MEMORY COPY INITIALIZATION =====================*/
1249
1220
                ut_error;
1250
1221
        }
1251
1222
 
1252
 
        undo_page = trx_undo_page_get(rseg->space, rseg->zip_size,
1253
 
                                      page_no, mtr);
 
1223
        undo_page = trx_undo_page_get(rseg->space, page_no, mtr);
1254
1224
 
1255
1225
        page_header = undo_page + TRX_UNDO_PAGE_HDR;
1256
1226
 
1303
1273
        undo->last_page_no = last_addr.page;
1304
1274
        undo->top_page_no = last_addr.page;
1305
1275
 
1306
 
        last_page = trx_undo_page_get(rseg->space, rseg->zip_size,
1307
 
                                      undo->last_page_no, mtr);
 
1276
        last_page = trx_undo_page_get(rseg->space, undo->last_page_no, mtr);
1308
1277
 
1309
1278
        rec = trx_undo_page_get_last_rec(last_page, page_no, offset);
1310
1279
 
1342
1311
Initializes the undo log lists for a rollback segment memory copy. This
1343
1312
function is only called when the database is started or a new rollback
1344
1313
segment is created. */
1345
 
UNIV_INTERN
 
1314
 
1346
1315
ulint
1347
1316
trx_undo_lists_init(
1348
1317
/*================*/
1364
1333
 
1365
1334
        mtr_start(&mtr);
1366
1335
 
1367
 
        rseg_header = trx_rsegf_get_new(rseg->space, rseg->zip_size,
1368
 
                                        rseg->page_no, &mtr);
 
1336
        rseg_header = trx_rsegf_get_new(rseg->space, rseg->page_no, &mtr);
1369
1337
 
1370
1338
        for (i = 0; i < TRX_RSEG_N_SLOTS; i++) {
1371
1339
                page_no = trx_rsegf_get_nth_undo(rseg_header, i, &mtr);
1386
1354
 
1387
1355
                        mtr_start(&mtr);
1388
1356
 
1389
 
                        rseg_header = trx_rsegf_get(
1390
 
                                rseg->space, rseg->zip_size, rseg->page_no,
1391
 
                                &mtr);
 
1357
                        rseg_header = trx_rsegf_get(rseg->space,
 
1358
                                                    rseg->page_no, &mtr);
1392
1359
                }
1393
1360
        }
1394
1361
 
1410
1377
                                TRX_UNDO_UPDATE */
1411
1378
        dulint          trx_id, /* in: id of the trx for which the undo log
1412
1379
                                is created */
1413
 
        const XID*      xid,    /* in: X/Open transaction identification */
 
1380
        XID*            xid,    /* in: X/Open transaction identification */
1414
1381
        ulint           page_no,/* in: undo log header page number */
1415
1382
        ulint           offset) /* in: undo log header byte offset on page */
1416
1383
{
1443
1410
        undo->rseg = rseg;
1444
1411
 
1445
1412
        undo->space = rseg->space;
1446
 
        undo->zip_size = rseg->zip_size;
1447
1413
        undo->hdr_page_no = page_no;
1448
1414
        undo->hdr_offset = offset;
1449
1415
        undo->last_page_no = page_no;
1451
1417
 
1452
1418
        undo->empty = TRUE;
1453
1419
        undo->top_page_no = page_no;
1454
 
        undo->guess_block = NULL;
 
1420
        undo->guess_page = NULL;
1455
1421
 
1456
1422
        return(undo);
1457
1423
}
1465
1431
        trx_undo_t*     undo,   /* in: undo log to init */
1466
1432
        dulint          trx_id, /* in: id of the trx for which the undo log
1467
1433
                                is created */
1468
 
        const XID*      xid,    /* in: X/Open XA transaction identification*/
 
1434
        XID*            xid,    /* in: X/Open XA transaction identification*/
1469
1435
        ulint           offset) /* in: undo log header byte offset on page */
1470
1436
{
1471
1437
        ut_ad(mutex_own(&((undo->rseg)->mutex)));
1524
1490
                                TRX_UNDO_UPDATE */
1525
1491
        dulint          trx_id, /* in: id of the trx for which the undo log
1526
1492
                                is created */
1527
 
        const XID*      xid,    /* in: X/Open transaction identification*/
 
1493
        XID*            xid,    /* in: X/Open transaction identification*/
1528
1494
        trx_undo_t**    undo,   /* out: the new undo log object, undefined
1529
1495
                                 * if did not succeed */
1530
1496
        mtr_t*          mtr)    /* in: mtr */
1545
1511
 
1546
1512
        rseg->curr_size++;
1547
1513
 
1548
 
        rseg_header = trx_rsegf_get(rseg->space, rseg->zip_size, rseg->page_no,
1549
 
                                    mtr);
 
1514
        rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
1550
1515
 
1551
1516
        err = trx_undo_seg_create(rseg, rseg_header, type, &id,
1552
 
                                  &undo_page, mtr);
 
1517
                                                        &undo_page, mtr);
1553
1518
 
1554
1519
        if (err != DB_SUCCESS) {
1555
1520
                /* Did not succeed */
1559
1524
                return(err);
1560
1525
        }
1561
1526
 
1562
 
        page_no = page_get_page_no(undo_page);
 
1527
        page_no = buf_frame_get_page_no(undo_page);
1563
1528
 
1564
1529
        offset = trx_undo_header_create(undo_page, trx_id, mtr);
1565
1530
 
1594
1559
                                TRX_UNDO_UPDATE */
1595
1560
        dulint          trx_id, /* in: id of the trx for which the undo log
1596
1561
                                is used */
1597
 
        const XID*      xid,    /* in: X/Open XA transaction identification */
 
1562
        XID*            xid,    /* in: X/Open XA transaction identification */
1598
1563
        mtr_t*          mtr)    /* in: mtr */
1599
1564
{
1600
1565
        trx_undo_t*     undo;
1633
1598
                ut_error;
1634
1599
        }
1635
1600
 
1636
 
        undo_page = trx_undo_page_get(undo->space, undo->zip_size,
1637
 
                                      undo->hdr_page_no, mtr);
 
1601
        undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
1638
1602
 
1639
1603
        if (type == TRX_UNDO_INSERT) {
1640
1604
                offset = trx_undo_insert_header_reuse(undo_page, trx_id, mtr);
1674
1638
{
1675
1639
        page_t* hdr_page;
1676
1640
 
1677
 
        hdr_page = trx_undo_page_get(undo->space, undo->zip_size,
1678
 
                                     undo->hdr_page_no, mtr);
 
1641
        ut_a(trx->dict_operation);
1679
1642
 
1680
 
        switch (trx_get_dict_operation(trx)) {
1681
 
        case TRX_DICT_OP_NONE:
1682
 
                ut_error;
1683
 
        case TRX_DICT_OP_INDEX:
1684
 
                /* Do not discard the table on recovery. */
1685
 
                undo->table_id = ut_dulint_zero;
1686
 
                break;
1687
 
        case TRX_DICT_OP_TABLE:
1688
 
                undo->table_id = trx->table_id;
1689
 
                break;
1690
 
        }
 
1643
        hdr_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
1691
1644
 
1692
1645
        mlog_write_ulint(hdr_page + undo->hdr_offset
1693
1646
                         + TRX_UNDO_DICT_TRANS,
1694
 
                         TRUE, MLOG_1BYTE, mtr);
 
1647
                         trx->dict_operation, MLOG_1BYTE, mtr);
1695
1648
 
1696
1649
        mlog_write_dulint(hdr_page + undo->hdr_offset + TRX_UNDO_TABLE_ID,
1697
 
                          undo->table_id, mtr);
 
1650
                          trx->table_id, mtr);
1698
1651
 
1699
 
        undo->dict_operation = TRUE;
 
1652
        undo->dict_operation = trx->dict_operation;
 
1653
        undo->table_id = trx->table_id;
1700
1654
}
1701
1655
 
1702
1656
/**************************************************************************
1703
1657
Assigns an undo log for a transaction. A new undo log is created or a cached
1704
1658
undo log reused. */
1705
 
UNIV_INTERN
 
1659
 
1706
1660
ulint
1707
1661
trx_undo_assign_undo(
1708
1662
/*=================*/
1752
1706
                trx->update_undo = undo;
1753
1707
        }
1754
1708
 
1755
 
        if (trx_get_dict_operation(trx) != TRX_DICT_OP_NONE) {
 
1709
        if (trx->dict_operation) {
1756
1710
                trx_undo_mark_as_dict_operation(trx, undo, &mtr);
1757
1711
        }
1758
1712
 
1765
1719
 
1766
1720
/**********************************************************************
1767
1721
Sets the state of the undo log segment at a transaction finish. */
1768
 
UNIV_INTERN
 
1722
 
1769
1723
page_t*
1770
1724
trx_undo_set_state_at_finish(
1771
1725
/*=========================*/
1793
1747
                ut_error;
1794
1748
        }
1795
1749
 
1796
 
        undo_page = trx_undo_page_get(undo->space, undo->zip_size,
1797
 
                                      undo->hdr_page_no, mtr);
 
1750
        undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
1798
1751
 
1799
1752
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
1800
1753
        page_hdr = undo_page + TRX_UNDO_PAGE_HDR;
1833
1786
 
1834
1787
/**********************************************************************
1835
1788
Sets the state of the undo log segment at a transaction prepare. */
1836
 
UNIV_INTERN
 
1789
 
1837
1790
page_t*
1838
1791
trx_undo_set_state_at_prepare(
1839
1792
/*==========================*/
1858
1811
                ut_error;
1859
1812
        }
1860
1813
 
1861
 
        undo_page = trx_undo_page_get(undo->space, undo->zip_size,
1862
 
                                      undo->hdr_page_no, mtr);
 
1814
        undo_page = trx_undo_page_get(undo->space, undo->hdr_page_no, mtr);
1863
1815
 
1864
1816
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
1865
1817
        page_hdr = undo_page + TRX_UNDO_PAGE_HDR;
1887
1839
Adds the update undo log header as the first in the history list, and
1888
1840
frees the memory object, or puts it to the list of cached update undo log
1889
1841
segments. */
1890
 
UNIV_INTERN
 
1842
 
1891
1843
void
1892
1844
trx_undo_update_cleanup(
1893
1845
/*====================*/
1924
1876
Frees or caches an insert undo log after a transaction commit or rollback.
1925
1877
Knowledge of inserts is not needed after a commit or rollback, therefore
1926
1878
the data can be discarded. */
1927
 
UNIV_INTERN
 
1879
 
1928
1880
void
1929
1881
trx_undo_insert_cleanup(
1930
1882
/*====================*/