← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-04-08 20:42:29 UTC
  • mto: (971.1.63 mordred)
  • mto: This revision was merged to the branch mainline in revision 990.
  • Revision ID: osullivan.padraig@gmail.com-20090408204229-okmeoxsqw21eav2o
Initial work on removing MY_BITMAP from the Drizzle code base. For a start,
I'm concentrating on removing the MY_BITMAP structures from the table
structure defined in drizzled/table.h

I'm replacing it with std::bitset for the moment unless I can think of a
better replacement. Still need to work on re-factoring the rest of the code
to work correctly with these changes that I have made.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
33
33
#include <drizzled/field/varstring.h>
34
34
#include <drizzled/field/double.h>
35
35
#include <string>
 
36
#include <bitset>
36
37
 
37
38
#include <drizzled/unireg.h>
38
39
#include <drizzled/serialize/table.pb.h>
1965
1966
  }
1966
1967
 
1967
1968
  /* Allocate bitmaps */
1968
 
 
1969
 
  bitmap_size= share->column_bitmap_size;
1970
 
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1971
 
    goto err;
1972
 
  bitmap_init(&outparam->def_read_set,
1973
 
              (my_bitmap_map*) bitmaps, share->fields, false);
1974
 
  bitmap_init(&outparam->def_write_set,
1975
 
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields, false);
1976
 
  bitmap_init(&outparam->tmp_set,
1977
 
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, false);
1978
1969
  outparam->default_column_bitmaps();
1979
1970
 
1980
1971
  /* The table struct is now initialized;  Open the table */
2474
2465
    a tmp_set bitmap to be used by things like filesort.
2475
2466
*/
2476
2467
 
2477
 
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
2468
void Table::setup_tmp_table_column_bitmaps()
2478
2469
{
2479
2470
  uint32_t field_count= s->fields;
2480
2471
 
2481
 
  bitmap_init(&this->def_read_set, (my_bitmap_map*) bitmaps, field_count, false);
2482
 
  bitmap_init(&this->tmp_set, (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count, false);
2483
 
 
2484
2472
  /* write_set and all_set are copies of read_set */
2485
2473
  def_write_set= def_read_set;
2486
2474
  s->all_set= def_read_set;
2487
 
  bitmap_set_all(&this->s->all_set);
 
2475
  this->s->all_set.set();
2488
2476
  default_column_bitmaps();
2489
2477
}
2490
2478
 
3116
3104
void Table::clear_column_bitmaps()
3117
3105
{
3118
3106
  /*
3119
 
    Reset column read/write usage. It's identical to:
3120
 
    bitmap_clear_all(&table->def_read_set);
3121
 
    bitmap_clear_all(&table->def_write_set);
 
3107
    Reset column read/write usage.
3122
3108
  */
3123
 
  memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);
 
3109
  def_read_set.reset();
 
3110
  def_write_set.reset(); /* TODO: is this needed here? */
3124
3111
  column_bitmaps_set(&def_read_set, &def_write_set);
3125
3112
}
3126
3113
 
3160
3147
 
3161
3148
void Table::mark_columns_used_by_index(uint32_t index)
3162
3149
{
3163
 
  MY_BITMAP *bitmap= &tmp_set;
 
3150
  bitset<MAX_FIELDS> *bitmap= &tmp_set;
3164
3151
 
3165
3152
  (void) file->extra(HA_EXTRA_KEYREAD);
3166
 
  bitmap_clear_all(bitmap);
 
3153
  bitmap->reset()
3167
3154
  mark_columns_used_by_index_no_reset(index, bitmap);
3168
3155
  column_bitmaps_set(bitmap, bitmap);
3169
3156
  return;
3197
3184
*/
3198
3185
 
3199
3186
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
3200
 
                                                   MY_BITMAP *bitmap)
 
3187
                                                bitset<MAX_FIELDS> *bitmap)
3201
3188
{
3202
3189
  KEY_PART_INFO *key_part= key_info[index].key_part;
3203
3190
  KEY_PART_INFO *key_part_end= (key_part +
3204
3191
                                key_info[index].key_parts);
3205
3192
  for (;key_part != key_part_end; key_part++)
3206
3193
  {
3207
 
    bitmap_set_bit(bitmap, key_part->fieldnr-1);
 
3194
    bitmap.set(key_part->fieldnr-1);
3208
3195
    if (key_part->field->vcol_info &&
3209
3196
        key_part->field->vcol_info->expr_item)
3210
3197
      key_part->field->vcol_info->
3229
3216
    We must set bit in read set as update_auto_increment() is using the
3230
3217
    store() to check overflow of auto_increment values
3231
3218
  */
3232
 
  bitmap_set_bit(read_set, found_next_number_field->field_index);
3233
 
  bitmap_set_bit(write_set, found_next_number_field->field_index);
 
3219
  read_set->set(found_next_number_field->field_index);
 
3220
  write_set->set(found_next_number_field->field_index);
3234
3221
  if (s->next_number_keypart)
3235
3222
    mark_columns_used_by_index_no_reset(s->next_number_index, read_set);
3236
3223
  file->column_bitmaps_signal();
3263
3250
    for (reg_field= field ; *reg_field ; reg_field++)
3264
3251
    {
3265
3252
      if ((*reg_field)->flags & PART_KEY_FLAG)
3266
 
        bitmap_set_bit(read_set, (*reg_field)->field_index);
 
3253
        read_set->set((*reg_field)->field_index);
3267
3254
    }
3268
3255
    file->column_bitmaps_signal();
3269
3256
  }
3314
3301
    {
3315
3302
      /* Merge keys is all keys that had a column refered to in the query */
3316
3303
      if (merge_keys.is_overlapping((*reg_field)->part_of_key))
3317
 
        bitmap_set_bit(read_set, (*reg_field)->field_index);
 
3304
        read_set->set((*reg_field)->field_index);
3318
3305
    }
3319
3306
    file->column_bitmaps_signal();
3320
3307
  }
3379
3366
    assert(tmp_vfield->vcol_info && tmp_vfield->vcol_info->expr_item);
3380
3367
    tmp_vfield->vcol_info->expr_item->walk(&Item::register_field_in_read_map,
3381
3368
                                           1, (unsigned char *) 0);
3382
 
    bitmap_set_bit(read_set, tmp_vfield->field_index);
3383
 
    bitmap_set_bit(write_set, tmp_vfield->field_index);
 
3369
    read_set->set(tmp_vfield->field_index);
 
3370
    write_set->set(tmp_vfield->field_index);
3384
3371
    bitmap_updated= true;
3385
3372
  }
3386
3373
  if (bitmap_updated)
4849
4836
  return(1);
4850
4837
}
4851
4838
 
4852
 
my_bitmap_map *Table::use_all_columns(MY_BITMAP *bitmap)
 
4839
bitset<MAX_FIELDS> *Table::use_all_columns(bitset<MAX_FIELDS> *bitmap)
4853
4840
{
4854
 
  my_bitmap_map *old= bitmap->bitmap;
4855
 
  bitmap->bitmap= s->all_set.bitmap;
 
4841
  bitset<MAX_FIELDS> *old= bitmap;
 
4842
  bitmap= s->all_set;
4856
4843
  return old;
4857
4844
}
4858
4845
 
4859
 
void Table::restore_column_map(my_bitmap_map *old)
 
4846
void Table::restore_column_map(bitset<MAX_FIELDS> *old)
4860
4847
{
4861
 
  read_set->bitmap= old;
 
4848
  read_set= old;
4862
4849
}
4863
4850
 
4864
4851
uint32_t Table::find_shortest_key(const key_map *usable_keys)