← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Merged from Mats.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
179
179
                       &path_buff, path_length + 1,
180
180
                       NULL))
181
181
  {
182
 
    memset((char*) share, 0, sizeof(*share));
 
182
    memset(share, 0, sizeof(*share));
183
183
 
184
184
    share->set_table_cache_key(key_buff, key, key_length);
185
185
 
208
208
    share->table_map_id= ~0UL;
209
209
    share->cached_row_logging_check= -1;
210
210
 
211
 
    memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
 
211
    memcpy(&share->mem_root, &mem_root, sizeof(mem_root));
212
212
    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
213
213
    pthread_cond_init(&share->cond, NULL);
214
214
  }
244
244
                          const char *path)
245
245
{
246
246
 
247
 
  memset((char*) share, 0, sizeof(*share));
 
247
  memset(share, 0, sizeof(*share));
248
248
  init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
249
249
  share->table_category=         TABLE_CATEGORY_TEMPORARY;
250
250
  share->tmp_table=              INTERNAL_TMP_TABLE;
314
314
  share->db_plugin= NULL;
315
315
 
316
316
  /* We must copy mem_root from share because share is allocated through it */
317
 
  memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
 
317
  memcpy(&mem_root, &share->mem_root, sizeof(mem_root));
318
318
  free_root(&mem_root, MYF(0));                 // Free's share
319
319
  return;
320
320
}
581
581
  if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
582
582
                                    n_length + uint2korr(disk_buff+4))))
583
583
    goto err;                                   /* purecov: inspected */
584
 
  memset((char*) keyinfo, 0, n_length);
 
584
  memset(keyinfo, 0, n_length);
585
585
  share->key_info= keyinfo;
586
586
  key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
587
587
  strpos=disk_buff+6;
821
821
  names= (char*) (interval_array+share->fields+interval_parts+keys+3);
822
822
  if (!interval_count)
823
823
    share->intervals= 0;                        // For better debugging
824
 
  memcpy((char*) names, strpos+(share->fields*field_pack_length),
 
824
  memcpy(names, strpos+(share->fields*field_pack_length),
825
825
         (uint) (n_length+int_length));
826
826
  comment_pos= names+(n_length+int_length);
827
827
  memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
958
958
      }
959
959
      else
960
960
        charset= share->table_charset;
961
 
      memset((char*) &comment, 0, sizeof(comment));
 
961
      memset(&comment, 0, sizeof(comment));
962
962
    }
963
963
 
964
964
    if (interval_nr && charset->mbminlen > 1)
1336
1336
  assert(thd->lex->is_lex_started);
1337
1337
 
1338
1338
  error= 1;
1339
 
  memset((char*) outparam, 0, sizeof(*outparam));
 
1339
  memset(outparam, 0, sizeof(*outparam));
1340
1340
  outparam->in_use= thd;
1341
1341
  outparam->s= share;
1342
1342
  outparam->db_stat= db_stat;
1544
1544
  }
1545
1545
 
1546
1546
#if defined(HAVE_purify) 
1547
 
  memset((char*) bitmaps, 0, bitmap_size*3);
 
1547
  memset(bitmaps, 0, bitmap_size*3);
1548
1548
#endif
1549
1549
 
1550
1550
  outparam->no_replicate= outparam->file &&
1653
1653
      my_free((uchar*) buf,MYF(0));
1654
1654
  }
1655
1655
  else if (!names)
1656
 
    memset((char*) save_names, 0, sizeof(save_names));
 
1656
    memset(save_names, 0, sizeof(save_names));
1657
1657
  else
1658
1658
  {
1659
1659
    char *str;
2038
2038
  {
2039
2039
    uint key_length, tmp_key_length;
2040
2040
    uint tmp;
2041
 
    memset((char*) fileinfo, 0, 64);
 
2041
    memset(fileinfo, 0, 64);
2042
2042
    /* header */
2043
2043
    fileinfo[0]=(uchar) 254;
2044
2044
    fileinfo[1]= 1;
3177
3177
    bitmap_clear_all(&table->def_read_set);
3178
3178
    bitmap_clear_all(&table->def_write_set);
3179
3179
  */
3180
 
  memset((char*) def_read_set.bitmap, 0, s->column_bitmap_size*2);
 
3180
  memset(def_read_set.bitmap, 0, s->column_bitmap_size*2);
3181
3181
  column_bitmaps_set(&def_read_set, &def_write_set);
3182
3182
}
3183
3183