← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Monty Taylor
  • Date: 2009-05-24 23:54:21 UTC
  • mfrom: (1014.2.12 kill-malloc)
  • mto: This revision was merged to the branch mainline in revision 1039.
  • Revision ID: mordred@inaugust.com-20090524235421-x5vfss90auzbn896
Merged Monty from lp:~mordred/drizzle/kill-malloc

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
1185
1185
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1186
1186
                                             share->column_bitmap_size)))
1187
1187
    goto err;
1188
 
  bitmap_init(&share->all_set, bitmaps, share->fields, false);
 
1188
  bitmap_init(&share->all_set, bitmaps, share->fields);
1189
1189
  bitmap_set_all(&share->all_set);
1190
1190
 
1191
1191
  if(handler_file)
1320
1320
  assert(session->lex->is_lex_started);
1321
1321
 
1322
1322
  error= 1;
1323
 
  memset(outparam, 0, sizeof(*outparam));
1324
 
  outparam->in_use= session;
1325
 
  outparam->s= share;
1326
 
  outparam->db_stat= db_stat;
1327
 
  outparam->write_row_record= NULL;
 
1323
  outparam->reset(session, share, db_stat);
1328
1324
 
1329
 
  init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
1330
1325
 
1331
1326
  if (!(outparam->alias= strdup(alias)))
1332
1327
    goto err;
1333
 
  outparam->quick_keys.reset();
1334
 
  outparam->covering_keys.reset();
1335
 
  outparam->keys_in_use_for_query.reset();
1336
1328
 
1337
1329
  /* Allocate handler */
1338
 
  outparam->file= 0;
1339
1330
  if (!(prgflag & OPEN_FRM_FILE_ONLY))
1340
1331
  {
1341
1332
    if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
1348
1339
  }
1349
1340
 
1350
1341
  error= 4;
1351
 
  outparam->reginfo.lock_type= TL_UNLOCK;
1352
 
  outparam->current_lock= F_UNLCK;
1353
1342
  records=0;
1354
1343
  if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
1355
1344
    records=1;
1467
1456
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1468
1457
    goto err;
1469
1458
  bitmap_init(&outparam->def_read_set,
1470
 
              (my_bitmap_map*) bitmaps, share->fields, false);
 
1459
              (my_bitmap_map*) bitmaps, share->fields);
1471
1460
  bitmap_init(&outparam->def_write_set,
1472
 
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields, false);
 
1461
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
1473
1462
  bitmap_init(&outparam->tmp_set,
1474
 
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, false);
 
1463
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
1475
1464
  outparam->default_column_bitmaps();
1476
1465
 
1477
1466
  /* The table struct is now initialized;  Open the table */
1974
1963
{
1975
1964
  uint32_t field_count= s->fields;
1976
1965
 
1977
 
  bitmap_init(&this->def_read_set, (my_bitmap_map*) bitmaps, field_count, false);
1978
 
  bitmap_init(&this->tmp_set, (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count, false);
 
1966
  bitmap_init(&this->def_read_set, (my_bitmap_map*) bitmaps, field_count);
 
1967
  bitmap_init(&this->tmp_set, (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
1979
1968
 
1980
1969
  /* write_set and all_set are copies of read_set */
1981
1970
  def_write_set= def_read_set;
3200
3189
  uint32_t  copy_func_count= param->func_count;
3201
3190
  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;
3202
3191
  uint32_t  blob_count,group_null_items, string_count;
3203
 
  uint32_t  temp_pool_slot=MY_BIT_NONE;
3204
3192
  uint32_t fieldnr= 0;
3205
3193
  ulong reclength, string_total_length;
3206
3194
  bool  using_unique_constraint= 0;
3221
3209
 
3222
3210
  status_var_increment(session->status_var.created_tmp_tables);
3223
3211
 
3224
 
  if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))
3225
 
    temp_pool_slot = bitmap_lock_set_next(&temp_pool);
3226
 
 
3227
 
  if (temp_pool_slot != MY_BIT_NONE) // we got a slot
3228
 
    sprintf(path, "%s_%lx_%i", TMP_FILE_PREFIX,
3229
 
            (unsigned long)current_pid, temp_pool_slot);
3230
 
  else
3231
 
  {
3232
 
    /* if we run out of slots or we are not using tempool */
3233
 
    sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
3234
 
            session->thread_id, session->tmp_table++);
3235
 
  }
 
3212
  /* if we run out of slots or we are not using tempool */
 
3213
  sprintf(path,"%s%lx_%"PRIx64"_%x", TMP_FILE_PREFIX, (unsigned long)current_pid,
 
3214
          session->thread_id, session->tmp_table++);
3236
3215
 
3237
3216
  /*
3238
3217
    No need to change table name to lower case as we are only creating
3297
3276
                        &bitmaps, bitmap_buffer_size(field_count)*2,
3298
3277
                        NULL))
3299
3278
  {
3300
 
    if (temp_pool_slot != MY_BIT_NONE)
3301
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
3302
3279
    return NULL;                                /* purecov: inspected */
3303
3280
  }
3304
3281
  /* Copy_field belongs to Tmp_Table_Param, allocate it in Session mem_root */
3305
3282
  if (!(param->copy_field= copy= new (session->mem_root) Copy_field[field_count]))
3306
3283
  {
3307
 
    if (temp_pool_slot != MY_BIT_NONE)
3308
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
3309
3284
    free_root(&own_root, MYF(0));               /* purecov: inspected */
3310
3285
    return NULL;                                /* purecov: inspected */
3311
3286
  }
3327
3302
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
3328
3303
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
3329
3304
  table->map=1;
3330
 
  table->temp_pool_slot = temp_pool_slot;
3331
3305
  table->copy_blobs= 1;
3332
3306
  table->in_use= session;
3333
3307
  table->quick_keys.reset();
3856
3830
err:
3857
3831
  session->mem_root= mem_root_save;
3858
3832
  table->free_tmp_table(session);                    /* purecov: inspected */
3859
 
  if (temp_pool_slot != MY_BIT_NONE)
3860
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
3861
3833
  return NULL;                          /* purecov: inspected */
3862
3834
}
3863
3835
 
4166
4138
    (*ptr)->free();
4167
4139
  free_io_cache(this);
4168
4140
 
4169
 
  if (temp_pool_slot != MY_BIT_NONE)
4170
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
4171
 
 
4172
4141
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
4173
4142
  session->set_proc_info(save_proc_info);
4174
4143