← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/heap/hp_create.cc

  • Committer: Brian Aker
  • Date: 2010-08-12 17:19:46 UTC
  • mfrom: (1701.1.1 turn-off-csv)
  • Revision ID: brian@tangent.org-20100812171946-n44naaqhg27gehlh
MErge Monty, remove CSV from auto-build

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/heap/hp_create.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
#include "heap_priv.h"
17
17
 
24
24
using namespace std;
25
25
using namespace drizzled;
26
26
 
 
27
static int keys_compare(heap_rb_param *param, unsigned char *key1, unsigned char *key2);
27
28
static void init_block(HP_BLOCK *block,uint32_t chunk_length, uint32_t min_records,
28
29
                        uint32_t max_records);
29
30
 
30
 
static const int FIXED_REC_OVERHEAD = (sizeof(unsigned char));
31
 
static const int VARIABLE_REC_OVERHEAD = (sizeof(unsigned char**) + ALIGN_SIZE(sizeof(unsigned char)));
 
31
#define FIXED_REC_OVERHEAD (sizeof(unsigned char))
 
32
#define VARIABLE_REC_OVERHEAD (sizeof(unsigned char**) + ALIGN_SIZE(sizeof(unsigned char)))
32
33
 
33
34
/* Minimum size that a chunk can take, 12 bytes on 32bit, 24 bytes on 64bit */
34
 
static const int VARIABLE_MIN_CHUNK_SIZE =
35
 
        ((sizeof(unsigned char**) + VARIABLE_REC_OVERHEAD + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1));
 
35
#define VARIABLE_MIN_CHUNK_SIZE \
 
36
        ((sizeof(unsigned char**) + VARIABLE_REC_OVERHEAD + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1))
36
37
 
37
38
 
38
39
/* Create a heap table */
39
40
 
40
41
int heap_create(const char *name, uint32_t keys, HP_KEYDEF *keydef,
41
 
                uint32_t columns,
42
 
                uint32_t key_part_size,
43
 
                uint32_t reclength, uint32_t keys_memory_size,
44
 
                uint32_t max_records, uint32_t min_records,
45
 
                HP_CREATE_INFO *create_info, HP_SHARE **res)
 
42
    uint32_t columns, HP_COLUMNDEF *columndef,
 
43
    uint32_t max_key_fieldnr, uint32_t key_part_size,
 
44
    uint32_t reclength, uint32_t keys_memory_size,
 
45
    uint32_t max_records, uint32_t min_records,
 
46
    HP_CREATE_INFO *create_info, HP_SHARE **res)
46
47
{
47
 
  uint32_t i, key_segs, max_length, length;
 
48
  uint32_t i, j, key_segs, max_length, length;
48
49
  uint32_t max_rows_for_stated_memory;
49
50
  HP_SHARE *share= 0;
50
51
  HA_KEYSEG *keyseg;
51
52
 
52
 
  if (not create_info->internal_table)
 
53
  if (!create_info->internal_table)
53
54
  {
54
55
    THR_LOCK_heap.lock();
55
56
    if ((share= hp_find_named_heap(name)) && share->open_count == 0)
62
63
  if (!share)
63
64
  {
64
65
    size_t chunk_dataspace_length;
65
 
    uint32_t chunk_length;
 
66
    uint32_t chunk_length, is_variable_size;
66
67
    uint32_t fixed_data_length, fixed_column_count;
67
68
    HP_KEYDEF *keyinfo;
68
69
 
75
76
      if (configured_chunk_size < key_part_size)
76
77
      {
77
78
        /* Eventual chunk_size cannot be smaller than key data,
78
 
          which allows all keys to fit into the first chunk */
 
79
           which allows all keys to fit into the first chunk */
79
80
        my_error(ER_CANT_USE_OPTION_HERE, MYF(0), "block_size");
80
81
        THR_LOCK_heap.unlock();
81
82
        return(ER_CANT_USE_OPTION_HERE);
82
83
      }
83
84
 
84
 
      /* max_chunk_size is near the full reclength, let's use fixed size */
85
 
      chunk_dataspace_length= reclength;
 
85
      if ((reclength - configured_chunk_size) >= VARIABLE_MIN_CHUNK_SIZE<<1)
 
86
      {
 
87
        /* Allow variable size only if we're saving at least two smallest chunks */
 
88
        /* There has to be at least one field after indexed fields */
 
89
        /* Note that NULL bits are already included in key_part_size */
 
90
        is_variable_size= 1;
 
91
        chunk_dataspace_length= configured_chunk_size;
 
92
      }
 
93
      else
 
94
      {
 
95
        /* max_chunk_size is near the full reclength, let's use fixed size */
 
96
        is_variable_size= 0;
 
97
        chunk_dataspace_length= reclength;
 
98
      }
 
99
    }
 
100
    else if (create_info->is_dynamic)
 
101
    {
 
102
      /* User asked for dynamic records - use 256 as the chunk size */
 
103
      if ((key_part_size + VARIABLE_REC_OVERHEAD) > 256)
 
104
        chunk_dataspace_length= key_part_size;
 
105
      else
 
106
        chunk_dataspace_length= 256 - VARIABLE_REC_OVERHEAD;
 
107
 
 
108
      is_variable_size= 1;
86
109
    }
87
110
    else
88
111
    {
89
112
      /* if max_chunk_size is not specified, put the whole record in one chunk */
 
113
      is_variable_size= 0;
90
114
      chunk_dataspace_length= reclength;
91
115
    }
92
116
 
 
117
    if (is_variable_size)
 
118
    {
 
119
      /* Check whether we have any variable size records past key data */
 
120
      uint32_t has_variable_fields= 0;
 
121
 
 
122
      fixed_data_length= key_part_size;
 
123
      fixed_column_count= max_key_fieldnr;
 
124
 
 
125
      for (i= max_key_fieldnr; i < columns; i++)
 
126
      {
 
127
        HP_COLUMNDEF* column= columndef + i;
 
128
        if (column->type == DRIZZLE_TYPE_VARCHAR && column->length >= 32)
 
129
        {
 
130
            /* The field has to be >= 5.0.3 true VARCHAR and have substantial length */
 
131
            /* TODO: do we want to calculate minimum length? */
 
132
            has_variable_fields= 1;
 
133
            break;
 
134
        }
 
135
 
 
136
        if (has_variable_fields)
 
137
        {
 
138
          break;
 
139
        }
 
140
 
 
141
        if ((column->offset + column->length) <= chunk_dataspace_length)
 
142
        {
 
143
          /* Still no variable-size columns, add one fixed-length */
 
144
          fixed_column_count= i + 1;
 
145
          fixed_data_length= column->offset + column->length;
 
146
        }
 
147
      }
 
148
 
 
149
      if (!has_variable_fields)
 
150
      {
 
151
        /* There is no need to use variable-size records without variable-size columns */
 
152
        /* Reset sizes if it's not variable size anymore */
 
153
        is_variable_size= 0;
 
154
        chunk_dataspace_length= reclength;
 
155
        fixed_data_length= reclength;
 
156
        fixed_column_count= columns;
 
157
      }
 
158
    }
 
159
    else
93
160
    {
94
161
      fixed_data_length= reclength;
95
162
      fixed_column_count= columns;
101
168
    */
102
169
    set_if_bigger(chunk_dataspace_length, sizeof (unsigned char**));
103
170
 
 
171
    if (is_variable_size)
 
172
    {
 
173
      chunk_length= chunk_dataspace_length + VARIABLE_REC_OVERHEAD;
 
174
    }
 
175
    else
104
176
    {
105
177
      chunk_length= chunk_dataspace_length + FIXED_REC_OVERHEAD;
106
178
    }
113
185
    for (i= key_segs= max_length= 0, keyinfo= keydef; i < keys; i++, keyinfo++)
114
186
    {
115
187
      memset(&keyinfo->block, 0, sizeof(keyinfo->block));
116
 
      for (uint32_t j= length= 0; j < keyinfo->keysegs; j++)
 
188
      memset(&keyinfo->rb_tree , 0, sizeof(keyinfo->rb_tree));
 
189
      for (j= length= 0; j < keyinfo->keysegs; j++)
117
190
      {
118
191
        length+= keyinfo->seg[j].length;
119
192
        if (keyinfo->seg[j].null_bit)
121
194
          length++;
122
195
          if (!(keyinfo->flag & HA_NULL_ARE_EQUAL))
123
196
            keyinfo->flag|= HA_NULL_PART_KEY;
 
197
          if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
 
198
            keyinfo->rb_tree.size_of_element++;
124
199
        }
125
200
        switch (keyinfo->seg[j].type) {
126
201
        case HA_KEYTYPE_LONG_INT:
128
203
        case HA_KEYTYPE_ULONG_INT:
129
204
        case HA_KEYTYPE_LONGLONG:
130
205
        case HA_KEYTYPE_ULONGLONG:
 
206
        case HA_KEYTYPE_UINT24:
131
207
          keyinfo->seg[j].flag|= HA_SWAP_KEY;
132
208
          break;
133
209
        case HA_KEYTYPE_VARBINARY1:
159
235
        }
160
236
      }
161
237
      keyinfo->length= length;
 
238
      length+= keyinfo->rb_tree.size_of_element +
 
239
               ((keyinfo->algorithm == HA_KEY_ALG_BTREE) ? sizeof(unsigned char*) : 0);
162
240
      if (length > max_length)
163
241
        max_length= length;
164
242
      key_segs+= keyinfo->keysegs;
 
243
      if (keyinfo->algorithm == HA_KEY_ALG_BTREE)
 
244
      {
 
245
        key_segs++; /* additional HA_KEYTYPE_END segment */
 
246
        if (keyinfo->flag & HA_VAR_LENGTH_KEY)
 
247
          keyinfo->get_key_length= hp_rb_var_key_length;
 
248
        else if (keyinfo->flag & HA_NULL_PART_KEY)
 
249
          keyinfo->get_key_length= hp_rb_null_key_length;
 
250
        else
 
251
          keyinfo->get_key_length= hp_rb_key_length;
 
252
      }
165
253
    }
166
254
    share= new HP_SHARE;
167
255
 
169
257
      goto err;
170
258
    if (keys && !(share->keydef->seg= new HA_KEYSEG[key_segs]))
171
259
      goto err;
 
260
    if (!(share->column_defs= new HP_COLUMNDEF[columns]))
 
261
      goto err;
172
262
 
173
263
    /*
174
264
       Max_records is used for estimating block sizes and for enforcement.
180
270
    max_records = ((max_records && max_records < max_rows_for_stated_memory) ?
181
271
                      max_records : max_rows_for_stated_memory);
182
272
 
 
273
#if 0
 
274
    memcpy(share->column_defs, columndef, (size_t) (sizeof(columndef[0]) * columns));
 
275
#endif
 
276
 
183
277
    share->key_stat_version= 1;
184
278
    keyseg= keys ? share->keydef->seg : NULL;
185
279
 
192
286
      memcpy(keyseg, keydef[i].seg,
193
287
             (size_t) (sizeof(keyseg[0]) * keydef[i].keysegs));
194
288
      keyseg+= keydef[i].keysegs;
 
289
 
 
290
      if (keydef[i].algorithm == HA_KEY_ALG_BTREE)
 
291
      {
 
292
        /* additional HA_KEYTYPE_END keyseg */
 
293
        keyseg->type=     HA_KEYTYPE_END;
 
294
        keyseg->length=   sizeof(unsigned char*);
 
295
        keyseg->flag=     0;
 
296
        keyseg->null_bit= 0;
 
297
        keyseg++;
 
298
 
 
299
        init_tree(&keyinfo->rb_tree, 0, 0, sizeof(unsigned char*),
 
300
                  (qsort_cmp2)keys_compare, true, NULL, NULL);
 
301
        keyinfo->delete_key= hp_rb_delete_key;
 
302
        keyinfo->write_key= hp_rb_write_key;
 
303
      }
 
304
      else
195
305
      {
196
306
        init_block(&keyinfo->block, sizeof(HASH_INFO), min_records,
197
307
                   max_records);
 
308
        keyinfo->delete_key= hp_delete_key;
 
309
        keyinfo->write_key= hp_write_key;
198
310
        keyinfo->hash_buckets= 0;
199
311
      }
200
312
      if ((keyinfo->flag & HA_AUTO_KEY) && create_info->with_auto_increment)
218
330
 
219
331
    share->recordspace.chunk_length= chunk_length;
220
332
    share->recordspace.chunk_dataspace_length= chunk_dataspace_length;
 
333
    share->recordspace.is_variable_size= is_variable_size;
221
334
    share->recordspace.total_data_length= 0;
222
335
 
223
 
    {
 
336
    if (is_variable_size) {
 
337
      share->recordspace.offset_link= chunk_dataspace_length;
 
338
      share->recordspace.offset_status= share->recordspace.offset_link + sizeof(unsigned char**);
 
339
    } else {
224
340
      share->recordspace.offset_link= 1<<22; /* Make it likely to fail if anyone uses this offset */
225
341
      share->recordspace.offset_status= chunk_dataspace_length;
226
342
    }
227
343
 
228
344
    /* Must be allocated separately for rename to work */
229
 
    share->name.append(name);
 
345
    if (!(share->name= strdup(name)))
 
346
    {
 
347
      goto err;
 
348
    }
 
349
    thr_lock_init(&share->lock);
 
350
    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
230
351
    if (!create_info->internal_table)
231
352
    {
232
353
      heap_share_list.push_front(share);
245
366
    delete [] share->keydef->seg;
246
367
  if (share && share->keydef)
247
368
    delete [] share->keydef;
 
369
  if (share && share->column_defs)
 
370
    delete [] share->column_defs;
248
371
  if (share)
249
372
    delete share;
250
373
  if (not create_info->internal_table)
253
376
} /* heap_create */
254
377
 
255
378
 
 
379
static int keys_compare(heap_rb_param *param, unsigned char *key1, unsigned char *key2)
 
380
{
 
381
  uint32_t not_used[2];
 
382
  return ha_key_cmp(param->keyseg, key1, key2, param->key_length,
 
383
                    param->search_flag, not_used);
 
384
}
 
385
 
256
386
static void init_block(HP_BLOCK *block, uint32_t chunk_length, uint32_t min_records,
257
387
                       uint32_t max_records)
258
388
{
259
 
  uint32_t recbuffer,records_in_block;
 
389
  uint32_t i,recbuffer,records_in_block;
260
390
 
261
391
  max_records= max(min_records,max_records);
262
392
  if (!max_records)
275
405
  block->recbuffer= recbuffer;
276
406
  block->last_allocated= 0L;
277
407
 
278
 
  for (uint32_t i= 0; i <= HP_MAX_LEVELS; i++)
279
 
  {
 
408
  for (i= 0; i <= HP_MAX_LEVELS; i++)
280
409
    block->level_info[i].records_under_level=
281
410
      (!i ? 1 : i == 1 ? records_in_block :
282
411
       HP_PTRS_IN_NOD * block->level_info[i - 1].records_under_level);
283
 
  }
284
412
}
285
413
 
286
414
 
317
445
{
318
446
  heap_share_list.remove(share);        /* If not internal table */
319
447
  hp_clear(share);                      /* Remove blocks from memory */
 
448
  share->lock.deinit();
 
449
  pthread_mutex_destroy(&share->intern_lock);
 
450
  if (share->keydef && share->keydef->seg)
 
451
    delete [] share->keydef->seg;
320
452
  if (share->keydef)
321
 
    delete [] share->keydef->seg;
322
 
  delete [] share->keydef;
 
453
    delete [] share->keydef;
 
454
  delete [] share->column_defs;
 
455
  free((unsigned char*) share->name);
323
456
  delete share;
324
457
}