← 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: 2010-10-08 20:13:50 UTC
  • mfrom: (1823.1.3 trunk-drizzle)
  • Revision ID: brian@tangent.org-20101008201350-bmjpgakk12zmyw10
Overall merge of Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
334
334
    a tmp_set bitmap to be used by things like filesort.
335
335
*/
336
336
 
337
 
void Table::setup_tmp_table_column_bitmaps(unsigned char *bitmaps)
 
337
void Table::setup_tmp_table_column_bitmaps()
338
338
{
339
339
  uint32_t field_count= s->sizeFields();
340
340
 
341
 
  this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
342
 
  this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
343
 
 
344
 
  /* write_set and all_set are copies of read_set */
345
 
  def_write_set= def_read_set;
346
 
  s->all_set= def_read_set;
347
 
  this->getMutableShare()->all_set.setAll();
 
341
  this->def_read_set.resize(field_count);
 
342
  this->def_write_set.resize(field_count);
 
343
  this->tmp_set.resize(field_count);
 
344
  this->getMutableShare()->all_set.resize(field_count);
 
345
  this->getMutableShare()->all_set.set();
 
346
  this->def_write_set.set();
 
347
  this->def_read_set.set();
348
348
  default_column_bitmaps();
349
349
}
350
350
 
452
452
    bitmap_clear_all(&table->def_read_set);
453
453
    bitmap_clear_all(&table->def_write_set);
454
454
  */
455
 
  def_read_set.clearAll();
456
 
  def_write_set.clearAll();
457
 
  column_bitmaps_set(&def_read_set, &def_write_set);
 
455
  def_read_set.reset();
 
456
  def_write_set.reset();
 
457
  column_bitmaps_set(def_read_set, def_write_set);
458
458
}
459
459
 
460
460
 
491
491
 
492
492
void Table::mark_columns_used_by_index(uint32_t index)
493
493
{
494
 
  MyBitmap *bitmap= &tmp_set;
 
494
  boost::dynamic_bitset<> *bitmap= &tmp_set;
495
495
 
496
496
  (void) cursor->extra(HA_EXTRA_KEYREAD);
497
 
  bitmap->clearAll();
498
 
  mark_columns_used_by_index_no_reset(index, bitmap);
499
 
  column_bitmaps_set(bitmap, bitmap);
 
497
  bitmap->reset();
 
498
  mark_columns_used_by_index_no_reset(index, *bitmap);
 
499
  column_bitmaps_set(*bitmap, *bitmap);
500
500
  return;
501
501
}
502
502
 
528
528
 
529
529
void Table::mark_columns_used_by_index_no_reset(uint32_t index)
530
530
{
531
 
    mark_columns_used_by_index_no_reset(index, read_set);
 
531
    mark_columns_used_by_index_no_reset(index, *read_set);
532
532
}
533
533
 
 
534
 
534
535
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
535
 
                                                MyBitmap *bitmap)
 
536
                                                boost::dynamic_bitset<>& bitmap)
536
537
{
537
538
  KeyPartInfo *key_part= key_info[index].key_part;
538
 
  KeyPartInfo *key_part_end= (key_part +
539
 
                                key_info[index].key_parts);
540
 
  for (;key_part != key_part_end; key_part++)
541
 
    bitmap->setBit(key_part->fieldnr-1);
 
539
  KeyPartInfo *key_part_end= (key_part + key_info[index].key_parts);
 
540
  for (; key_part != key_part_end; key_part++)
 
541
  {
 
542
    if (! bitmap.empty())
 
543
      bitmap.set(key_part->fieldnr-1);
 
544
  }
542
545
}
543
546
 
544
547
 
805
808
  bool  using_unique_constraint= false;
806
809
  bool  use_packed_rows= true;
807
810
  bool  not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);
808
 
  unsigned char *pos, *group_buff, *bitmaps;
 
811
  unsigned char *pos, *group_buff;
809
812
  unsigned char *null_flags;
810
813
  Field **reg_field, **from_field, **default_field;
811
814
  CopyField *copy= 0;
869
872
                                                &param->start_recinfo, sizeof(*param->recinfo)*(field_count*2+4),
870
873
                                                &group_buff, (group && ! using_unique_constraint ?
871
874
                                                              param->group_length : 0),
872
 
                                                &bitmaps, bitmap_buffer_size(field_count)*2,
873
875
                                                NULL))
874
876
  {
875
877
    return NULL;
1121
1123
  copy_func[0]= 0;                              // End marker
1122
1124
  param->func_count= copy_func - param->items_to_copy;
1123
1125
 
1124
 
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
1126
  table->setup_tmp_table_column_bitmaps();
1125
1127
 
1126
1128
  recinfo=param->start_recinfo;
1127
1129
  null_flags=(unsigned char*) table->getInsertRecord();
1454
1456
  uint32_t record_length= 0;
1455
1457
  uint32_t null_count= 0;                 /* number of columns which may be null */
1456
1458
  uint32_t null_pack_length;              /* NULL representation array length */
1457
 
  unsigned char *bitmaps;
1458
1459
  Table *table;
1459
1460
 
1460
1461
  TableShareInstance *share= getTemporaryShare(message::Table::INTERNAL); // This will not go into the tableshare cache, so no key is used.
1461
 
 
1462
 
  if (! share->getMemRoot()->multi_alloc_root(0,
1463
 
                                              &bitmaps, bitmap_buffer_size(field_count)*2,
1464
 
                                              NULL))
1465
 
  {
1466
 
    return NULL;
1467
 
  }
1468
 
 
1469
1462
  table= share->getTable();
1470
1463
  share->setFields(field_count + 1);
1471
1464
  table->setFields(share->getFields(true));
1473
1466
  share->blob_field.resize(field_count+1);
1474
1467
  share->fields= field_count;
1475
1468
  share->blob_ptr_size= portable_sizeof_char_ptr;
1476
 
  table->setup_tmp_table_column_bitmaps(bitmaps);
 
1469
  table->setup_tmp_table_column_bitmaps();
1477
1470
 
1478
1471
  table->in_use= this;           /* field->reset() may access table->in_use */
1479
1472
 
1745
1738
  session->set_proc_info(save_proc_info);
1746
1739
}
1747
1740
 
1748
 
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
1749
 
{
1750
 
  my_bitmap_map *old= bitmap->getBitmap();
1751
 
  bitmap->setBitmap(s->all_set.getBitmap());
 
1741
void Table::column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
 
1742
                               boost::dynamic_bitset<>& write_set_arg)
 
1743
{
 
1744
  read_set= &read_set_arg;
 
1745
  write_set= &write_set_arg;
 
1746
}
 
1747
 
 
1748
 
 
1749
const boost::dynamic_bitset<> Table::use_all_columns(boost::dynamic_bitset<>& in_map)
 
1750
{
 
1751
  const boost::dynamic_bitset<> old= in_map;
 
1752
  in_map= s->all_set;
1752
1753
  return old;
1753
1754
}
1754
1755
 
1755
 
void Table::restore_column_map(my_bitmap_map *old)
 
1756
void Table::restore_column_map(const boost::dynamic_bitset<>& old)
1756
1757
{
1757
 
  read_set->setBitmap(old);
 
1758
  for (boost::dynamic_bitset<>::size_type i= 0; i < old.size(); i++)
 
1759
  {
 
1760
    if (old.test(i))
 
1761
    {
 
1762
      read_set->set(i);
 
1763
    }
 
1764
    else
 
1765
    {
 
1766
      read_set->reset(i);
 
1767
    }
 
1768
  }
1758
1769
}
1759
1770
 
1760
1771
uint32_t Table::find_shortest_key(const key_map *usable_keys)
1883
1894
  write_set(NULL),
1884
1895
  tablenr(0),
1885
1896
  db_stat(0),
 
1897
  def_read_set(),
 
1898
  def_write_set(),
 
1899
  tmp_set(),
1886
1900
  in_use(NULL),
1887
1901
  key_info(NULL),
1888
1902
  next_number_field(NULL),
1919
1933
  map(0),
1920
1934
  is_placeholder_created(0)
1921
1935
{
1922
 
  memset(&def_read_set, 0, sizeof(MyBitmap)); /**< Default read set of columns */
1923
 
  memset(&def_write_set, 0, sizeof(MyBitmap)); /**< Default write set of columns */
1924
 
  memset(&tmp_set, 0, sizeof(MyBitmap)); /* Not sure about this... */
1925
 
 
1926
1936
  record[0]= (unsigned char *) 0;
1927
1937
  record[1]= (unsigned char *) 0;
1928
1938