← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Removing redundant use of casts in drizzled/ for memcmp(), memcpy(), memset(), and memmove().
Adding non-const version of String::ptr() to provide covariance on const:ness.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
3477
3477
    table->quick_keys.clear_all();
3478
3478
    table->reginfo.join_tab=s;
3479
3479
    table->reginfo.not_exists_optimize=0;
3480
 
    memset((char*) table->const_key_parts, 0,
 
3480
    memset(table->const_key_parts, 0,
3481
3481
           sizeof(key_part_map)*table->s->keys);
3482
3482
    all_table_map|= table->map;
3483
3483
    s->join=join;
3839
3839
  }
3840
3840
  else
3841
3841
  {
3842
 
    memcpy((uchar*) join->best_positions,(uchar*) join->positions,
3843
 
           sizeof(POSITION)*join->const_tables);
 
3842
    memcpy(join->best_positions, join->positions,
 
3843
           sizeof(POSITION)*join->const_tables);
3844
3844
    join->best_read=1.0;
3845
3845
  }
3846
3846
  /* Generate an execution plan from the found optimal join order. */
4694
4694
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
4695
4695
          (qsort_cmp) sort_keyuse);
4696
4696
 
4697
 
    memset((char*) &key_end, 0, sizeof(key_end)); /* Add for easy testing */
 
4697
    memset(&key_end, 0, sizeof(key_end)); /* Add for easy testing */
4698
4698
    VOID(insert_dynamic(keyuse,(uchar*) &key_end));
4699
4699
 
4700
4700
    use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
5774
5774
  if (join->sort_by_table &&
5775
5775
      join->sort_by_table != join->positions[join->const_tables].table->table)
5776
5776
    read_time+= record_count;  // We have to make a temp table
5777
 
  memcpy((uchar*) join->best_positions, (uchar*) join->positions,
5778
 
         sizeof(POSITION)*idx);
 
5777
  memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);
5779
5778
  join->best_read= read_time;
5780
5779
}
5781
5780
 
6149
6148
          current_read_time+= current_record_count;
6150
6149
        if ((search_depth == 1) || (current_read_time < join->best_read))
6151
6150
        {
6152
 
          memcpy((uchar*) join->best_positions, (uchar*) join->positions,
 
6151
          memcpy(join->best_positions, join->positions,
6153
6152
                 sizeof(POSITION) * (idx + 1));
6154
6153
          join->best_read= current_read_time - 0.001;
6155
6154
        }
6187
6186
      read_time+=record_count;                  // We have to make a temp table
6188
6187
    if (read_time < join->best_read)
6189
6188
    {
6190
 
      memcpy((uchar*) join->best_positions,(uchar*) join->positions,
6191
 
             sizeof(POSITION)*idx);
 
6189
      memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);
6192
6190
      join->best_read= read_time - 0.001;
6193
6191
    }
6194
6192
    return(false);
6699
6697
  join_tab->ref.key_parts= 0;
6700
6698
  join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;
6701
6699
  join_tab->do_firstmatch= NULL;
6702
 
  memset((char*) &join_tab->read_record, 0, sizeof(join_tab->read_record));
 
6700
  memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));
6703
6701
  tmp_table->status=0;
6704
6702
  tmp_table->null_row=0;
6705
6703
  return(false);
11069
11067
  strmov(tmpname,path);
11070
11068
  /* make table according to fields */
11071
11069
 
11072
 
  memset((char*) table, 0, sizeof(*table));
11073
 
  memset((char*) reg_field, 0, sizeof(Field*)*(field_count+1));
11074
 
  memset((char*) default_field, 0, sizeof(Field*) * (field_count));
11075
 
  memset((char*) from_field, 0, sizeof(Field*)*field_count);
 
11070
  memset(table, 0, sizeof(*table));
 
11071
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
 
11072
  memset(default_field, 0, sizeof(Field*) * (field_count));
 
11073
  memset(from_field, 0, sizeof(Field*)*field_count);
11076
11074
 
11077
11075
  table->mem_root= own_root;
11078
11076
  mem_root_save= thd->mem_root;
11323
11321
  pos=table->record[0]+ null_pack_length;
11324
11322
  if (null_pack_length)
11325
11323
  {
11326
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11324
    memset(recinfo, 0, sizeof(*recinfo));
11327
11325
    recinfo->type=FIELD_NORMAL;
11328
11326
    recinfo->length=null_pack_length;
11329
11327
    recinfo++;
11339
11337
  {
11340
11338
    Field *field= *reg_field;
11341
11339
    uint length;
11342
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11340
    memset(recinfo, 0, sizeof(*recinfo));
11343
11341
 
11344
11342
    if (!(field->flags & NOT_NULL_FLAG))
11345
11343
    {
11353
11351
        recinfo->length=1;
11354
11352
        recinfo->type=FIELD_NORMAL;
11355
11353
        recinfo++;
11356
 
        memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11354
        memset(recinfo, 0, sizeof(*recinfo));
11357
11355
      }
11358
11356
      else
11359
11357
      {
11725
11723
  
11726
11724
 
11727
11725
  /* STEP 4: Create TABLE description */
11728
 
  memset((char*) table, 0, sizeof(*table));
11729
 
  memset((char*) reg_field, 0, sizeof(Field*)*2);
 
11726
  memset(table, 0, sizeof(*table));
 
11727
  memset(reg_field, 0, sizeof(Field*)*2);
11730
11728
 
11731
11729
  table->mem_root= own_root;
11732
11730
  mem_root_save= thd->mem_root;
11825
11823
  pos=table->record[0]+ null_pack_length;
11826
11824
  if (null_pack_length)
11827
11825
  {
11828
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11826
    memset(recinfo, 0, sizeof(*recinfo));
11829
11827
    recinfo->type=FIELD_NORMAL;
11830
11828
    recinfo->length=null_pack_length;
11831
11829
    recinfo++;
11840
11838
  {
11841
11839
    //Field *field= *reg_field;
11842
11840
    uint length;
11843
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11841
    memset(recinfo, 0, sizeof(*recinfo));
11844
11842
    field->move_field(pos,(uchar*) 0,0);
11845
11843
 
11846
11844
    field->reset();
12140
12138
      share->keys=    0;
12141
12139
      share->uniques= 1;
12142
12140
      using_unique_constraint=1;
12143
 
      memset((char*) &uniquedef, 0, sizeof(uniquedef));
 
12141
      memset(&uniquedef, 0, sizeof(uniquedef));
12144
12142
      uniquedef.keysegs=keyinfo->key_parts;
12145
12143
      uniquedef.seg=seg;
12146
12144
      uniquedef.null_are_equal=1;
12147
12145
 
12148
12146
      /* Create extra column for hash value */
12149
 
      memset((uchar*) *recinfo, 0, sizeof(**recinfo));
 
12147
      memset(*recinfo, 0, sizeof(**recinfo));
12150
12148
      (*recinfo)->type= FIELD_CHECK;
12151
12149
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
12152
12150
      (*recinfo)++;
12155
12153
    else
12156
12154
    {
12157
12155
      /* Create an unique key */
12158
 
      memset((char*) &keydef, 0, sizeof(keydef));
 
12156
      memset(&keydef, 0, sizeof(keydef));
12159
12157
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
12160
12158
      keydef.keysegs=  keyinfo->key_parts;
12161
12159
      keydef.seg= seg;
12199
12197
    }
12200
12198
  }
12201
12199
  MI_CREATE_INFO create_info;
12202
 
  memset((char*) &create_info, 0, sizeof(create_info));
 
12200
  memset(&create_info, 0, sizeof(create_info));
12203
12201
 
12204
12202
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
12205
12203
      OPTION_BIG_TABLES)
17547
17545
  for (i= send_group_parts ; i-- > idx ; )
17548
17546
  {
17549
17547
    /* Get reference pointers to sum functions in place */
17550
 
    memcpy((char*) ref_pointer_array,
17551
 
           (char*) rollup.ref_pointer_arrays[i],
 
17548
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17552
17549
           ref_pointer_array_size);
17553
17550
    if ((!having || having->val_int()))
17554
17551
    {
17589
17586
  for (i= send_group_parts ; i-- > idx ; )
17590
17587
  {
17591
17588
    /* Get reference pointers to sum functions in place */
17592
 
    memcpy((char*) ref_pointer_array,
17593
 
           (char*) rollup.ref_pointer_arrays[i],
 
17589
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17594
17590
           ref_pointer_array_size);
17595
17591
    if ((!having || having->val_int()))
17596
17592
    {