← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2008-11-04 15:39:09 UTC
  • mfrom: (575.1.2 devel)
  • Revision ID: brian@tangent.org-20081104153909-c72hn65udxs1ccal
Merge of Monty's work

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