← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Brian Aker
  • Date: 2009-04-13 16:22:40 UTC
  • mfrom: (971.1.78 mordred)
  • Revision ID: brian@gaz-20090413162240-ugi3gvhofmcuglzl
Merge Monty

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
 
#include <drizzled/serialize/table.pb.h>
 
39
#include <drizzled/message/table.pb.h>
39
40
 
40
41
#include <drizzled/item/string.h>
41
42
#include <drizzled/item/int.h>
291
292
 
292
293
  switch(proto_field_type)
293
294
  {
294
 
  case drizzle::Table::Field::TINYINT:
 
295
  case drizzled::message::Table::Field::TINYINT:
295
296
    field_type= DRIZZLE_TYPE_TINY;
296
297
    break;
297
 
  case drizzle::Table::Field::INTEGER:
 
298
  case drizzled::message::Table::Field::INTEGER:
298
299
    field_type= DRIZZLE_TYPE_LONG;
299
300
    break;
300
 
  case drizzle::Table::Field::DOUBLE:
 
301
  case drizzled::message::Table::Field::DOUBLE:
301
302
    field_type= DRIZZLE_TYPE_DOUBLE;
302
303
    break;
303
 
  case drizzle::Table::Field::TIMESTAMP:
 
304
  case drizzled::message::Table::Field::TIMESTAMP:
304
305
    field_type= DRIZZLE_TYPE_TIMESTAMP;
305
306
    break;
306
 
  case drizzle::Table::Field::BIGINT:
 
307
  case drizzled::message::Table::Field::BIGINT:
307
308
    field_type= DRIZZLE_TYPE_LONGLONG;
308
309
    break;
309
 
  case drizzle::Table::Field::DATETIME:
 
310
  case drizzled::message::Table::Field::DATETIME:
310
311
    field_type= DRIZZLE_TYPE_DATETIME;
311
312
    break;
312
 
  case drizzle::Table::Field::DATE:
 
313
  case drizzled::message::Table::Field::DATE:
313
314
    field_type= DRIZZLE_TYPE_DATE;
314
315
    break;
315
 
  case drizzle::Table::Field::VARCHAR:
 
316
  case drizzled::message::Table::Field::VARCHAR:
316
317
    field_type= DRIZZLE_TYPE_VARCHAR;
317
318
    break;
318
 
  case drizzle::Table::Field::DECIMAL:
 
319
  case drizzled::message::Table::Field::DECIMAL:
319
320
    field_type= DRIZZLE_TYPE_NEWDECIMAL;
320
321
    break;
321
 
  case drizzle::Table::Field::ENUM:
 
322
  case drizzled::message::Table::Field::ENUM:
322
323
    field_type= DRIZZLE_TYPE_ENUM;
323
324
    break;
324
 
  case drizzle::Table::Field::BLOB:
 
325
  case drizzled::message::Table::Field::BLOB:
325
326
    field_type= DRIZZLE_TYPE_BLOB;
326
327
    break;
327
 
  case drizzle::Table::Field::VIRTUAL:
 
328
  case drizzled::message::Table::Field::VIRTUAL:
328
329
    field_type= DRIZZLE_TYPE_VIRTUAL;
329
330
    break;
330
331
  default:
402
403
  return default_item;
403
404
}
404
405
 
405
 
int parse_table_proto(Session *session, drizzle::Table &table, TABLE_SHARE *share)
 
406
int parse_table_proto(Session *session, drizzled::message::Table &table, TABLE_SHARE *share)
406
407
{
407
408
  int error= 0;
408
409
  handler *handler_file= NULL;
415
416
 
416
417
  share->mysql_version= DRIZZLE_VERSION_ID; // TODO: remove
417
418
 
418
 
  drizzle::Table::TableOptions table_options;
 
419
  drizzled::message::Table::TableOptions table_options;
419
420
 
420
421
  if(table.has_options())
421
422
    table_options= table.options();
533
534
  KEY* keyinfo= share->key_info;
534
535
  for (int keynr=0; keynr < table.indexes_size(); keynr++, keyinfo++)
535
536
  {
536
 
    drizzle::Table::Index indx= table.indexes(keynr);
 
537
    drizzled::message::Table::Index indx= table.indexes(keynr);
537
538
 
538
539
    keyinfo->table= 0;
539
540
    keyinfo->flags= 0;
543
544
 
544
545
    if(indx.has_options())
545
546
    {
546
 
      drizzle::Table::Index::IndexOptions indx_options= indx.options();
 
547
      drizzled::message::Table::Index::IndexOptions indx_options= indx.options();
547
548
      if(indx_options.pack_key())
548
549
        keyinfo->flags|= HA_PACK_KEY;
549
550
 
576
577
 
577
578
    switch(indx.type())
578
579
    {
579
 
    case drizzle::Table::Index::UNKNOWN_INDEX:
 
580
    case drizzled::message::Table::Index::UNKNOWN_INDEX:
580
581
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
581
582
      break;
582
 
    case drizzle::Table::Index::BTREE:
 
583
    case drizzled::message::Table::Index::BTREE:
583
584
      keyinfo->algorithm= HA_KEY_ALG_BTREE;
584
585
      break;
585
 
    case drizzle::Table::Index::RTREE:
 
586
    case drizzled::message::Table::Index::RTREE:
586
587
      keyinfo->algorithm= HA_KEY_ALG_RTREE;
587
588
      break;
588
 
    case drizzle::Table::Index::HASH:
 
589
    case drizzled::message::Table::Index::HASH:
589
590
      keyinfo->algorithm= HA_KEY_ALG_HASH;
590
591
      break;
591
 
    case drizzle::Table::Index::FULLTEXT:
 
592
    case drizzled::message::Table::Index::FULLTEXT:
592
593
      keyinfo->algorithm= HA_KEY_ALG_FULLTEXT;
593
594
 
594
595
    default:
608
609
        partnr < keyinfo->key_parts;
609
610
        partnr++, key_part++)
610
611
    {
611
 
      drizzle::Table::Index::IndexPart part;
 
612
      drizzled::message::Table::Index::IndexPart part;
612
613
      part= indx.index_part(partnr);
613
614
 
614
615
      *rec_per_key++=0;
701
702
 
702
703
  for(unsigned int fieldnr=0; fieldnr < share->fields; fieldnr++)
703
704
  {
704
 
    drizzle::Table::Field pfield= table.field(fieldnr);
 
705
    drizzled::message::Table::Field pfield= table.field(fieldnr);
705
706
    if(pfield.has_constraints() && pfield.constraints().is_nullable())
706
707
      null_fields++;
707
708
 
712
713
 
713
714
    if(drizzle_field_type==DRIZZLE_TYPE_VIRTUAL)
714
715
    {
715
 
      drizzle::Table::Field::VirtualFieldOptions field_options=
 
716
      drizzled::message::Table::Field::VirtualFieldOptions field_options=
716
717
        pfield.virtual_options();
717
718
 
718
719
      drizzle_field_type=proto_field_type_to_drizzle_type(field_options.type());
731
732
    case DRIZZLE_TYPE_BLOB:
732
733
    case DRIZZLE_TYPE_VARCHAR:
733
734
      {
734
 
        drizzle::Table::Field::StringFieldOptions field_options=
 
735
        drizzled::message::Table::Field::StringFieldOptions field_options=
735
736
          pfield.string_options();
736
737
 
737
738
        const CHARSET_INFO *cs= get_charset(field_options.has_collation_id()?
748
749
      break;
749
750
    case DRIZZLE_TYPE_ENUM:
750
751
      {
751
 
        drizzle::Table::Field::SetFieldOptions field_options=
 
752
        drizzled::message::Table::Field::SetFieldOptions field_options=
752
753
          pfield.set_options();
753
754
 
754
755
        field_pack_length[fieldnr]=
760
761
      break;
761
762
    case DRIZZLE_TYPE_NEWDECIMAL:
762
763
      {
763
 
        drizzle::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
 
764
        drizzled::message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
764
765
 
765
766
        field_pack_length[fieldnr]=
766
767
          my_decimal_get_binary_size(fo.precision(), fo.scale());
783
784
  /* fix up offsets for non-stored fields (at end of record) */
784
785
  for(unsigned int fieldnr=0; fieldnr < share->fields; fieldnr++)
785
786
  {
786
 
    drizzle::Table::Field pfield= table.field(fieldnr);
 
787
    drizzled::message::Table::Field pfield= table.field(fieldnr);
787
788
 
788
789
    bool field_is_stored= true;
789
790
 
792
793
 
793
794
    if(drizzle_field_type==DRIZZLE_TYPE_VIRTUAL)
794
795
    {
795
 
      drizzle::Table::Field::VirtualFieldOptions field_options=
 
796
      drizzled::message::Table::Field::VirtualFieldOptions field_options=
796
797
        pfield.virtual_options();
797
798
 
798
799
      field_is_stored= field_options.physically_stored();
865
866
 
866
867
  for(unsigned int fieldnr=0; fieldnr < share->fields; fieldnr++)
867
868
  {
868
 
    drizzle::Table::Field pfield= table.field(fieldnr);
 
869
    drizzled::message::Table::Field pfield= table.field(fieldnr);
869
870
 
870
871
    /* field names */
871
872
    share->fieldnames.type_names[fieldnr]= strmake_root(&share->mem_root,
875
876
    share->fieldnames.type_lengths[fieldnr]= pfield.name().length();
876
877
 
877
878
    /* enum typelibs */
878
 
    if(pfield.type() != drizzle::Table::Field::ENUM)
 
879
    if(pfield.type() != drizzled::message::Table::Field::ENUM)
879
880
      continue;
880
881
 
881
 
    drizzle::Table::Field::SetFieldOptions field_options=
 
882
    drizzled::message::Table::Field::SetFieldOptions field_options=
882
883
      pfield.set_options();
883
884
 
884
885
    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id()?
935
936
 
936
937
  for(unsigned int fieldnr=0; fieldnr < share->fields; fieldnr++)
937
938
  {
938
 
    drizzle::Table::Field pfield= table.field(fieldnr);
 
939
    drizzled::message::Table::Field pfield= table.field(fieldnr);
939
940
 
940
941
    enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
941
942
 
942
943
    switch(pfield.format())
943
944
    {
944
 
    case drizzle::Table::Field::DefaultFormat:
 
945
    case drizzled::message::Table::Field::DefaultFormat:
945
946
      column_format= COLUMN_FORMAT_TYPE_DEFAULT;
946
947
      break;
947
 
    case drizzle::Table::Field::FixedFormat:
 
948
    case drizzled::message::Table::Field::FixedFormat:
948
949
      column_format= COLUMN_FORMAT_TYPE_FIXED;
949
950
      break;
950
 
    case drizzle::Table::Field::DynamicFormat:
 
951
    case drizzled::message::Table::Field::DynamicFormat:
951
952
      column_format= COLUMN_FORMAT_TYPE_DYNAMIC;
952
953
      break;
953
954
    default:
1009
1010
 
1010
1011
    if(field_type==DRIZZLE_TYPE_VIRTUAL)
1011
1012
    {
1012
 
      drizzle::Table::Field::VirtualFieldOptions field_options=
 
1013
      drizzled::message::Table::Field::VirtualFieldOptions field_options=
1013
1014
        pfield.virtual_options();
1014
1015
 
1015
1016
      vcol_info= new virtual_column_info();
1030
1031
    if(field_type==DRIZZLE_TYPE_BLOB
1031
1032
       || field_type==DRIZZLE_TYPE_VARCHAR)
1032
1033
    {
1033
 
      drizzle::Table::Field::StringFieldOptions field_options=
 
1034
      drizzled::message::Table::Field::StringFieldOptions field_options=
1034
1035
        pfield.string_options();
1035
1036
 
1036
1037
      charset= get_charset(field_options.has_collation_id()?
1043
1044
 
1044
1045
    if(field_type==DRIZZLE_TYPE_ENUM)
1045
1046
    {
1046
 
      drizzle::Table::Field::SetFieldOptions field_options=
 
1047
      drizzled::message::Table::Field::SetFieldOptions field_options=
1047
1048
        pfield.set_options();
1048
1049
 
1049
1050
      charset= get_charset(field_options.has_collation_id()?
1379
1380
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1380
1381
                                             share->column_bitmap_size)))
1381
1382
    goto err;
1382
 
  bitmap_init(&share->all_set, bitmaps, share->fields, false);
1383
 
  bitmap_set_all(&share->all_set);
 
1383
  share->all_set.set();
1384
1384
 
1385
1385
  if(handler_file)
1386
1386
    delete handler_file;
1436
1436
 
1437
1437
  proto_path.append(".dfe");
1438
1438
 
1439
 
  drizzle::Table table;
 
1439
  drizzled::message::Table table;
1440
1440
 
1441
1441
  if((error= drizzle_read_table_proto(proto_path.c_str(), &table)))
1442
1442
  {
1775
1775
                          Table *outparam, open_table_mode open_mode)
1776
1776
{
1777
1777
  int error;
1778
 
  uint32_t records, i, bitmap_size;
 
1778
  uint32_t records, i;
1779
1779
  bool error_reported= false;
1780
 
  unsigned char *record, *bitmaps;
 
1780
  unsigned char *record;
1781
1781
  Field **field_ptr, **vfield_ptr;
1782
1782
 
1783
1783
  /* Parsing of partitioning information from .frm needs session->lex set up. */
1965
1965
  }
1966
1966
 
1967
1967
  /* 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
1968
  outparam->default_column_bitmaps();
1979
1969
 
1980
1970
  /* The table struct is now initialized;  Open the table */
2474
2464
    a tmp_set bitmap to be used by things like filesort.
2475
2465
*/
2476
2466
 
2477
 
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
2467
void Table::setup_tmp_table_column_bitmaps()
2478
2468
{
2479
 
  uint32_t field_count= s->fields;
2480
 
 
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
2469
  /* write_set and all_set are copies of read_set */
2485
2470
  def_write_set= def_read_set;
2486
2471
  s->all_set= def_read_set;
2487
 
  bitmap_set_all(&this->s->all_set);
 
2472
  this->s->all_set.set();
2488
2473
  default_column_bitmaps();
2489
2474
}
2490
2475
 
3116
3101
void Table::clear_column_bitmaps()
3117
3102
{
3118
3103
  /*
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);
 
3104
    Reset column read/write usage.
3122
3105
  */
3123
 
  memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);
 
3106
  def_read_set.reset();
 
3107
  def_write_set.reset(); /* TODO: is this needed here? */
3124
3108
  column_bitmaps_set(&def_read_set, &def_write_set);
3125
3109
}
3126
3110
 
3160
3144
 
3161
3145
void Table::mark_columns_used_by_index(uint32_t index)
3162
3146
{
3163
 
  MY_BITMAP *bitmap= &tmp_set;
 
3147
  bitset<MAX_FIELDS> *bitmap= &tmp_set;
3164
3148
 
3165
3149
  (void) file->extra(HA_EXTRA_KEYREAD);
3166
 
  bitmap_clear_all(bitmap);
 
3150
  bitmap->reset();
3167
3151
  mark_columns_used_by_index_no_reset(index, bitmap);
3168
3152
  column_bitmaps_set(bitmap, bitmap);
3169
3153
  return;
3197
3181
*/
3198
3182
 
3199
3183
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
3200
 
                                                   MY_BITMAP *bitmap)
 
3184
                                                bitset<MAX_FIELDS> *bitmap)
3201
3185
{
3202
3186
  KEY_PART_INFO *key_part= key_info[index].key_part;
3203
3187
  KEY_PART_INFO *key_part_end= (key_part +
3204
3188
                                key_info[index].key_parts);
3205
3189
  for (;key_part != key_part_end; key_part++)
3206
3190
  {
3207
 
    bitmap_set_bit(bitmap, key_part->fieldnr-1);
 
3191
    bitmap->set(key_part->fieldnr-1);
3208
3192
    if (key_part->field->vcol_info &&
3209
3193
        key_part->field->vcol_info->expr_item)
3210
3194
      key_part->field->vcol_info->
3229
3213
    We must set bit in read set as update_auto_increment() is using the
3230
3214
    store() to check overflow of auto_increment values
3231
3215
  */
3232
 
  bitmap_set_bit(read_set, found_next_number_field->field_index);
3233
 
  bitmap_set_bit(write_set, found_next_number_field->field_index);
 
3216
  read_set->set(found_next_number_field->field_index);
 
3217
  write_set->set(found_next_number_field->field_index);
3234
3218
  if (s->next_number_keypart)
3235
3219
    mark_columns_used_by_index_no_reset(s->next_number_index, read_set);
3236
3220
  file->column_bitmaps_signal();
3263
3247
    for (reg_field= field ; *reg_field ; reg_field++)
3264
3248
    {
3265
3249
      if ((*reg_field)->flags & PART_KEY_FLAG)
3266
 
        bitmap_set_bit(read_set, (*reg_field)->field_index);
 
3250
        read_set->set((*reg_field)->field_index);
3267
3251
    }
3268
3252
    file->column_bitmaps_signal();
3269
3253
  }
3314
3298
    {
3315
3299
      /* Merge keys is all keys that had a column refered to in the query */
3316
3300
      if (merge_keys.is_overlapping((*reg_field)->part_of_key))
3317
 
        bitmap_set_bit(read_set, (*reg_field)->field_index);
 
3301
        read_set->set((*reg_field)->field_index);
3318
3302
    }
3319
3303
    file->column_bitmaps_signal();
3320
3304
  }
3379
3363
    assert(tmp_vfield->vcol_info && tmp_vfield->vcol_info->expr_item);
3380
3364
    tmp_vfield->vcol_info->expr_item->walk(&Item::register_field_in_read_map,
3381
3365
                                           1, (unsigned char *) 0);
3382
 
    bitmap_set_bit(read_set, tmp_vfield->field_index);
3383
 
    bitmap_set_bit(write_set, tmp_vfield->field_index);
 
3366
    read_set->set(tmp_vfield->field_index);
 
3367
    write_set->set(tmp_vfield->field_index);
3384
3368
    bitmap_updated= true;
3385
3369
  }
3386
3370
  if (bitmap_updated)
3767
3751
  uint32_t  copy_func_count= param->func_count;
3768
3752
  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;
3769
3753
  uint32_t  blob_count,group_null_items, string_count;
3770
 
  uint32_t  temp_pool_slot=MY_BIT_NONE;
 
3754
  uint32_t  temp_pool_slot= MY_BIT_NONE;
3771
3755
  uint32_t fieldnr= 0;
3772
3756
  ulong reclength, string_total_length;
3773
3757
  bool  using_unique_constraint= 0;
3789
3773
  status_var_increment(session->status_var.created_tmp_tables);
3790
3774
 
3791
3775
  if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))
3792
 
    temp_pool_slot = bitmap_lock_set_next(&temp_pool);
 
3776
    setNextBit(temp_pool);
3793
3777
 
3794
3778
  if (temp_pool_slot != MY_BIT_NONE) // we got a slot
3795
3779
    sprintf(path, "%s_%lx_%i", TMP_FILE_PREFIX,
3865
3849
                        NULL))
3866
3850
  {
3867
3851
    if (temp_pool_slot != MY_BIT_NONE)
3868
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
 
3852
      temp_pool.reset(temp_pool_slot);
3869
3853
    return(NULL);                               /* purecov: inspected */
3870
3854
  }
3871
3855
  /* Copy_field belongs to Tmp_Table_Param, allocate it in Session mem_root */
3872
3856
  if (!(param->copy_field= copy= new (session->mem_root) Copy_field[field_count]))
3873
3857
  {
3874
3858
    if (temp_pool_slot != MY_BIT_NONE)
3875
 
      bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
 
3859
      temp_pool.reset(temp_pool_slot);
3876
3860
    free_root(&own_root, MYF(0));               /* purecov: inspected */
3877
3861
    return(NULL);                               /* purecov: inspected */
3878
3862
  }
3894
3878
  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */
3895
3879
  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;
3896
3880
  table->map=1;
3897
 
  table->temp_pool_slot = temp_pool_slot;
 
3881
  table->temp_pool_slot= temp_pool_slot;
3898
3882
  table->copy_blobs= 1;
3899
3883
  table->in_use= session;
3900
3884
  table->quick_keys.init();
4126
4110
  copy_func[0]=0;                               // End marker
4127
4111
  param->func_count= copy_func - param->items_to_copy;
4128
4112
 
4129
 
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
4113
  table->setup_tmp_table_column_bitmaps();
4130
4114
 
4131
4115
  recinfo=param->start_recinfo;
4132
4116
  null_flags=(unsigned char*) table->record[0];
4424
4408
  session->mem_root= mem_root_save;
4425
4409
  table->free_tmp_table(session);                    /* purecov: inspected */
4426
4410
  if (temp_pool_slot != MY_BIT_NONE)
4427
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
 
4411
    temp_pool.reset(temp_pool_slot);
4428
4412
  return(NULL);                         /* purecov: inspected */
4429
4413
}
4430
4414
 
4479
4463
  share->blob_field= blob_field;
4480
4464
  share->fields= field_count;
4481
4465
  share->blob_ptr_size= portable_sizeof_char_ptr;
4482
 
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
4466
  table->setup_tmp_table_column_bitmaps();
4483
4467
 
4484
4468
  /* Create all fields and calculate the total length of record */
4485
4469
  List_iterator_fast<Create_field> it(field_list);
4734
4718
  free_io_cache(this);
4735
4719
 
4736
4720
  if (temp_pool_slot != MY_BIT_NONE)
4737
 
    bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);
 
4721
    temp_pool.reset(temp_pool_slot);
4738
4722
 
4739
4723
  free_root(&own_root, MYF(0)); /* the table is allocated in its own root */
4740
4724
  session->set_proc_info(save_proc_info);
4849
4833
  return(1);
4850
4834
}
4851
4835
 
4852
 
my_bitmap_map *Table::use_all_columns(MY_BITMAP *bitmap)
 
4836
bitset<MAX_FIELDS> *Table::use_all_columns(bitset<MAX_FIELDS> *bitmap)
4853
4837
{
4854
 
  my_bitmap_map *old= bitmap->bitmap;
4855
 
  bitmap->bitmap= s->all_set.bitmap;
 
4838
  bitset<MAX_FIELDS> *old= bitmap;
 
4839
  bitmap= &s->all_set;
4856
4840
  return old;
4857
4841
}
4858
4842
 
4859
 
void Table::restore_column_map(my_bitmap_map *old)
 
4843
void Table::restore_column_map(bitset<MAX_FIELDS> *old)
4860
4844
{
4861
 
  read_set->bitmap= old;
 
4845
  read_set= old;
4862
4846
}
4863
4847
 
4864
4848
uint32_t Table::find_shortest_key(const key_map *usable_keys)
4914
4898
  /* Compare updated fields */
4915
4899
  for (Field **ptr= field ; *ptr ; ptr++)
4916
4900
  {
4917
 
    if (bitmap_is_set(write_set, (*ptr)->field_index) &&
 
4901
    if (write_set->test((*ptr)->field_index) &&
4918
4902
        (*ptr)->cmp_binary_offset(s->rec_buff_length))
4919
4903
      return true;
4920
4904
  }
4987
4971
      Only update those fields that are marked in the write_set bitmap
4988
4972
      and not _already_ physically stored in the database.
4989
4973
    */
4990
 
    if (bitmap_is_set(table->write_set, vfield->field_index) &&
 
4974
    if (table->write_set->test(vfield->field_index) &&
4991
4975
        (not (ignore_stored && vfield->is_stored))
4992
4976
       )
4993
4977
    {