← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Merged from Mats.

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);
11068
11066
  strmov(tmpname,path);
11069
11067
  /* make table according to fields */
11070
11068
 
11071
 
  memset((char*) table, 0, sizeof(*table));
11072
 
  memset((char*) reg_field, 0, sizeof(Field*)*(field_count+1));
11073
 
  memset((char*) default_field, 0, sizeof(Field*) * (field_count));
11074
 
  memset((char*) from_field, 0, sizeof(Field*)*field_count);
 
11069
  memset(table, 0, sizeof(*table));
 
11070
  memset(reg_field, 0, sizeof(Field*)*(field_count+1));
 
11071
  memset(default_field, 0, sizeof(Field*) * (field_count));
 
11072
  memset(from_field, 0, sizeof(Field*)*field_count);
11075
11073
 
11076
11074
  table->mem_root= own_root;
11077
11075
  mem_root_save= thd->mem_root;
11321
11319
  pos=table->record[0]+ null_pack_length;
11322
11320
  if (null_pack_length)
11323
11321
  {
11324
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11322
    memset(recinfo, 0, sizeof(*recinfo));
11325
11323
    recinfo->type=FIELD_NORMAL;
11326
11324
    recinfo->length=null_pack_length;
11327
11325
    recinfo++;
11337
11335
  {
11338
11336
    Field *field= *reg_field;
11339
11337
    uint length;
11340
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11338
    memset(recinfo, 0, sizeof(*recinfo));
11341
11339
 
11342
11340
    if (!(field->flags & NOT_NULL_FLAG))
11343
11341
    {
11351
11349
        recinfo->length=1;
11352
11350
        recinfo->type=FIELD_NORMAL;
11353
11351
        recinfo++;
11354
 
        memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11352
        memset(recinfo, 0, sizeof(*recinfo));
11355
11353
      }
11356
11354
      else
11357
11355
      {
11721
11719
  
11722
11720
 
11723
11721
  /* STEP 4: Create TABLE description */
11724
 
  memset((char*) table, 0, sizeof(*table));
11725
 
  memset((char*) reg_field, 0, sizeof(Field*)*2);
 
11722
  memset(table, 0, sizeof(*table));
 
11723
  memset(reg_field, 0, sizeof(Field*)*2);
11726
11724
 
11727
11725
  table->mem_root= own_root;
11728
11726
  mem_root_save= thd->mem_root;
11820
11818
  pos=table->record[0]+ null_pack_length;
11821
11819
  if (null_pack_length)
11822
11820
  {
11823
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11821
    memset(recinfo, 0, sizeof(*recinfo));
11824
11822
    recinfo->type=FIELD_NORMAL;
11825
11823
    recinfo->length=null_pack_length;
11826
11824
    recinfo++;
11835
11833
  {
11836
11834
    //Field *field= *reg_field;
11837
11835
    uint length;
11838
 
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
 
11836
    memset(recinfo, 0, sizeof(*recinfo));
11839
11837
    field->move_field(pos,(uchar*) 0,0);
11840
11838
 
11841
11839
    field->reset();
12131
12129
      share->keys=    0;
12132
12130
      share->uniques= 1;
12133
12131
      using_unique_constraint=1;
12134
 
      memset((char*) &uniquedef, 0, sizeof(uniquedef));
 
12132
      memset(&uniquedef, 0, sizeof(uniquedef));
12135
12133
      uniquedef.keysegs=keyinfo->key_parts;
12136
12134
      uniquedef.seg=seg;
12137
12135
      uniquedef.null_are_equal=1;
12138
12136
 
12139
12137
      /* Create extra column for hash value */
12140
 
      memset((uchar*) *recinfo, 0, sizeof(**recinfo));
 
12138
      memset(*recinfo, 0, sizeof(**recinfo));
12141
12139
      (*recinfo)->type= FIELD_CHECK;
12142
12140
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
12143
12141
      (*recinfo)++;
12146
12144
    else
12147
12145
    {
12148
12146
      /* Create an unique key */
12149
 
      memset((char*) &keydef, 0, sizeof(keydef));
 
12147
      memset(&keydef, 0, sizeof(keydef));
12150
12148
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
12151
12149
      keydef.keysegs=  keyinfo->key_parts;
12152
12150
      keydef.seg= seg;
12186
12184
    }
12187
12185
  }
12188
12186
  MI_CREATE_INFO create_info;
12189
 
  memset((char*) &create_info, 0, sizeof(create_info));
 
12187
  memset(&create_info, 0, sizeof(create_info));
12190
12188
 
12191
12189
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
12192
12190
      OPTION_BIG_TABLES)
17533
17531
  for (i= send_group_parts ; i-- > idx ; )
17534
17532
  {
17535
17533
    /* Get reference pointers to sum functions in place */
17536
 
    memcpy((char*) ref_pointer_array,
17537
 
           (char*) rollup.ref_pointer_arrays[i],
 
17534
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17538
17535
           ref_pointer_array_size);
17539
17536
    if ((!having || having->val_int()))
17540
17537
    {
17575
17572
  for (i= send_group_parts ; i-- > idx ; )
17576
17573
  {
17577
17574
    /* Get reference pointers to sum functions in place */
17578
 
    memcpy((char*) ref_pointer_array,
17579
 
           (char*) rollup.ref_pointer_arrays[i],
 
17575
    memcpy(ref_pointer_array, rollup.ref_pointer_arrays[i],
17580
17576
           ref_pointer_array_size);
17581
17577
    if ((!having || having->val_int()))
17582
17578
    {