← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/opt_range.cc

  • Committer: Brian Aker
  • Date: 2009-08-21 06:18:23 UTC
  • mfrom: (1115.3.12 captain)
  • Revision ID: brian@gaz-20090821061823-ljcpbpvun22lsvem
Merge Jay

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/opt_range.cc
709
709
  bool quick;                           // Don't calulate possible keys
710
710
 
711
711
  uint32_t fields_bitmap_size;
712
 
  MY_BITMAP needed_fields;    /* bitmask of fields needed by the query */
713
 
  MY_BITMAP tmp_covered_fields;
 
712
  MyBitmap needed_fields;    /* bitmask of fields needed by the query */
 
713
  MyBitmap tmp_covered_fields;
714
714
 
715
715
  key_map *needed_reg;        /* ptr to SQL_SELECT::needed_reg */
716
716
 
1137
1137
  save_write_set= head->write_set;
1138
1138
 
1139
1139
  /* Allocate a bitmap for used columns (Q: why not on MEM_ROOT?) */
1140
 
  if (!(bitmap= (my_bitmap_map*) malloc(head->s->column_bitmap_size)))
 
1140
  if (! (bitmap= (my_bitmap_map*) malloc(head->s->column_bitmap_size)))
1141
1141
  {
1142
 
    column_bitmap.bitmap= 0;
 
1142
    column_bitmap.setBitmap(NULL);
1143
1143
    *create_error= 1;
1144
1144
  }
1145
1145
  else
1146
 
    bitmap_init(&column_bitmap, bitmap, head->s->fields);
1147
 
  return;
 
1146
  {
 
1147
    column_bitmap.init(bitmap, head->s->fields);
 
1148
  }
1148
1149
}
1149
1150
 
1150
1151
 
1185
1186
    }
1186
1187
    delete_dynamic(&ranges); /* ranges are allocated in alloc */
1187
1188
    free_root(&alloc,MYF(0));
1188
 
    free((char*) column_bitmap.bitmap);
1189
1189
  }
1190
1190
  head->column_bitmaps_set(save_read_set, save_write_set);
1191
1191
  assert(mrr_buf_desc == NULL);
1371
1371
  }
1372
1372
  head->prepare_for_position();
1373
1373
  head->file= org_file;
1374
 
  bitmap_copy(&column_bitmap, head->read_set);
 
1374
  column_bitmap= *head->read_set;
1375
1375
  head->column_bitmaps_set(&column_bitmap, &column_bitmap);
1376
1376
 
1377
1377
  return 0;
2095
2095
  Table *table= param->table;
2096
2096
  my_bitmap_map *tmp;
2097
2097
  uint32_t pk;
2098
 
  param->tmp_covered_fields.bitmap= 0;
 
2098
  param->tmp_covered_fields.setBitmap(0);
2099
2099
  param->fields_bitmap_size= table->s->column_bitmap_size;
2100
2100
  if (!(tmp= (my_bitmap_map*) alloc_root(param->mem_root,
2101
2101
                                  param->fields_bitmap_size)) ||
2102
 
      bitmap_init(&param->needed_fields, tmp, table->s->fields))
 
2102
      param->needed_fields.init(tmp, table->s->fields))
2103
2103
    return 1;
2104
2104
 
2105
 
  bitmap_copy(&param->needed_fields, table->read_set);
 
2105
  param->needed_fields= *table->read_set;
2106
2106
  bitmap_union(&param->needed_fields, table->write_set);
2107
2107
 
2108
2108
  pk= param->table->s->primary_key;
2113
2113
    KEY_PART_INFO *key_part_end= key_part +
2114
2114
                                 param->table->key_info[pk].key_parts;
2115
2115
    for (;key_part != key_part_end; ++key_part)
2116
 
      bitmap_clear_bit(&param->needed_fields, key_part->fieldnr-1);
 
2116
      param->needed_fields.clearBit(key_part->fieldnr-1);
2117
2117
  }
2118
2118
  return 0;
2119
2119
}
2738
2738
  SEL_ARG   *sel_arg;
2739
2739
 
2740
2740
  /* Fields used in the query and covered by this ROR scan. */
2741
 
  MY_BITMAP covered_fields;
 
2741
  MyBitmap covered_fields;
2742
2742
  uint32_t      used_fields_covered; /* # of set bits in covered_fields */
2743
2743
  int       key_rec_length; /* length of key record (including rowid) */
2744
2744
 
2790
2790
                                                param->fields_bitmap_size)))
2791
2791
    return NULL;
2792
2792
 
2793
 
  if (bitmap_init(&ror_scan->covered_fields, bitmap_buf,
2794
 
                  param->table->s->fields))
 
2793
  if (ror_scan->covered_fields.init(bitmap_buf,
 
2794
                                    param->table->s->fields))
2795
2795
    return NULL;
2796
 
  bitmap_clear_all(&ror_scan->covered_fields);
 
2796
  ror_scan->covered_fields.clearAll();
2797
2797
 
2798
2798
  KEY_PART_INFO *key_part= param->table->key_info[keynr].key_part;
2799
2799
  KEY_PART_INFO *key_part_end= key_part +
2800
2800
                               param->table->key_info[keynr].key_parts;
2801
2801
  for (;key_part != key_part_end; ++key_part)
2802
2802
  {
2803
 
    if (bitmap_is_set(&param->needed_fields, key_part->fieldnr-1))
2804
 
      bitmap_set_bit(&ror_scan->covered_fields, key_part->fieldnr-1);
 
2803
    if (param->needed_fields.isBitSet(key_part->fieldnr-1))
 
2804
      ror_scan->covered_fields.setBit(key_part->fieldnr-1);
2805
2805
  }
2806
2806
  double rows= rows2double(param->table->quick_rows[ror_scan->keynr]);
2807
2807
  ror_scan->index_read_cost=
2869
2869
typedef struct
2870
2870
{
2871
2871
  const PARAM *param;
2872
 
  MY_BITMAP covered_fields; /* union of fields covered by all scans */
 
2872
  MyBitmap covered_fields; /* union of fields covered by all scans */
2873
2873
  /*
2874
2874
    Fraction of table records that satisfies conditions of all scans.
2875
2875
    This is the number of full records that will be retrieved if a
2909
2909
  if (!(buf= (my_bitmap_map*) alloc_root(param->mem_root,
2910
2910
                                         param->fields_bitmap_size)))
2911
2911
    return NULL;
2912
 
  if (bitmap_init(&info->covered_fields, buf, param->table->s->fields))
 
2912
  if (info->covered_fields.init(buf, param->table->s->fields))
2913
2913
    return NULL;
2914
2914
  info->is_covering= false;
2915
2915
  info->index_scan_costs= 0.0;
2916
2916
  info->index_records= 0;
2917
2917
  info->out_rows= (double) param->table->file->stats.records;
2918
 
  bitmap_clear_all(&info->covered_fields);
 
2918
  info->covered_fields.clearAll();
2919
2919
  return info;
2920
2920
}
2921
2921
 
2923
2923
                              const ROR_INTERSECT_INFO *src)
2924
2924
{
2925
2925
  dst->param= src->param;
2926
 
  memcpy(dst->covered_fields.bitmap, src->covered_fields.bitmap,
2927
 
         no_bytes_in_map(&src->covered_fields));
 
2926
  dst->covered_fields= src->covered_fields;
2928
2927
  dst->out_rows= src->out_rows;
2929
2928
  dst->is_covering= src->is_covering;
2930
2929
  dst->index_records= src->index_records;
3033
3032
  SEL_ARG *sel_arg, *tuple_arg= NULL;
3034
3033
  key_part_map keypart_map= 0;
3035
3034
  bool cur_covered;
3036
 
  bool prev_covered= test(bitmap_is_set(&info->covered_fields,
3037
 
                                        key_part->fieldnr-1));
 
3035
  bool prev_covered= test(info->covered_fields.isBitSet(key_part->fieldnr-1));
3038
3036
  key_range min_range;
3039
3037
  key_range max_range;
3040
3038
  min_range.key= key_val;
3046
3044
  for (sel_arg= scan->sel_arg; sel_arg;
3047
3045
       sel_arg= sel_arg->next_key_part)
3048
3046
  {
3049
 
    cur_covered= test(bitmap_is_set(&info->covered_fields,
3050
 
                                    key_part[sel_arg->part].fieldnr-1));
 
3047
    cur_covered= 
 
3048
      test(info->covered_fields.isBitSet(key_part[sel_arg->part].fieldnr-1));
3051
3049
    if (cur_covered != prev_covered)
3052
3050
    {
3053
3051
      /* create (part1val, ..., part{n-1}val) tuple. */
3450
3448
  /*I=set of all covering indexes */
3451
3449
  ror_scan_mark= tree->ror_scans;
3452
3450
 
3453
 
  MY_BITMAP *covered_fields= &param->tmp_covered_fields;
3454
 
  if (!covered_fields->bitmap)
3455
 
    covered_fields->bitmap= (my_bitmap_map*)alloc_root(param->mem_root,
 
3451
  MyBitmap *covered_fields= &param->tmp_covered_fields;
 
3452
  if (! covered_fields->getBitmap())
 
3453
  {
 
3454
    my_bitmap_map *tmp_bitmap= (my_bitmap_map*)alloc_root(param->mem_root,
3456
3455
                                               param->fields_bitmap_size);
3457
 
  if (!covered_fields->bitmap ||
3458
 
      bitmap_init(covered_fields, covered_fields->bitmap,
3459
 
                  param->table->s->fields))
 
3456
    covered_fields->setBitmap(tmp_bitmap);
 
3457
  }
 
3458
  if (! covered_fields->getBitmap() ||
 
3459
      covered_fields->init(covered_fields->getBitmap(),
 
3460
                           param->table->s->fields))
3460
3461
    return 0;
3461
 
  bitmap_clear_all(covered_fields);
 
3462
  covered_fields->clearAll();
3462
3463
 
3463
3464
  double total_cost= 0.0f;
3464
3465
  ha_rows records=0;
3479
3480
    {
3480
3481
      bitmap_subtract(&(*scan)->covered_fields, covered_fields);
3481
3482
      (*scan)->used_fields_covered=
3482
 
        bitmap_bits_set(&(*scan)->covered_fields);
 
3483
        (*scan)->covered_fields.getBitsSet();
3483
3484
      (*scan)->first_uncovered_field=
3484
 
        bitmap_get_first(&(*scan)->covered_fields);
 
3485
        (*scan)->covered_fields.getFirst();
3485
3486
    }
3486
3487
 
3487
3488
    my_qsort(ror_scan_mark, ror_scans_end-ror_scan_mark, sizeof(ROR_SCAN_INFO*),
6685
6686
}
6686
6687
 
6687
6688
 
6688
 
bool QUICK_SELECT_I::is_keys_used(const MY_BITMAP *fields)
 
6689
bool QUICK_SELECT_I::is_keys_used(const MyBitmap *fields)
6689
6690
{
6690
6691
  return is_key_used(head, index, fields);
6691
6692
}
6692
6693
 
6693
 
bool QUICK_INDEX_MERGE_SELECT::is_keys_used(const MY_BITMAP *fields)
6694
 
{
6695
 
  QUICK_RANGE_SELECT *quick;
6696
 
  List_iterator_fast<QUICK_RANGE_SELECT> it(quick_selects);
6697
 
  while ((quick= it++))
6698
 
  {
6699
 
    if (is_key_used(head, quick->index, fields))
6700
 
      return 1;
6701
 
  }
6702
 
  return 0;
6703
 
}
6704
 
 
6705
 
bool QUICK_ROR_INTERSECT_SELECT::is_keys_used(const MY_BITMAP *fields)
6706
 
{
6707
 
  QUICK_RANGE_SELECT *quick;
6708
 
  List_iterator_fast<QUICK_RANGE_SELECT> it(quick_selects);
6709
 
  while ((quick= it++))
6710
 
  {
6711
 
    if (is_key_used(head, quick->index, fields))
6712
 
      return 1;
6713
 
  }
6714
 
  return 0;
6715
 
}
6716
 
 
6717
 
bool QUICK_ROR_UNION_SELECT::is_keys_used(const MY_BITMAP *fields)
 
6694
bool QUICK_INDEX_MERGE_SELECT::is_keys_used(const MyBitmap *fields)
 
6695
{
 
6696
  QUICK_RANGE_SELECT *quick;
 
6697
  List_iterator_fast<QUICK_RANGE_SELECT> it(quick_selects);
 
6698
  while ((quick= it++))
 
6699
  {
 
6700
    if (is_key_used(head, quick->index, fields))
 
6701
      return 1;
 
6702
  }
 
6703
  return 0;
 
6704
}
 
6705
 
 
6706
bool QUICK_ROR_INTERSECT_SELECT::is_keys_used(const MyBitmap *fields)
 
6707
{
 
6708
  QUICK_RANGE_SELECT *quick;
 
6709
  List_iterator_fast<QUICK_RANGE_SELECT> it(quick_selects);
 
6710
  while ((quick= it++))
 
6711
  {
 
6712
    if (is_key_used(head, quick->index, fields))
 
6713
      return 1;
 
6714
  }
 
6715
  return 0;
 
6716
}
 
6717
 
 
6718
bool QUICK_ROR_UNION_SELECT::is_keys_used(const MyBitmap *fields)
6718
6719
{
6719
6720
  QUICK_SELECT_I *quick;
6720
6721
  List_iterator_fast<QUICK_SELECT_I> it(quick_selects);