← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
17
17
/* Some general useful functions */
18
18
 
19
19
#include "mysql_priv.h"
20
 
#include <m_ctype.h>
21
 
#include "my_md5.h"
22
20
 
23
21
/* INFORMATION_SCHEMA name */
24
22
LEX_STRING INFORMATION_SCHEMA_NAME= {C_STRING_WITH_LEN("information_schema")};
180
178
                       &path_buff, path_length + 1,
181
179
                       NULL))
182
180
  {
183
 
    bzero((char*) share, sizeof(*share));
 
181
    memset((char*) share, 0, sizeof(*share));
184
182
 
185
183
    share->set_table_cache_key(key_buff, key, key_length);
186
184
 
245
243
                          const char *path)
246
244
{
247
245
 
248
 
  bzero((char*) share, sizeof(*share));
 
246
  memset((char*) share, 0, sizeof(*share));
249
247
  init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
250
248
  share->table_category=         TABLE_CATEGORY_TEMPORARY;
251
249
  share->tmp_table=              INTERNAL_TMP_TABLE;
583
581
  if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
584
582
                                    n_length + uint2korr(disk_buff+4))))
585
583
    goto err;                                   /* purecov: inspected */
586
 
  bzero((char*) keyinfo,n_length);
 
584
  memset((char*) keyinfo, 0, n_length);
587
585
  share->key_info= keyinfo;
588
586
  key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
589
587
  strpos=disk_buff+6;
610
608
    for (j=keyinfo->key_parts ; j-- ; key_part++)
611
609
    {
612
610
      *rec_per_key++=0;
613
 
      key_part->fieldnr=        (uint16) (uint2korr(strpos) & FIELD_NR_MASK);
 
611
      key_part->fieldnr=        (uint16_t) (uint2korr(strpos) & FIELD_NR_MASK);
614
612
      key_part->offset= (uint) uint2korr(strpos+2)-1;
615
613
      key_part->key_type=       (uint) uint2korr(strpos+5);
616
614
      // key_part->field=       (Field*) 0;     // Will be fixed later
960
958
      }
961
959
      else
962
960
        charset= share->table_charset;
963
 
      bzero((char*) &comment, sizeof(comment));
 
961
      memset((char*) &comment, 0, sizeof(comment));
964
962
    }
965
963
 
966
964
    if (interval_nr && charset->mbminlen > 1)
971
969
    }
972
970
    
973
971
#ifndef TO_BE_DELETED_ON_PRODUCTION
974
 
    if (field_type == MYSQL_TYPE_NEWDECIMAL && !share->mysql_version)
 
972
    if (field_type == DRIZZLE_TYPE_NEWDECIMAL && !share->mysql_version)
975
973
    {
976
974
      /*
977
975
        Fix pack length of old decimal values from 5.0.3 -> 5.0.4
999
997
 
1000
998
    *field_ptr= reg_field=
1001
999
      make_field(share, record+recpos,
1002
 
                 (uint32) field_length,
 
1000
                 (uint32_t) field_length,
1003
1001
                 null_pos, null_bit_pos,
1004
1002
                 pack_flag,
1005
1003
                 field_type,
1076
1074
      {
1077
1075
        Field *field;
1078
1076
        if (new_field_pack_flag <= 1)
1079
 
          key_part->fieldnr= (uint16) find_field(share->field,
 
1077
          key_part->fieldnr= (uint16_t) find_field(share->field,
1080
1078
                                                 share->default_values,
1081
1079
                                                 (uint) key_part->offset,
1082
1080
                                                 (uint) key_part->length);
1097
1095
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
1098
1096
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
1099
1097
        }
1100
 
        if (field->type() == MYSQL_TYPE_BLOB ||
1101
 
            field->real_type() == MYSQL_TYPE_VARCHAR)
 
1098
        if (field->type() == DRIZZLE_TYPE_BLOB ||
 
1099
            field->real_type() == DRIZZLE_TYPE_VARCHAR)
1102
1100
        {
1103
 
          if (field->type() == MYSQL_TYPE_BLOB)
 
1101
          if (field->type() == DRIZZLE_TYPE_BLOB)
1104
1102
            key_part->key_part_flag|= HA_BLOB_PART;
1105
1103
          else
1106
1104
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
1147
1145
        if (field->key_length() != key_part->length)
1148
1146
        {
1149
1147
#ifndef TO_BE_DELETED_ON_PRODUCTION
1150
 
          if (field->type() == MYSQL_TYPE_NEWDECIMAL)
 
1148
          if (field->type() == DRIZZLE_TYPE_NEWDECIMAL)
1151
1149
          {
1152
1150
            /*
1153
1151
              Fix a fatal error in decimal key handling that causes crashes
1157
1155
              error.
1158
1156
            */
1159
1157
            keyinfo->key_length-= (key_part->length - field->key_length());
1160
 
            key_part->store_length-= (uint16)(key_part->length -
 
1158
            key_part->store_length-= (uint16_t)(key_part->length -
1161
1159
                                              field->key_length());
1162
 
            key_part->length= (uint16)field->key_length();
 
1160
            key_part->length= (uint16_t)field->key_length();
1163
1161
            sql_print_error("Found wrong key definition in %s; "
1164
1162
                            "Please do \"ALTER TABLE '%s' FORCE \" to fix it!",
1165
1163
                            share->table_name.str,
1221
1219
  {
1222
1220
    /* Old file format with default as not null */
1223
1221
    uint null_length= (share->null_fields+7)/8;
1224
 
    bfill(share->default_values + (null_flags - (uchar*) record),
 
1222
    memset(share->default_values + (null_flags - (uchar*) record), 
1225
1223
          null_length, 255);
1226
1224
  }
1227
1225
 
1339
1337
  assert(thd->lex->is_lex_started);
1340
1338
 
1341
1339
  error= 1;
1342
 
  bzero((char*) outparam, sizeof(*outparam));
 
1340
  memset((char*) outparam, 0, sizeof(*outparam));
1343
1341
  outparam->in_use= thd;
1344
1342
  outparam->s= share;
1345
1343
  outparam->db_stat= db_stat;
1547
1545
  }
1548
1546
 
1549
1547
#if defined(HAVE_purify) 
1550
 
  bzero((char*) bitmaps, bitmap_size*3);
 
1548
  memset((char*) bitmaps, 0, bitmap_size*3);
1551
1549
#endif
1552
1550
 
1553
1551
  outparam->no_replicate= outparam->file &&
1563
1561
  delete outparam->file;
1564
1562
  outparam->file= 0;                            // For easier error checking
1565
1563
  outparam->db_stat=0;
1566
 
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on bzero'd root
 
1564
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on zeroed root
1567
1565
  my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));
1568
1566
  return (error);
1569
1567
}
1656
1654
      my_free((uchar*) buf,MYF(0));
1657
1655
  }
1658
1656
  else if (!names)
1659
 
    bzero((char*) save_names,sizeof(save_names));
 
1657
    memset((char*) save_names, 0, sizeof(save_names));
1660
1658
  else
1661
1659
  {
1662
1660
    char *str;
1724
1722
        return(0);
1725
1723
      endpos-=bufflength; bufflength=IO_SIZE;
1726
1724
    }
1727
 
    bzero(buff,IO_SIZE);                        /* Null new block */
 
1725
    memset(buff, 0, IO_SIZE);                   /* Null new block */
1728
1726
    VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
1729
1727
    if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
1730
1728
        return(0L);
2041
2039
  {
2042
2040
    uint key_length, tmp_key_length;
2043
2041
    uint tmp;
2044
 
    bzero((char*) fileinfo,64);
 
2042
    memset((char*) fileinfo, 0, 64);
2045
2043
    /* header */
2046
2044
    fileinfo[0]=(uchar) 254;
2047
2045
    fileinfo[1]= 1;
2110
2108
      61 for default_part_db_type
2111
2109
    */
2112
2110
    int2store(fileinfo+62, create_info->key_block_size);
2113
 
    bzero(fill,IO_SIZE);
 
2111
    memset(fill, 0, IO_SIZE);
2114
2112
    for (; length > IO_SIZE ; length-= IO_SIZE)
2115
2113
    {
2116
2114
      if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
2225
2223
    that are present in this value, returns the length of the value
2226
2224
*/
2227
2225
uint calculate_key_len(TABLE *table, uint key,
2228
 
                       const uchar *buf __attribute__((__unused__)),
 
2226
                       const uchar *buf __attribute__((unused)),
2229
2227
                       key_part_map keypart_map)
2230
2228
{
2231
2229
  /* works only with key prefixes */
2690
2688
 
2691
2689
TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
2692
2690
{
2693
 
  TABLE_LIST *cur_table_ref;
 
2691
  TABLE_LIST *cur_table_ref= NULL;
2694
2692
  NESTED_JOIN *cur_nested_join;
2695
2693
 
2696
2694
  if (is_leaf_for_name_resolution())
2899
2897
  return create_view_field(thd, view, &ptr->item, ptr->name);
2900
2898
}
2901
2899
 
2902
 
Item *create_view_field(THD *thd __attribute__((__unused__)),
 
2900
Item *create_view_field(THD *thd __attribute__((unused)),
2903
2901
                        TABLE_LIST *view, Item **field_ref,
2904
 
                        const char *name __attribute__((__unused__)))
 
2902
                        const char *name __attribute__((unused)))
2905
2903
{
2906
2904
  if (view->schema_table_reformed)
2907
2905
  {
3180
3178
    bitmap_clear_all(&table->def_read_set);
3181
3179
    bitmap_clear_all(&table->def_write_set);
3182
3180
  */
3183
 
  bzero((char*) def_read_set.bitmap, s->column_bitmap_size*2);
 
3181
  memset((char*) def_read_set.bitmap, 0, s->column_bitmap_size*2);
3184
3182
  column_bitmaps_set(&def_read_set, &def_write_set);
3185
3183
}
3186
3184
 
3653
3651
  FRMTYPE_TABLE       table
3654
3652
*/
3655
3653
 
3656
 
frm_type_enum mysql_frm_type(THD *thd __attribute__((__unused__)),
 
3654
frm_type_enum mysql_frm_type(THD *thd __attribute__((unused)),
3657
3655
                             char *path, enum legacy_db_type *dbt)
3658
3656
{
3659
3657
  File file;