← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_select.cc

Replacing all bzero() calls with memset() calls and removing the bzero.c file.
Also removing check for bzero from the 'configure.ac' autoconf file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/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
 
    bzero((char*) table->const_key_parts, sizeof(key_part_map)*table->s->keys);
 
3480
    memset((char*) table->const_key_parts, 0,
 
3481
           sizeof(key_part_map)*table->s->keys);
3481
3482
    all_table_map|= table->map;
3482
3483
    s->join=join;
3483
3484
    s->info=0;                                  // For describe
4693
4694
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
4694
4695
          (qsort_cmp) sort_keyuse);
4695
4696
 
4696
 
    bzero((char*) &key_end,sizeof(key_end));    /* Add for easy testing */
 
4697
    memset((char*) &key_end, 0, sizeof(key_end)); /* Add for easy testing */
4697
4698
    VOID(insert_dynamic(keyuse,(uchar*) &key_end));
4698
4699
 
4699
4700
    use=save_pos=dynamic_element(keyuse,0,KEYUSE*);
6698
6699
  join_tab->ref.key_parts= 0;
6699
6700
  join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;
6700
6701
  join_tab->do_firstmatch= NULL;
6701
 
  bzero((char*) &join_tab->read_record,sizeof(join_tab->read_record));
 
6702
  memset((char*) &join_tab->read_record, 0, sizeof(join_tab->read_record));
6702
6703
  tmp_table->status=0;
6703
6704
  tmp_table->null_row=0;
6704
6705
  return(false);
11068
11069
  strmov(tmpname,path);
11069
11070
  /* make table according to fields */
11070
11071
 
11071
 
  bzero((char*) table,sizeof(*table));
11072
 
  bzero((char*) reg_field,sizeof(Field*)*(field_count+1));
11073
 
  bzero((char*) default_field, sizeof(Field*) * (field_count));
11074
 
  bzero((char*) from_field,sizeof(Field*)*field_count);
 
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);
11075
11076
 
11076
11077
  table->mem_root= own_root;
11077
11078
  mem_root_save= thd->mem_root;
11322
11323
  pos=table->record[0]+ null_pack_length;
11323
11324
  if (null_pack_length)
11324
11325
  {
11325
 
    bzero((uchar*) recinfo,sizeof(*recinfo));
 
11326
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
11326
11327
    recinfo->type=FIELD_NORMAL;
11327
11328
    recinfo->length=null_pack_length;
11328
11329
    recinfo++;
11338
11339
  {
11339
11340
    Field *field= *reg_field;
11340
11341
    uint length;
11341
 
    bzero((uchar*) recinfo,sizeof(*recinfo));
 
11342
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
11342
11343
 
11343
11344
    if (!(field->flags & NOT_NULL_FLAG))
11344
11345
    {
11352
11353
        recinfo->length=1;
11353
11354
        recinfo->type=FIELD_NORMAL;
11354
11355
        recinfo++;
11355
 
        bzero((uchar*) recinfo,sizeof(*recinfo));
 
11356
        memset((uchar*) recinfo, 0, sizeof(*recinfo));
11356
11357
      }
11357
11358
      else
11358
11359
      {
11528
11529
          alloc_root(&table->mem_root,
11529
11530
                     keyinfo->key_parts * sizeof(KEY_PART_INFO))))
11530
11531
      goto err;
11531
 
    bzero((void*) key_part_info, keyinfo->key_parts * sizeof(KEY_PART_INFO));
 
11532
    memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));
11532
11533
    table->key_info=keyinfo;
11533
11534
    keyinfo->key_part=key_part_info;
11534
11535
    keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;
11724
11725
  
11725
11726
 
11726
11727
  /* STEP 4: Create TABLE description */
11727
 
  bzero((char*) table,sizeof(*table));
11728
 
  bzero((char*) reg_field,sizeof(Field*)*2);
 
11728
  memset((char*) table, 0, sizeof(*table));
 
11729
  memset((char*) reg_field, 0, sizeof(Field*)*2);
11729
11730
 
11730
11731
  table->mem_root= own_root;
11731
11732
  mem_root_save= thd->mem_root;
11824
11825
  pos=table->record[0]+ null_pack_length;
11825
11826
  if (null_pack_length)
11826
11827
  {
11827
 
    bzero((uchar*) recinfo,sizeof(*recinfo));
 
11828
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
11828
11829
    recinfo->type=FIELD_NORMAL;
11829
11830
    recinfo->length=null_pack_length;
11830
11831
    recinfo++;
11839
11840
  {
11840
11841
    //Field *field= *reg_field;
11841
11842
    uint length;
11842
 
    bzero((uchar*) recinfo,sizeof(*recinfo));
 
11843
    memset((uchar*) recinfo, 0, sizeof(*recinfo));
11843
11844
    field->move_field(pos,(uchar*) 0,0);
11844
11845
 
11845
11846
    field->reset();
11848
11849
      'offset' fields generated by initalize_tables
11849
11850
    */
11850
11851
    // Initialize the table field:
11851
 
    bzero(field->ptr, field->pack_length());
 
11852
    memset(field->ptr, 0, field->pack_length());
11852
11853
 
11853
11854
    length=field->pack_length();
11854
11855
    pos+= length;
11983
11984
                        NullS))
11984
11985
    return 0;
11985
11986
 
11986
 
  bzero(table, sizeof(*table));
11987
 
  bzero(share, sizeof(*share));
 
11987
  memset(table, 0, sizeof(*table));
 
11988
  memset(share, 0, sizeof(*share));
11988
11989
  table->field= field;
11989
11990
  table->s= share;
11990
11991
  share->blob_field= blob_field;
12130
12131
    if (!seg)
12131
12132
      goto err;
12132
12133
 
12133
 
    bzero(seg, sizeof(*seg) * keyinfo->key_parts);
 
12134
    memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);
12134
12135
    if (keyinfo->key_length >= table->file->max_key_length() ||
12135
12136
        keyinfo->key_parts > table->file->max_key_parts() ||
12136
12137
        share->uniques)
12139
12140
      share->keys=    0;
12140
12141
      share->uniques= 1;
12141
12142
      using_unique_constraint=1;
12142
 
      bzero((char*) &uniquedef,sizeof(uniquedef));
 
12143
      memset((char*) &uniquedef, 0, sizeof(uniquedef));
12143
12144
      uniquedef.keysegs=keyinfo->key_parts;
12144
12145
      uniquedef.seg=seg;
12145
12146
      uniquedef.null_are_equal=1;
12146
12147
 
12147
12148
      /* Create extra column for hash value */
12148
 
      bzero((uchar*) *recinfo,sizeof(**recinfo));
 
12149
      memset((uchar*) *recinfo, 0, sizeof(**recinfo));
12149
12150
      (*recinfo)->type= FIELD_CHECK;
12150
12151
      (*recinfo)->length=MI_UNIQUE_HASH_LENGTH;
12151
12152
      (*recinfo)++;
12154
12155
    else
12155
12156
    {
12156
12157
      /* Create an unique key */
12157
 
      bzero((char*) &keydef,sizeof(keydef));
 
12158
      memset((char*) &keydef, 0, sizeof(keydef));
12158
12159
      keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;
12159
12160
      keydef.keysegs=  keyinfo->key_parts;
12160
12161
      keydef.seg= seg;
12198
12199
    }
12199
12200
  }
12200
12201
  MI_CREATE_INFO create_info;
12201
 
  bzero((char*) &create_info,sizeof(create_info));
 
12202
  memset((char*) &create_info, 0, sizeof(create_info));
12202
12203
 
12203
12204
  if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==
12204
12205
      OPTION_BIG_TABLES)