← Back to branch summary

~mordred/drizzle/codestyle

« back to all changes in this revision

Viewing changes to drizzled/opt_range.cc

  • Committer: Brian Aker
  • Date: 2008-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/opt_range.cc
117
117
*/
118
118
#define double2rows(x) ((ha_rows)(x))
119
119
 
120
 
static int sel_cmp(Field *f,uchar *a,uchar *b,uint8_t a_flag,uint8_t b_flag);
 
120
static int sel_cmp(Field *f,unsigned char *a,unsigned char *b,uint8_t a_flag,uint8_t b_flag);
121
121
 
122
 
static uchar is_null_string[2]= {1,0};
 
122
static unsigned char is_null_string[2]= {1,0};
123
123
 
124
124
class RANGE_OPT_PARAM;
125
125
/*
311
311
  ulong use_count;
312
312
 
313
313
  Field *field;
314
 
  uchar *min_value,*max_value;                  // Pointer to range
 
314
  unsigned char *min_value,*max_value;                  // Pointer to range
315
315
 
316
316
  /*
317
317
    eq_tree() requires that left == right == 0 if the type is MAYBE_KEY.
327
327
 
328
328
  SEL_ARG() {}
329
329
  SEL_ARG(SEL_ARG &);
330
 
  SEL_ARG(Field *,const uchar *, const uchar *);
331
 
  SEL_ARG(Field *field, uint8_t part, uchar *min_value, uchar *max_value,
 
330
  SEL_ARG(Field *,const unsigned char *, const unsigned char *);
 
331
  SEL_ARG(Field *field, uint8_t part, unsigned char *min_value, unsigned char *max_value,
332
332
          uint8_t min_flag, uint8_t max_flag, uint8_t maybe_flag);
333
333
  SEL_ARG(enum Type type_arg)
334
334
    :min_flag(0),elements(1),use_count(1),left(0),right(0),next_key_part(0),
364
364
  }
365
365
  SEL_ARG *clone_and(SEL_ARG* arg)
366
366
  {                                             // Get overlapping range
367
 
    uchar *new_min,*new_max;
 
367
    unsigned char *new_min,*new_max;
368
368
    uint8_t flag_min,flag_max;
369
369
    if (cmp_min_to_min(arg) >= 0)
370
370
    {
438
438
    min_flag=arg->max_flag & NEAR_MAX ? 0 : NEAR_MIN;
439
439
  }
440
440
  /* returns a number of keypart values (0 or 1) appended to the key buffer */
441
 
  int store_min(uint length, uchar **min_key,uint min_key_flag)
 
441
  int store_min(uint length, unsigned char **min_key,uint min_key_flag)
442
442
  {
443
443
    /* "(kp1 > c1) AND (kp2 OP c2) AND ..." -> (kp1 > c1) */
444
444
    if ((!(min_flag & NO_MIN_RANGE) &&
457
457
    return 0;
458
458
  }
459
459
  /* returns a number of keypart values (0 or 1) appended to the key buffer */
460
 
  int store_max(uint length, uchar **max_key, uint max_key_flag)
 
460
  int store_max(uint length, unsigned char **max_key, uint max_key_flag)
461
461
  {
462
462
    if (!(max_flag & NO_MAX_RANGE) &&
463
463
        !(max_key_flag & (NO_MAX_RANGE | NEAR_MAX)))
476
476
  }
477
477
 
478
478
  /* returns a number of keypart values appended to the key buffer */
479
 
  int store_min_key(KEY_PART *key, uchar **range_key, uint *range_key_flag)
 
479
  int store_min_key(KEY_PART *key, unsigned char **range_key, uint *range_key_flag)
480
480
  {
481
481
    SEL_ARG *key_tree= first();
482
482
    uint res= key_tree->store_min(key[key_tree->part].store_length,
493
493
  }
494
494
 
495
495
  /* returns a number of keypart values appended to the key buffer */
496
 
  int store_max_key(KEY_PART *key, uchar **range_key, uint *range_key_flag)
 
496
  int store_max_key(KEY_PART *key, unsigned char **range_key, uint *range_key_flag)
497
497
  {
498
498
    SEL_ARG *key_tree= last();
499
499
    uint res=key_tree->store_max(key[key_tree->part].store_length,
575
575
    */
576
576
    if (min_flag || max_flag)
577
577
      return false;
578
 
    uchar *min_val= min_value;
579
 
    uchar *max_val= max_value;
 
578
    unsigned char *min_val= min_value;
 
579
    unsigned char *max_val= max_value;
580
580
 
581
581
    if (maybe_null)
582
582
    {
684
684
  uint max_key_part;
685
685
  /* Number of ranges in the last checked tree->key */
686
686
  uint range_count;
687
 
  uchar min_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH],
 
687
  unsigned char min_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH],
688
688
    max_key[MAX_KEY_LENGTH+MAX_FIELD_WIDTH];
689
689
  bool quick;                           // Don't calulate possible keys
690
690
 
727
727
                                  COST_VECT *cost);
728
728
                                  //bool update_tbl_stats);
729
729
/*static ha_rows check_quick_keys(PARAM *param,uint index,SEL_ARG *key_tree,
730
 
                                uchar *min_key, uint min_key_flag, int,
731
 
                                uchar *max_key, uint max_key_flag, int);
 
730
                                unsigned char *min_key, uint min_key_flag, int,
 
731
                                unsigned char *max_key, uint max_key_flag, int);
732
732
*/
733
733
 
734
734
QUICK_RANGE_SELECT *get_quick_select(PARAM *param,uint index,
766
766
                        uint clone_flag);
767
767
static bool get_range(SEL_ARG **e1,SEL_ARG **e2,SEL_ARG *root1);
768
768
bool get_quick_keys(PARAM *param,QUICK_RANGE_SELECT *quick,KEY_PART *key,
769
 
                    SEL_ARG *key_tree, uchar *min_key,uint min_key_flag,
770
 
                    uchar *max_key,uint max_key_flag);
 
769
                    SEL_ARG *key_tree, unsigned char *min_key,uint min_key_flag,
 
770
                    unsigned char *max_key,uint max_key_flag);
771
771
static bool eq_tree(SEL_ARG* a,SEL_ARG *b);
772
772
 
773
773
static SEL_ARG null_element(SEL_ARG::IMPOSSIBLE);
774
 
static bool null_part_in_key(KEY_PART *key_part, const uchar *key,
 
774
static bool null_part_in_key(KEY_PART *key_part, const unsigned char *key,
775
775
                             uint length);
776
776
bool sel_trees_can_be_ored(SEL_TREE *tree1, SEL_TREE *tree2, RANGE_OPT_PARAM* param);
777
777
 
1217
1217
    init_sql_alloc(&alloc, thd->variables.range_alloc_block_size, 0);
1218
1218
  else
1219
1219
    memset(&alloc, 0, sizeof(MEM_ROOT));
1220
 
  last_rowid= (uchar*) alloc_root(parent_alloc? parent_alloc : &alloc,
 
1220
  last_rowid= (unsigned char*) alloc_root(parent_alloc? parent_alloc : &alloc,
1221
1221
                                  head->file->ref_length);
1222
1222
}
1223
1223
 
1475
1475
    return(1);
1476
1476
  }
1477
1477
 
1478
 
  if (!(cur_rowid= (uchar*) alloc_root(&alloc, 2*head->file->ref_length)))
 
1478
  if (!(cur_rowid= (unsigned char*) alloc_root(&alloc, 2*head->file->ref_length)))
1479
1479
    return(1);
1480
1480
  prev_rowid= cur_rowid + head->file->ref_length;
1481
1481
  return(0);
1493
1493
      val2  Second merged select
1494
1494
*/
1495
1495
 
1496
 
int QUICK_ROR_UNION_SELECT::queue_cmp(void *arg, uchar *val1, uchar *val2)
 
1496
int QUICK_ROR_UNION_SELECT::queue_cmp(void *arg, unsigned char *val1, unsigned char *val2)
1497
1497
{
1498
1498
  QUICK_ROR_UNION_SELECT *self= (QUICK_ROR_UNION_SELECT*)arg;
1499
1499
  return self->head->file->cmp_ref(((QUICK_SELECT_I*)val1)->last_rowid,
1543
1543
      return(error);
1544
1544
    }
1545
1545
    quick->save_last_pos();
1546
 
    queue_insert(&queue, (uchar*)quick);
 
1546
    queue_insert(&queue, (unsigned char*)quick);
1547
1547
  }
1548
1548
 
1549
1549
  if (head->file->ha_rnd_init(1))
1602
1602
  use_count=0; elements=1;
1603
1603
}
1604
1604
 
1605
 
SEL_ARG::SEL_ARG(Field *f,const uchar *min_value_arg,
1606
 
                 const uchar *max_value_arg)
 
1605
SEL_ARG::SEL_ARG(Field *f,const unsigned char *min_value_arg,
 
1606
                 const unsigned char *max_value_arg)
1607
1607
  :min_flag(0), max_flag(0), maybe_flag(0), maybe_null(f->real_maybe_null()),
1608
 
   elements(1), use_count(1), field(f), min_value((uchar*) min_value_arg),
1609
 
   max_value((uchar*) max_value_arg), next(0),prev(0),
 
1608
   elements(1), use_count(1), field(f), min_value((unsigned char*) min_value_arg),
 
1609
   max_value((unsigned char*) max_value_arg), next(0),prev(0),
1610
1610
   next_key_part(0),color(BLACK),type(KEY_RANGE)
1611
1611
{
1612
1612
  left=right= &null_element;
1613
1613
}
1614
1614
 
1615
1615
SEL_ARG::SEL_ARG(Field *field_,uint8_t part_,
1616
 
                 uchar *min_value_, uchar *max_value_,
 
1616
                 unsigned char *min_value_, unsigned char *max_value_,
1617
1617
                 uint8_t min_flag_,uint8_t max_flag_,uint8_t maybe_flag_)
1618
1618
  :min_flag(min_flag_),max_flag(max_flag_),maybe_flag(maybe_flag_),
1619
1619
   part(part_),maybe_null(field_->real_maybe_null()), elements(1),use_count(1),
1691
1691
  Returns -2 or 2 if the ranges where 'joined' like  < 2 and >= 2
1692
1692
*/
1693
1693
 
1694
 
static int sel_cmp(Field *field, uchar *a, uchar *b, uint8_t a_flag,
 
1694
static int sel_cmp(Field *field, unsigned char *a, unsigned char *b, uint8_t a_flag,
1695
1695
                   uint8_t b_flag)
1696
1696
{
1697
1697
  int cmp;
2003
2003
  KEY *index_info;
2004
2004
  uint index;
2005
2005
  uint key_infix_len;
2006
 
  uchar key_infix[MAX_KEY_LENGTH];
 
2006
  unsigned char key_infix[MAX_KEY_LENGTH];
2007
2007
  SEL_TREE *range_tree; /* Represents all range predicates in the query. */
2008
2008
  SEL_ARG  *index_tree; /* The SEL_ARG sub-tree corresponding to index_info. */
2009
2009
  uint param_idx; /* Index of used key in param->key. */
2016
2016
                    uint group_prefix_len_arg, uint used_key_parts_arg,
2017
2017
                    uint group_key_parts_arg, KEY *index_info_arg,
2018
2018
                    uint index_arg, uint key_infix_len_arg,
2019
 
                    uchar *key_infix_arg,
 
2019
                    unsigned char *key_infix_arg,
2020
2020
                    SEL_TREE *tree_arg, SEL_ARG *index_tree_arg,
2021
2021
                    uint param_idx_arg, ha_rows quick_prefix_records_arg)
2022
2022
  : have_min(have_min_arg), have_max(have_max_arg),
2986
2986
{
2987
2987
  double selectivity_mult= 1.0;
2988
2988
  KEY_PART_INFO *key_part= info->param->table->key_info[scan->keynr].key_part;
2989
 
  uchar key_val[MAX_KEY_LENGTH+MAX_FIELD_WIDTH]; /* key values tuple */
2990
 
  uchar *key_ptr= key_val;
 
2989
  unsigned char key_val[MAX_KEY_LENGTH+MAX_FIELD_WIDTH]; /* key values tuple */
 
2990
  unsigned char *key_ptr= key_val;
2991
2991
  SEL_ARG *sel_arg, *tuple_arg= NULL;
2992
2992
  key_part_map keypart_map= 0;
2993
2993
  bool cur_covered;
4296
4296
        if (!(sel_arg= new SEL_ARG(SEL_ARG::MAYBE_KEY)))
4297
4297
          return(0);                    // OOM
4298
4298
      }
4299
 
      sel_arg->part=(uchar) key_part->part;
 
4299
      sel_arg->part=(unsigned char) key_part->part;
4300
4300
      tree->keys[key_part->key]=sel_add(tree->keys[key_part->key],sel_arg);
4301
4301
      tree->keys_map.set_bit(key_part->key);
4302
4302
    }
4314
4314
  bool optimize_range;
4315
4315
  SEL_ARG *tree= 0;
4316
4316
  MEM_ROOT *alloc= param->mem_root;
4317
 
  uchar *str;
 
4317
  unsigned char *str;
4318
4318
  ulong orig_sql_mode;
4319
4319
  int err;
4320
4320
 
4376
4376
  {
4377
4377
    bool like_error;
4378
4378
    char buff1[MAX_FIELD_WIDTH];
4379
 
    uchar *min_str,*max_str;
 
4379
    unsigned char *min_str,*max_str;
4380
4380
    String tmp(buff1,sizeof(buff1),value->collation.collation),*res;
4381
4381
    size_t length, offset, min_length, max_length;
4382
4382
    uint field_length= field->pack_length()+maybe_null;
4425
4425
        field_length= length;
4426
4426
    }
4427
4427
    length+=offset;
4428
 
    if (!(min_str= (uchar*) alloc_root(alloc, length*2)))
 
4428
    if (!(min_str= (unsigned char*) alloc_root(alloc, length*2)))
4429
4429
      goto end;
4430
4430
 
4431
4431
    max_str=min_str+length;
4543
4543
    goto end;
4544
4544
  }
4545
4545
  field->table->in_use->variables.sql_mode= orig_sql_mode;
4546
 
  str= (uchar*) alloc_root(alloc, key_part->store_length+1);
 
4546
  str= (unsigned char*) alloc_root(alloc, key_part->store_length+1);
4547
4547
  if (!str)
4548
4548
    goto end;
4549
4549
  if (maybe_null)
4550
 
    *str= (uchar) field->is_real_null();        // Set to 1 if null
 
4550
    *str= (unsigned char) field->is_real_null();        // Set to 1 if null
4551
4551
  field->get_key_image(str+maybe_null, key_part->length,
4552
4552
                       key_part->image_type);
4553
4553
  if (!(tree= new (alloc) SEL_ARG(field, str, str)))
5876
5876
    Pointers in min and max keys. They point to right-after-end of key
5877
5877
    images. The 0-th entry has these pointing to key tuple start.
5878
5878
  */
5879
 
  uchar *min_key, *max_key;
 
5879
  unsigned char *min_key, *max_key;
5880
5880
  
5881
5881
  /* 
5882
5882
    Flags, for {keypart0, keypart1, ... this_keypart} subtuple.
6378
6378
*/
6379
6379
bool
6380
6380
get_quick_keys(PARAM *param,QUICK_RANGE_SELECT *quick,KEY_PART *key,
6381
 
               SEL_ARG *key_tree, uchar *min_key,uint min_key_flag,
6382
 
               uchar *max_key, uint max_key_flag)
 
6381
               SEL_ARG *key_tree, unsigned char *min_key,uint min_key_flag,
 
6382
               unsigned char *max_key, uint max_key_flag)
6383
6383
{
6384
6384
  QUICK_RANGE *range;
6385
6385
  uint flag;
6392
6392
                       min_key,min_key_flag, max_key, max_key_flag))
6393
6393
      return 1;
6394
6394
  }
6395
 
  uchar *tmp_min_key=min_key,*tmp_max_key=max_key;
 
6395
  unsigned char *tmp_min_key=min_key,*tmp_max_key=max_key;
6396
6396
  min_part+= key_tree->store_min(key[key_tree->part].store_length,
6397
6397
                                 &tmp_min_key,min_key_flag);
6398
6398
  max_part+= key_tree->store_max(key[key_tree->part].store_length,
6477
6477
  set_if_bigger(quick->max_used_key_length, range->min_length);
6478
6478
  set_if_bigger(quick->max_used_key_length, range->max_length);
6479
6479
  set_if_bigger(quick->used_key_parts, (uint) key_tree->part+1);
6480
 
  if (insert_dynamic(&quick->ranges, (uchar*) &range))
 
6480
  if (insert_dynamic(&quick->ranges, (unsigned char*) &range))
6481
6481
    return 1;
6482
6482
 
6483
6483
 end:
6523
6523
    false  Otherwise
6524
6524
*/
6525
6525
 
6526
 
static bool null_part_in_key(KEY_PART *key_part, const uchar *key, uint length)
 
6526
static bool null_part_in_key(KEY_PART *key_part, const unsigned char *key, uint length)
6527
6527
{
6528
 
  for (const uchar *end=key+length ;
 
6528
  for (const unsigned char *end=key+length ;
6529
6529
       key < end;
6530
6530
       key+= key_part++->store_length)
6531
6531
  {
6650
6650
    key_part->null_bit=     key_info->key_part[part].null_bit;
6651
6651
    key_part->flag=         (uint8_t) key_info->key_part[part].key_part_flag;
6652
6652
  }
6653
 
  if (insert_dynamic(&quick->ranges,(uchar*)&range))
 
6653
  if (insert_dynamic(&quick->ranges,(unsigned char*)&range))
6654
6654
    goto err;
6655
6655
 
6656
6656
  /*
6671
6671
                      make_prev_keypart_map(ref->key_parts), EQ_RANGE)))
6672
6672
      goto err;
6673
6673
    *ref->null_ref_key= 0;              // Clear null byte
6674
 
    if (insert_dynamic(&quick->ranges,(uchar*)&null_range))
 
6674
    if (insert_dynamic(&quick->ranges,(unsigned char*)&null_range))
6675
6675
      goto err;
6676
6676
  }
6677
6677
 
6933
6933
{
6934
6934
  int error, dup_row;
6935
6935
  QUICK_SELECT_I *quick;
6936
 
  uchar *tmp;
 
6936
  unsigned char *tmp;
6937
6937
 
6938
6938
  do
6939
6939
  {
6982
6982
int QUICK_RANGE_SELECT::reset()
6983
6983
{
6984
6984
  uint  buf_size;
6985
 
  uchar *mrange_buff;
 
6985
  unsigned char *mrange_buff;
6986
6986
  int   error;
6987
6987
  HANDLER_BUFFER empty_buf;
6988
6988
  last_range= NULL;
7224
7224
 
7225
7225
int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length,
7226
7226
                                        key_part_map keypart_map,
7227
 
                                        uchar *cur_prefix)
 
7227
                                        unsigned char *cur_prefix)
7228
7228
{
7229
7229
  for (;;)
7230
7230
  {
7249
7249
    }
7250
7250
    last_range= *(cur_range++);
7251
7251
 
7252
 
    start_key.key=    (const uchar*) last_range->min_key;
 
7252
    start_key.key=    (const unsigned char*) last_range->min_key;
7253
7253
    start_key.length= cmin(last_range->min_length, (uint16_t)prefix_length);
7254
7254
    start_key.keypart_map= last_range->min_keypart_map & keypart_map;
7255
7255
    start_key.flag=   ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
7256
7256
                       (last_range->flag & EQ_RANGE) ?
7257
7257
                       HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
7258
 
    end_key.key=      (const uchar*) last_range->max_key;
 
7258
    end_key.key=      (const unsigned char*) last_range->max_key;
7259
7259
    end_key.length=   cmin(last_range->max_length, (uint16_t)prefix_length);
7260
7260
    end_key.keypart_map= last_range->max_keypart_map & keypart_map;
7261
7261
    /*
7447
7447
  KEY_PART *key_part=key_parts;
7448
7448
  uint store_length;
7449
7449
 
7450
 
  for (uchar *key=range_arg->max_key, *end=key+range_arg->max_length;
 
7450
  for (unsigned char *key=range_arg->max_key, *end=key+range_arg->max_length;
7451
7451
       key < end;
7452
7452
       key+= store_length, key_part++)
7453
7453
  {
7687
7687
                       KEY_PART_INFO *first_non_group_part,
7688
7688
                       KEY_PART_INFO *min_max_arg_part,
7689
7689
                       KEY_PART_INFO *last_part, THD *thd,
7690
 
                       uchar *key_infix, uint *key_infix_len,
 
7690
                       unsigned char *key_infix, uint *key_infix_len,
7691
7691
                       KEY_PART_INFO **first_non_infix_part);
7692
7692
static bool
7693
7693
check_group_min_max_predicates(COND *cond, Item_field *min_max_arg_item,
7844
7844
  uint index= 0;            /* The id of the chosen index. */
7845
7845
  uint group_key_parts= 0;  // Number of index key parts in the group prefix.
7846
7846
  uint used_key_parts= 0;   /* Number of index key parts used for access. */
7847
 
  uchar key_infix[MAX_KEY_LENGTH]; /* Constants from equality predicates.*/
 
7847
  unsigned char key_infix[MAX_KEY_LENGTH]; /* Constants from equality predicates.*/
7848
7848
  uint key_infix_len= 0;          /* Length of key_infix. */
7849
7849
  TRP_GROUP_MIN_MAX *read_plan= NULL; /* The eventually constructed TRP. */
7850
7850
  uint key_part_nr;
8127
8127
 
8128
8128
        /* Check if cur_part is referenced in the WHERE clause. */
8129
8129
        if (join->conds->walk(&Item::find_item_in_field_list_processor, 0,
8130
 
                              (uchar*) key_part_range))
 
8130
                              (unsigned char*) key_part_range))
8131
8131
          goto next_index;
8132
8132
      }
8133
8133
    }
8395
8395
                       KEY_PART_INFO *min_max_arg_part,
8396
8396
                       KEY_PART_INFO *last_part,
8397
8397
                       THD *thd __attribute__((unused)),
8398
 
                       uchar *key_infix, uint *key_infix_len,
 
8398
                       unsigned char *key_infix, uint *key_infix_len,
8399
8399
                       KEY_PART_INFO **first_non_infix_part)
8400
8400
{
8401
8401
  SEL_ARG       *cur_range;
8404
8404
  KEY_PART_INFO *end_part= min_max_arg_part ? min_max_arg_part : last_part;
8405
8405
 
8406
8406
  *key_infix_len= 0;
8407
 
  uchar *key_ptr= key_infix;
 
8407
  unsigned char *key_ptr= key_infix;
8408
8408
  for (cur_part= first_non_group_part; cur_part != end_part; cur_part++)
8409
8409
  {
8410
8410
    /*
8790
8790
                           uint used_key_parts_arg, KEY *index_info_arg,
8791
8791
                           uint use_index, double read_cost_arg,
8792
8792
                           ha_rows records_arg, uint key_infix_len_arg,
8793
 
                           uchar *key_infix_arg, MEM_ROOT *parent_alloc)
 
8793
                           unsigned char *key_infix_arg, MEM_ROOT *parent_alloc)
8794
8794
  :join(join_arg), index_info(index_info_arg),
8795
8795
   group_prefix_len(group_prefix_len_arg),
8796
8796
   group_key_parts(group_key_parts_arg), have_min(have_min_arg),
8849
8849
  if (group_prefix) /* Already initialized. */
8850
8850
    return 0;
8851
8851
 
8852
 
  if (!(last_prefix= (uchar*) alloc_root(&alloc, group_prefix_len)))
 
8852
  if (!(last_prefix= (unsigned char*) alloc_root(&alloc, group_prefix_len)))
8853
8853
      return 1;
8854
8854
  /*
8855
8855
    We may use group_prefix to store keys with all select fields, so allocate
8856
8856
    enough space for it.
8857
8857
  */
8858
 
  if (!(group_prefix= (uchar*) alloc_root(&alloc,
 
8858
  if (!(group_prefix= (unsigned char*) alloc_root(&alloc,
8859
8859
                                         real_prefix_len + min_max_arg_len)))
8860
8860
    return 1;
8861
8861
 
8865
8865
      The memory location pointed to by key_infix will be deleted soon, so
8866
8866
      allocate a new buffer and copy the key_infix into it.
8867
8867
    */
8868
 
    uchar *tmp_key_infix= (uchar*) alloc_root(&alloc, key_infix_len);
 
8868
    unsigned char *tmp_key_infix= (unsigned char*) alloc_root(&alloc, key_infix_len);
8869
8869
    if (!tmp_key_infix)
8870
8870
      return 1;
8871
8871
    memcpy(tmp_key_infix, this->key_infix, key_infix_len);
8979
8979
                         range_flag);
8980
8980
  if (!range)
8981
8981
    return true;
8982
 
  if (insert_dynamic(&min_max_ranges, (uchar*)&range))
 
8982
  if (insert_dynamic(&min_max_ranges, (unsigned char*)&range))
8983
8983
    return true;
8984
8984
  return false;
8985
8985
}
9014
9014
    {
9015
9015
      QUICK_RANGE *range;
9016
9016
 
9017
 
      get_dynamic(arr, (uchar*)&range, inx);
 
9017
      get_dynamic(arr, (unsigned char*)&range, inx);
9018
9018
      range->flag &= ~(NEAR_MIN | NEAR_MAX);
9019
9019
    }
9020
9020
  }
9050
9050
    QUICK_RANGE *cur_range;
9051
9051
    if (have_min)
9052
9052
    { /* Check if the right-most range has a lower boundary. */
9053
 
      get_dynamic(&min_max_ranges, (uchar*)&cur_range,
 
9053
      get_dynamic(&min_max_ranges, (unsigned char*)&cur_range,
9054
9054
                  min_max_ranges.elements - 1);
9055
9055
      if (!(cur_range->flag & NO_MIN_RANGE))
9056
9056
      {
9061
9061
    }
9062
9062
    if (have_max)
9063
9063
    { /* Check if the left-most range has an upper boundary. */
9064
 
      get_dynamic(&min_max_ranges, (uchar*)&cur_range, 0);
 
9064
      get_dynamic(&min_max_ranges, (unsigned char*)&cur_range, 0);
9065
9065
      if (!(cur_range->flag & NO_MAX_RANGE))
9066
9066
      {
9067
9067
        max_used_key_length+= min_max_arg_len;
9372
9372
 
9373
9373
  if (quick_prefix_select)
9374
9374
  {
9375
 
    uchar *cur_prefix= seen_first_key ? group_prefix : NULL;
 
9375
    unsigned char *cur_prefix= seen_first_key ? group_prefix : NULL;
9376
9376
    if ((result= quick_prefix_select->get_next_prefix(group_prefix_len,
9377
9377
                         make_prev_keypart_map(group_key_parts), cur_prefix)))
9378
9378
      return(result);
9442
9442
 
9443
9443
  for (uint range_idx= 0; range_idx < min_max_ranges.elements; range_idx++)
9444
9444
  { /* Search from the left-most range to the right. */
9445
 
    get_dynamic(&min_max_ranges, (uchar*)&cur_range, range_idx);
 
9445
    get_dynamic(&min_max_ranges, (unsigned char*)&cur_range, range_idx);
9446
9446
 
9447
9447
    /*
9448
9448
      If the current value for the min/max argument is bigger than the right
9449
9449
      boundary of cur_range, there is no need to check this range.
9450
9450
    */
9451
9451
    if (range_idx != 0 && !(cur_range->flag & NO_MAX_RANGE) &&
9452
 
        (key_cmp(min_max_arg_part, (const uchar*) cur_range->max_key,
 
9452
        (key_cmp(min_max_arg_part, (const unsigned char*) cur_range->max_key,
9453
9453
                 min_max_arg_len) == 1))
9454
9454
      continue;
9455
9455
 
9510
9510
    if ( !(cur_range->flag & NO_MAX_RANGE) )
9511
9511
    {
9512
9512
      /* Compose the MAX key for the range. */
9513
 
      uchar *max_key= (uchar*) my_alloca(real_prefix_len + min_max_arg_len);
 
9513
      unsigned char *max_key= (unsigned char*) my_alloca(real_prefix_len + min_max_arg_len);
9514
9514
      memcpy(max_key, group_prefix, real_prefix_len);
9515
9515
      memcpy(max_key + real_prefix_len, cur_range->max_key,
9516
9516
             cur_range->max_length);
9573
9573
 
9574
9574
  for (uint range_idx= min_max_ranges.elements; range_idx > 0; range_idx--)
9575
9575
  { /* Search from the right-most range to the left. */
9576
 
    get_dynamic(&min_max_ranges, (uchar*)&cur_range, range_idx - 1);
 
9576
    get_dynamic(&min_max_ranges, (unsigned char*)&cur_range, range_idx - 1);
9577
9577
 
9578
9578
    /*
9579
9579
      If the current value for the min/max argument is smaller than the left
9581
9581
    */
9582
9582
    if (range_idx != min_max_ranges.elements &&
9583
9583
        !(cur_range->flag & NO_MIN_RANGE) &&
9584
 
        (key_cmp(min_max_arg_part, (const uchar*) cur_range->min_key,
 
9584
        (key_cmp(min_max_arg_part, (const unsigned char*) cur_range->min_key,
9585
9585
                 min_max_arg_len) == -1))
9586
9586
      continue;
9587
9587
 
9627
9627
    if ( !(cur_range->flag & NO_MIN_RANGE) )
9628
9628
    {
9629
9629
      /* Compose the MIN key for the range. */
9630
 
      uchar *min_key= (uchar*) my_alloca(real_prefix_len + min_max_arg_len);
 
9630
      unsigned char *min_key= (unsigned char*) my_alloca(real_prefix_len + min_max_arg_len);
9631
9631
      memcpy(min_key, group_prefix, real_prefix_len);
9632
9632
      memcpy(min_key + real_prefix_len, cur_range->min_key,
9633
9633
             cur_range->min_length);