← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2009-03-22 07:55:08 UTC
  • mto: (960.5.2 mordred)
  • mto: This revision was merged to the branch mainline in revision 961.
  • Revision ID: mordred@inaugust.com-20090322075508-1h34cksq2knhaxc3
Removed global.h from a header.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/row0merge.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 2005, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 2005, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
11
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
12
 
13
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
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
16
16
 
17
17
*****************************************************************************/
18
18
 
19
 
/**************************************************//**
20
 
@file include/row0merge.h
 
19
/******************************************************
21
20
Index build routines using a merge sort
22
21
 
23
22
Created 13/06/2005 Jan Lindstrom
39
38
#include "row0mysql.h"
40
39
#include "lock0types.h"
41
40
 
42
 
/** Index field definition */
 
41
/* This structure holds index field definitions */
 
42
 
43
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 */
 
44
        ulint           prefix_len;     /* Prefix len */
 
45
        const char*     field_name;     /* Field name */
47
46
};
48
47
 
49
 
/** Index field definition */
50
48
typedef struct merge_index_field_struct merge_index_field_t;
51
49
 
52
 
/** Definition of an index being created */
 
50
/* This structure holds index definitions */
 
51
 
53
52
struct merge_index_def_struct {
54
 
        const char*             name;           /*!< index name */
55
 
        ulint                   ind_type;       /*!< 0, DICT_UNIQUE,
 
53
        const char*             name;           /* Index name */
 
54
        ulint                   ind_type;       /* 0, DICT_UNIQUE,
56
55
                                                or DICT_CLUSTERED */
57
 
        ulint                   n_fields;       /*!< number of fields
58
 
                                                in index */
59
 
        merge_index_field_t*    fields;         /*!< field definitions */
 
56
        ulint                   n_fields;       /* Number of fields in index */
 
57
        merge_index_field_t*    fields;         /* Field definitions */
60
58
};
61
59
 
62
 
/** Definition of an index being created */
63
60
typedef struct merge_index_def_struct merge_index_def_t;
64
61
 
65
 
/*********************************************************************//**
66
 
Sets an exclusive lock on a table, for the duration of creating indexes.
67
 
@return error code or DB_SUCCESS */
 
62
/*************************************************************************
 
63
Sets an exclusive lock on a table, for the duration of creating indexes. */
68
64
UNIV_INTERN
69
65
ulint
70
66
row_merge_lock_table(
71
67
/*=================*/
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
 
/*********************************************************************//**
 
68
                                        /* out: error code or DB_SUCCESS */
 
69
        trx_t*          trx,            /* in/out: transaction */
 
70
        dict_table_t*   table,          /* in: table to lock */
 
71
        enum lock_mode  mode);          /* in: LOCK_X or LOCK_S */
 
72
/*************************************************************************
76
73
Drop an index from the InnoDB system tables.  The data dictionary must
77
74
have been locked exclusively by the caller, because the transaction
78
75
will not be committed. */
80
77
void
81
78
row_merge_drop_index(
82
79
/*=================*/
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
 
/*********************************************************************//**
 
80
        dict_index_t*   index,  /* in: index to be removed */
 
81
        dict_table_t*   table,  /* in: table */
 
82
        trx_t*          trx);   /* in: transaction handle */
 
83
/*************************************************************************
87
84
Drop those indexes which were created before an error occurred when
88
85
building an index.  The data dictionary must have been locked
89
86
exclusively by the caller, because the transaction will not be
92
89
void
93
90
row_merge_drop_indexes(
94
91
/*===================*/
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
 
/*********************************************************************//**
 
92
        trx_t*          trx,            /* in: transaction */
 
93
        dict_table_t*   table,          /* in: table containing the indexes */
 
94
        dict_index_t**  index,          /* in: indexes to drop */
 
95
        ulint           num_created);   /* in: number of elements in index[] */
 
96
/*************************************************************************
100
97
Drop all partially created indexes during crash recovery. */
101
98
UNIV_INTERN
102
99
void
103
100
row_merge_drop_temp_indexes(void);
104
101
/*=============================*/
105
 
/*********************************************************************//**
 
102
/*************************************************************************
106
103
Rename the tables in the data dictionary.  The data dictionary must
107
104
have been locked exclusively by the caller, because the transaction
108
 
will not be committed.
109
 
@return error code or DB_SUCCESS */
 
105
will not be committed. */
110
106
UNIV_INTERN
111
107
ulint
112
108
row_merge_rename_tables(
113
109
/*====================*/
114
 
        dict_table_t*   old_table,      /*!< in/out: old table, renamed to
 
110
                                        /* out: error code or DB_SUCCESS */
 
111
        dict_table_t*   old_table,      /* in/out: old table, renamed to
115
112
                                        tmp_name */
116
 
        dict_table_t*   new_table,      /*!< in/out: new table, renamed to
 
113
        dict_table_t*   new_table,      /* in/out: new table, renamed to
117
114
                                        old_table->name */
118
 
        const char*     tmp_name,       /*!< in: new name for old_table */
119
 
        trx_t*          trx);           /*!< in: transaction handle */
 
115
        const char*     tmp_name,       /* in: new name for old_table */
 
116
        trx_t*          trx);           /* in: transaction handle */
120
117
 
121
 
/*********************************************************************//**
 
118
/*************************************************************************
122
119
Create a temporary table for creating a primary key, using the definition
123
 
of an existing table.
124
 
@return table, or NULL on error */
 
120
of an existing table. */
125
121
UNIV_INTERN
126
122
dict_table_t*
127
123
row_merge_create_temporary_table(
128
124
/*=============================*/
129
 
        const char*             table_name,     /*!< in: new table name */
130
 
        const merge_index_def_t*index_def,      /*!< in: the index definition
 
125
                                                /* out: table,
 
126
                                                or NULL on error */
 
127
        const char*             table_name,     /* in: new table name */
 
128
        const merge_index_def_t*index_def,      /* in: the index definition
131
129
                                                of the primary key */
132
 
        const dict_table_t*     table,          /*!< in: old table definition */
133
 
        trx_t*                  trx);           /*!< in/out: transaction
 
130
        const dict_table_t*     table,          /* in: old table definition */
 
131
        trx_t*                  trx);           /* in/out: transaction
134
132
                                                (sets error_state) */
135
 
/*********************************************************************//**
 
133
/*************************************************************************
136
134
Rename the temporary indexes in the dictionary to permanent ones.  The
137
135
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 */
 
136
because the transaction will not be committed. */
140
137
UNIV_INTERN
141
138
ulint
142
139
row_merge_rename_indexes(
143
140
/*=====================*/
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 */
 
141
                                        /* out: DB_SUCCESS if all OK */
 
142
        trx_t*          trx,            /* in/out: transaction */
 
143
        dict_table_t*   table);         /* in/out: table with new indexes */
 
144
/*************************************************************************
 
145
Create the index and load in to the dictionary. */
149
146
UNIV_INTERN
150
147
dict_index_t*
151
148
row_merge_create_index(
152
149
/*===================*/
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 */
 
150
                                        /* out: index, or NULL on error */
 
151
        trx_t*          trx,            /* in/out: trx (sets error_state) */
 
152
        dict_table_t*   table,          /* in: the index is on this table */
 
153
        const merge_index_def_t*        /* in: the index definition */
 
154
                        index_def);
 
155
#ifdef ROW_MERGE_IS_INDEX_USABLE
 
156
/*************************************************************************
 
157
Check if a transaction can use an index. */
160
158
UNIV_INTERN
161
159
ibool
162
160
row_merge_is_index_usable(
163
161
/*======================*/
164
 
        const trx_t*            trx,    /*!< in: transaction */
165
 
        const dict_index_t*     index); /*!< in: index to check */
166
 
/*********************************************************************//**
 
162
                                        /* out: TRUE if index can be used by
 
163
                                        the transaction else FALSE*/
 
164
        const trx_t*            trx,    /* in: transaction */
 
165
        const dict_index_t*     index); /* in: index to check */
 
166
#endif /* ROW_MERGE_IS_INDEX_USABLE */
 
167
/*************************************************************************
167
168
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 */
 
169
the new instance of the table else we drop it immediately. */
170
170
UNIV_INTERN
171
171
ulint
172
172
row_merge_drop_table(
173
173
/*=================*/
174
 
        trx_t*          trx,            /*!< in: transaction */
175
 
        dict_table_t*   table);         /*!< in: table instance to drop */
 
174
                                        /* out: DB_SUCCESS or error code */
 
175
        trx_t*          trx,            /* in: transaction */
 
176
        dict_table_t*   table);         /* in: table instance to drop */
176
177
 
177
 
/*********************************************************************//**
 
178
/*************************************************************************
178
179
Build indexes on a table by reading a clustered index,
179
180
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 */
 
181
these index entries and inserting sorted index entries to indexes. */
182
182
UNIV_INTERN
183
183
ulint
184
184
row_merge_build_indexes(
185
185
/*====================*/
186
 
        trx_t*          trx,            /*!< in: transaction */
187
 
        dict_table_t*   old_table,      /*!< in: table where rows are
 
186
                                        /* out: DB_SUCCESS or error code */
 
187
        trx_t*          trx,            /* in: transaction */
 
188
        dict_table_t*   old_table,      /* in: table where rows are
188
189
                                        read from */
189
 
        dict_table_t*   new_table,      /*!< in: table where indexes are
 
190
        dict_table_t*   new_table,      /* in: table where indexes are
190
191
                                        created; identical to old_table
191
192
                                        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
 
193
        dict_index_t**  indexes,        /* in: indexes to be created */
 
194
        ulint           n_indexes,      /* in: size of indexes[] */
 
195
        TABLE*          table);         /* in/out: MySQL table, for
195
196
                                        reporting erroneous key value
196
197
                                        if applicable */
197
198
#endif /* row0merge.h */