← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/handler/handler0alter.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/handler/handler0alter.cc
 
1
/******************************************************
 
2
Smart ALTER TABLE
 
3
 
 
4
(c) 2005-2008 Innobase Oy
 
5
*******************************************************/
 
6
 
 
7
#include <mysql_priv.h>
 
8
#include <mysqld_error.h>
 
9
 
 
10
extern "C" {
 
11
#include "log0log.h"
 
12
#include "row0merge.h"
 
13
#include "srv0srv.h"
 
14
#include "trx0trx.h"
 
15
#include "trx0roll.h"
 
16
#include "ha_prototypes.h"
 
17
#include "handler0alter.h"
 
18
}
 
19
 
 
20
#include "ha_innodb.h"
 
21
 
 
22
/*****************************************************************
 
23
Copies an InnoDB column to a MySQL field.  This function is
 
24
adapted from row_sel_field_store_in_mysql_format(). */
 
25
static
 
26
void
 
27
innobase_col_to_mysql(
 
28
/*==================*/
 
29
        const dict_col_t*       col,    /* in: InnoDB column */
 
30
        const uchar*            data,   /* in: InnoDB column data */
 
31
        ulint                   len,    /* in: length of data, in bytes */
 
32
        Field*                  field)  /* in/out: MySQL field */
 
33
{
 
34
        uchar*  ptr;
 
35
        uchar*  dest    = field->ptr;
 
36
        ulint   flen    = field->pack_length();
 
37
 
 
38
        switch (col->mtype) {
 
39
        case DATA_INT:
 
40
                ut_ad(len == flen);
 
41
 
 
42
                /* Convert integer data from Innobase to little-endian
 
43
                format, sign bit restored to normal */
 
44
 
 
45
                for (ptr = dest + len; ptr != dest; ) {
 
46
                        *--ptr = *data++;
 
47
                }
 
48
 
 
49
                if (!(field->flags & UNSIGNED_FLAG)) {
 
50
                        ((byte*) dest)[len - 1] ^= 0x80;
 
51
                }
 
52
 
 
53
                break;
 
54
 
 
55
        case DATA_VARCHAR:
 
56
        case DATA_VARMYSQL:
 
57
        case DATA_BINARY:
 
58
                field->reset();
 
59
 
 
60
                if (field->type() == MYSQL_TYPE_VARCHAR) {
 
61
                        /* This is a >= 5.0.3 type true VARCHAR. Store the
 
62
                        length of the data to the first byte or the first
 
63
                        two bytes of dest. */
 
64
 
 
65
                        dest = row_mysql_store_true_var_len(
 
66
                                dest, len, flen - field->key_length());
 
67
                }
 
68
 
 
69
                /* Copy the actual data */
 
70
                memcpy(dest, data, len);
 
71
                break;
 
72
 
 
73
        case DATA_BLOB:
 
74
                /* Store a pointer to the BLOB buffer to dest: the BLOB was
 
75
                already copied to the buffer in row_sel_store_mysql_rec */
 
76
 
 
77
                row_mysql_store_blob_ref(dest, flen, data, len);
 
78
                break;
 
79
 
 
80
#ifdef UNIV_DEBUG
 
81
        case DATA_MYSQL:
 
82
                ut_ad(flen >= len);
 
83
                ut_ad(col->mbmaxlen >= col->mbminlen);
 
84
                ut_ad(col->mbmaxlen > col->mbminlen || flen == len);
 
85
                memcpy(dest, data, len);
 
86
                break;
 
87
 
 
88
        default:
 
89
        case DATA_SYS_CHILD:
 
90
        case DATA_SYS:
 
91
                /* These column types should never be shipped to MySQL. */
 
92
                ut_ad(0);
 
93
 
 
94
        case DATA_CHAR:
 
95
        case DATA_FIXBINARY:
 
96
        case DATA_FLOAT:
 
97
        case DATA_DOUBLE:
 
98
        case DATA_DECIMAL:
 
99
                /* Above are the valid column types for MySQL data. */
 
100
                ut_ad(flen == len);
 
101
#else /* UNIV_DEBUG */
 
102
        default:
 
103
#endif /* UNIV_DEBUG */
 
104
                memcpy(dest, data, len);
 
105
        }
 
106
}
 
107
 
 
108
/*****************************************************************
 
109
Copies an InnoDB record to table->record[0]. */
 
110
extern "C" UNIV_INTERN
 
111
void
 
112
innobase_rec_to_mysql(
 
113
/*==================*/
 
114
        TABLE*                  table,          /* in/out: MySQL table */
 
115
        const rec_t*            rec,            /* in: record */
 
116
        const dict_index_t*     index,          /* in: index */
 
117
        const ulint*            offsets)        /* in: rec_get_offsets(
 
118
                                                rec, index, ...) */
 
119
{
 
120
        uint    n_fields        = table->s->fields;
 
121
        uint    i;
 
122
 
 
123
        ut_ad(n_fields == dict_table_get_n_user_cols(index->table));
 
124
 
 
125
        for (i = 0; i < n_fields; i++) {
 
126
                Field*          field   = table->field[i];
 
127
                ulint           ipos;
 
128
                ulint           ilen;
 
129
                const uchar*    ifield;
 
130
 
 
131
                field->reset();
 
132
 
 
133
                ipos = dict_index_get_nth_col_pos(index, i);
 
134
 
 
135
                if (UNIV_UNLIKELY(ipos == ULINT_UNDEFINED)) {
 
136
null_field:
 
137
                        field->set_null();
 
138
                        continue;
 
139
                }
 
140
 
 
141
                ifield = rec_get_nth_field(rec, offsets, ipos, &ilen);
 
142
 
 
143
                /* Assign the NULL flag */
 
144
                if (ilen == UNIV_SQL_NULL) {
 
145
                        ut_ad(field->real_maybe_null());
 
146
                        goto null_field;
 
147
                }
 
148
 
 
149
                field->set_notnull();
 
150
 
 
151
                innobase_col_to_mysql(
 
152
                        dict_field_get_col(
 
153
                                dict_index_get_nth_field(index, ipos)),
 
154
                        ifield, ilen, field);
 
155
        }
 
156
}
 
157
 
 
158
/*****************************************************************
 
159
Resets table->record[0]. */
 
160
extern "C" UNIV_INTERN
 
161
void
 
162
innobase_rec_reset(
 
163
/*===============*/
 
164
        TABLE*                  table)          /* in/out: MySQL table */
 
165
{
 
166
        uint    n_fields        = table->s->fields;
 
167
        uint    i;
 
168
 
 
169
        for (i = 0; i < n_fields; i++) {
 
170
                table->field[i]->set_default();
 
171
        }
 
172
}
 
173
 
 
174
/**********************************************************************
 
175
Removes the filename encoding of a database and table name. */
 
176
static
 
177
void
 
178
innobase_convert_tablename(
 
179
/*=======================*/
 
180
        char*   s)      /* in: identifier; out: decoded identifier */
 
181
{
 
182
        uint    errors;
 
183
 
 
184
        char*   slash = strchr(s, '/');
 
185
 
 
186
        if (slash) {
 
187
                char*   t;
 
188
                /* Temporarily replace the '/' with NUL. */
 
189
                *slash = 0;
 
190
                /* Convert the database name. */
 
191
                strconvert(&my_charset_filename, s, system_charset_info,
 
192
                           s, slash - s + 1, &errors);
 
193
 
 
194
                t = s + strlen(s);
 
195
                ut_ad(slash >= t);
 
196
                /* Append a  '.' after the database name. */
 
197
                *t++ = '.';
 
198
                slash++;
 
199
                /* Convert the table name. */
 
200
                strconvert(&my_charset_filename, slash, system_charset_info,
 
201
                           t, slash - t + strlen(slash), &errors);
 
202
        } else {
 
203
                strconvert(&my_charset_filename, s,
 
204
                           system_charset_info, s, strlen(s), &errors);
 
205
        }
 
206
}
 
207
 
 
208
/***********************************************************************
 
209
This function checks that index keys are sensible. */
 
210
static
 
211
int
 
212
innobase_check_index_keys(
 
213
/*======================*/
 
214
                                        /* out: 0 or error number */
 
215
        const KEY*      key_info,       /* in: Indexes to be created */
 
216
        ulint           num_of_keys)    /* in: Number of indexes to
 
217
                                        be created */
 
218
{
 
219
        ulint           key_num;
 
220
 
 
221
        ut_ad(key_info);
 
222
        ut_ad(num_of_keys);
 
223
 
 
224
        for (key_num = 0; key_num < num_of_keys; key_num++) {
 
225
                const KEY&      key = key_info[key_num];
 
226
 
 
227
                /* Check that the same index name does not appear
 
228
                twice in indexes to be created. */
 
229
 
 
230
                for (ulint i = 0; i < key_num; i++) {
 
231
                        const KEY&      key2 = key_info[i];
 
232
 
 
233
                        if (0 == strcmp(key.name, key2.name)) {
 
234
                                sql_print_error("InnoDB: key name `%s` appears"
 
235
                                                " twice in CREATE INDEX\n",
 
236
                                                key.name);
 
237
 
 
238
                                return(ER_WRONG_NAME_FOR_INDEX);
 
239
                        }
 
240
                }
 
241
 
 
242
                /* Check that MySQL does not try to create a column
 
243
                prefix index field on an inappropriate data type and
 
244
                that the same colum does not appear twice in the index. */
 
245
 
 
246
                for (ulint i = 0; i < key.key_parts; i++) {
 
247
                        const KEY_PART_INFO&    key_part1
 
248
                                = key.key_part[i];
 
249
                        const Field*            field
 
250
                                = key_part1.field;
 
251
                        ibool                   is_unsigned;
 
252
 
 
253
                        switch (get_innobase_type_from_mysql_type(
 
254
                                        &is_unsigned, field)) {
 
255
                        default:
 
256
                                break;
 
257
                        case DATA_INT:
 
258
                        case DATA_FLOAT:
 
259
                        case DATA_DOUBLE:
 
260
                        case DATA_DECIMAL:
 
261
                                if (field->type() == MYSQL_TYPE_VARCHAR) {
 
262
                                        if (key_part1.length
 
263
                                            >= field->pack_length()
 
264
                                            - ((Field_varstring*) field)
 
265
                                            ->length_bytes) {
 
266
                                                break;
 
267
                                        }
 
268
                                } else {
 
269
                                        if (key_part1.length
 
270
                                            >= field->pack_length()) {
 
271
                                                break;
 
272
                                        }
 
273
                                }
 
274
 
 
275
                                sql_print_error("InnoDB: MySQL is trying to"
 
276
                                                " create a column prefix"
 
277
                                                " index field on an"
 
278
                                                " inappropriate data type."
 
279
                                                " column `%s`,"
 
280
                                                " index `%s`.\n",
 
281
                                                field->field_name,
 
282
                                                key.name);
 
283
                                return(ER_WRONG_KEY_COLUMN);
 
284
                        }
 
285
 
 
286
                        for (ulint j = 0; j < i; j++) {
 
287
                                const KEY_PART_INFO&    key_part2
 
288
                                        = key.key_part[j];
 
289
 
 
290
                                if (strcmp(key_part1.field->field_name,
 
291
                                           key_part2.field->field_name)) {
 
292
                                        continue;
 
293
                                }
 
294
 
 
295
                                sql_print_error("InnoDB: column `%s`"
 
296
                                                " is not allowed to occur"
 
297
                                                " twice in index `%s`.\n",
 
298
                                                key_part1.field->field_name,
 
299
                                                key.name);
 
300
                                return(ER_WRONG_KEY_COLUMN);
 
301
                        }
 
302
                }
 
303
        }
 
304
 
 
305
        return(0);
 
306
}
 
307
 
 
308
/***********************************************************************
 
309
Create index field definition for key part */
 
310
static
 
311
void
 
312
innobase_create_index_field_def(
 
313
/*============================*/
 
314
        KEY_PART_INFO*          key_part,       /* in: MySQL key definition */
 
315
        mem_heap_t*             heap,           /* in: memory heap */
 
316
        merge_index_field_t*    index_field)    /* out: index field
 
317
                                                definition for key_part */
 
318
{
 
319
        Field*          field;
 
320
        ibool           is_unsigned;
 
321
        ulint           col_type;
 
322
 
 
323
        DBUG_ENTER("innobase_create_index_field_def");
 
324
 
 
325
        ut_ad(key_part);
 
326
        ut_ad(index_field);
 
327
 
 
328
        field = key_part->field;
 
329
        ut_a(field);
 
330
 
 
331
        col_type = get_innobase_type_from_mysql_type(&is_unsigned, field);
 
332
 
 
333
        if (DATA_BLOB == col_type
 
334
            || (key_part->length < field->pack_length()
 
335
                && field->type() != MYSQL_TYPE_VARCHAR)
 
336
            || (field->type() == MYSQL_TYPE_VARCHAR
 
337
                && key_part->length < field->pack_length()
 
338
                        - ((Field_varstring*)field)->length_bytes)) {
 
339
 
 
340
                index_field->prefix_len = key_part->length;
 
341
        } else {
 
342
                index_field->prefix_len = 0;
 
343
        }
 
344
 
 
345
        index_field->field_name = mem_heap_strdup(heap, field->field_name);
 
346
 
 
347
        DBUG_VOID_RETURN;
 
348
}
 
349
 
 
350
/***********************************************************************
 
351
Create index definition for key */
 
352
static
 
353
void
 
354
innobase_create_index_def(
 
355
/*======================*/
 
356
        KEY*                    key,            /* in: key definition */
 
357
        bool                    new_primary,    /* in: TRUE=generating
 
358
                                                a new primary key
 
359
                                                on the table */
 
360
        bool                    key_primary,    /* in: TRUE if this key
 
361
                                                is a primary key */
 
362
        merge_index_def_t*      index,          /* out: index definition */
 
363
        mem_heap_t*             heap)           /* in: heap where memory
 
364
                                                is allocated */
 
365
{
 
366
        ulint   i;
 
367
        ulint   len;
 
368
        ulint   n_fields = key->key_parts;
 
369
        char*   index_name;
 
370
 
 
371
        DBUG_ENTER("innobase_create_index_def");
 
372
 
 
373
        index->fields = (merge_index_field_t*) mem_heap_alloc(
 
374
                heap, n_fields * sizeof *index->fields);
 
375
 
 
376
        index->ind_type = 0;
 
377
        index->n_fields = n_fields;
 
378
        len = strlen(key->name) + 1;
 
379
        index->name = index_name = (char*) mem_heap_alloc(heap,
 
380
                                                          len + !new_primary);
 
381
 
 
382
        if (UNIV_LIKELY(!new_primary)) {
 
383
                *index_name++ = TEMP_INDEX_PREFIX;
 
384
        }
 
385
 
 
386
        memcpy(index_name, key->name, len);
 
387
 
 
388
        if (key->flags & HA_NOSAME) {
 
389
                index->ind_type |= DICT_UNIQUE;
 
390
        }
 
391
 
 
392
        if (key_primary) {
 
393
                index->ind_type |= DICT_CLUSTERED;
 
394
        }
 
395
 
 
396
        for (i = 0; i < n_fields; i++) {
 
397
                innobase_create_index_field_def(&key->key_part[i], heap,
 
398
                                                &index->fields[i]);
 
399
        }
 
400
 
 
401
        DBUG_VOID_RETURN;
 
402
}
 
403
 
 
404
/***********************************************************************
 
405
Copy index field definition */
 
406
static
 
407
void
 
408
innobase_copy_index_field_def(
 
409
/*==========================*/
 
410
        const dict_field_t*     field,          /* in: definition to copy */
 
411
        merge_index_field_t*    index_field)    /* out: copied definition */
 
412
{
 
413
        DBUG_ENTER("innobase_copy_index_field_def");
 
414
        DBUG_ASSERT(field != NULL);
 
415
        DBUG_ASSERT(index_field != NULL);
 
416
 
 
417
        index_field->field_name = field->name;
 
418
        index_field->prefix_len = field->prefix_len;
 
419
 
 
420
        DBUG_VOID_RETURN;
 
421
}
 
422
 
 
423
/***********************************************************************
 
424
Copy index definition for the index */
 
425
static
 
426
void
 
427
innobase_copy_index_def(
 
428
/*====================*/
 
429
        const dict_index_t*     index,  /* in: index definition to copy */
 
430
        merge_index_def_t*      new_index,/* out: Index definition */
 
431
        mem_heap_t*             heap)   /* in: heap where allocated */
 
432
{
 
433
        ulint   n_fields;
 
434
        ulint   i;
 
435
 
 
436
        DBUG_ENTER("innobase_copy_index_def");
 
437
 
 
438
        /* Note that we take only those fields that user defined to be
 
439
        in the index.  In the internal representation more colums were
 
440
        added and those colums are not copied .*/
 
441
 
 
442
        n_fields = index->n_user_defined_cols;
 
443
 
 
444
        new_index->fields = (merge_index_field_t*) mem_heap_alloc(
 
445
                heap, n_fields * sizeof *new_index->fields);
 
446
 
 
447
        /* When adding a PRIMARY KEY, we may convert a previous
 
448
        clustered index to a secondary index (UNIQUE NOT NULL). */
 
449
        new_index->ind_type = index->type & ~DICT_CLUSTERED;
 
450
        new_index->n_fields = n_fields;
 
451
        new_index->name = index->name;
 
452
 
 
453
        for (i = 0; i < n_fields; i++) {
 
454
                innobase_copy_index_field_def(&index->fields[i],
 
455
                                              &new_index->fields[i]);
 
456
        }
 
457
 
 
458
        DBUG_VOID_RETURN;
 
459
}
 
460
 
 
461
/***********************************************************************
 
462
Create an index table where indexes are ordered as follows:
 
463
 
 
464
IF a new primary key is defined for the table THEN
 
465
 
 
466
        1) New primary key
 
467
        2) Original secondary indexes
 
468
        3) New secondary indexes
 
469
 
 
470
ELSE
 
471
 
 
472
        1) All new indexes in the order they arrive from MySQL
 
473
 
 
474
ENDIF
 
475
 
 
476
*/
 
477
static
 
478
merge_index_def_t*
 
479
innobase_create_key_def(
 
480
/*====================*/
 
481
                                        /* out: key definitions or NULL */
 
482
        trx_t*          trx,            /* in: trx */
 
483
        const dict_table_t*table,               /* in: table definition */
 
484
        mem_heap_t*     heap,           /* in: heap where space for key
 
485
                                        definitions are allocated */
 
486
        KEY*            key_info,       /* in: Indexes to be created */
 
487
        ulint&          n_keys)         /* in/out: Number of indexes to
 
488
                                        be created */
 
489
{
 
490
        ulint                   i = 0;
 
491
        merge_index_def_t*      indexdef;
 
492
        merge_index_def_t*      indexdefs;
 
493
        bool                    new_primary;
 
494
 
 
495
        DBUG_ENTER("innobase_create_key_def");
 
496
 
 
497
        indexdef = indexdefs = (merge_index_def_t*)
 
498
                mem_heap_alloc(heap, sizeof *indexdef
 
499
                               * (n_keys + UT_LIST_GET_LEN(table->indexes)));
 
500
 
 
501
        /* If there is a primary key, it is always the first index
 
502
        defined for the table. */
 
503
 
 
504
        new_primary = !my_strcasecmp(system_charset_info,
 
505
                                     key_info->name, "PRIMARY");
 
506
 
 
507
        /* If there is a UNIQUE INDEX consisting entirely of NOT NULL
 
508
        columns, MySQL will treat it as a PRIMARY KEY unless the
 
509
        table already has one. */
 
510
 
 
511
        if (!new_primary && (key_info->flags & HA_NOSAME)
 
512
            && row_table_got_default_clust_index(table)) {
 
513
                uint    key_part = key_info->key_parts;
 
514
 
 
515
                new_primary = TRUE;
 
516
 
 
517
                while (key_part--) {
 
518
                        if (key_info->key_part[key_part].key_type
 
519
                            & FIELDFLAG_MAYBE_NULL) {
 
520
                                new_primary = FALSE;
 
521
                                break;
 
522
                        }
 
523
                }
 
524
        }
 
525
 
 
526
        if (new_primary) {
 
527
                const dict_index_t*     index;
 
528
 
 
529
                /* Create the PRIMARY key index definition */
 
530
                innobase_create_index_def(&key_info[i++], TRUE, TRUE,
 
531
                                          indexdef++, heap);
 
532
 
 
533
                row_mysql_lock_data_dictionary(trx);
 
534
 
 
535
                index = dict_table_get_first_index(table);
 
536
 
 
537
                /* Copy the index definitions of the old table.  Skip
 
538
                the old clustered index if it is a generated clustered
 
539
                index or a PRIMARY KEY.  If the clustered index is a
 
540
                UNIQUE INDEX, it must be converted to a secondary index. */
 
541
 
 
542
                if (dict_index_get_nth_col(index, 0)->mtype == DATA_SYS
 
543
                    || !my_strcasecmp(system_charset_info,
 
544
                                      index->name, "PRIMARY")) {
 
545
                        index = dict_table_get_next_index(index);
 
546
                }
 
547
 
 
548
                while (index) {
 
549
                        innobase_copy_index_def(index, indexdef++, heap);
 
550
                        index = dict_table_get_next_index(index);
 
551
                }
 
552
 
 
553
                row_mysql_unlock_data_dictionary(trx);
 
554
        }
 
555
 
 
556
        /* Create definitions for added secondary indexes. */
 
557
 
 
558
        while (i < n_keys) {
 
559
                innobase_create_index_def(&key_info[i++], new_primary, FALSE,
 
560
                                          indexdef++, heap);
 
561
        }
 
562
 
 
563
        n_keys = indexdef - indexdefs;
 
564
 
 
565
        DBUG_RETURN(indexdefs);
 
566
}
 
567
 
 
568
/***********************************************************************
 
569
Create a temporary tablename using query id, thread id, and id */
 
570
static
 
571
char*
 
572
innobase_create_temporary_tablename(
 
573
/*================================*/
 
574
                                        /* out: temporary tablename */
 
575
        mem_heap_t*     heap,           /* in: memory heap */
 
576
        char            id,             /* in: identifier [0-9a-zA-Z] */
 
577
        const char*     table_name)     /* in: table name */
 
578
{
 
579
        char*                   name;
 
580
        ulint                   len;
 
581
        static const char       suffix[] = "@0023 "; /* "# " */
 
582
 
 
583
        len = strlen(table_name);
 
584
 
 
585
        name = (char*) mem_heap_alloc(heap, len + sizeof suffix);
 
586
        memcpy(name, table_name, len);
 
587
        memcpy(name + len, suffix, sizeof suffix);
 
588
        name[len + (sizeof suffix - 2)] = id;
 
589
 
 
590
        return(name);
 
591
}
 
592
 
 
593
/***********************************************************************
 
594
Create indexes. */
 
595
UNIV_INTERN
 
596
int
 
597
ha_innobase::add_index(
 
598
/*===================*/
 
599
                                /* out: 0 or error number */
 
600
        TABLE*  table,          /* in: Table where indexes are created */
 
601
        KEY*    key_info,       /* in: Indexes to be created */
 
602
        uint    num_of_keys)    /* in: Number of indexes to be created */
 
603
{
 
604
        dict_index_t**  index;          /* Index to be created */
 
605
        dict_table_t*   innodb_table;   /* InnoDB table in dictionary */
 
606
        dict_table_t*   indexed_table;  /* Table where indexes are created */
 
607
        merge_index_def_t* index_defs;  /* Index definitions */
 
608
        mem_heap_t*     heap;           /* Heap for index definitions */
 
609
        trx_t*          trx;            /* Transaction */
 
610
        ulint           num_of_idx;
 
611
        ulint           num_created     = 0;
 
612
        ibool           dict_locked     = FALSE;
 
613
        ulint           new_primary;
 
614
        ulint           error;
 
615
 
 
616
        DBUG_ENTER("ha_innobase::add_index");
 
617
        ut_a(table);
 
618
        ut_a(key_info);
 
619
        ut_a(num_of_keys);
 
620
 
 
621
        if (srv_created_new_raw || srv_force_recovery) {
 
622
                DBUG_RETURN(HA_ERR_WRONG_COMMAND);
 
623
        }
 
624
 
 
625
        update_thd();
 
626
 
 
627
        heap = mem_heap_create(1024);
 
628
 
 
629
        /* In case MySQL calls this in the middle of a SELECT query, release
 
630
        possible adaptive hash latch to avoid deadlocks of threads. */
 
631
        trx_search_latch_release_if_reserved(prebuilt->trx);
 
632
 
 
633
        /* Create a background transaction for the operations on
 
634
        the data dictionary tables. */
 
635
        trx = trx_allocate_for_mysql();
 
636
        trx_start_if_not_started(trx);
 
637
 
 
638
        trans_register_ha(user_thd, FALSE, ht);
 
639
        prebuilt->trx->active_trans = 1;
 
640
 
 
641
        trx->mysql_thd = user_thd;
 
642
        trx->mysql_query_str = thd_query(user_thd);
 
643
 
 
644
        innodb_table = indexed_table
 
645
                = dict_table_get(prebuilt->table->name, FALSE);
 
646
 
 
647
        /* Check that index keys are sensible */
 
648
 
 
649
        error = innobase_check_index_keys(key_info, num_of_keys);
 
650
 
 
651
        if (UNIV_UNLIKELY(error)) {
 
652
err_exit:
 
653
                mem_heap_free(heap);
 
654
                trx_general_rollback_for_mysql(trx, FALSE, NULL);
 
655
                trx_free_for_mysql(trx);
 
656
                trx_commit_for_mysql(prebuilt->trx);
 
657
                DBUG_RETURN(error);
 
658
        }
 
659
 
 
660
        /* Create table containing all indexes to be built in this
 
661
        alter table add index so that they are in the correct order
 
662
        in the table. */
 
663
 
 
664
        num_of_idx = num_of_keys;
 
665
 
 
666
        index_defs = innobase_create_key_def(
 
667
                trx, innodb_table, heap, key_info, num_of_idx);
 
668
 
 
669
        new_primary = DICT_CLUSTERED & index_defs[0].ind_type;
 
670
 
 
671
        /* Allocate memory for dictionary index definitions */
 
672
 
 
673
        index = (dict_index_t**) mem_heap_alloc(
 
674
                heap, num_of_idx * sizeof *index);
 
675
 
 
676
        /* Flag this transaction as a dictionary operation, so that
 
677
        the data dictionary will be locked in crash recovery. */
 
678
        trx_set_dict_operation(trx, TRX_DICT_OP_INDEX);
 
679
 
 
680
        /* Acquire a lock on the table before creating any indexes. */
 
681
        error = row_merge_lock_table(prebuilt->trx, innodb_table,
 
682
                                     new_primary ? LOCK_X : LOCK_S);
 
683
 
 
684
        if (UNIV_UNLIKELY(error != DB_SUCCESS)) {
 
685
 
 
686
                goto error_handling;
 
687
        }
 
688
 
 
689
        /* Latch the InnoDB data dictionary exclusively so that no deadlocks
 
690
        or lock waits can happen in it during an index create operation. */
 
691
 
 
692
        row_mysql_lock_data_dictionary(trx);
 
693
        dict_locked = TRUE;
 
694
 
 
695
        /* If a new primary key is defined for the table we need
 
696
        to drop the original table and rebuild all indexes. */
 
697
 
 
698
        if (UNIV_UNLIKELY(new_primary)) {
 
699
                /* This transaction should be the only one
 
700
                operating on the table. */
 
701
                ut_a(innodb_table->n_mysql_handles_opened == 1);
 
702
 
 
703
                char*   new_table_name = innobase_create_temporary_tablename(
 
704
                        heap, '1', innodb_table->name);
 
705
 
 
706
                /* Clone the table. */
 
707
                trx_set_dict_operation(trx, TRX_DICT_OP_TABLE);
 
708
                indexed_table = row_merge_create_temporary_table(
 
709
                        new_table_name, index_defs, innodb_table, trx);
 
710
 
 
711
                if (!indexed_table) {
 
712
 
 
713
                        switch (trx->error_state) {
 
714
                        case DB_TABLESPACE_ALREADY_EXISTS:
 
715
                        case DB_DUPLICATE_KEY:
 
716
                                innobase_convert_tablename(new_table_name);
 
717
                                my_error(HA_ERR_TABLE_EXIST, MYF(0),
 
718
                                         new_table_name);
 
719
                                error = HA_ERR_TABLE_EXIST;
 
720
                                break;
 
721
                        default:
 
722
                                error = convert_error_code_to_mysql(
 
723
                                        trx->error_state, innodb_table->flags,
 
724
                                        user_thd);
 
725
                        }
 
726
 
 
727
                        row_mysql_unlock_data_dictionary(trx);
 
728
                        goto err_exit;
 
729
                }
 
730
 
 
731
                trx->table_id = indexed_table->id;
 
732
        }
 
733
 
 
734
        /* Create the indexes in SYS_INDEXES and load into dictionary. */
 
735
 
 
736
        for (ulint i = 0; i < num_of_idx; i++) {
 
737
 
 
738
                index[i] = row_merge_create_index(trx, indexed_table,
 
739
                                                  &index_defs[i]);
 
740
 
 
741
                if (!index[i]) {
 
742
                        error = trx->error_state;
 
743
                        goto error_handling;
 
744
                }
 
745
 
 
746
                num_created++;
 
747
        }
 
748
 
 
749
        ut_ad(error == DB_SUCCESS);
 
750
 
 
751
        /* Commit the data dictionary transaction in order to release
 
752
        the table locks on the system tables.  Unfortunately, this
 
753
        means that if MySQL crashes while creating a new primary key
 
754
        inside row_merge_build_indexes(), indexed_table will not be
 
755
        dropped on crash recovery.  Thus, it will become orphaned. */
 
756
        trx_commit_for_mysql(trx);
 
757
 
 
758
        row_mysql_unlock_data_dictionary(trx);
 
759
        dict_locked = FALSE;
 
760
 
 
761
        ut_a(trx->n_active_thrs == 0);
 
762
        ut_a(UT_LIST_GET_LEN(trx->signals) == 0);
 
763
 
 
764
        if (UNIV_UNLIKELY(new_primary)) {
 
765
                /* A primary key is to be built.  Acquire an exclusive
 
766
                table lock also on the table that is being created. */
 
767
                ut_ad(indexed_table != innodb_table);
 
768
 
 
769
                error = row_merge_lock_table(prebuilt->trx, indexed_table,
 
770
                                             LOCK_X);
 
771
 
 
772
                if (UNIV_UNLIKELY(error != DB_SUCCESS)) {
 
773
 
 
774
                        goto error_handling;
 
775
                }
 
776
        }
 
777
 
 
778
        /* Read the clustered index of the table and build indexes
 
779
        based on this information using temporary files and merge sort. */
 
780
        error = row_merge_build_indexes(prebuilt->trx,
 
781
                                        innodb_table, indexed_table,
 
782
                                        index, num_of_idx, table);
 
783
 
 
784
error_handling:
 
785
#ifdef UNIV_DEBUG
 
786
        /* TODO: At the moment we can't handle the following statement
 
787
        in our debugging code below:
 
788
 
 
789
        alter table t drop index b, add index (b);
 
790
 
 
791
        The fix will have to parse the SQL and note that the index
 
792
        being added has the same name as the the one being dropped and
 
793
        ignore that in the dup index check.*/
 
794
        //dict_table_check_for_dup_indexes(prebuilt->table);
 
795
#endif
 
796
 
 
797
        /* After an error, remove all those index definitions from the
 
798
        dictionary which were defined. */
 
799
 
 
800
        switch (error) {
 
801
                const char*     old_name;
 
802
                char*           tmp_name;
 
803
        case DB_SUCCESS:
 
804
                ut_ad(!dict_locked);
 
805
 
 
806
                if (!new_primary) {
 
807
                        error = row_merge_rename_indexes(trx, indexed_table);
 
808
 
 
809
                        if (error != DB_SUCCESS) {
 
810
                                row_merge_drop_indexes(trx, indexed_table,
 
811
                                                       index, num_created);
 
812
                        }
 
813
 
 
814
                        goto convert_error;
 
815
                }
 
816
 
 
817
                /* If a new primary key was defined for the table and
 
818
                there was no error at this point, we can now rename
 
819
                the old table as a temporary table, rename the new
 
820
                temporary table as the old table and drop the old table. */
 
821
                old_name = innodb_table->name;
 
822
                tmp_name = innobase_create_temporary_tablename(heap, '2',
 
823
                                                               old_name);
 
824
 
 
825
                row_mysql_lock_data_dictionary(trx);
 
826
                dict_locked = TRUE;
 
827
 
 
828
                error = row_merge_rename_tables(innodb_table, indexed_table,
 
829
                                                tmp_name, trx);
 
830
 
 
831
                if (error != DB_SUCCESS) {
 
832
 
 
833
                        row_merge_drop_table(trx, indexed_table);
 
834
 
 
835
                        switch (error) {
 
836
                        case DB_TABLESPACE_ALREADY_EXISTS:
 
837
                        case DB_DUPLICATE_KEY:
 
838
                                innobase_convert_tablename(tmp_name);
 
839
                                my_error(HA_ERR_TABLE_EXIST, MYF(0), tmp_name);
 
840
                                error = HA_ERR_TABLE_EXIST;
 
841
                                break;
 
842
                        default:
 
843
                                goto convert_error;
 
844
                        }
 
845
                        break;
 
846
                }
 
847
 
 
848
                trx_commit_for_mysql(prebuilt->trx);
 
849
                row_prebuilt_free(prebuilt, TRUE);
 
850
                prebuilt = row_create_prebuilt(indexed_table);
 
851
 
 
852
                indexed_table->n_mysql_handles_opened++;
 
853
 
 
854
                error = row_merge_drop_table(trx, innodb_table);
 
855
                goto convert_error;
 
856
 
 
857
        case DB_TOO_BIG_RECORD:
 
858
                my_error(HA_ERR_TO_BIG_ROW, MYF(0));
 
859
                goto error;
 
860
        case DB_PRIMARY_KEY_IS_NULL:
 
861
                my_error(ER_PRIMARY_CANT_HAVE_NULL, MYF(0));
 
862
                /* fall through */
 
863
        case DB_DUPLICATE_KEY:
 
864
error:
 
865
                prebuilt->trx->error_info = NULL;
 
866
                /* fall through */
 
867
        default:
 
868
                if (new_primary) {
 
869
                        row_merge_drop_table(trx, indexed_table);
 
870
                } else {
 
871
                        row_merge_drop_indexes(trx, indexed_table,
 
872
                                               index, num_created);
 
873
                }
 
874
 
 
875
convert_error:
 
876
                error = convert_error_code_to_mysql(error,
 
877
                                                    innodb_table->flags,
 
878
                                                    user_thd);
 
879
        }
 
880
 
 
881
        mem_heap_free(heap);
 
882
        trx_commit_for_mysql(trx);
 
883
        if (prebuilt->trx) {
 
884
                trx_commit_for_mysql(prebuilt->trx);
 
885
        }
 
886
 
 
887
        if (dict_locked) {
 
888
                row_mysql_unlock_data_dictionary(trx);
 
889
        }
 
890
 
 
891
        trx_free_for_mysql(trx);
 
892
 
 
893
        /* There might be work for utility threads.*/
 
894
        srv_active_wake_master_thread();
 
895
 
 
896
        DBUG_RETURN(error);
 
897
}
 
898
 
 
899
/***********************************************************************
 
900
Prepare to drop some indexes of a table. */
 
901
UNIV_INTERN
 
902
int
 
903
ha_innobase::prepare_drop_index(
 
904
/*============================*/
 
905
                                /* out: 0 or error number */
 
906
        TABLE*  table,          /* in: Table where indexes are dropped */
 
907
        uint*   key_num,        /* in: Key nums to be dropped */
 
908
        uint    num_of_keys)    /* in: Number of keys to be dropped */
 
909
{
 
910
        trx_t*          trx;
 
911
        int             err = 0;
 
912
        uint            n_key;
 
913
 
 
914
        DBUG_ENTER("ha_innobase::prepare_drop_index");
 
915
        ut_ad(table);
 
916
        ut_ad(key_num);
 
917
        ut_ad(num_of_keys);
 
918
        if (srv_created_new_raw || srv_force_recovery) {
 
919
                DBUG_RETURN(HA_ERR_WRONG_COMMAND);
 
920
        }
 
921
 
 
922
        update_thd();
 
923
 
 
924
        trx_search_latch_release_if_reserved(prebuilt->trx);
 
925
        trx = prebuilt->trx;
 
926
 
 
927
        /* Test and mark all the indexes to be dropped */
 
928
 
 
929
        row_mysql_lock_data_dictionary(trx);
 
930
 
 
931
        /* Check that none of the indexes have previously been flagged
 
932
        for deletion. */
 
933
        {
 
934
                const dict_index_t*     index
 
935
                        = dict_table_get_first_index(prebuilt->table);
 
936
                do {
 
937
                        ut_a(!index->to_be_dropped);
 
938
                        index = dict_table_get_next_index(index);
 
939
                } while (index);
 
940
        }
 
941
 
 
942
        for (n_key = 0; n_key < num_of_keys; n_key++) {
 
943
                const KEY*      key;
 
944
                dict_index_t*   index;
 
945
 
 
946
                key = table->key_info + key_num[n_key];
 
947
                index = dict_table_get_index_on_name_and_min_id(
 
948
                        prebuilt->table, key->name);
 
949
 
 
950
                if (!index) {
 
951
                        sql_print_error("InnoDB could not find key n:o %u "
 
952
                                        "with name %s for table %s",
 
953
                                        key_num[n_key],
 
954
                                        key ? key->name : "NULL",
 
955
                                        prebuilt->table->name);
 
956
 
 
957
                        err = HA_ERR_KEY_NOT_FOUND;
 
958
                        goto func_exit;
 
959
                }
 
960
 
 
961
                /* Refuse to drop the clustered index.  It would be
 
962
                better to automatically generate a clustered index,
 
963
                but mysql_alter_table() will call this method only
 
964
                after ha_innobase::add_index(). */
 
965
 
 
966
                if (dict_index_is_clust(index)) {
 
967
                        my_error(ER_REQUIRES_PRIMARY_KEY, MYF(0));
 
968
                        err = -1;
 
969
                        goto func_exit;
 
970
                }
 
971
 
 
972
                index->to_be_dropped = TRUE;
 
973
        }
 
974
 
 
975
        /* If FOREIGN_KEY_CHECK = 1 you may not drop an index defined
 
976
        for a foreign key constraint because InnoDB requires that both
 
977
        tables contain indexes for the constraint.  Note that CREATE
 
978
        INDEX id ON table does a CREATE INDEX and DROP INDEX, and we
 
979
        can ignore here foreign keys because a new index for the
 
980
        foreign key has already been created.
 
981
 
 
982
        We check for the foreign key constraints after marking the
 
983
        candidate indexes for deletion, because when we check for an
 
984
        equivalent foreign index we don't want to select an index that
 
985
        is later deleted. */
 
986
 
 
987
        if (trx->check_foreigns
 
988
            && thd_sql_command(user_thd) != SQLCOM_CREATE_INDEX) {
 
989
                dict_index_t*   index
 
990
                        = dict_table_get_first_index(prebuilt->table);
 
991
 
 
992
                do {
 
993
                        dict_foreign_t* foreign;
 
994
 
 
995
                        if (!index->to_be_dropped) {
 
996
 
 
997
                                goto next_index;
 
998
                        }
 
999
 
 
1000
                        /* Check if the index is referenced. */
 
1001
                        foreign = dict_table_get_referenced_constraint(
 
1002
                                prebuilt->table, index);
 
1003
 
 
1004
                        if (foreign) {
 
1005
index_needed:
 
1006
                                trx_set_detailed_error(
 
1007
                                        trx,
 
1008
                                        "Index needed in foreign key "
 
1009
                                        "constraint");
 
1010
 
 
1011
                                trx->error_info = index;
 
1012
 
 
1013
                                err = HA_ERR_DROP_INDEX_FK;
 
1014
                                break;
 
1015
                        } else {
 
1016
                                /* Check if this index references some
 
1017
                                other table */
 
1018
                                foreign = dict_table_get_foreign_constraint(
 
1019
                                        prebuilt->table, index);
 
1020
 
 
1021
                                if (foreign) {
 
1022
                                        ut_a(foreign->foreign_index == index);
 
1023
 
 
1024
                                        /* Search for an equivalent index that
 
1025
                                        the foreign key contraint could use
 
1026
                                        if this index were to be deleted. */
 
1027
                                        if (!dict_table_find_equivalent_index(
 
1028
                                                prebuilt->table,
 
1029
                                                foreign->foreign_index)) {
 
1030
 
 
1031
                                                goto index_needed;
 
1032
                                        }
 
1033
                                }
 
1034
                        }
 
1035
 
 
1036
next_index:
 
1037
                        index = dict_table_get_next_index(index);
 
1038
                } while (index);
 
1039
        }
 
1040
 
 
1041
func_exit:
 
1042
        if (err) {
 
1043
                /* Undo our changes since there was some sort of error. */
 
1044
                dict_index_t*   index
 
1045
                        = dict_table_get_first_index(prebuilt->table);
 
1046
 
 
1047
                do {
 
1048
                        index->to_be_dropped = FALSE;
 
1049
                        index = dict_table_get_next_index(index);
 
1050
                } while (index);
 
1051
        }
 
1052
 
 
1053
        row_mysql_unlock_data_dictionary(trx);
 
1054
 
 
1055
        DBUG_RETURN(err);
 
1056
}
 
1057
 
 
1058
/***********************************************************************
 
1059
Drop the indexes that were passed to a successful prepare_drop_index(). */
 
1060
UNIV_INTERN
 
1061
int
 
1062
ha_innobase::final_drop_index(
 
1063
/*==========================*/
 
1064
                                /* out: 0 or error number */
 
1065
        TABLE*  table)          /* in: Table where indexes are dropped */
 
1066
{
 
1067
        dict_index_t*   index;          /* Index to be dropped */
 
1068
        trx_t*          trx;            /* Transaction */
 
1069
        int             err;
 
1070
 
 
1071
        DBUG_ENTER("ha_innobase::final_drop_index");
 
1072
        ut_ad(table);
 
1073
 
 
1074
        if (srv_created_new_raw || srv_force_recovery) {
 
1075
                DBUG_RETURN(HA_ERR_WRONG_COMMAND);
 
1076
        }
 
1077
 
 
1078
        update_thd();
 
1079
 
 
1080
        trx_search_latch_release_if_reserved(prebuilt->trx);
 
1081
 
 
1082
        /* Create a background transaction for the operations on
 
1083
        the data dictionary tables. */
 
1084
        trx = trx_allocate_for_mysql();
 
1085
        trx_start_if_not_started(trx);
 
1086
 
 
1087
        trans_register_ha(user_thd, FALSE, ht);
 
1088
        prebuilt->trx->active_trans = 1;
 
1089
 
 
1090
        trx->mysql_thd = user_thd;
 
1091
        trx->mysql_query_str = thd_query(user_thd);
 
1092
 
 
1093
        /* Flag this transaction as a dictionary operation, so that
 
1094
        the data dictionary will be locked in crash recovery. */
 
1095
        trx_set_dict_operation(trx, TRX_DICT_OP_INDEX);
 
1096
 
 
1097
        /* Lock the table exclusively, to ensure that no active
 
1098
        transaction depends on an index that is being dropped. */
 
1099
        err = convert_error_code_to_mysql(
 
1100
                row_merge_lock_table(prebuilt->trx, prebuilt->table, LOCK_X),
 
1101
                prebuilt->table->flags, user_thd);
 
1102
 
 
1103
        if (UNIV_UNLIKELY(err)) {
 
1104
 
 
1105
                /* Unmark the indexes to be dropped. */
 
1106
                row_mysql_lock_data_dictionary(trx);
 
1107
 
 
1108
                for (index = dict_table_get_first_index(prebuilt->table);
 
1109
                     index; index = dict_table_get_next_index(index)) {
 
1110
 
 
1111
                        index->to_be_dropped = FALSE;
 
1112
                }
 
1113
 
 
1114
                row_mysql_unlock_data_dictionary(trx);
 
1115
                goto func_exit;
 
1116
        }
 
1117
 
 
1118
        /* Drop indexes marked to be dropped */
 
1119
 
 
1120
        row_mysql_lock_data_dictionary(trx);
 
1121
 
 
1122
        index = dict_table_get_first_index(prebuilt->table);
 
1123
 
 
1124
        while (index) {
 
1125
                dict_index_t*   next_index;
 
1126
 
 
1127
                next_index = dict_table_get_next_index(index);
 
1128
 
 
1129
                if (index->to_be_dropped) {
 
1130
 
 
1131
                        row_merge_drop_index(index, prebuilt->table, trx);
 
1132
                }
 
1133
 
 
1134
                index = next_index;
 
1135
        }
 
1136
 
 
1137
        /* Check that all flagged indexes were dropped. */
 
1138
        for (index = dict_table_get_first_index(prebuilt->table);
 
1139
             index; index = dict_table_get_next_index(index)) {
 
1140
                ut_a(!index->to_be_dropped);
 
1141
        }
 
1142
 
 
1143
#ifdef UNIV_DEBUG
 
1144
        dict_table_check_for_dup_indexes(prebuilt->table);
 
1145
#endif
 
1146
        row_mysql_unlock_data_dictionary(trx);
 
1147
 
 
1148
func_exit:
 
1149
        trx_commit_for_mysql(trx);
 
1150
        trx_commit_for_mysql(prebuilt->trx);
 
1151
 
 
1152
        /* Flush the log to reduce probability that the .frm files and
 
1153
        the InnoDB data dictionary get out-of-sync if the user runs
 
1154
        with innodb_flush_log_at_trx_commit = 0 */
 
1155
 
 
1156
        log_buffer_flush_to_disk();
 
1157
 
 
1158
        trx_free_for_mysql(trx);
 
1159
 
 
1160
        /* Tell the InnoDB server that there might be work for
 
1161
        utility threads: */
 
1162
 
 
1163
        srv_active_wake_master_thread();
 
1164
 
 
1165
        DBUG_RETURN(err);
 
1166
}