← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

Moved m_ctype, m_string and my_bitmap. Removed t_ctype.

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