← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/opt_range.cc

  • Committer: Monty Taylor
  • Date: 2008-10-02 01:31:53 UTC
  • mfrom: (398.1.6 codestyle-new)
  • Revision ID: monty@inaugust.com-20081002013153-b097om921cd3j1pn
Merged from stdint-includes-fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/opt_range.cc
2285
2285
    group_trp= get_best_group_min_max(&param, tree);
2286
2286
    if (group_trp)
2287
2287
    {
2288
 
      param.table->quick_condition_rows= min(group_trp->records,
 
2288
      param.table->quick_condition_rows= cmin(group_trp->records,
2289
2289
                                             head->file->stats.records);
2290
2290
      if (group_trp->read_cost < best_read_time)
2291
2291
      {
2576
2576
    {
2577
2577
      imerge_trp->read_cost= imerge_cost;
2578
2578
      imerge_trp->records= non_cpk_scan_records + cpk_scan_records;
2579
 
      imerge_trp->records= min(imerge_trp->records,
 
2579
      imerge_trp->records= cmin(imerge_trp->records,
2580
2580
                               param->table->file->stats.records);
2581
2581
      imerge_trp->range_scans= range_scans;
2582
2582
      imerge_trp->range_scans_end= range_scans + n_child_scans;
5241
5241
      }
5242
5242
    }
5243
5243
 
5244
 
    // tmp.max >= key2.min && tmp.min <= key.max  (overlapping ranges)
 
5244
    // tmp.max >= key2.min && tmp.min <= key.cmax(overlapping ranges)
5245
5245
    if (eq_tree(tmp->next_key_part,key2->next_key_part))
5246
5246
    {
5247
5247
      if (tmp->is_same(key2))
6127
6127
    }
6128
6128
  }
6129
6129
  seq->param->range_count++;
6130
 
  seq->param->max_key_part=max(seq->param->max_key_part,(uint)key_tree->part);
 
6130
  seq->param->max_key_part=cmax(seq->param->max_key_part,(uint)key_tree->part);
6131
6131
  return 0;
6132
6132
}
6133
6133
 
6214
6214
      param->table->quick_key_parts[keynr]=param->max_key_part+1;
6215
6215
      param->table->quick_n_ranges[keynr]= param->range_count;
6216
6216
      param->table->quick_condition_rows=
6217
 
        min(param->table->quick_condition_rows, rows);
 
6217
        cmin(param->table->quick_condition_rows, rows);
6218
6218
    }
6219
6219
  }
6220
6220
  /* Figure out if the key scan is ROR (returns rows in ROWID order) or not */
7249
7249
    last_range= *(cur_range++);
7250
7250
 
7251
7251
    start_key.key=    (const uchar*) last_range->min_key;
7252
 
    start_key.length= min(last_range->min_length, (uint16_t)prefix_length);
 
7252
    start_key.length= cmin(last_range->min_length, (uint16_t)prefix_length);
7253
7253
    start_key.keypart_map= last_range->min_keypart_map & keypart_map;
7254
7254
    start_key.flag=   ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
7255
7255
                       (last_range->flag & EQ_RANGE) ?
7256
7256
                       HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
7257
7257
    end_key.key=      (const uchar*) last_range->max_key;
7258
 
    end_key.length=   min(last_range->max_length, (uint16_t)prefix_length);
 
7258
    end_key.length=   cmin(last_range->max_length, (uint16_t)prefix_length);
7259
7259
    end_key.keypart_map= last_range->max_keypart_map & keypart_map;
7260
7260
    /*
7261
7261
      We use READ_AFTER_KEY here because if we are reading on a key
8033
8033
        cur_group_prefix_len+= cur_part->store_length;
8034
8034
        cur_used_key_parts.set_bit(key_part_nr);
8035
8035
        ++cur_group_key_parts;
8036
 
        max_key_part= max(max_key_part,key_part_nr);
 
8036
        max_key_part= cmax(max_key_part,key_part_nr);
8037
8037
      }
8038
8038
      /*
8039
8039
        Check that used key parts forms a prefix of the index.
8638
8638
    {
8639
8639
      double blocks_per_group= (double) num_blocks / (double) num_groups;
8640
8640
      p_overlap= (blocks_per_group * (keys_per_subgroup - 1)) / keys_per_group;
8641
 
      p_overlap= min(p_overlap, 1.0);
 
8641
      p_overlap= cmin(p_overlap, 1.0);
8642
8642
    }
8643
 
    io_cost= (double) min(num_groups * (1 + p_overlap), (double)num_blocks);
 
8643
    io_cost= (double) cmin(num_groups * (1 + p_overlap), (double)num_blocks);
8644
8644
  }
8645
8645
  else
8646
8646
    io_cost= (keys_per_group > keys_per_block) ?