← 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-18 16:12:58 UTC
  • mto: This revision was merged to the branch mainline in revision 1720.
  • Revision ID: brian@tangent.org-20100818161258-1vm71da888dfvwsx
Remove the code surrounding stack trace.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/heap/hp_create.cc
45
45
    uint32_t max_records, uint32_t min_records,
46
46
    HP_CREATE_INFO *create_info, HP_SHARE **res)
47
47
{
48
 
  uint32_t i, j, key_segs, max_length, length;
 
48
  uint32_t i, key_segs, max_length, length;
49
49
  uint32_t max_rows_for_stated_memory;
50
50
  HP_SHARE *share= 0;
51
51
  HA_KEYSEG *keyseg;
52
52
 
53
53
  if (!create_info->internal_table)
54
54
  {
55
 
    pthread_mutex_lock(&THR_LOCK_heap);
 
55
    THR_LOCK_heap.lock();
56
56
    if ((share= hp_find_named_heap(name)) && share->open_count == 0)
57
57
    {
58
58
      hp_free(share);
78
78
        /* Eventual chunk_size cannot be smaller than key data,
79
79
           which allows all keys to fit into the first chunk */
80
80
        my_error(ER_CANT_USE_OPTION_HERE, MYF(0), "block_size");
81
 
        pthread_mutex_unlock(&THR_LOCK_heap);
 
81
        THR_LOCK_heap.unlock();
82
82
        return(ER_CANT_USE_OPTION_HERE);
83
83
      }
84
84
 
186
186
    {
187
187
      memset(&keyinfo->block, 0, sizeof(keyinfo->block));
188
188
      memset(&keyinfo->rb_tree , 0, sizeof(keyinfo->rb_tree));
189
 
      for (j= length= 0; j < keyinfo->keysegs; j++)
 
189
      for (uint32_t j= length= 0; j < keyinfo->keysegs; j++)
190
190
      {
191
191
        length+= keyinfo->seg[j].length;
192
192
        if (keyinfo->seg[j].null_bit)
251
251
          keyinfo->get_key_length= hp_rb_key_length;
252
252
      }
253
253
    }
254
 
    share= NULL;
255
 
    if (!(share= (HP_SHARE*) malloc(sizeof(HP_SHARE))))
256
 
      goto err;
257
 
 
258
 
    memset(share, 0, sizeof(HP_SHARE));
259
 
 
260
 
    if (keys && !(share->keydef= (HP_KEYDEF*) malloc(keys*sizeof(HP_KEYDEF))))
261
 
      goto err;
262
 
 
263
 
    memset(share->keydef, 0, keys*sizeof(HP_KEYDEF));
264
 
 
265
 
    if (keys && !(share->keydef->seg= (HA_KEYSEG*) malloc(key_segs*sizeof(HA_KEYSEG))))
266
 
      goto err;
267
 
    if (!(share->column_defs= (HP_COLUMNDEF*)
268
 
          malloc(columns*sizeof(HP_COLUMNDEF))))
269
 
      goto err;
270
 
 
271
 
    memset(share->column_defs, 0, columns*sizeof(HP_COLUMNDEF));
 
254
    share= new HP_SHARE;
 
255
 
 
256
    if (keys && !(share->keydef= new HP_KEYDEF[keys]))
 
257
      goto err;
 
258
    if (keys && !(share->keydef->seg= new HA_KEYSEG[key_segs]))
 
259
      goto err;
 
260
    if (!(share->column_defs= new HP_COLUMNDEF[columns]))
 
261
      goto err;
272
262
 
273
263
    /*
274
264
       Max_records is used for estimating block sizes and for enforcement.
280
270
    max_records = ((max_records && max_records < max_rows_for_stated_memory) ?
281
271
                      max_records : max_rows_for_stated_memory);
282
272
 
283
 
    memcpy(share->column_defs, columndef, (size_t) (sizeof(columndef[0]) * columns));
284
 
 
285
273
    share->key_stat_version= 1;
286
274
    keyseg= keys ? share->keydef->seg : NULL;
287
275
 
350
338
    }
351
339
 
352
340
    /* Must be allocated separately for rename to work */
353
 
    if (!(share->name= strdup(name)))
354
 
    {
355
 
      goto err;
356
 
    }
 
341
    share->name.append(name);
357
342
    thr_lock_init(&share->lock);
358
 
    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
359
343
    if (!create_info->internal_table)
360
344
    {
361
345
      heap_share_list.push_front(share);
364
348
      share->delete_on_close= 1;
365
349
  }
366
350
  if (!create_info->internal_table)
367
 
    pthread_mutex_unlock(&THR_LOCK_heap);
 
351
    THR_LOCK_heap.unlock();
368
352
 
369
353
  *res= share;
370
354
  return(0);
371
355
 
372
356
err:
373
 
  if(share && share->keydef && share->keydef->seg)
374
 
    free(share->keydef->seg);
375
 
  if(share && share->keydef)
376
 
    free(share->keydef);
377
 
  if(share && share->column_defs)
378
 
    free(share->column_defs);
379
 
  if(share)
380
 
    free(share);
381
 
  if (!create_info->internal_table)
382
 
    pthread_mutex_unlock(&THR_LOCK_heap);
 
357
  if (share && share->keydef && share->keydef->seg)
 
358
    delete [] share->keydef->seg;
 
359
  if (share && share->keydef)
 
360
    delete [] share->keydef;
 
361
  if (share && share->column_defs)
 
362
    delete [] share->column_defs;
 
363
  if (share)
 
364
    delete share;
 
365
  if (not create_info->internal_table)
 
366
    THR_LOCK_heap.unlock();
383
367
  return(1);
384
368
} /* heap_create */
385
369
 
394
378
static void init_block(HP_BLOCK *block, uint32_t chunk_length, uint32_t min_records,
395
379
                       uint32_t max_records)
396
380
{
397
 
  uint32_t i,recbuffer,records_in_block;
 
381
  uint32_t recbuffer,records_in_block;
398
382
 
399
383
  max_records= max(min_records,max_records);
400
384
  if (!max_records)
413
397
  block->recbuffer= recbuffer;
414
398
  block->last_allocated= 0L;
415
399
 
416
 
  for (i= 0; i <= HP_MAX_LEVELS; i++)
 
400
  for (uint32_t i= 0; i <= HP_MAX_LEVELS; i++)
 
401
  {
417
402
    block->level_info[i].records_under_level=
418
403
      (!i ? 1 : i == 1 ? records_in_block :
419
404
       HP_PTRS_IN_NOD * block->level_info[i - 1].records_under_level);
 
405
  }
420
406
}
421
407
 
422
408
 
434
420
  int result;
435
421
  register HP_SHARE *share;
436
422
 
437
 
  pthread_mutex_lock(&THR_LOCK_heap);
 
423
  THR_LOCK_heap.lock();
438
424
  if ((share= hp_find_named_heap(name)))
439
425
  {
440
426
    heap_try_free(share);
444
430
  {
445
431
    result= errno=ENOENT;
446
432
  }
447
 
  pthread_mutex_unlock(&THR_LOCK_heap);
 
433
  THR_LOCK_heap.unlock();
448
434
  return(result);
449
435
}
450
436
 
451
437
 
452
 
void heap_drop_table(HP_INFO *info)
453
 
{
454
 
  pthread_mutex_lock(&THR_LOCK_heap);
455
 
  heap_try_free(info->s);
456
 
  pthread_mutex_unlock(&THR_LOCK_heap);
457
 
  return;
458
 
}
459
 
 
460
 
 
461
438
void hp_free(HP_SHARE *share)
462
439
{
463
440
  heap_share_list.remove(share);        /* If not internal table */
464
441
  hp_clear(share);                      /* Remove blocks from memory */
465
 
  thr_lock_delete(&share->lock);
466
 
  pthread_mutex_destroy(&share->intern_lock);
467
 
  if (share->keydef && share->keydef->seg)
468
 
    free(share->keydef->seg);
 
442
  share->lock.deinit();
469
443
  if (share->keydef)
470
 
    free(share->keydef);
471
 
  free(share->column_defs);
472
 
  free((unsigned char*) share->name);
473
 
  free((unsigned char*) share);
474
 
  return;
 
444
    delete [] share->keydef->seg;
 
445
  delete [] share->keydef;
 
446
  delete [] share->column_defs;
 
447
  delete share;
475
448
}