← Back to branch summary

~mkindahl/drizzle/remove-mem-casts

« back to all changes in this revision

Viewing changes to server/opt_range.cc

  • Committer: Brian Aker
  • Date: 2008-07-23 00:11:39 UTC
  • Revision ID: brian@tangent.org-20080723001139-967ewfngqqotwb6e
Removed final uint dead types.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/opt_range.cc
122
122
*/
123
123
#define double2rows(x) ((ha_rows)(x))
124
124
 
125
 
static int sel_cmp(Field *f,uchar *a,uchar *b,uint8 a_flag,uint8 b_flag);
 
125
static int sel_cmp(Field *f,uchar *a,uchar *b,uint8_t a_flag,uint8_t b_flag);
126
126
 
127
127
static uchar is_null_string[2]= {1,0};
128
128
 
300
300
class SEL_ARG :public Sql_alloc
301
301
{
302
302
public:
303
 
  uint8 min_flag,max_flag,maybe_flag;
304
 
  uint8 part;                                   // Which key part
305
 
  uint8 maybe_null;
 
303
  uint8_t min_flag,max_flag,maybe_flag;
 
304
  uint8_t part;                                 // Which key part
 
305
  uint8_t maybe_null;
306
306
  /* 
307
307
    Number of children of this element in the RB-tree, plus 1 for this
308
308
    element itself.
309
309
  */
310
 
  uint16 elements;
 
310
  uint16_t elements;
311
311
  /*
312
312
    Valid only for elements which are RB-tree roots: Number of times this
313
313
    RB-tree is referred to (it is referred by SEL_ARG::next_key_part or by
333
333
  SEL_ARG() {}
334
334
  SEL_ARG(SEL_ARG &);
335
335
  SEL_ARG(Field *,const uchar *, const uchar *);
336
 
  SEL_ARG(Field *field, uint8 part, uchar *min_value, uchar *max_value,
337
 
          uint8 min_flag, uint8 max_flag, uint8 maybe_flag);
 
336
  SEL_ARG(Field *field, uint8_t part, uchar *min_value, uchar *max_value,
 
337
          uint8_t min_flag, uint8_t max_flag, uint8_t maybe_flag);
338
338
  SEL_ARG(enum Type type_arg)
339
339
    :min_flag(0),elements(1),use_count(1),left(0),right(0),next_key_part(0),
340
340
    color(BLACK), type(type_arg)
370
370
  SEL_ARG *clone_and(SEL_ARG* arg)
371
371
  {                                             // Get overlapping range
372
372
    uchar *new_min,*new_max;
373
 
    uint8 flag_min,flag_max;
 
373
    uint8_t flag_min,flag_max;
374
374
    if (cmp_min_to_min(arg) >= 0)
375
375
    {
376
376
      new_min=min_value; flag_min=min_flag;
725
725
                            Item_func::Functype type,Item *value);
726
726
static SEL_TREE *get_mm_tree(RANGE_OPT_PARAM *param,COND *cond);
727
727
 
728
 
static bool is_key_scan_ror(PARAM *param, uint keynr, uint8 nparts);
 
728
static bool is_key_scan_ror(PARAM *param, uint keynr, uint8_t nparts);
729
729
static ha_rows check_quick_select(PARAM *param, uint idx, bool index_only,
730
730
                                  SEL_ARG *tree, bool update_tbl_stats, 
731
731
                                  uint *mrr_flags, uint *bufsize,
1616
1616
  left=right= &null_element;
1617
1617
}
1618
1618
 
1619
 
SEL_ARG::SEL_ARG(Field *field_,uint8 part_,
 
1619
SEL_ARG::SEL_ARG(Field *field_,uint8_t part_,
1620
1620
                 uchar *min_value_, uchar *max_value_,
1621
 
                 uint8 min_flag_,uint8 max_flag_,uint8 maybe_flag_)
 
1621
                 uint8_t min_flag_,uint8_t max_flag_,uint8_t maybe_flag_)
1622
1622
  :min_flag(min_flag_),max_flag(max_flag_),maybe_flag(maybe_flag_),
1623
1623
   part(part_),maybe_null(field_->real_maybe_null()), elements(1),use_count(1),
1624
1624
   field(field_), min_value(min_value_), max_value(max_value_),
1695
1695
  Returns -2 or 2 if the ranges where 'joined' like  < 2 and >= 2
1696
1696
*/
1697
1697
 
1698
 
static int sel_cmp(Field *field, uchar *a, uchar *b, uint8 a_flag,
1699
 
                   uint8 b_flag)
 
1698
static int sel_cmp(Field *field, uchar *a, uchar *b, uint8_t a_flag,
 
1699
                   uint8_t b_flag)
1700
1700
{
1701
1701
  int cmp;
1702
1702
  /* First check if there was a compare to a min or max element */
2241
2241
        key_parts->null_bit=     key_part_info->null_bit;
2242
2242
        key_parts->image_type =  Field::itRAW;
2243
2243
        /* Only HA_PART_KEY_SEG is used */
2244
 
        key_parts->flag=         (uint8) key_part_info->key_part_flag;
 
2244
        key_parts->flag=         (uint8_t) key_part_info->key_part_flag;
2245
2245
      }
2246
2246
      param.real_keynr[param.keys++]=idx;
2247
2247
    }
5954
5954
  cur->min_key_parts= prev->min_key_parts;
5955
5955
  cur->max_key_parts= prev->max_key_parts;
5956
5956
 
5957
 
  uint16 stor_length= arg->param->key[arg->keyno][key_tree->part].store_length;
 
5957
  uint16_t stor_length= arg->param->key[arg->keyno][key_tree->part].store_length;
5958
5958
  cur->min_key_parts += key_tree->store_min(stor_length, &cur->min_key,
5959
5959
                                            prev->min_key_flag);
5960
5960
  cur->max_key_parts += key_tree->store_max(stor_length, &cur->max_key,
6281
6281
    false  Otherwise
6282
6282
*/
6283
6283
 
6284
 
static bool is_key_scan_ror(PARAM *param, uint keynr, uint8 nparts)
 
6284
static bool is_key_scan_ror(PARAM *param, uint keynr, uint8_t nparts)
6285
6285
{
6286
6286
  KEY *table_key= param->table->key_info + keynr;
6287
6287
  KEY_PART_INFO *key_part= table_key->key_part + nparts;
6291
6291
  
6292
6292
  for (KEY_PART_INFO *kp= table_key->key_part; kp < key_part; kp++)
6293
6293
  {
6294
 
    uint16 fieldnr= param->table->key_info[keynr].
 
6294
    uint16_t fieldnr= param->table->key_info[keynr].
6295
6295
                    key_part[kp - table_key->key_part].fieldnr - 1;
6296
6296
    if (param->table->field[fieldnr]->key_length() != kp->length)
6297
6297
      return false;
6652
6652
    key_part->length=       key_info->key_part[part].length;
6653
6653
    key_part->store_length= key_info->key_part[part].store_length;
6654
6654
    key_part->null_bit=     key_info->key_part[part].null_bit;
6655
 
    key_part->flag=         (uint8) key_info->key_part[part].key_part_flag;
 
6655
    key_part->flag=         (uint8_t) key_info->key_part[part].key_part_flag;
6656
6656
  }
6657
6657
  if (insert_dynamic(&quick->ranges,(uchar*)&range))
6658
6658
    goto err;
7120
7120
    Reference to range_flag associated with range number #idx
7121
7121
*/
7122
7122
 
7123
 
uint16 &mrr_persistent_flag_storage(range_seq_t seq, uint idx)
 
7123
uint16_t &mrr_persistent_flag_storage(range_seq_t seq, uint idx)
7124
7124
{
7125
7125
  QUICK_RANGE_SEQ_CTX *ctx= (QUICK_RANGE_SEQ_CTX*)seq;
7126
7126
  return ctx->first[idx]->flag;