← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to plugin/innobase/include/row0merge.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-03-18 12:12:31 UTC
  • Revision ID: james.westby@ubuntu.com-20100318121231-k6g1xe6cshbwa0f8
Tags: upstream-2010.03.1347
Import upstream version 2010.03.1347

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/row0merge.h
 
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 include/row0merge.h
 
21
Index build routines using a merge sort
 
22
 
 
23
Created 13/06/2005 Jan Lindstrom
 
24
*******************************************************/
 
25
 
 
26
#ifndef row0merge_h
 
27
#define row0merge_h
 
28
 
 
29
#include "univ.i"
 
30
#include "data0data.h"
 
31
#include "dict0types.h"
 
32
#include "trx0types.h"
 
33
#include "que0types.h"
 
34
#include "mtr0mtr.h"
 
35
#include "rem0types.h"
 
36
#include "rem0rec.h"
 
37
#include "read0types.h"
 
38
#include "btr0types.h"
 
39
#include "row0mysql.h"
 
40
#include "lock0types.h"
 
41
 
 
42
/** Index field definition */
 
43
struct merge_index_field_struct {
 
44
        ulint           prefix_len;     /*!< column prefix length, or 0
 
45
                                        if indexing the whole column */
 
46
        const char*     field_name;     /*!< field name */
 
47
};
 
48
 
 
49
/** Index field definition */
 
50
typedef struct merge_index_field_struct merge_index_field_t;
 
51
 
 
52
/** Definition of an index being created */
 
53
struct merge_index_def_struct {
 
54
        const char*             name;           /*!< index name */
 
55
        ulint                   ind_type;       /*!< 0, DICT_UNIQUE,
 
56
                                                or DICT_CLUSTERED */
 
57
        ulint                   n_fields;       /*!< number of fields
 
58
                                                in index */
 
59
        merge_index_field_t*    fields;         /*!< field definitions */
 
60
};
 
61
 
 
62
/** Definition of an index being created */
 
63
typedef struct merge_index_def_struct merge_index_def_t;
 
64
 
 
65
/*********************************************************************//**
 
66
Sets an exclusive lock on a table, for the duration of creating indexes.
 
67
@return error code or DB_SUCCESS */
 
68
UNIV_INTERN
 
69
ulint
 
70
row_merge_lock_table(
 
71
/*=================*/
 
72
        trx_t*          trx,            /*!< in/out: transaction */
 
73
        dict_table_t*   table,          /*!< in: table to lock */
 
74
        enum lock_mode  mode);          /*!< in: LOCK_X or LOCK_S */
 
75
/*********************************************************************//**
 
76
Drop an index from the InnoDB system tables.  The data dictionary must
 
77
have been locked exclusively by the caller, because the transaction
 
78
will not be committed. */
 
79
UNIV_INTERN
 
80
void
 
81
row_merge_drop_index(
 
82
/*=================*/
 
83
        dict_index_t*   index,  /*!< in: index to be removed */
 
84
        dict_table_t*   table,  /*!< in: table */
 
85
        trx_t*          trx);   /*!< in: transaction handle */
 
86
/*********************************************************************//**
 
87
Drop those indexes which were created before an error occurred when
 
88
building an index.  The data dictionary must have been locked
 
89
exclusively by the caller, because the transaction will not be
 
90
committed. */
 
91
UNIV_INTERN
 
92
void
 
93
row_merge_drop_indexes(
 
94
/*===================*/
 
95
        trx_t*          trx,            /*!< in: transaction */
 
96
        dict_table_t*   table,          /*!< in: table containing the indexes */
 
97
        dict_index_t**  index,          /*!< in: indexes to drop */
 
98
        ulint           num_created);   /*!< in: number of elements in index[] */
 
99
/*********************************************************************//**
 
100
Drop all partially created indexes during crash recovery. */
 
101
UNIV_INTERN
 
102
void
 
103
row_merge_drop_temp_indexes(void);
 
104
/*=============================*/
 
105
/*********************************************************************//**
 
106
Rename the tables in the data dictionary.  The data dictionary must
 
107
have been locked exclusively by the caller, because the transaction
 
108
will not be committed.
 
109
@return error code or DB_SUCCESS */
 
110
UNIV_INTERN
 
111
ulint
 
112
row_merge_rename_tables(
 
113
/*====================*/
 
114
        dict_table_t*   old_table,      /*!< in/out: old table, renamed to
 
115
                                        tmp_name */
 
116
        dict_table_t*   new_table,      /*!< in/out: new table, renamed to
 
117
                                        old_table->name */
 
118
        const char*     tmp_name,       /*!< in: new name for old_table */
 
119
        trx_t*          trx);           /*!< in: transaction handle */
 
120
 
 
121
/*********************************************************************//**
 
122
Create a temporary table for creating a primary key, using the definition
 
123
of an existing table.
 
124
@return table, or NULL on error */
 
125
UNIV_INTERN
 
126
dict_table_t*
 
127
row_merge_create_temporary_table(
 
128
/*=============================*/
 
129
        const char*             table_name,     /*!< in: new table name */
 
130
        const merge_index_def_t*index_def,      /*!< in: the index definition
 
131
                                                of the primary key */
 
132
        const dict_table_t*     table,          /*!< in: old table definition */
 
133
        trx_t*                  trx);           /*!< in/out: transaction
 
134
                                                (sets error_state) */
 
135
/*********************************************************************//**
 
136
Rename the temporary indexes in the dictionary to permanent ones.  The
 
137
data dictionary must have been locked exclusively by the caller,
 
138
because the transaction will not be committed.
 
139
@return DB_SUCCESS if all OK */
 
140
UNIV_INTERN
 
141
ulint
 
142
row_merge_rename_indexes(
 
143
/*=====================*/
 
144
        trx_t*          trx,            /*!< in/out: transaction */
 
145
        dict_table_t*   table);         /*!< in/out: table with new indexes */
 
146
/*********************************************************************//**
 
147
Create the index and load in to the dictionary.
 
148
@return index, or NULL on error */
 
149
UNIV_INTERN
 
150
dict_index_t*
 
151
row_merge_create_index(
 
152
/*===================*/
 
153
        trx_t*                  trx,    /*!< in/out: trx (sets error_state) */
 
154
        dict_table_t*           table,  /*!< in: the index is on this table */
 
155
        const merge_index_def_t*index_def);
 
156
                                        /*!< in: the index definition */
 
157
/*********************************************************************//**
 
158
Check if a transaction can use an index.
 
159
@return TRUE if index can be used by the transaction else FALSE */
 
160
UNIV_INTERN
 
161
ibool
 
162
row_merge_is_index_usable(
 
163
/*======================*/
 
164
        const trx_t*            trx,    /*!< in: transaction */
 
165
        const dict_index_t*     index); /*!< in: index to check */
 
166
/*********************************************************************//**
 
167
If there are views that refer to the old table name then we "attach" to
 
168
the new instance of the table else we drop it immediately.
 
169
@return DB_SUCCESS or error code */
 
170
UNIV_INTERN
 
171
ulint
 
172
row_merge_drop_table(
 
173
/*=================*/
 
174
        trx_t*          trx,            /*!< in: transaction */
 
175
        dict_table_t*   table);         /*!< in: table instance to drop */
 
176
 
 
177
/*********************************************************************//**
 
178
Build indexes on a table by reading a clustered index,
 
179
creating a temporary file containing index entries, merge sorting
 
180
these index entries and inserting sorted index entries to indexes.
 
181
@return DB_SUCCESS or error code */
 
182
UNIV_INTERN
 
183
ulint
 
184
row_merge_build_indexes(
 
185
/*====================*/
 
186
        trx_t*          trx,            /*!< in: transaction */
 
187
        dict_table_t*   old_table,      /*!< in: table where rows are
 
188
                                        read from */
 
189
        dict_table_t*   new_table,      /*!< in: table where indexes are
 
190
                                        created; identical to old_table
 
191
                                        unless creating a PRIMARY KEY */
 
192
        dict_index_t**  indexes,        /*!< in: indexes to be created */
 
193
        ulint           n_indexes,      /*!< in: size of indexes[] */
 
194
        TABLE*          table);         /*!< in/out: MySQL table, for
 
195
                                        reporting erroneous key value
 
196
                                        if applicable */
 
197
#endif /* row0merge.h */