← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.cc
16
16
/* drop and alter of tables */
17
17
 
18
18
#include "mysql_priv.h"
19
 
#include <hash.h>
20
 
#include <myisam.h>
21
 
#include <my_dir.h>
 
19
#include <mysys/hash.h>
 
20
#include <storage/myisam/myisam.h>
22
21
#include "sql_show.h"
23
22
 
24
23
int creating_table= 0;        // How many mysql_create_table are running
732
731
    void
733
732
*/
734
733
void calculate_interval_lengths(CHARSET_INFO *cs, TYPELIB *interval,
735
 
                                uint32 *max_length, uint32 *tot_length)
 
734
                                uint32_t *max_length, uint32_t *tot_length)
736
735
{
737
736
  const char **pos;
738
737
  uint *len;
742
741
  {
743
742
    uint length= cs->cset->numchars(cs, *pos, *pos + *len);
744
743
    *tot_length+= length;
745
 
    set_if_bigger(*max_length, (uint32)length);
 
744
    set_if_bigger(*max_length, (uint32_t)length);
746
745
  }
747
746
}
748
747
 
769
768
int prepare_create_field(Create_field *sql_field, 
770
769
                         uint *blob_columns,
771
770
                         int *timestamps, int *timestamps_with_niladic,
772
 
                         int64_t table_flags __attribute__((__unused__)))
 
771
                         int64_t table_flags __attribute__((unused)))
773
772
{
774
773
  unsigned int dup_val_count;
775
774
 
780
779
  assert(sql_field->charset);
781
780
 
782
781
  switch (sql_field->sql_type) {
783
 
  case MYSQL_TYPE_BLOB:
 
782
  case DRIZZLE_TYPE_BLOB:
784
783
    sql_field->pack_flag=FIELDFLAG_BLOB |
785
784
      pack_length_to_packflag(sql_field->pack_length -
786
785
                              portable_sizeof_char_ptr);
790
789
    sql_field->unireg_check=Field::BLOB_FIELD;
791
790
    (*blob_columns)++;
792
791
    break;
793
 
  case MYSQL_TYPE_VARCHAR:
794
 
  case MYSQL_TYPE_STRING:
 
792
  case DRIZZLE_TYPE_VARCHAR:
 
793
  case DRIZZLE_TYPE_STRING:
795
794
    sql_field->pack_flag=0;
796
795
    if (sql_field->charset->state & MY_CS_BINSORT)
797
796
      sql_field->pack_flag|=FIELDFLAG_BINARY;
798
797
    break;
799
 
  case MYSQL_TYPE_ENUM:
 
798
  case DRIZZLE_TYPE_ENUM:
800
799
    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
801
800
      FIELDFLAG_INTERVAL;
802
801
    if (sql_field->charset->state & MY_CS_BINSORT)
807
806
                                     sql_field->charset, &dup_val_count))
808
807
      return(1);
809
808
    break;
810
 
  case MYSQL_TYPE_SET:
 
809
  case DRIZZLE_TYPE_SET:
811
810
    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length) |
812
811
      FIELDFLAG_BITFIELD;
813
812
    if (sql_field->charset->state & MY_CS_BINSORT)
824
823
       return(1);
825
824
    }
826
825
    break;
827
 
  case MYSQL_TYPE_NEWDATE:  // Rest of string types
828
 
  case MYSQL_TYPE_TIME:
829
 
  case MYSQL_TYPE_DATETIME:
830
 
  case MYSQL_TYPE_NULL:
 
826
  case DRIZZLE_TYPE_NEWDATE:  // Rest of string types
 
827
  case DRIZZLE_TYPE_TIME:
 
828
  case DRIZZLE_TYPE_DATETIME:
 
829
  case DRIZZLE_TYPE_NULL:
831
830
    sql_field->pack_flag=f_settype((uint) sql_field->sql_type);
832
831
    break;
833
 
  case MYSQL_TYPE_NEWDECIMAL:
 
832
  case DRIZZLE_TYPE_NEWDECIMAL:
834
833
    sql_field->pack_flag=(FIELDFLAG_NUMBER |
835
834
                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
836
835
                           FIELDFLAG_DECIMAL) |
837
 
                          (sql_field->flags & ZEROFILL_FLAG ?
838
 
                           FIELDFLAG_ZEROFILL : 0) |
 
836
                          (sql_field->flags & DECIMAL_FLAG ?  FIELDFLAG_DECIMAL_POSITION : 0) |
839
837
                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
840
838
    break;
841
 
  case MYSQL_TYPE_TIMESTAMP:
 
839
  case DRIZZLE_TYPE_TIMESTAMP:
842
840
    /* We should replace old TIMESTAMP fields with their newer analogs */
843
841
    if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
844
842
    {
859
857
    sql_field->pack_flag=(FIELDFLAG_NUMBER |
860
858
                          (sql_field->flags & UNSIGNED_FLAG ? 0 :
861
859
                           FIELDFLAG_DECIMAL) |
862
 
                          (sql_field->flags & ZEROFILL_FLAG ?
863
 
                           FIELDFLAG_ZEROFILL : 0) |
864
860
                          f_settype((uint) sql_field->sql_type) |
865
861
                          (sql_field->decimals << FIELDFLAG_DEC_SHIFT));
866
862
    break;
963
959
    */
964
960
    if (sql_field->def && 
965
961
        save_cs != sql_field->def->collation.collation &&
966
 
        (sql_field->sql_type == MYSQL_TYPE_VAR_STRING ||
967
 
         sql_field->sql_type == MYSQL_TYPE_STRING ||
968
 
         sql_field->sql_type == MYSQL_TYPE_SET ||
969
 
         sql_field->sql_type == MYSQL_TYPE_ENUM))
 
962
        (sql_field->sql_type == DRIZZLE_TYPE_VAR_STRING ||
 
963
         sql_field->sql_type == DRIZZLE_TYPE_STRING ||
 
964
         sql_field->sql_type == DRIZZLE_TYPE_SET ||
 
965
         sql_field->sql_type == DRIZZLE_TYPE_ENUM))
970
966
    {
971
967
      /*
972
968
        Starting from 5.1 we work here with a copy of Create_field
988
984
      }
989
985
    }
990
986
 
991
 
    if (sql_field->sql_type == MYSQL_TYPE_SET ||
992
 
        sql_field->sql_type == MYSQL_TYPE_ENUM)
 
987
    if (sql_field->sql_type == DRIZZLE_TYPE_SET ||
 
988
        sql_field->sql_type == DRIZZLE_TYPE_ENUM)
993
989
    {
994
 
      uint32 dummy;
 
990
      uint32_t dummy;
995
991
      CHARSET_INFO *cs= sql_field->charset;
996
992
      TYPELIB *interval= sql_field->interval;
997
993
 
1034
1030
                                       interval->type_lengths[i]);
1035
1031
          interval->type_lengths[i]= lengthsp;
1036
1032
          ((uchar *)interval->type_names[i])[lengthsp]= '\0';
1037
 
          if (sql_field->sql_type == MYSQL_TYPE_SET)
 
1033
          if (sql_field->sql_type == DRIZZLE_TYPE_SET)
1038
1034
          {
1039
1035
            if (cs->coll->instr(cs, interval->type_names[i], 
1040
1036
                                interval->type_lengths[i], 
1048
1044
        sql_field->interval_list.empty(); // Don't need interval_list anymore
1049
1045
      }
1050
1046
 
1051
 
      if (sql_field->sql_type == MYSQL_TYPE_SET)
 
1047
      if (sql_field->sql_type == DRIZZLE_TYPE_SET)
1052
1048
      {
1053
 
        uint32 field_length;
 
1049
        uint32_t field_length;
1054
1050
        if (sql_field->def != NULL)
1055
1051
        {
1056
1052
          char *not_used;
1084
1080
        calculate_interval_lengths(cs, interval, &dummy, &field_length);
1085
1081
        sql_field->length= field_length + (interval->count - 1);
1086
1082
      }
1087
 
      else  /* MYSQL_TYPE_ENUM */
 
1083
      else  /* DRIZZLE_TYPE_ENUM */
1088
1084
      {
1089
 
        uint32 field_length;
1090
 
        assert(sql_field->sql_type == MYSQL_TYPE_ENUM);
 
1085
        uint32_t field_length;
 
1086
        assert(sql_field->sql_type == DRIZZLE_TYPE_ENUM);
1091
1087
        if (sql_field->def != NULL)
1092
1088
        {
1093
1089
          String str, *def= sql_field->def->val_str(&str);
1177
1173
    }
1178
1174
    /* Don't pack rows in old tables if the user has requested this */
1179
1175
    if ((sql_field->flags & BLOB_FLAG) ||
1180
 
        (sql_field->sql_type == MYSQL_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
 
1176
        (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
1181
1177
      (*db_options)|= HA_OPTION_PACK_RECORD;
1182
1178
    it2.rewind();
1183
1179
  }
1195
1191
                             &timestamps, &timestamps_with_niladic,
1196
1192
                             file->ha_table_flags()))
1197
1193
      return(true);
1198
 
    if (sql_field->sql_type == MYSQL_TYPE_VARCHAR)
 
1194
    if (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)
1199
1195
      create_info->varchar= true;
1200
1196
    sql_field->offset= record_offset;
1201
1197
    if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1352
1348
    if (key->generated)
1353
1349
      key_info->flags|= HA_GENERATED_KEY;
1354
1350
 
1355
 
    key_info->key_parts=(uint8) key->columns.elements;
 
1351
    key_info->key_parts=(uint8_t) key->columns.elements;
1356
1352
    key_info->key_part=key_part_info;
1357
1353
    key_info->usable_key_parts= key_number;
1358
1354
    key_info->algorithm= key->key_create_info.algorithm;
1463
1459
      }
1464
1460
 
1465
1461
      key_part_info->fieldnr= field;
1466
 
      key_part_info->offset=  (uint16) sql_field->offset;
 
1462
      key_part_info->offset=  (uint16_t) sql_field->offset;
1467
1463
      key_part_info->key_type=sql_field->pack_flag;
1468
1464
      length= sql_field->key_length;
1469
1465
 
1531
1527
          return(true);
1532
1528
        }
1533
1529
      }
1534
 
      key_part_info->length=(uint16) length;
 
1530
      key_part_info->length=(uint16_t) length;
1535
1531
      /* Use packed keys for long strings on the first column */
1536
1532
      if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&
1537
1533
          (length >= KEY_DEFAULT_PACK_LENGTH &&
1538
 
           (sql_field->sql_type == MYSQL_TYPE_STRING ||
1539
 
            sql_field->sql_type == MYSQL_TYPE_VARCHAR ||
 
1534
           (sql_field->sql_type == DRIZZLE_TYPE_STRING ||
 
1535
            sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||
1540
1536
            sql_field->pack_flag & FIELDFLAG_BLOB)))
1541
1537
      {
1542
1538
        if ((column_nr == 0 && (sql_field->pack_flag & FIELDFLAG_BLOB)) ||
1543
 
            sql_field->sql_type == MYSQL_TYPE_VARCHAR)
 
1539
            sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)
1544
1540
          key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
1545
1541
        else
1546
1542
          key_info->flags|= HA_PACK_KEY;
1584
1580
    }
1585
1581
    if (!(key_info->flags & HA_NULL_PART_KEY))
1586
1582
      unique_key=1;
1587
 
    key_info->key_length=(uint16) key_length;
 
1583
    key_info->key_length=(uint16_t) key_length;
1588
1584
    if (key_length > max_key_length)
1589
1585
    {
1590
1586
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
1616
1612
 
1617
1613
    if (thd->variables.sql_mode & MODE_NO_ZERO_DATE &&
1618
1614
        !sql_field->def &&
1619
 
        sql_field->sql_type == MYSQL_TYPE_TIMESTAMP &&
 
1615
        sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&
1620
1616
        (sql_field->flags & NOT_NULL_FLAG) &&
1621
1617
        (type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))
1622
1618
    {
1688
1684
        In this case the error is given
1689
1685
*/
1690
1686
 
1691
 
static bool prepare_blob_field(THD *thd __attribute__((__unused__)),
 
1687
static bool prepare_blob_field(THD *thd __attribute__((unused)),
1692
1688
                               Create_field *sql_field)
1693
1689
{
1694
1690
 
1702
1698
    
1703
1699
  if ((sql_field->flags & BLOB_FLAG) && sql_field->length)
1704
1700
  {
1705
 
    if (sql_field->sql_type == MYSQL_TYPE_BLOB)
 
1701
    if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
1706
1702
    {
1707
1703
      /* The user has given a length to the blob column */
1708
1704
      sql_field->sql_type= get_blob_type_from_length(sql_field->length);
1731
1727
 
1732
1728
void sp_prepare_create_field(THD *thd, Create_field *sql_field)
1733
1729
{
1734
 
  if (sql_field->sql_type == MYSQL_TYPE_SET ||
1735
 
      sql_field->sql_type == MYSQL_TYPE_ENUM)
 
1730
  if (sql_field->sql_type == DRIZZLE_TYPE_SET ||
 
1731
      sql_field->sql_type == DRIZZLE_TYPE_ENUM)
1736
1732
  {
1737
 
    uint32 field_length, dummy;
1738
 
    if (sql_field->sql_type == MYSQL_TYPE_SET)
 
1733
    uint32_t field_length, dummy;
 
1734
    if (sql_field->sql_type == DRIZZLE_TYPE_SET)
1739
1735
    {
1740
1736
      calculate_interval_lengths(sql_field->charset,
1741
1737
                                 sql_field->interval, &dummy, 
1743
1739
      sql_field->length= field_length + 
1744
1740
                         (sql_field->interval->count - 1);
1745
1741
    }
1746
 
    else /* MYSQL_TYPE_ENUM */
 
1742
    else /* DRIZZLE_TYPE_ENUM */
1747
1743
    {
1748
1744
      calculate_interval_lengths(sql_field->charset,
1749
1745
                                 sql_field->interval,
2924
2920
    0     ok
2925
2921
*/
2926
2922
 
2927
 
int reassign_keycache_tables(THD *thd __attribute__((__unused__)),
 
2923
int reassign_keycache_tables(THD *thd __attribute__((unused)),
2928
2924
                             KEY_CACHE *src_cache,
2929
2925
                             KEY_CACHE *dst_cache)
2930
2926
{
2957
2953
  uint keys= schema_table->table->s->keys;
2958
2954
  uint db_options= 0;
2959
2955
 
2960
 
  bzero((char*) &local_create_info, sizeof(local_create_info));
 
2956
  memset((char*) &local_create_info, 0, sizeof(local_create_info));
2961
2957
  local_create_info.db_type= schema_table->table->s->db_type();
2962
2958
  local_create_info.row_type= schema_table->table->s->row_type;
2963
2959
  local_create_info.default_table_charset=default_charset_info;
3487
3483
    /* Don't pack rows in old tables if the user has requested this. */
3488
3484
    if (create_info->row_type == ROW_TYPE_DYNAMIC ||
3489
3485
        (new_field->flags & BLOB_FLAG) ||
3490
 
        (new_field->sql_type == MYSQL_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
 
3486
        (new_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
3491
3487
      create_info->table_options|= HA_OPTION_PACK_RECORD;
3492
3488
 
3493
3489
    /* Check how fields have been modified */
4100
4096
  Field **f_ptr,*field;
4101
4097
  for (f_ptr=table->field ; (field= *f_ptr) ; f_ptr++)
4102
4098
    {
4103
 
    if (field->type() == MYSQL_TYPE_STRING)
 
4099
    if (field->type() == DRIZZLE_TYPE_STRING)
4104
4100
      create_info->varchar= true;
4105
4101
    /* Check if field should be dropped */
4106
4102
    Alter_drop *drop;
4159
4155
        }
4160
4156
      if (alter)
4161
4157
        {
4162
 
        if (def->sql_type == MYSQL_TYPE_BLOB)
 
4158
        if (def->sql_type == DRIZZLE_TYPE_BLOB)
4163
4159
        {
4164
4160
          my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);
4165
4161
          goto err;
4187
4183
      If the '0000-00-00' value isn't allowed then raise the error_if_not_empty
4188
4184
      flag to allow ALTER TABLE only if the table to be altered is empty.
4189
4185
      */
4190
 
    if ((def->sql_type == MYSQL_TYPE_NEWDATE ||
4191
 
         def->sql_type == MYSQL_TYPE_DATETIME) &&
 
4186
    if ((def->sql_type == DRIZZLE_TYPE_NEWDATE ||
 
4187
         def->sql_type == DRIZZLE_TYPE_DATETIME) &&
4192
4188
         !alter_info->datetime_field &&
4193
4189
         !(~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)) &&
4194
4190
         thd->variables.sql_mode & MODE_NO_ZERO_DATE)
4324
4320
      KEY_CREATE_INFO key_create_info;
4325
4321
      Key *key;
4326
4322
      enum Key::Keytype key_type;
4327
 
      bzero((char*) &key_create_info, sizeof(key_create_info));
 
4323
      memset((char*) &key_create_info, 0, sizeof(key_create_info));
4328
4324
 
4329
4325
      key_create_info.algorithm= key_info->algorithm;
4330
4326
      if (key_info->flags & HA_USES_BLOCK_SIZE)
4899
4895
  if (table->s->tmp_table)
4900
4896
  {
4901
4897
    TABLE_LIST tbl;
4902
 
    bzero((void*) &tbl, sizeof(tbl));
 
4898
    memset((void*) &tbl, 0, sizeof(tbl));
4903
4899
    tbl.db= new_db;
4904
4900
    tbl.table_name= tbl.alias= tmp_name;
4905
4901
    /* Table is in thd->temporary_tables */
5145
5141
    enum enum_mysql_timestamp_type t_type= MYSQL_TIMESTAMP_DATE;
5146
5142
    switch (alter_info->datetime_field->sql_type)
5147
5143
    {
5148
 
      case MYSQL_TYPE_NEWDATE:
 
5144
      case DRIZZLE_TYPE_NEWDATE:
5149
5145
        f_val= "0000-00-00";
5150
5146
        t_type= MYSQL_TIMESTAMP_DATE;
5151
5147
        break;
5152
 
      case MYSQL_TYPE_DATETIME:
 
5148
      case DRIZZLE_TYPE_DATETIME:
5153
5149
        f_val= "0000-00-00 00:00:00";
5154
5150
        t_type= MYSQL_TIMESTAMP_DATETIME;
5155
5151
        break;
5280
5276
    {
5281
5277
      from->sort.io_cache=(IO_CACHE*) my_malloc(sizeof(IO_CACHE),
5282
5278
                                                MYF(MY_FAE | MY_ZEROFILL));
5283
 
      bzero((char *) &tables, sizeof(tables));
 
5279
      memset((char *) &tables, 0, sizeof(tables));
5284
5280
      tables.table= from;
5285
5281
      tables.alias= tables.table_name= from->s->table_name.str;
5286
5282
      tables.db= from->s->db.str;
5426
5422
  */
5427
5423
  table_list->table= NULL;
5428
5424
 
5429
 
  bzero((char*) &create_info, sizeof(create_info));
 
5425
  memset((char*) &create_info, 0, sizeof(create_info));
5430
5426
  create_info.row_type=ROW_TYPE_NOT_USED;
5431
5427
  create_info.default_table_charset=default_charset_info;
5432
5428
  /* Force alter table to recreate table */
5517
5513
            for (uint i= 0; i < t->s->fields; i++ )
5518
5514
            {
5519
5515
              Field *f= t->field[i];
5520
 
              if ((f->type() == MYSQL_TYPE_BLOB) ||
5521
 
                  (f->type() == MYSQL_TYPE_VARCHAR))
 
5516
              if ((f->type() == DRIZZLE_TYPE_BLOB) ||
 
5517
                  (f->type() == DRIZZLE_TYPE_VARCHAR))
5522
5518
              {
5523
5519
                String tmp;
5524
5520
                f->val_str(&tmp);