← Back to branch summary

~ubuntu-branches/ubuntu/lucid/mysql-dfsg-5.1/lucid-security

« back to all changes in this revision

Viewing changes to storage/innodb_plugin/dict/dict0crea.c

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-02-22 22:33:55 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120222223355-or06x1euyk8n0ldi
Tags: 5.1.61-0ubuntu0.10.04.1
https://launchpad.net/bugs/937869
* SECURITY UPDATE: Update to 5.1.61 to fix multiple security issues
  (LP: #937869)
  - http://www.oracle.com/technetwork/topics/security/cpujan2012-366304.html
  - CVE-2011-2262
  - CVE-2012-0075
  - CVE-2012-0112
  - CVE-2012-0113
  - CVE-2012-0114
  - CVE-2012-0115
  - CVE-2012-0116
  - CVE-2012-0117
  - CVE-2012-0118
  - CVE-2012-0119
  - CVE-2012-0120
  - CVE-2012-0484
  - CVE-2012-0485
  - CVE-2012-0486
  - CVE-2012-0487
  - CVE-2012-0488
  - CVE-2012-0489
  - CVE-2012-0490
  - CVE-2012-0491
  - CVE-2012-0492
  - CVE-2012-0493
  - CVE-2012-0494
  - CVE-2012-0495
  - CVE-2012-0496
* Dropped patches unnecessary with 5.1.61:
  - debian/patches/90_mysql_safer_strmov.dpatch
  - debian/patches/51_ssl_test_certs.dpatch
  - debian/patches/52_CVE-2009-4030.dpatch
  - debian/patches/53_CVE-2009-4484.dpatch
  - debian/patches/54_CVE-2008-7247.dpatch
  - debian/patches/55_CVE-2010-1621.dpatch
  - debian/patches/56_CVE-2010-1850.dpatch
  - debian/patches/57_CVE-2010-1849.dpatch
  - debian/patches/58_CVE-2010-1848.dpatch
  - debian/patches/59_CVE-2010-1626.dpatch
  - debian/patches/60_CVE-2010-2008.dpatch
  - debian/patches/60_CVE-2010-3677.dpatch
  - debian/patches/60_CVE-2010-3678.dpatch
  - debian/patches/60_CVE-2010-3679.dpatch
  - debian/patches/60_CVE-2010-3680.dpatch
  - debian/patches/60_CVE-2010-3681.dpatch
  - debian/patches/60_CVE-2010-3682.dpatch
  - debian/patches/60_CVE-2010-3683.dpatch
  - debian/patches/60_CVE-2010-3833.dpatch
  - debian/patches/60_CVE-2010-3834.dpatch
  - debian/patches/60_CVE-2010-3835.dpatch
  - debian/patches/60_CVE-2010-3836.dpatch
  - debian/patches/60_CVE-2010-3837.dpatch
  - debian/patches/60_CVE-2010-3838.dpatch
  - debian/patches/60_CVE-2010-3839.dpatch
  - debian/patches/60_CVE-2010-3840.dpatch
  - debian/patches/61_disable_longfilename_test.dpatch
  - debian/patches/62_alter_table_fix.dpatch
  - debian/patches/63_cherrypick-upstream-49479.dpatch
  - debian/patches/10_readline_build_fix.dpatch
* debian/mysql-client-5.1.docs: removed EXCEPTIONS-CLIENT file
* debian/mysql-server-5.1.docs,debian/libmysqlclient16.docs,
  debian/libmysqlclient-dev.docs: removed, no longer necessary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innodb_plugin/dict/dict0crea.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1996, 2011, Oracle and/or its affiliates. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
51
51
dtuple_t*
52
52
dict_create_sys_tables_tuple(
53
53
/*=========================*/
54
 
        dict_table_t*   table,  /*!< in: table */
55
 
        mem_heap_t*     heap)   /*!< in: memory heap from which the memory for
56
 
                                the built tuple is allocated */
 
54
        const dict_table_t*     table,  /*!< in: table */
 
55
        mem_heap_t*             heap)   /*!< in: memory heap from
 
56
                                        which the memory for the built
 
57
                                        tuple is allocated */
57
58
{
58
59
        dict_table_t*   sys_tables;
59
60
        dtuple_t*       entry;
60
61
        dfield_t*       dfield;
61
62
        byte*           ptr;
62
63
 
63
 
        ut_ad(table && heap);
 
64
        ut_ad(table);
 
65
        ut_ad(heap);
64
66
 
65
67
        sys_tables = dict_sys->sys_tables;
66
68
 
69
71
        dict_table_copy_types(entry, sys_tables);
70
72
 
71
73
        /* 0: NAME -----------------------------*/
72
 
        dfield = dtuple_get_nth_field(entry, 0);
 
74
        dfield = dtuple_get_nth_field(entry, 0/*NAME*/);
73
75
 
74
76
        dfield_set_data(dfield, table->name, ut_strlen(table->name));
75
77
        /* 3: ID -------------------------------*/
76
 
        dfield = dtuple_get_nth_field(entry, 1);
 
78
        dfield = dtuple_get_nth_field(entry, 1/*ID*/);
77
79
 
78
80
        ptr = mem_heap_alloc(heap, 8);
79
81
        mach_write_to_8(ptr, table->id);
80
82
 
81
83
        dfield_set_data(dfield, ptr, 8);
82
84
        /* 4: N_COLS ---------------------------*/
83
 
        dfield = dtuple_get_nth_field(entry, 2);
 
85
        dfield = dtuple_get_nth_field(entry, 2/*N_COLS*/);
84
86
 
85
87
#if DICT_TF_COMPACT != 1
86
88
#error
91
93
                        | ((table->flags & DICT_TF_COMPACT) << 31));
92
94
        dfield_set_data(dfield, ptr, 4);
93
95
        /* 5: TYPE -----------------------------*/
94
 
        dfield = dtuple_get_nth_field(entry, 3);
 
96
        dfield = dtuple_get_nth_field(entry, 3/*TYPE*/);
95
97
 
96
98
        ptr = mem_heap_alloc(heap, 4);
97
 
        if (table->flags & ~DICT_TF_COMPACT) {
 
99
        if (table->flags & (~DICT_TF_COMPACT & ~(~0 << DICT_TF_BITS))) {
98
100
                ut_a(table->flags & DICT_TF_COMPACT);
99
101
                ut_a(dict_table_get_format(table) >= DICT_TF_FORMAT_ZIP);
100
102
                ut_a((table->flags & DICT_TF_ZSSIZE_MASK)
101
103
                     <= (DICT_TF_ZSSIZE_MAX << DICT_TF_ZSSIZE_SHIFT));
102
 
                ut_a(!(table->flags & (~0 << DICT_TF_BITS)));
103
 
                mach_write_to_4(ptr, table->flags);
 
104
                ut_a(!(table->flags & (~0 << DICT_TF2_BITS)));
 
105
                mach_write_to_4(ptr, table->flags & ~(~0 << DICT_TF_BITS));
104
106
        } else {
105
107
                mach_write_to_4(ptr, DICT_TABLE_ORDINARY);
106
108
        }
107
109
 
108
110
        dfield_set_data(dfield, ptr, 4);
109
111
        /* 6: MIX_ID (obsolete) ---------------------------*/
110
 
        dfield = dtuple_get_nth_field(entry, 4);
 
112
        dfield = dtuple_get_nth_field(entry, 4/*MIX_ID*/);
111
113
 
112
114
        ptr = mem_heap_zalloc(heap, 8);
113
115
 
114
116
        dfield_set_data(dfield, ptr, 8);
115
 
        /* 7: MIX_LEN (obsolete) --------------------------*/
116
 
 
117
 
        dfield = dtuple_get_nth_field(entry, 5);
118
 
 
119
 
        ptr = mem_heap_zalloc(heap, 4);
 
117
        /* 7: MIX_LEN (additional flags) --------------------------*/
 
118
 
 
119
        dfield = dtuple_get_nth_field(entry, 5/*MIX_LEN*/);
 
120
 
 
121
        ptr = mem_heap_alloc(heap, 4);
 
122
        mach_write_to_4(ptr, table->flags >> DICT_TF2_SHIFT);
120
123
 
121
124
        dfield_set_data(dfield, ptr, 4);
122
125
        /* 8: CLUSTER_NAME ---------------------*/
123
 
        dfield = dtuple_get_nth_field(entry, 6);
 
126
        dfield = dtuple_get_nth_field(entry, 6/*CLUSTER_NAME*/);
124
127
        dfield_set_null(dfield); /* not supported */
125
128
 
126
129
        /* 9: SPACE ----------------------------*/
127
 
        dfield = dtuple_get_nth_field(entry, 7);
 
130
        dfield = dtuple_get_nth_field(entry, 7/*SPACE*/);
128
131
 
129
132
        ptr = mem_heap_alloc(heap, 4);
130
133
        mach_write_to_4(ptr, table->space);
143
146
dtuple_t*
144
147
dict_create_sys_columns_tuple(
145
148
/*==========================*/
146
 
        dict_table_t*   table,  /*!< in: table */
147
 
        ulint           i,      /*!< in: column number */
148
 
        mem_heap_t*     heap)   /*!< in: memory heap from which the memory for
149
 
                                the built tuple is allocated */
 
149
        const dict_table_t*     table,  /*!< in: table */
 
150
        ulint                   i,      /*!< in: column number */
 
151
        mem_heap_t*             heap)   /*!< in: memory heap from
 
152
                                        which the memory for the built
 
153
                                        tuple is allocated */
150
154
{
151
155
        dict_table_t*           sys_columns;
152
156
        dtuple_t*               entry;
153
157
        const dict_col_t*       column;
154
158
        dfield_t*               dfield;
155
159
        byte*                   ptr;
156
 
        const char*     col_name;
 
160
        const char*             col_name;
157
161
 
158
 
        ut_ad(table && heap);
 
162
        ut_ad(table);
 
163
        ut_ad(heap);
159
164
 
160
165
        column = dict_table_get_nth_col(table, i);
161
166
 
166
171
        dict_table_copy_types(entry, sys_columns);
167
172
 
168
173
        /* 0: TABLE_ID -----------------------*/
169
 
        dfield = dtuple_get_nth_field(entry, 0);
 
174
        dfield = dtuple_get_nth_field(entry, 0/*TABLE_ID*/);
170
175
 
171
176
        ptr = mem_heap_alloc(heap, 8);
172
177
        mach_write_to_8(ptr, table->id);
173
178
 
174
179
        dfield_set_data(dfield, ptr, 8);
175
180
        /* 1: POS ----------------------------*/
176
 
        dfield = dtuple_get_nth_field(entry, 1);
 
181
        dfield = dtuple_get_nth_field(entry, 1/*POS*/);
177
182
 
178
183
        ptr = mem_heap_alloc(heap, 4);
179
184
        mach_write_to_4(ptr, i);
180
185
 
181
186
        dfield_set_data(dfield, ptr, 4);
182
187
        /* 4: NAME ---------------------------*/
183
 
        dfield = dtuple_get_nth_field(entry, 2);
 
188
        dfield = dtuple_get_nth_field(entry, 2/*NAME*/);
184
189
 
185
190
        col_name = dict_table_get_col_name(table, i);
186
191
        dfield_set_data(dfield, col_name, ut_strlen(col_name));
187
192
        /* 5: MTYPE --------------------------*/
188
 
        dfield = dtuple_get_nth_field(entry, 3);
 
193
        dfield = dtuple_get_nth_field(entry, 3/*MTYPE*/);
189
194
 
190
195
        ptr = mem_heap_alloc(heap, 4);
191
196
        mach_write_to_4(ptr, column->mtype);
192
197
 
193
198
        dfield_set_data(dfield, ptr, 4);
194
199
        /* 6: PRTYPE -------------------------*/
195
 
        dfield = dtuple_get_nth_field(entry, 4);
 
200
        dfield = dtuple_get_nth_field(entry, 4/*PRTYPE*/);
196
201
 
197
202
        ptr = mem_heap_alloc(heap, 4);
198
203
        mach_write_to_4(ptr, column->prtype);
199
204
 
200
205
        dfield_set_data(dfield, ptr, 4);
201
206
        /* 7: LEN ----------------------------*/
202
 
        dfield = dtuple_get_nth_field(entry, 5);
 
207
        dfield = dtuple_get_nth_field(entry, 5/*LEN*/);
203
208
 
204
209
        ptr = mem_heap_alloc(heap, 4);
205
210
        mach_write_to_4(ptr, column->len);
206
211
 
207
212
        dfield_set_data(dfield, ptr, 4);
208
213
        /* 8: PREC ---------------------------*/
209
 
        dfield = dtuple_get_nth_field(entry, 6);
 
214
        dfield = dtuple_get_nth_field(entry, 6/*PREC*/);
210
215
 
211
216
        ptr = mem_heap_alloc(heap, 4);
212
217
        mach_write_to_4(ptr, 0/* unused */);
230
235
        dict_table_t*   table;
231
236
        dtuple_t*       row;
232
237
        ulint           error;
 
238
        ulint           flags;
233
239
        const char*     path_or_name;
234
240
        ibool           is_path;
235
241
        mtr_t           mtr;
 
242
        ulint           space = 0;
 
243
        ibool           file_per_table;
236
244
 
237
245
        ut_ad(mutex_own(&(dict_sys->mutex)));
238
246
 
239
247
        table = node->table;
240
248
 
241
 
        table->id = dict_hdr_get_new_id(DICT_HDR_TABLE_ID);
 
249
        /* Cache the global variable "srv_file_per_table" to
 
250
        a local variable before using it. Please note
 
251
        "srv_file_per_table" is not under dict_sys mutex
 
252
        protection, and could be changed while executing
 
253
        this function. So better to cache the current value
 
254
        to a local variable, and all future reference to
 
255
        "srv_file_per_table" should use this local variable. */
 
256
        file_per_table = srv_file_per_table;
 
257
 
 
258
        dict_hdr_get_new_id(&table->id, NULL, NULL);
242
259
 
243
260
        thr_get_trx(thr)->table_id = table->id;
244
261
 
245
 
        if (srv_file_per_table) {
 
262
        if (file_per_table) {
 
263
                /* Get a new space id if srv_file_per_table is set */
 
264
                dict_hdr_get_new_id(NULL, NULL, &space);
 
265
 
 
266
                if (UNIV_UNLIKELY(space == ULINT_UNDEFINED)) {
 
267
                        return(DB_ERROR);
 
268
                }
 
269
 
246
270
                /* We create a new single-table tablespace for the table.
247
271
                We initially let it be 4 pages:
248
272
                - page 0 is the fsp header and an extent descriptor page,
251
275
                - page 3 will contain the root of the clustered index of the
252
276
                table we create here. */
253
277
 
254
 
                ulint   space = 0;      /* reset to zero for the call below */
255
 
 
256
278
                if (table->dir_path_of_temp_table) {
257
279
                        /* We place tables created with CREATE TEMPORARY
258
280
                        TABLE in the tmp dir of mysqld server */
268
290
                ut_ad(!dict_table_zip_size(table)
269
291
                      || dict_table_get_format(table) >= DICT_TF_FORMAT_ZIP);
270
292
 
 
293
                flags = table->flags & ~(~0 << DICT_TF_BITS);
271
294
                error = fil_create_new_single_table_tablespace(
272
 
                        &space, path_or_name, is_path,
273
 
                        table->flags == DICT_TF_COMPACT ? 0 : table->flags,
 
295
                        space, path_or_name, is_path,
 
296
                        flags == DICT_TF_COMPACT ? 0 : flags,
274
297
                        FIL_IBD_FILE_INITIAL_SIZE);
275
298
                table->space = (unsigned int) space;
276
299
 
286
309
                mtr_commit(&mtr);
287
310
        } else {
288
311
                /* Create in the system tablespace: disallow new features */
289
 
                table->flags &= DICT_TF_COMPACT;
 
312
                table->flags &= (~0 << DICT_TF_BITS) | DICT_TF_COMPACT;
290
313
        }
291
314
 
292
315
        row = dict_create_sys_tables_tuple(table, node->heap);
322
345
dtuple_t*
323
346
dict_create_sys_indexes_tuple(
324
347
/*==========================*/
325
 
        dict_index_t*   index,  /*!< in: index */
326
 
        mem_heap_t*     heap)   /*!< in: memory heap from which the memory for
327
 
                                the built tuple is allocated */
 
348
        const dict_index_t*     index,  /*!< in: index */
 
349
        mem_heap_t*             heap)   /*!< in: memory heap from
 
350
                                        which the memory for the built
 
351
                                        tuple is allocated */
328
352
{
329
353
        dict_table_t*   sys_indexes;
330
354
        dict_table_t*   table;
333
357
        byte*           ptr;
334
358
 
335
359
        ut_ad(mutex_own(&(dict_sys->mutex)));
336
 
        ut_ad(index && heap);
 
360
        ut_ad(index);
 
361
        ut_ad(heap);
337
362
 
338
363
        sys_indexes = dict_sys->sys_indexes;
339
364
 
344
369
        dict_table_copy_types(entry, sys_indexes);
345
370
 
346
371
        /* 0: TABLE_ID -----------------------*/
347
 
        dfield = dtuple_get_nth_field(entry, 0);
 
372
        dfield = dtuple_get_nth_field(entry, 0/*TABLE_ID*/);
348
373
 
349
374
        ptr = mem_heap_alloc(heap, 8);
350
375
        mach_write_to_8(ptr, table->id);
351
376
 
352
377
        dfield_set_data(dfield, ptr, 8);
353
378
        /* 1: ID ----------------------------*/
354
 
        dfield = dtuple_get_nth_field(entry, 1);
 
379
        dfield = dtuple_get_nth_field(entry, 1/*ID*/);
355
380
 
356
381
        ptr = mem_heap_alloc(heap, 8);
357
382
        mach_write_to_8(ptr, index->id);
358
383
 
359
384
        dfield_set_data(dfield, ptr, 8);
360
385
        /* 4: NAME --------------------------*/
361
 
        dfield = dtuple_get_nth_field(entry, 2);
 
386
        dfield = dtuple_get_nth_field(entry, 2/*NAME*/);
362
387
 
363
388
        dfield_set_data(dfield, index->name, ut_strlen(index->name));
364
389
        /* 5: N_FIELDS ----------------------*/
365
 
        dfield = dtuple_get_nth_field(entry, 3);
 
390
        dfield = dtuple_get_nth_field(entry, 3/*N_FIELDS*/);
366
391
 
367
392
        ptr = mem_heap_alloc(heap, 4);
368
393
        mach_write_to_4(ptr, index->n_fields);
369
394
 
370
395
        dfield_set_data(dfield, ptr, 4);
371
396
        /* 6: TYPE --------------------------*/
372
 
        dfield = dtuple_get_nth_field(entry, 4);
 
397
        dfield = dtuple_get_nth_field(entry, 4/*TYPE*/);
373
398
 
374
399
        ptr = mem_heap_alloc(heap, 4);
375
400
        mach_write_to_4(ptr, index->type);
381
406
#error "DICT_SYS_INDEXES_SPACE_NO_FIELD != 7"
382
407
#endif
383
408
 
384
 
        dfield = dtuple_get_nth_field(entry, 5);
 
409
        dfield = dtuple_get_nth_field(entry, 5/*SPACE*/);
385
410
 
386
411
        ptr = mem_heap_alloc(heap, 4);
387
412
        mach_write_to_4(ptr, index->space);
393
418
#error "DICT_SYS_INDEXES_PAGE_NO_FIELD != 8"
394
419
#endif
395
420
 
396
 
        dfield = dtuple_get_nth_field(entry, 6);
 
421
        dfield = dtuple_get_nth_field(entry, 6/*PAGE_NO*/);
397
422
 
398
423
        ptr = mem_heap_alloc(heap, 4);
399
424
        mach_write_to_4(ptr, FIL_NULL);
412
437
dtuple_t*
413
438
dict_create_sys_fields_tuple(
414
439
/*=========================*/
415
 
        dict_index_t*   index,  /*!< in: index */
416
 
        ulint           i,      /*!< in: field number */
417
 
        mem_heap_t*     heap)   /*!< in: memory heap from which the memory for
418
 
                                the built tuple is allocated */
 
440
        const dict_index_t*     index,  /*!< in: index */
 
441
        ulint                   i,      /*!< in: field number */
 
442
        mem_heap_t*             heap)   /*!< in: memory heap from
 
443
                                        which the memory for the built
 
444
                                        tuple is allocated */
419
445
{
420
446
        dict_table_t*   sys_fields;
421
447
        dtuple_t*       entry;
425
451
        ibool           index_contains_column_prefix_field      = FALSE;
426
452
        ulint           j;
427
453
 
428
 
        ut_ad(index && heap);
 
454
        ut_ad(index);
 
455
        ut_ad(heap);
429
456
 
430
457
        for (j = 0; j < index->n_fields; j++) {
431
458
                if (dict_index_get_nth_field(index, j)->prefix_len > 0) {
443
470
        dict_table_copy_types(entry, sys_fields);
444
471
 
445
472
        /* 0: INDEX_ID -----------------------*/
446
 
        dfield = dtuple_get_nth_field(entry, 0);
 
473
        dfield = dtuple_get_nth_field(entry, 0/*INDEX_ID*/);
447
474
 
448
475
        ptr = mem_heap_alloc(heap, 8);
449
476
        mach_write_to_8(ptr, index->id);
451
478
        dfield_set_data(dfield, ptr, 8);
452
479
        /* 1: POS + PREFIX LENGTH ----------------------------*/
453
480
 
454
 
        dfield = dtuple_get_nth_field(entry, 1);
 
481
        dfield = dtuple_get_nth_field(entry, 1/*POS*/);
455
482
 
456
483
        ptr = mem_heap_alloc(heap, 4);
457
484
 
471
498
 
472
499
        dfield_set_data(dfield, ptr, 4);
473
500
        /* 4: COL_NAME -------------------------*/
474
 
        dfield = dtuple_get_nth_field(entry, 2);
 
501
        dfield = dtuple_get_nth_field(entry, 2/*COL_NAME*/);
475
502
 
476
503
        dfield_set_data(dfield, field->name,
477
504
                        ut_strlen(field->name));
550
577
        ut_ad((UT_LIST_GET_LEN(table->indexes) > 0)
551
578
              || dict_index_is_clust(index));
552
579
 
553
 
        index->id = dict_hdr_get_new_id(DICT_HDR_INDEX_ID);
 
580
        dict_hdr_get_new_id(NULL, &index->id, NULL);
554
581
 
555
582
        /* Inherit the space id from the table; we store all indexes of a
556
583
        table in the same tablespace */
600
627
{
601
628
        dict_index_t*   index;
602
629
        dict_table_t*   sys_indexes;
603
 
        dict_table_t*   table;
604
630
        dtuple_t*       search_tuple;
 
631
        ulint           zip_size;
605
632
        btr_pcur_t      pcur;
606
633
        mtr_t           mtr;
607
634
 
608
635
        ut_ad(mutex_own(&(dict_sys->mutex)));
609
636
 
610
637
        index = node->index;
611
 
        table = node->table;
612
638
 
613
639
        sys_indexes = dict_sys->sys_indexes;
614
640
 
626
652
 
627
653
        btr_pcur_move_to_next_user_rec(&pcur, &mtr);
628
654
 
629
 
        node->page_no = btr_create(index->type, index->space,
630
 
                                   dict_table_zip_size(index->table),
 
655
        zip_size = dict_table_zip_size(index->table);
 
656
 
 
657
        node->page_no = btr_create(index->type, index->space, zip_size,
631
658
                                   index->id, index, &mtr);
632
659
        /* printf("Created a new index tree in space %lu root page %lu\n",
633
660
        index->space, index->page_no); */
801
828
        appropriate field in the SYS_INDEXES record: this mini-transaction
802
829
        marks the B-tree totally truncated */
803
830
 
804
 
        btr_page_get(space, zip_size, root_page_no, RW_X_LATCH, mtr);
 
831
        btr_block_get(space, zip_size, root_page_no, RW_X_LATCH, NULL, mtr);
805
832
 
806
833
        btr_free_root(space, zip_size, root_page_no, mtr);
807
834
create:
1092
1119
 
1093
1120
                dulint  index_id = node->index->id;
1094
1121
 
1095
 
                err = dict_index_add_to_cache(node->table, node->index,
1096
 
                                              FIL_NULL, TRUE);
 
1122
                err = dict_index_add_to_cache(
 
1123
                        node->table, node->index, FIL_NULL,
 
1124
                        trx_is_strict(trx)
 
1125
                        || dict_table_get_format(node->table)
 
1126
                        >= DICT_TF_FORMAT_ZIP);
1097
1127
 
1098
1128
                node->index = dict_index_get_if_in_cache_low(index_id);
1099
1129
                ut_a(!node->index == (err != DB_SUCCESS));