← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/dict/dict0mem.c

  • Committer: Monty Taylor
  • Date: 2010-10-13 17:53:36 UTC
  • mto: This revision was merged to the branch mainline in revision 1845.
  • Revision ID: mordred@inaugust.com-20101013175336-amzhjftgztblvua5
Updated pandora-build files to version 0.161

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/dict/dict0mem.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1996, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1996, 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
40
40
#define DICT_HEAP_SIZE          100     /*!< initial memory heap size when
41
41
                                        creating a table or index object */
42
42
 
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
43
/**********************************************************************//**
49
44
Creates a table memory object.
50
45
@return own: table object */
64
59
        mem_heap_t*     heap;
65
60
 
66
61
        ut_ad(name);
67
 
        ut_a(!(flags & (~0 << DICT_TF2_BITS)));
 
62
        ut_a(!(flags & (~0 << DICT_TF_BITS)));
68
63
 
69
64
        heap = mem_heap_create(DICT_HEAP_SIZE);
70
65
 
73
68
        table->heap = heap;
74
69
 
75
70
        table->flags = (unsigned int) flags;
76
 
        table->name = ut_malloc(strlen(name) + 1);
77
 
        memcpy(table->name, name, strlen(name) + 1);
 
71
        table->name = mem_heap_strdup(heap, name);
78
72
        table->space = (unsigned int) space;
79
73
        table->n_cols = (unsigned int) (n_cols + DATA_N_SYS_COLS);
80
74
 
84
78
#ifndef UNIV_HOTBACKUP
85
79
        table->autoinc_lock = mem_heap_alloc(heap, lock_get_size());
86
80
 
87
 
        mutex_create(autoinc_mutex_key,
88
 
                     &table->autoinc_mutex, SYNC_DICT_AUTOINC_MUTEX);
 
81
        mutex_create(&table->autoinc_mutex, SYNC_DICT_AUTOINC_MUTEX);
89
82
 
90
83
        table->autoinc = 0;
91
84
 
113
106
#ifndef UNIV_HOTBACKUP
114
107
        mutex_free(&(table->autoinc_mutex));
115
108
#endif /* UNIV_HOTBACKUP */
116
 
        ut_free(table->name);
117
109
        mem_heap_free(table->heap);
118
110
}
119
111
 
179
171
        ulint           len)    /*!< in: precision */
180
172
{
181
173
        dict_col_t*     col;
 
174
#ifndef UNIV_HOTBACKUP
 
175
        ulint           mbminlen;
 
176
        ulint           mbmaxlen;
 
177
#endif /* !UNIV_HOTBACKUP */
182
178
        ulint           i;
183
179
 
184
180
        ut_ad(table);
203
199
 
204
200
        col = dict_table_get_nth_col(table, i);
205
201
 
206
 
        dict_mem_fill_column_struct(col, i, mtype, prtype, len);
207
 
}
208
 
 
209
 
 
210
 
/**********************************************************************//**
211
 
This function populates a dict_col_t memory structure with
212
 
supplied information. */
213
 
UNIV_INTERN
214
 
void
215
 
dict_mem_fill_column_struct(
216
 
/*========================*/
217
 
        dict_col_t*     column,         /*!< out: column struct to be
218
 
                                        filled */
219
 
        ulint           col_pos,        /*!< in: column position */
220
 
        ulint           mtype,          /*!< in: main data type */
221
 
        ulint           prtype,         /*!< in: precise type */
222
 
        ulint           col_len)        /*!< in: column length */
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);
 
202
        col->ind = (unsigned int) i;
 
203
        col->ord_part = 0;
 
204
 
 
205
        col->mtype = (unsigned int) mtype;
 
206
        col->prtype = (unsigned int) prtype;
 
207
        col->len = (unsigned int) len;
 
208
 
 
209
#ifndef UNIV_HOTBACKUP
 
210
        dtype_get_mblen(mtype, prtype, &mbminlen, &mbmaxlen);
 
211
 
 
212
        col->mbminlen = (unsigned int) mbminlen;
 
213
        col->mbmaxlen = (unsigned int) mbmaxlen;
237
214
#endif /* !UNIV_HOTBACKUP */
238
215
}
239
216
 
261
238
        heap = mem_heap_create(DICT_HEAP_SIZE);
262
239
        index = mem_heap_zalloc(heap, sizeof(dict_index_t));
263
240
 
264
 
        dict_mem_fill_index_struct(index, heap, table_name, index_name,
265
 
                                   space, type, n_fields);
 
241
        index->heap = heap;
266
242
 
 
243
        index->type = type;
 
244
#ifndef UNIV_HOTBACKUP
 
245
        index->space = (unsigned int) space;
 
246
#endif /* !UNIV_HOTBACKUP */
 
247
        index->name = mem_heap_strdup(heap, index_name);
 
248
        index->table_name = table_name;
 
249
        index->n_fields = (unsigned int) n_fields;
 
250
        index->fields = mem_heap_alloc(heap, 1 + n_fields
 
251
                                       * sizeof(dict_field_t));
 
252
        /* The '1 +' above prevents allocation
 
253
        of an empty mem block */
 
254
#ifdef UNIV_DEBUG
 
255
        index->magic_n = DICT_INDEX_MAGIC_N;
 
256
#endif /* UNIV_DEBUG */
267
257
        return(index);
268
258
}
269
259