← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Removed/replaced DBUG symbols and TRUE/FALSE

Show diffs side-by-side

added added

removed removed

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