← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

  • Committer: Olaf van der Spek
  • Date: 2011-10-18 13:52:19 UTC
  • mto: This revision was merged to the branch mainline in revision 2443.
  • Revision ID: olafvdspek@gmail.com-20111018135219-vn5xhy8pvumotthk
Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.cc
56
56
 
57
57
namespace drizzled {
58
58
 
59
 
bool is_primary_key(KeyInfo *key_info)
60
 
{
61
 
  static const char * primary_key_name="PRIMARY";
62
 
  return (strcmp(key_info->name, primary_key_name)==0);
63
 
}
64
 
 
65
 
const char* is_primary_key_name(const char* key_name)
66
 
{
67
 
  static const char * primary_key_name="PRIMARY";
68
 
  if (strcmp(key_name, primary_key_name)==0)
69
 
    return key_name;
70
 
  else
71
 
    return NULL;
 
59
bool is_primary_key(const char* name)
 
60
{
 
61
  return strcmp(name, "PRIMARY") == 0;
72
62
}
73
63
 
74
64
static bool check_if_keyname_exists(const char *name,KeyInfo *start, KeyInfo *end);
75
 
static char *make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end);
76
 
 
 
65
static const char *make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end);
77
66
static bool prepare_blob_field(Session *session, CreateField *sql_field);
78
67
 
79
68
void set_table_default_charset(HA_CREATE_INFO *create_info, const char *db)
83
72
    let's fetch the database default character set and
84
73
    apply it to the table.
85
74
  */
86
 
  identifier::Schema identifier(db);
87
 
  if (create_info->default_table_charset == NULL)
88
 
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier);
 
75
  if (not create_info->default_table_charset)
 
76
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier::Schema(str_ref(db)));
89
77
}
90
78
 
91
79
/*
282
270
      /* Sort NOT NULL keys before other keys */
283
271
      return (a_flags & (HA_NULL_PART_KEY)) ? 1 : -1;
284
272
    }
285
 
    if (is_primary_key(a))
 
273
    if (is_primary_key(a->name))
286
274
      return -1;
287
 
    if (is_primary_key(b))
 
275
    if (is_primary_key(b->name))
288
276
      return 1;
289
277
    /* Sort keys don't containing partial segments before others */
290
278
    if ((a_flags ^ b_flags) & HA_KEY_HAS_PART_KEY_SEG)
818
806
      Foreign_key *fk_key= (Foreign_key*) key;
819
807
 
820
808
      add_foreign_key_to_table_message(&create_proto,
821
 
                                       fk_key->name.str,
 
809
                                       fk_key->name.data(),
822
810
                                       fk_key->columns,
823
811
                                       fk_key->ref_table,
824
812
                                       fk_key->ref_columns,
830
818
          fk_key->ref_columns.size() != fk_key->columns.size())
831
819
      {
832
820
        my_error(ER_WRONG_FK_DEF, MYF(0),
833
 
                 (fk_key->name.str ? fk_key->name.str :
834
 
                                     "foreign key without name"),
 
821
                 (fk_key->name.data() ? fk_key->name.data() : "foreign key without name"),
835
822
                 ER(ER_KEY_REF_DO_NOT_MATCH_TABLE_REF));
836
823
        return true;
837
824
      }
844
831
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
845
832
      return true;
846
833
    }
847
 
    if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))
 
834
    if (check_identifier_name(key->name, ER_TOO_LONG_IDENT))
848
835
      return true;
849
836
    key_iterator2= alter_info->key_list.begin();
850
837
    if (key->type != Key::FOREIGN_KEY)
857
844
          Then we do not need the generated shorter key.
858
845
        */
859
846
        if ((key2->type != Key::FOREIGN_KEY &&
860
 
             key2->name.str != ignore_key &&
 
847
             key2->name.data() != ignore_key &&
861
848
             !foreign_key_prefix(key, key2)))
862
849
        {
863
850
          /* @todo issue warning message */
865
852
          if (!key2->generated ||
866
853
              (key->generated && key->columns.size() <
867
854
               key2->columns.size()))
868
 
            key->name.str= ignore_key;
 
855
            key->name.assign(ignore_key, 1);
869
856
          else
870
857
          {
871
 
            key2->name.str= ignore_key;
 
858
            key2->name.assign(ignore_key, 1);
872
859
            key_parts-= key2->columns.size();
873
860
            (*key_count)--;
874
861
          }
876
863
        }
877
864
      }
878
865
    }
879
 
    if (key->name.str != ignore_key)
 
866
    if (key->name.data() != ignore_key)
880
867
      key_parts+=key->columns.size();
881
868
    else
882
869
      (*key_count)--;
883
 
    if (key->name.str && !tmp_table && (key->type != Key::PRIMARY) &&
884
 
        is_primary_key_name(key->name.str))
 
870
    if (key->name.data() && !tmp_table && (key->type != Key::PRIMARY) && is_primary_key(key->name.data()))
885
871
    {
886
 
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.str);
 
872
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.data());
887
873
      return true;
888
874
    }
889
875
  }
904
890
    uint32_t key_length=0;
905
891
    Key_part_spec *column;
906
892
 
907
 
    if (key->name.str == ignore_key)
 
893
    if (key->name.data() == ignore_key)
908
894
    {
909
895
      /* ignore redundant keys */
910
896
      do
911
897
        key=key_iterator++;
912
 
      while (key && key->name.str == ignore_key);
 
898
      while (key && key->name.data() == ignore_key);
913
899
      if (!key)
914
900
        break;
915
901
    }
934
920
    key_info->algorithm= key->key_create_info.algorithm;
935
921
 
936
922
    uint32_t tmp_len= system_charset_info->cset->charpos(system_charset_info,
937
 
                                           key->key_create_info.comment.str,
938
 
                                           key->key_create_info.comment.str +
939
 
                                           key->key_create_info.comment.length,
 
923
                                           key->key_create_info.comment.begin(),
 
924
                                           key->key_create_info.comment.end(),
940
925
                                           INDEX_COMMENT_MAXLEN);
941
926
 
942
 
    if (tmp_len < key->key_create_info.comment.length)
 
927
    if (tmp_len < key->key_create_info.comment.size())
943
928
    {
944
 
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
945
 
               key->key_create_info.comment.str,"INDEX COMMENT",
946
 
               (uint32_t) INDEX_COMMENT_MAXLEN);
 
929
      my_error(ER_WRONG_STRING_LENGTH, MYF(0), key->key_create_info.comment.data(), "INDEX COMMENT", (uint32_t) INDEX_COMMENT_MAXLEN);
947
930
      return -1;
948
931
    }
949
932
 
950
 
    key_info->comment.length= key->key_create_info.comment.length;
951
 
    if (key_info->comment.length > 0)
 
933
    key_info->comment.assign(key_info->comment.data(), key->key_create_info.comment.size());
 
934
    if (key_info->comment.size() > 0)
952
935
    {
953
936
      key_info->flags|= HA_USES_COMMENT;
954
 
      key_info->comment.str= key->key_create_info.comment.str;
 
937
      key_info->comment.assign(key->key_create_info.comment.data(), key_info->comment.size()); // weird
955
938
    }
956
939
 
957
940
    message::Table::Field *protofield= NULL;
968
951
      field=0;
969
952
      while ((sql_field=it++) && ++proto_field_nr &&
970
953
             my_strcasecmp(system_charset_info,
971
 
                           column->field_name.str,
 
954
                           column->field_name.data(),
972
955
                           sql_field->field_name))
973
956
      {
974
957
        field++;
976
959
 
977
960
      if (!sql_field)
978
961
      {
979
 
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
 
962
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.data());
980
963
        return true;
981
964
      }
982
965
 
983
966
      while ((dup_column= cols2++) != column)
984
967
      {
985
968
        if (!my_strcasecmp(system_charset_info,
986
 
                           column->field_name.str, dup_column->field_name.str))
 
969
                           column->field_name.data(), dup_column->field_name.data()))
987
970
        {
988
971
          my_printf_error(ER_DUP_FIELDNAME,
989
972
                          ER(ER_DUP_FIELDNAME),MYF(0),
990
 
                          column->field_name.str);
 
973
                          column->field_name.data());
991
974
          return true;
992
975
        }
993
976
      }
1003
986
        {
1004
987
          if (! (engine->check_flag(HTON_BIT_CAN_INDEX_BLOBS)))
1005
988
          {
1006
 
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
 
989
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.data());
1007
990
            return true;
1008
991
          }
1009
992
          if (! column->length)
1010
993
          {
1011
 
            my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
 
994
            my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.data());
1012
995
            return true;
1013
996
          }
1014
997
        }
1034
1017
            key_info->flags|= HA_NULL_PART_KEY;
1035
1018
            if (! (engine->check_flag(HTON_BIT_NULL_IN_KEY)))
1036
1019
            {
1037
 
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
 
1020
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.data());
1038
1021
              return true;
1039
1022
            }
1040
1023
          }
1091
1074
      }
1092
1075
      else if (length == 0)
1093
1076
      {
1094
 
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.str);
 
1077
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.data());
1095
1078
          return true;
1096
1079
      }
1097
1080
      if (length > engine->max_key_part_length())
1153
1136
          key_name=pkey_name;
1154
1137
          primary_key=1;
1155
1138
        }
1156
 
        else if (!(key_name= key->name.str))
 
1139
        else if (!(key_name= key->name.data()))
1157
1140
          key_name=make_unique_key_name(sql_field->field_name,
1158
1141
                                        *key_info_buffer, key_info);
1159
1142
        if (check_if_keyname_exists(key_name, *key_info_buffer, key_info))
1555
1538
}
1556
1539
 
1557
1540
 
1558
 
static char *
 
1541
static const char*
1559
1542
make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end)
1560
1543
{
1561
1544
  char buff[MAX_FIELD_NAME],*buff_end;
1562
1545
 
1563
 
  if (!check_if_keyname_exists(field_name,start,end) &&
1564
 
      !is_primary_key_name(field_name))
1565
 
    return (char*) field_name;                  // Use fieldname
 
1546
  if (not check_if_keyname_exists(field_name,start,end) && not is_primary_key(field_name))
 
1547
    return field_name;                  // Use fieldname
1566
1548
 
1567
1549
  buff_end= strncpy(buff, field_name, sizeof(buff)-4);
1568
1550
  buff_end+= strlen(buff);
1823
1805
      {
1824
1806
        session->getClient()->store(table_name.c_str());
1825
1807
        session->getClient()->store(operator_name);
1826
 
        session->getClient()->store(warning_level_names[err->level].str, warning_level_names[err->level].length);
 
1808
        session->getClient()->store(warning_level_names[err->level].data(), warning_level_names[err->level].size());
1827
1809
        session->getClient()->store(err->msg);
1828
1810
        if (session->getClient()->flush())
1829
1811
          goto err;
1963
1945
  }
1964
1946
 
1965
1947
  new_table_message.CopyFrom(*source_table_message);
1966
 
 
1967
 
  if (destination_identifier.isTmp())
1968
 
  {
1969
 
    new_table_message.set_type(message::Table::TEMPORARY);
1970
 
  }
1971
 
  else
1972
 
  {
1973
 
    new_table_message.set_type(message::Table::STANDARD);
1974
 
  }
 
1948
  new_table_message.set_type(destination_identifier.isTmp() ? message::Table::TEMPORARY : message::Table::STANDARD);
1975
1949
 
1976
1950
  if (is_engine_set)
1977
1951
  {
2005
1979
    As mysql_truncate don't work on a new table at this stage of
2006
1980
    creation, instead create the table directly (for both normal and temporary tables).
2007
1981
  */
2008
 
  bool success= plugin::StorageEngine::createTable(session,
2009
 
                                                   destination_identifier,
2010
 
                                                   new_table_message);
 
1982
  bool success= plugin::StorageEngine::createTable(session, destination_identifier, new_table_message);
2011
1983
 
2012
1984
  if (success && not destination_identifier.isTmp())
2013
1985
  {