← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Reverted 1103

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/row0merge.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 2005, 2010, 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., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 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 */