← 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-08-26 03:17:31 UTC
  • mfrom: (1124 staging)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: osullivan.padraig@gmail.com-20090826031731-at2as3ledixngra3
Merge from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
47
47
 
48
48
 
49
49
using namespace std;
 
50
using namespace drizzled;
50
51
 
51
52
/* Functions defined in this file */
52
53
 
168
169
 
169
170
  switch(proto_field_type)
170
171
  {
171
 
  case drizzled::message::Table::Field::TINYINT:
 
172
  case message::Table::Field::TINYINT:
172
173
    field_type= DRIZZLE_TYPE_TINY;
173
174
    break;
174
 
  case drizzled::message::Table::Field::INTEGER:
 
175
  case message::Table::Field::INTEGER:
175
176
    field_type= DRIZZLE_TYPE_LONG;
176
177
    break;
177
 
  case drizzled::message::Table::Field::DOUBLE:
 
178
  case message::Table::Field::DOUBLE:
178
179
    field_type= DRIZZLE_TYPE_DOUBLE;
179
180
    break;
180
 
  case drizzled::message::Table::Field::TIMESTAMP:
 
181
  case message::Table::Field::TIMESTAMP:
181
182
    field_type= DRIZZLE_TYPE_TIMESTAMP;
182
183
    break;
183
 
  case drizzled::message::Table::Field::BIGINT:
 
184
  case message::Table::Field::BIGINT:
184
185
    field_type= DRIZZLE_TYPE_LONGLONG;
185
186
    break;
186
 
  case drizzled::message::Table::Field::DATETIME:
 
187
  case message::Table::Field::DATETIME:
187
188
    field_type= DRIZZLE_TYPE_DATETIME;
188
189
    break;
189
 
  case drizzled::message::Table::Field::DATE:
 
190
  case message::Table::Field::DATE:
190
191
    field_type= DRIZZLE_TYPE_DATE;
191
192
    break;
192
 
  case drizzled::message::Table::Field::VARCHAR:
 
193
  case message::Table::Field::VARCHAR:
193
194
    field_type= DRIZZLE_TYPE_VARCHAR;
194
195
    break;
195
 
  case drizzled::message::Table::Field::DECIMAL:
 
196
  case message::Table::Field::DECIMAL:
196
197
    field_type= DRIZZLE_TYPE_NEWDECIMAL;
197
198
    break;
198
 
  case drizzled::message::Table::Field::ENUM:
 
199
  case message::Table::Field::ENUM:
199
200
    field_type= DRIZZLE_TYPE_ENUM;
200
201
    break;
201
 
  case drizzled::message::Table::Field::BLOB:
 
202
  case message::Table::Field::BLOB:
202
203
    field_type= DRIZZLE_TYPE_BLOB;
203
204
    break;
204
205
  default:
275
276
}
276
277
 
277
278
int parse_table_proto(Session *session,
278
 
                      drizzled::message::Table &table,
 
279
                      message::Table &table,
279
280
                      TableShare *share)
280
281
{
281
282
  int error= 0;
282
283
  handler *handler_file= NULL;
283
284
 
284
 
  {
285
 
    share->storage_engine= ha_resolve_by_name(session, table.engine().name());
286
 
  }
287
 
 
288
 
  drizzled::message::Table::TableOptions table_options;
 
285
  share->setTableProto(new(std::nothrow) message::Table(table));
 
286
 
 
287
  share->storage_engine= ha_resolve_by_name(session, table.engine().name());
 
288
 
 
289
  message::Table::TableOptions table_options;
289
290
 
290
291
  if (table.has_options())
291
292
    table_options= table.options();
292
293
 
293
 
  uint32_t db_create_options= HA_OPTION_LONG_BLOB_PTR;
 
294
  uint32_t db_create_options= 0;
294
295
 
295
296
  if (table_options.has_pack_keys())
296
297
  {
303
304
  if (table_options.pack_record())
304
305
    db_create_options|= HA_OPTION_PACK_RECORD;
305
306
 
306
 
  if (table_options.has_checksum())
307
 
  {
308
 
    if (table_options.checksum())
309
 
      db_create_options|= HA_OPTION_CHECKSUM;
310
 
    else
311
 
      db_create_options|= HA_OPTION_NO_CHECKSUM;
312
 
  }
313
 
 
314
 
  if (table_options.has_delay_key_write())
315
 
  {
316
 
    if (table_options.delay_key_write())
317
 
      db_create_options|= HA_OPTION_DELAY_KEY_WRITE;
318
 
    else
319
 
      db_create_options|= HA_OPTION_NO_DELAY_KEY_WRITE;
320
 
  }
321
 
 
322
307
  /* db_create_options was stored as 2 bytes in FRM
323
308
     Any HA_OPTION_ that doesn't fit into 2 bytes was silently truncated away.
324
309
   */
325
310
  share->db_create_options= (db_create_options & 0x0000FFFF);
326
311
  share->db_options_in_use= share->db_create_options;
327
312
 
328
 
 
329
 
  share->avg_row_length= table_options.has_avg_row_length() ?
330
 
    table_options.avg_row_length() : 0;
331
 
 
332
 
  share->page_checksum= table_options.has_page_checksum() ?
333
 
    (table_options.page_checksum()?HA_CHOICE_YES:HA_CHOICE_NO)
334
 
    : HA_CHOICE_UNDEF;
335
 
 
336
313
  share->row_type= table_options.has_row_type() ?
337
314
    (enum row_type) table_options.row_type() : ROW_TYPE_DEFAULT;
338
315
 
363
340
 
364
341
  share->db_low_byte_first= true;
365
342
 
366
 
  share->max_rows= table_options.has_max_rows() ?
367
 
    table_options.max_rows() : 0;
368
 
 
369
 
  share->min_rows= table_options.has_min_rows() ?
370
 
    table_options.min_rows() : 0;
371
 
 
372
343
  share->keys= table.indexes_size();
373
344
 
374
345
  share->key_parts= 0;
403
374
  KEY* keyinfo= share->key_info;
404
375
  for (int keynr= 0; keynr < table.indexes_size(); keynr++, keyinfo++)
405
376
  {
406
 
    drizzled::message::Table::Index indx= table.indexes(keynr);
 
377
    message::Table::Index indx= table.indexes(keynr);
407
378
 
408
379
    keyinfo->table= 0;
409
380
    keyinfo->flags= 0;
413
384
 
414
385
    if (indx.has_options())
415
386
    {
416
 
      drizzled::message::Table::Index::IndexOptions indx_options= indx.options();
 
387
      message::Table::Index::IndexOptions indx_options= indx.options();
417
388
      if (indx_options.pack_key())
418
389
        keyinfo->flags|= HA_PACK_KEY;
419
390
 
446
417
 
447
418
    switch(indx.type())
448
419
    {
449
 
    case drizzled::message::Table::Index::UNKNOWN_INDEX:
 
420
    case message::Table::Index::UNKNOWN_INDEX:
450
421
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
451
422
      break;
452
 
    case drizzled::message::Table::Index::BTREE:
 
423
    case message::Table::Index::BTREE:
453
424
      keyinfo->algorithm= HA_KEY_ALG_BTREE;
454
425
      break;
455
 
    case drizzled::message::Table::Index::RTREE:
 
426
    case message::Table::Index::RTREE:
456
427
      keyinfo->algorithm= HA_KEY_ALG_RTREE;
457
428
      break;
458
 
    case drizzled::message::Table::Index::HASH:
 
429
    case message::Table::Index::HASH:
459
430
      keyinfo->algorithm= HA_KEY_ALG_HASH;
460
431
      break;
461
 
    case drizzled::message::Table::Index::FULLTEXT:
 
432
    case message::Table::Index::FULLTEXT:
462
433
      keyinfo->algorithm= HA_KEY_ALG_FULLTEXT;
463
434
 
464
435
    default:
478
449
        partnr < keyinfo->key_parts;
479
450
        partnr++, key_part++)
480
451
    {
481
 
      drizzled::message::Table::Index::IndexPart part;
 
452
      message::Table::Index::IndexPart part;
482
453
      part= indx.index_part(partnr);
483
454
 
484
455
      *rec_per_key++= 0;
536
507
    share->connect_string.str= strmake_root(&share->mem_root, str, len);
537
508
  }
538
509
 
539
 
  if (table_options.has_comment())
540
 
  {
541
 
    size_t len= table_options.comment().length();
542
 
    const char* str= table_options.comment().c_str();
543
 
 
544
 
    share->comment.length= len;
545
 
    share->comment.str= strmake_root(&share->mem_root, str, len);
546
 
  }
547
 
 
548
510
  share->key_block_size= table_options.has_key_block_size() ?
549
511
    table_options.key_block_size() : 0;
550
512
 
569
531
 
570
532
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
571
533
  {
572
 
    drizzled::message::Table::Field pfield= table.field(fieldnr);
 
534
    message::Table::Field pfield= table.field(fieldnr);
573
535
    if (pfield.has_constraints() && pfield.constraints().is_nullable())
574
536
      null_fields++;
575
537
 
587
549
    case DRIZZLE_TYPE_BLOB:
588
550
    case DRIZZLE_TYPE_VARCHAR:
589
551
      {
590
 
        drizzled::message::Table::Field::StringFieldOptions field_options=
 
552
        message::Table::Field::StringFieldOptions field_options=
591
553
          pfield.string_options();
592
554
 
593
555
        const CHARSET_INFO *cs= get_charset(field_options.has_collation_id()?
604
566
      break;
605
567
    case DRIZZLE_TYPE_ENUM:
606
568
      {
607
 
        drizzled::message::Table::Field::SetFieldOptions field_options=
 
569
        message::Table::Field::SetFieldOptions field_options=
608
570
          pfield.set_options();
609
571
 
610
572
        field_pack_length[fieldnr]=
616
578
      break;
617
579
    case DRIZZLE_TYPE_NEWDECIMAL:
618
580
      {
619
 
        drizzled::message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
620
 
 
 
581
        message::Table::Field::NumericFieldOptions fo= pfield.numeric_options();
621
582
        field_pack_length[fieldnr]=
622
583
          my_decimal_get_binary_size(fo.precision(), fo.scale());
623
584
      }
696
657
 
697
658
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
698
659
  {
699
 
    drizzled::message::Table::Field pfield= table.field(fieldnr);
 
660
    message::Table::Field pfield= table.field(fieldnr);
700
661
 
701
662
    /* field names */
702
663
    share->fieldnames.type_names[fieldnr]= strmake_root(&share->mem_root,
706
667
    share->fieldnames.type_lengths[fieldnr]= pfield.name().length();
707
668
 
708
669
    /* enum typelibs */
709
 
    if (pfield.type() != drizzled::message::Table::Field::ENUM)
 
670
    if (pfield.type() != message::Table::Field::ENUM)
710
671
      continue;
711
672
 
712
 
    drizzled::message::Table::Field::SetFieldOptions field_options=
713
 
      pfield.set_options();
 
673
    message::Table::Field::SetFieldOptions field_options= pfield.set_options();
714
674
 
715
675
    const CHARSET_INFO *charset= get_charset(field_options.has_collation_id()?
716
676
                                             field_options.collation_id() : 0);
766
726
 
767
727
  for (unsigned int fieldnr= 0; fieldnr < share->fields; fieldnr++)
768
728
  {
769
 
    drizzled::message::Table::Field pfield= table.field(fieldnr);
 
729
    message::Table::Field pfield= table.field(fieldnr);
770
730
 
771
731
    enum column_format_type column_format= COLUMN_FORMAT_TYPE_DEFAULT;
772
732
 
773
733
    switch(pfield.format())
774
734
    {
775
 
    case drizzled::message::Table::Field::DefaultFormat:
 
735
    case message::Table::Field::DefaultFormat:
776
736
      column_format= COLUMN_FORMAT_TYPE_DEFAULT;
777
737
      break;
778
 
    case drizzled::message::Table::Field::FixedFormat:
 
738
    case message::Table::Field::FixedFormat:
779
739
      column_format= COLUMN_FORMAT_TYPE_FIXED;
780
740
      break;
781
 
    case drizzled::message::Table::Field::DynamicFormat:
 
741
    case message::Table::Field::DynamicFormat:
782
742
      column_format= COLUMN_FORMAT_TYPE_DYNAMIC;
783
743
      break;
784
744
    default:
840
800
    if (field_type==DRIZZLE_TYPE_BLOB
841
801
       || field_type==DRIZZLE_TYPE_VARCHAR)
842
802
    {
843
 
      drizzled::message::Table::Field::StringFieldOptions field_options=
 
803
      message::Table::Field::StringFieldOptions field_options=
844
804
        pfield.string_options();
845
805
 
846
806
      charset= get_charset(field_options.has_collation_id()?
853
813
 
854
814
    if (field_type==DRIZZLE_TYPE_ENUM)
855
815
    {
856
 
      drizzled::message::Table::Field::SetFieldOptions field_options=
 
816
      message::Table::Field::SetFieldOptions field_options=
857
817
        pfield.set_options();
858
818
 
859
819
      charset= get_charset(field_options.has_collation_id()?
1183
1143
  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
1184
1144
                                             share->column_bitmap_size)))
1185
1145
    goto err;
1186
 
  bitmap_init(&share->all_set, bitmaps, share->fields);
1187
 
  bitmap_set_all(&share->all_set);
 
1146
  share->all_set.init(bitmaps, share->fields);
 
1147
  share->all_set.setAll();
1188
1148
 
1189
1149
  if (handler_file)
1190
1150
    delete handler_file;
1234
1194
  error= 1;
1235
1195
  error_given= 0;
1236
1196
 
1237
 
  drizzled::message::Table table;
 
1197
  message::Table table;
1238
1198
 
1239
1199
  error= StorageEngine::getTableProto(share->normalized_path.str, &table);
1240
1200
 
1450
1410
  bitmap_size= share->column_bitmap_size;
1451
1411
  if (!(bitmaps= (unsigned char*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1452
1412
    goto err;
1453
 
  bitmap_init(&outparam->def_read_set,
1454
 
              (my_bitmap_map*) bitmaps, share->fields);
1455
 
  bitmap_init(&outparam->def_write_set,
1456
 
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
1457
 
  bitmap_init(&outparam->tmp_set,
1458
 
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
 
1413
  outparam->def_read_set.init((my_bitmap_map*) bitmaps, share->fields);
 
1414
  outparam->def_write_set.init((my_bitmap_map*) (bitmaps+bitmap_size), share->fields);
 
1415
  outparam->tmp_set.init((my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields);
1459
1416
  outparam->default_column_bitmaps();
1460
1417
 
1461
1418
  /* The table struct is now initialized;  Open the table */
1773
1730
{
1774
1731
  uint32_t field_count= s->fields;
1775
1732
 
1776
 
  bitmap_init(&this->def_read_set, (my_bitmap_map*) bitmaps, field_count);
1777
 
  bitmap_init(&this->tmp_set, (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
 
1733
  this->def_read_set.init((my_bitmap_map*) bitmaps, field_count);
 
1734
  this->tmp_set.init((my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)), field_count);
1778
1735
 
1779
1736
  /* write_set and all_set are copies of read_set */
1780
1737
  def_write_set= def_read_set;
1781
1738
  s->all_set= def_read_set;
1782
 
  bitmap_set_all(&this->s->all_set);
 
1739
  this->s->all_set.setAll();
1783
1740
  default_column_bitmaps();
1784
1741
}
1785
1742
 
1786
1743
 
1787
1744
 
1788
 
void Table::updateCreateInfo(HA_CREATE_INFO *create_info)
 
1745
void Table::updateCreateInfo(HA_CREATE_INFO *create_info,
 
1746
                             message::Table *table_proto)
1789
1747
{
1790
 
  create_info->max_rows= s->max_rows;
1791
 
  create_info->min_rows= s->min_rows;
 
1748
  message::Table::TableOptions *table_options= table_proto->mutable_options();
1792
1749
  create_info->table_options= s->db_create_options;
1793
 
  create_info->avg_row_length= s->avg_row_length;
1794
1750
  create_info->block_size= s->block_size;
1795
1751
  create_info->row_type= s->row_type;
1796
1752
  create_info->default_table_charset= s->table_charset;
1797
1753
  create_info->table_charset= 0;
1798
 
  create_info->comment= s->comment;
1799
 
 
1800
 
  return;
 
1754
  table_options->set_comment(s->getComment());
1801
1755
}
1802
1756
 
1803
1757
int rename_file_ext(const char * from,const char * to,const char * ext)
1934
1888
    bitmap_clear_all(&table->def_read_set);
1935
1889
    bitmap_clear_all(&table->def_write_set);
1936
1890
  */
1937
 
  memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);
 
1891
  def_read_set.clearAll();
 
1892
  def_write_set.clearAll();
1938
1893
  column_bitmaps_set(&def_read_set, &def_write_set);
1939
1894
}
1940
1895
 
1972
1927
 
1973
1928
void Table::mark_columns_used_by_index(uint32_t index)
1974
1929
{
1975
 
  MY_BITMAP *bitmap= &tmp_set;
 
1930
  MyBitmap *bitmap= &tmp_set;
1976
1931
 
1977
1932
  (void) file->extra(HA_EXTRA_KEYREAD);
1978
 
  bitmap_clear_all(bitmap);
 
1933
  bitmap->clearAll();
1979
1934
  mark_columns_used_by_index_no_reset(index, bitmap);
1980
1935
  column_bitmaps_set(bitmap, bitmap);
1981
1936
  return;
2013
1968
}
2014
1969
 
2015
1970
void Table::mark_columns_used_by_index_no_reset(uint32_t index,
2016
 
                                                MY_BITMAP *bitmap)
 
1971
                                                MyBitmap *bitmap)
2017
1972
{
2018
1973
  KEY_PART_INFO *key_part= key_info[index].key_part;
2019
1974
  KEY_PART_INFO *key_part_end= (key_part +
2020
1975
                                key_info[index].key_parts);
2021
1976
  for (;key_part != key_part_end; key_part++)
2022
 
    bitmap_set_bit(bitmap, key_part->fieldnr-1);
 
1977
    bitmap->setBit(key_part->fieldnr-1);
2023
1978
}
2024
1979
 
2025
1980
 
2337
2292
  MI_COLUMNDEF *recinfo;
2338
2293
  uint32_t total_uneven_bit_length= 0;
2339
2294
  bool force_copy_fields= param->force_copy_fields;
 
2295
  uint64_t max_rows= 0;
2340
2296
 
2341
2297
  status_var_increment(session->status_var.created_tmp_tables);
2342
2298
 
2769
2725
  table->storeRecordAsDefault();        // Make empty default record
2770
2726
 
2771
2727
  if (session->variables.tmp_table_size == ~ (uint64_t) 0)              // No limit
2772
 
    share->max_rows= ~(ha_rows) 0;
 
2728
    max_rows= ~(uint64_t) 0;
2773
2729
  else
2774
 
    share->max_rows= (ha_rows) (((share->db_type() == heap_engine) ?
2775
 
                                 min(session->variables.tmp_table_size,
2776
 
                                     session->variables.max_heap_table_size) :
2777
 
                                 session->variables.tmp_table_size) /
2778
 
                                 share->reclength);
 
2730
    max_rows= (uint64_t) (((share->db_type() == heap_engine) ?
 
2731
                          min(session->variables.tmp_table_size,
 
2732
                              session->variables.max_heap_table_size) :
 
2733
                          session->variables.tmp_table_size) /
 
2734
                         share->reclength);
2779
2735
 
2780
 
  set_if_bigger(share->max_rows,(ha_rows)1);    // For dummy start options
 
2736
  set_if_bigger(max_rows, (uint64_t)1); // For dummy start options
2781
2737
  /*
2782
2738
    Push the LIMIT clause to the temporary table creation, so that we
2783
2739
    materialize only up to 'rows_limit' records instead of all result records.
2784
2740
  */
2785
 
  set_if_smaller(share->max_rows, rows_limit);
 
2741
  set_if_smaller(max_rows, rows_limit);
 
2742
 
 
2743
  share->setMaxRows(max_rows);
 
2744
 
2786
2745
  param->end_write_records= rows_limit;
2787
2746
 
2788
2747
  keyinfo= param->keyinfo;
3380
3339
  return true;
3381
3340
}
3382
3341
 
3383
 
my_bitmap_map *Table::use_all_columns(MY_BITMAP *bitmap)
 
3342
my_bitmap_map *Table::use_all_columns(MyBitmap *bitmap)
3384
3343
{
3385
 
  my_bitmap_map *old= bitmap->bitmap;
3386
 
  bitmap->bitmap= s->all_set.bitmap;
 
3344
  my_bitmap_map *old= bitmap->getBitmap();
 
3345
  bitmap->setBitmap(s->all_set.getBitmap());
3387
3346
  return old;
3388
3347
}
3389
3348
 
3390
3349
void Table::restore_column_map(my_bitmap_map *old)
3391
3350
{
3392
 
  read_set->bitmap= old;
 
3351
  read_set->setBitmap(old);
3393
3352
}
3394
3353
 
3395
3354
uint32_t Table::find_shortest_key(const key_map *usable_keys)