Drizzled Public API Documentation

dict0mem.cc
1 /*****************************************************************************
2 
3 Copyright (C) 1996, 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 /******************************************************************/
26 #include "dict0mem.h"
27 
28 #ifdef UNIV_NONINL
29 #include "dict0mem.ic"
30 #endif
31 
32 #include "rem0rec.h"
33 #include "data0type.h"
34 #include "mach0data.h"
35 #include "dict0dict.h"
36 #ifndef UNIV_HOTBACKUP
37 # include "lock0lock.h"
38 #endif /* !UNIV_HOTBACKUP */
39 
40 #define DICT_HEAP_SIZE 100
43 #ifdef UNIV_PFS_MUTEX
44 /* Key to register autoinc_mutex with performance schema */
45 UNIV_INTERN mysql_pfs_key_t autoinc_mutex_key;
46 #endif /* UNIV_PFS_MUTEX */
47 
48 /**********************************************************************/
51 UNIV_INTERN
53 dict_mem_table_create(
54 /*==================*/
55  const char* name,
56  ulint space,
60  ulint n_cols,
61  ulint flags)
62 {
63  dict_table_t* table;
64  mem_heap_t* heap;
65 
66  ut_ad(name);
67  ut_a(!(flags & (SIZE_MAX << DICT_TF2_BITS)));
68 
69  heap = mem_heap_create(DICT_HEAP_SIZE);
70 
71  table = static_cast<dict_table_struct *>(mem_heap_zalloc(heap, sizeof(dict_table_t)));
72 
73  table->heap = heap;
74 
75  table->flags = (unsigned int) flags;
76  table->name = static_cast<char *>(ut_malloc(strlen(name) + 1));
77  memcpy(table->name, name, strlen(name) + 1);
78  table->space = (unsigned int) space;
79  table->n_cols = (unsigned int) (n_cols + DATA_N_SYS_COLS);
80 
81  table->cols = static_cast<dict_col_t *>(mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
82  * sizeof(dict_col_t)));
83 
84 #ifndef UNIV_HOTBACKUP
85  table->autoinc_lock = static_cast<lock_t *>(mem_heap_alloc(heap, lock_get_size()));
86 
87  mutex_create(autoinc_mutex_key,
88  &table->autoinc_mutex, SYNC_DICT_AUTOINC_MUTEX);
89 
90  table->autoinc = 0;
91 
92  /* The number of transactions that are either waiting on the
93  AUTOINC lock or have been granted the lock. */
95 #endif /* !UNIV_HOTBACKUP */
96 
97  ut_d(table->magic_n = DICT_TABLE_MAGIC_N);
98  return(table);
99 }
100 
101 /****************************************************************/
103 UNIV_INTERN
104 void
105 dict_mem_table_free(
106 /*================*/
107  dict_table_t* table)
108 {
109  ut_ad(table);
110  ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
111  ut_d(table->cached = FALSE);
112 
113 #ifndef UNIV_HOTBACKUP
114  mutex_free(&(table->autoinc_mutex));
115 #endif /* UNIV_HOTBACKUP */
116  ut_free(table->name);
117  mem_heap_free(table->heap);
118 }
119 
120 /****************************************************************/
123 static
124 const char*
125 dict_add_col_name(
126 /*==============*/
127  const char* col_names,
129  ulint cols,
130  const char* name,
131  mem_heap_t* heap)
132 {
133  ulint old_len;
134  ulint new_len;
135  ulint total_len;
136  char* res;
137 
138  ut_ad(!cols == !col_names);
139 
140  /* Find out length of existing array. */
141  if (col_names) {
142  const char* s = col_names;
143  ulint i;
144 
145  for (i = 0; i < cols; i++) {
146  s += strlen(s) + 1;
147  }
148 
149  old_len = s - col_names;
150  } else {
151  old_len = 0;
152  }
153 
154  new_len = strlen(name) + 1;
155  total_len = old_len + new_len;
156 
157  res = static_cast<char *>(mem_heap_alloc(heap, total_len));
158 
159  if (old_len > 0) {
160  memcpy(res, col_names, old_len);
161  }
162 
163  memcpy(res + old_len, name, new_len);
164 
165  return(res);
166 }
167 
168 /**********************************************************************/
170 UNIV_INTERN
171 void
172 dict_mem_table_add_col(
173 /*===================*/
174  dict_table_t* table,
175  mem_heap_t* heap,
176  const char* name,
177  ulint mtype,
178  ulint prtype,
179  ulint len)
180 {
181  dict_col_t* col;
182  ulint i;
183 
184  ut_ad(table);
185  ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
186  ut_ad(!heap == !name);
187 
188  i = table->n_def++;
189 
190  if (name) {
191  if (UNIV_UNLIKELY(table->n_def == table->n_cols)) {
192  heap = table->heap;
193  }
194  if (UNIV_LIKELY(i) && UNIV_UNLIKELY(!table->col_names)) {
195  /* All preceding column names are empty. */
196  char* s = static_cast<char *>(mem_heap_zalloc(heap, table->n_def));
197  table->col_names = s;
198  }
199 
200  table->col_names = dict_add_col_name(table->col_names,
201  i, name, heap);
202  }
203 
204  col = dict_table_get_nth_col(table, i);
205 
206  dict_mem_fill_column_struct(col, i, mtype, prtype, len);
207 }
208 
209 
210 /**********************************************************************/
213 UNIV_INTERN
214 void
215 dict_mem_fill_column_struct(
216 /*========================*/
217  dict_col_t* column,
219  ulint col_pos,
220  ulint mtype,
221  ulint prtype,
222  ulint col_len)
223 {
224 #ifndef UNIV_HOTBACKUP
225  ulint mbminlen;
226  ulint mbmaxlen;
227 #endif /* !UNIV_HOTBACKUP */
228 
229  column->ind = (unsigned int) col_pos;
230  column->ord_part = 0;
231  column->mtype = (unsigned int) mtype;
232  column->prtype = (unsigned int) prtype;
233  column->len = (unsigned int) col_len;
234 #ifndef UNIV_HOTBACKUP
235  dtype_get_mblen(mtype, prtype, &mbminlen, &mbmaxlen);
236  dict_col_set_mbminmaxlen(column, mbminlen, mbmaxlen);
237 #endif /* !UNIV_HOTBACKUP */
238 }
239 
240 /**********************************************************************/
243 UNIV_INTERN
245 dict_mem_index_create(
246 /*==================*/
247  const char* table_name,
248  const char* index_name,
249  ulint space,
252  ulint type,
254  ulint n_fields)
255 {
256  dict_index_t* index;
257  mem_heap_t* heap;
258 
259  ut_ad(table_name && index_name);
260 
261  heap = mem_heap_create(DICT_HEAP_SIZE);
262  index = static_cast<dict_index_t *>(mem_heap_zalloc(heap, sizeof(dict_index_t)));
263 
264  dict_mem_fill_index_struct(index, heap, table_name, index_name,
265  space, type, n_fields);
266 
267  return(index);
268 }
269 
270 /**********************************************************************/
273 UNIV_INTERN
275 dict_mem_foreign_create(void)
276 /*=========================*/
277 {
278  dict_foreign_t* foreign;
279  mem_heap_t* heap;
280 
281  heap = mem_heap_create(100);
282 
283  foreign = static_cast<dict_foreign_t *>(mem_heap_zalloc(heap, sizeof(dict_foreign_t)));
284 
285  foreign->heap = heap;
286 
287  return(foreign);
288 }
289 
290 /**********************************************************************/
294 UNIV_INTERN
295 void
296 dict_mem_index_add_field(
297 /*=====================*/
298  dict_index_t* index,
299  const char* name,
300  ulint prefix_len)
303 {
304  dict_field_t* field;
305 
306  ut_ad(index);
307  ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
308 
309  index->n_def++;
310 
311  field = dict_index_get_nth_field(index, index->n_def - 1);
312 
313  field->name = name;
314  field->prefix_len = (unsigned int) prefix_len;
315 }
316 
317 /**********************************************************************/
319 UNIV_INTERN
320 void
321 dict_mem_index_free(
322 /*================*/
323  dict_index_t* index)
324 {
325  ut_ad(index);
326  ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
327 
328  mem_heap_free(index->heap);
329 }