← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Eric Day
  • Date: 2009-10-31 21:53:33 UTC
  • mfrom: (1200 staging)
  • mto: This revision was merged to the branch mainline in revision 1202.
  • Revision ID: eday@oddments.org-20091031215333-j94bjoanwmi68p6f
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/handler/handler0alter.cc
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/******************************************************
 
19
/**************************************************//**
 
20
@file handler/handler0alter.cc
20
21
Smart ALTER TABLE
21
22
*******************************************************/
22
23
 
40
41
#include "ha_innodb.h"
41
42
#include "handler0vars.h"
42
43
 
43
 
/*****************************************************************
 
44
/*************************************************************//**
44
45
Copies an InnoDB column to a MySQL field.  This function is
45
46
adapted from row_sel_field_store_in_mysql_format(). */
46
47
static
47
48
void
48
49
innobase_col_to_mysql(
49
50
/*==================*/
50
 
        const dict_col_t*       col,    /* in: InnoDB column */
51
 
        const unsigned char*            data,   /* in: InnoDB column data */
52
 
        ulint                   len,    /* in: length of data, in bytes */
53
 
        Field*                  field)  /* in/out: MySQL field */
 
51
        const dict_col_t*       col,    /*!< in: InnoDB column */
 
52
        const unsigned char*    data,   /*!< in: InnoDB column data */
 
53
        ulint                   len,    /*!< in: length of data, in bytes */
 
54
        Field*                  field)  /*!< in/out: MySQL field */
54
55
{
55
56
        unsigned char*  ptr;
56
57
        unsigned char*  dest    = field->ptr;
126
127
        }
127
128
}
128
129
 
129
 
/*****************************************************************
 
130
/*************************************************************//**
130
131
Copies an InnoDB record to table->record[0]. */
131
132
extern "C" UNIV_INTERN
132
133
void
133
134
innobase_rec_to_mysql(
134
135
/*==================*/
135
 
        Table*                  table,          /* in/out: MySQL table */
136
 
        const rec_t*            rec,            /* in: record */
137
 
        const dict_index_t*     index,          /* in: index */
138
 
        const ulint*            offsets)        /* in: rec_get_offsets(
 
136
        Table*                  table,          /*!< in/out: MySQL table */
 
137
        const rec_t*            rec,            /*!< in: record */
 
138
        const dict_index_t*     index,          /*!< in: index */
 
139
        const ulint*            offsets)        /*!< in: rec_get_offsets(
139
140
                                                rec, index, ...) */
140
141
{
141
142
        uint    n_fields        = table->s->fields;
176
177
        }
177
178
}
178
179
 
179
 
/*****************************************************************
 
180
/*************************************************************//**
180
181
Resets table->record[0]. */
181
182
extern "C" UNIV_INTERN
182
183
void
183
184
innobase_rec_reset(
184
185
/*===============*/
185
 
        Table*                  table)          /* in/out: MySQL table */
 
186
        Table*                  table)          /*!< in/out: MySQL table */
186
187
{
187
188
        uint    n_fields        = table->s->fields;
188
189
        uint    i;
192
193
        }
193
194
}
194
195
 
195
 
/**********************************************************************
 
196
/******************************************************************//**
196
197
Removes the filename encoding of a database and table name. */
197
198
static
198
199
void
199
200
innobase_convert_tablename(
200
201
/*=======================*/
201
 
        char*   s)      /* in: identifier; out: decoded identifier */
 
202
        char*   s)      /*!< in: identifier; out: decoded identifier */
202
203
{
203
204
 
204
205
        char*   slash = strchr(s, '/');
219
220
        }
220
221
}
221
222
 
222
 
/***********************************************************************
223
 
This function checks that index keys are sensible. */
 
223
/*******************************************************************//**
 
224
This function checks that index keys are sensible.
 
225
@return 0 or error number */
224
226
static
225
227
int
226
228
innobase_check_index_keys(
227
229
/*======================*/
228
 
                                        /* out: 0 or error number */
229
 
        const KEY*      key_info,       /* in: Indexes to be created */
230
 
        ulint           num_of_keys)    /* in: Number of indexes to
 
230
        const KEY*      key_info,       /*!< in: Indexes to be created */
 
231
        ulint           num_of_keys)    /*!< in: Number of indexes to
231
232
                                        be created */
232
233
{
233
234
        ulint           key_num;
319
320
        return(0);
320
321
}
321
322
 
322
 
/***********************************************************************
 
323
/*******************************************************************//**
323
324
Create index field definition for key part */
324
325
static
325
326
void
326
327
innobase_create_index_field_def(
327
328
/*============================*/
328
 
        KEY_PART_INFO*          key_part,       /* in: MySQL key definition */
329
 
        mem_heap_t*             heap,           /* in: memory heap */
330
 
        merge_index_field_t*    index_field)    /* out: index field
 
329
        KEY_PART_INFO*          key_part,       /*!< in: MySQL key definition */
 
330
        mem_heap_t*             heap,           /*!< in: memory heap */
 
331
        merge_index_field_t*    index_field)    /*!< out: index field
331
332
                                                definition for key_part */
332
333
{
333
334
        Field*          field;
359
360
        return;
360
361
}
361
362
 
362
 
/***********************************************************************
 
363
/*******************************************************************//**
363
364
Create index definition for key */
364
365
static
365
366
void
366
367
innobase_create_index_def(
367
368
/*======================*/
368
 
        KEY*                    key,            /* in: key definition */
369
 
        bool                    new_primary,    /* in: TRUE=generating
 
369
        KEY*                    key,            /*!< in: key definition */
 
370
        bool                    new_primary,    /*!< in: TRUE=generating
370
371
                                                a new primary key
371
372
                                                on the table */
372
 
        bool                    key_primary,    /* in: TRUE if this key
 
373
        bool                    key_primary,    /*!< in: TRUE if this key
373
374
                                                is a primary key */
374
 
        merge_index_def_t*      index,          /* out: index definition */
375
 
        mem_heap_t*             heap)           /* in: heap where memory
 
375
        merge_index_def_t*      index,          /*!< out: index definition */
 
376
        mem_heap_t*             heap)           /*!< in: heap where memory
376
377
                                                is allocated */
377
378
{
378
379
        ulint   i;
411
412
        return;
412
413
}
413
414
 
414
 
/***********************************************************************
 
415
/*******************************************************************//**
415
416
Copy index field definition */
416
417
static
417
418
void
418
419
innobase_copy_index_field_def(
419
420
/*==========================*/
420
 
        const dict_field_t*     field,          /* in: definition to copy */
421
 
        merge_index_field_t*    index_field)    /* out: copied definition */
 
421
        const dict_field_t*     field,          /*!< in: definition to copy */
 
422
        merge_index_field_t*    index_field)    /*!< out: copied definition */
422
423
{
423
424
        assert(field != NULL);
424
425
        assert(index_field != NULL);
429
430
        return;
430
431
}
431
432
 
432
 
/***********************************************************************
 
433
/*******************************************************************//**
433
434
Copy index definition for the index */
434
435
static
435
436
void
436
437
innobase_copy_index_def(
437
438
/*====================*/
438
 
        const dict_index_t*     index,  /* in: index definition to copy */
439
 
        merge_index_def_t*      new_index,/* out: Index definition */
440
 
        mem_heap_t*             heap)   /* in: heap where allocated */
 
439
        const dict_index_t*     index,  /*!< in: index definition to copy */
 
440
        merge_index_def_t*      new_index,/*!< out: Index definition */
 
441
        mem_heap_t*             heap)   /*!< in: heap where allocated */
441
442
{
442
443
        ulint   n_fields;
443
444
        ulint   i;
465
466
        return;
466
467
}
467
468
 
468
 
/***********************************************************************
 
469
/*******************************************************************//**
469
470
Create an index table where indexes are ordered as follows:
470
471
 
471
472
IF a new primary key is defined for the table THEN
480
481
 
481
482
ENDIF
482
483
 
483
 
*/
 
484
 
 
485
@return key definitions or NULL */
484
486
static
485
487
merge_index_def_t*
486
488
innobase_create_key_def(
487
489
/*====================*/
488
 
                                        /* out: key definitions or NULL */
489
 
        trx_t*          trx,            /* in: trx */
490
 
        const dict_table_t*table,               /* in: table definition */
491
 
        mem_heap_t*     heap,           /* in: heap where space for key
 
490
        trx_t*          trx,            /*!< in: trx */
 
491
        const dict_table_t*table,               /*!< in: table definition */
 
492
        mem_heap_t*     heap,           /*!< in: heap where space for key
492
493
                                        definitions are allocated */
493
 
        KEY*            key_info,       /* in: Indexes to be created */
494
 
        ulint&          n_keys)         /* in/out: Number of indexes to
 
494
        KEY*            key_info,       /*!< in: Indexes to be created */
 
495
        ulint&          n_keys)         /*!< in/out: Number of indexes to
495
496
                                        be created */
496
497
{
497
498
        ulint                   i = 0;
569
570
        return(indexdefs);
570
571
}
571
572
 
572
 
/***********************************************************************
573
 
Create a temporary tablename using query id, thread id, and id */
 
573
/*******************************************************************//**
 
574
Create a temporary tablename using query id, thread id, and id
 
575
@return temporary tablename */
574
576
static
575
577
char*
576
578
innobase_create_temporary_tablename(
577
579
/*================================*/
578
 
                                        /* out: temporary tablename */
579
 
        mem_heap_t*     heap,           /* in: memory heap */
580
 
        char            id,             /* in: identifier [0-9a-zA-Z] */
581
 
        const char*     table_name)     /* in: table name */
 
580
        mem_heap_t*     heap,           /*!< in: memory heap */
 
581
        char            id,             /*!< in: identifier [0-9a-zA-Z] */
 
582
        const char*     table_name)     /*!< in: table name */
582
583
{
583
584
        char*                   name;
584
585
        ulint                   len;
594
595
        return(name);
595
596
}
596
597
 
597
 
/***********************************************************************
598
 
Create indexes. */
 
598
/*******************************************************************//**
 
599
Create indexes.
 
600
@return 0 or error number */
599
601
UNIV_INTERN
600
602
int
601
603
ha_innobase::add_index(
602
604
/*===================*/
603
 
                                /* out: 0 or error number */
604
 
        Table*  i_table,        /* in: Table where indexes are created */
605
 
        KEY*    key_info,       /* in: Indexes to be created */
606
 
        uint    num_of_keys)    /* in: Number of indexes to be created */
 
605
        Table*  i_table,        /*!< in: Table where indexes are created */
 
606
        KEY*    key_info,       /*!< in: Indexes to be created */
 
607
        uint    num_of_keys)    /*!< in: Number of indexes to be created */
607
608
{
608
 
        dict_index_t**  index;          /* Index to be created */
609
 
        dict_table_t*   innodb_table;   /* InnoDB table in dictionary */
610
 
        dict_table_t*   indexed_table;  /* Table where indexes are created */
611
 
        merge_index_def_t* index_defs;  /* Index definitions */
612
 
        mem_heap_t*     heap;           /* Heap for index definitions */
613
 
        trx_t*          trx;            /* Transaction */
 
609
        dict_index_t**  index;          /*!< Index to be created */
 
610
        dict_table_t*   innodb_table;   /*!< InnoDB table in dictionary */
 
611
        dict_table_t*   indexed_table;  /*!< Table where indexes are created */
 
612
        merge_index_def_t* index_defs;  /*!< Index definitions */
 
613
        mem_heap_t*     heap;           /*!< Heap for index definitions */
 
614
        trx_t*          trx;            /*!< Transaction */
614
615
        ulint           num_of_idx;
615
616
        ulint           num_created     = 0;
616
617
        ibool           dict_locked     = FALSE;
632
633
        /* In case MySQL calls this in the middle of a SELECT query, release
633
634
        possible adaptive hash latch to avoid deadlocks of threads. */
634
635
        trx_search_latch_release_if_reserved(prebuilt->trx);
 
636
        trx_start_if_not_started(prebuilt->trx);
635
637
 
636
638
        /* Create a background transaction for the operations on
637
639
        the data dictionary tables. */
897
899
        return(error);
898
900
}
899
901
 
900
 
/***********************************************************************
901
 
Prepare to drop some indexes of a table. */
 
902
/*******************************************************************//**
 
903
Prepare to drop some indexes of a table.
 
904
@return 0 or error number */
902
905
UNIV_INTERN
903
906
int
904
907
ha_innobase::prepare_drop_index(
905
908
/*============================*/
906
 
                                /* out: 0 or error number */
907
 
        Table*  i_table,        /* in: Table where indexes are dropped */
908
 
        uint*   key_num,        /* in: Key nums to be dropped */
909
 
        uint    num_of_keys)    /* in: Number of keys to be dropped */
 
909
        Table*  i_table,        /*!< in: Table where indexes are dropped */
 
910
        uint*   key_num,        /*!< in: Key nums to be dropped */
 
911
        uint    num_of_keys)    /*!< in: Number of keys to be dropped */
910
912
{
911
913
        trx_t*          trx;
912
914
        int             err = 0;
960
962
 
961
963
                /* Refuse to drop the clustered index.  It would be
962
964
                better to automatically generate a clustered index,
963
 
                but mysql_alter_table() will call this method only
 
965
                but drizzled::alter_table() will call this method only
964
966
                after ha_innobase::add_index(). */
965
967
 
966
968
                if (dict_index_is_clust(index)) {
1097
1099
        return(err);
1098
1100
}
1099
1101
 
1100
 
/***********************************************************************
1101
 
Drop the indexes that were passed to a successful prepare_drop_index(). */
 
1102
/*******************************************************************//**
 
1103
Drop the indexes that were passed to a successful prepare_drop_index().
 
1104
@return 0 or error number */
1102
1105
UNIV_INTERN
1103
1106
int
1104
1107
ha_innobase::final_drop_index(
1105
1108
/*==========================*/
1106
 
                                /* out: 0 or error number */
1107
 
        Table*          )       /* in: Table where indexes are dropped */
 
1109
        Table*  )               /*!< in: Table where indexes are dropped */
1108
1110
{
1109
 
        dict_index_t*   index;          /* Index to be dropped */
1110
 
        trx_t*          trx;            /* Transaction */
 
1111
        dict_index_t*   index;          /*!< Index to be dropped */
 
1112
        trx_t*          trx;            /*!< Transaction */
1111
1113
        int             err;
1112
1114
 
1113
1115
        if (srv_created_new_raw || srv_force_recovery) {
1117
1119
        update_session();
1118
1120
 
1119
1121
        trx_search_latch_release_if_reserved(prebuilt->trx);
 
1122
        trx_start_if_not_started(prebuilt->trx);
1120
1123
 
1121
1124
        /* Create a background transaction for the operations on
1122
1125
        the data dictionary tables. */