← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

  • Committer: Mark Atwood
  • Date: 2011-12-16 15:35:52 UTC
  • mfrom: (2472.1.1 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111216153552-0zk0mmf1tt22p92n
merge lp:~brianaker/drizzle/libdrizzle-valgrind-test-warnings

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.cc
73
73
    apply it to the table.
74
74
  */
75
75
  if (not create_info->default_table_charset)
76
 
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier::Schema(db));
 
76
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier::Schema(str_ref(db)));
77
77
}
78
78
 
79
79
/*
685
685
    /* Check if we have used the same field name before */
686
686
    for (dup_no=0; (dup_field=it2++) != sql_field; dup_no++)
687
687
    {
688
 
      if (my_strcasecmp(system_charset_info,
689
 
                        sql_field->field_name,
690
 
                        dup_field->field_name) == 0)
 
688
      if (system_charset_info->strcasecmp(sql_field->field_name, dup_field->field_name) == 0)
691
689
      {
692
690
        /*
693
691
          If this was a CREATE ... SELECT statement, accept a field
806
804
      Foreign_key *fk_key= (Foreign_key*) key;
807
805
 
808
806
      add_foreign_key_to_table_message(&create_proto,
809
 
                                       fk_key->name.str,
 
807
                                       fk_key->name.data(),
810
808
                                       fk_key->columns,
811
809
                                       fk_key->ref_table,
812
810
                                       fk_key->ref_columns,
818
816
          fk_key->ref_columns.size() != fk_key->columns.size())
819
817
      {
820
818
        my_error(ER_WRONG_FK_DEF, MYF(0),
821
 
                 (fk_key->name.str ? fk_key->name.str :
822
 
                                     "foreign key without name"),
 
819
                 (fk_key->name.data() ? fk_key->name.data() : "foreign key without name"),
823
820
                 ER(ER_KEY_REF_DO_NOT_MATCH_TABLE_REF));
824
821
        return true;
825
822
      }
832
829
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
833
830
      return true;
834
831
    }
835
 
    if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))
 
832
    if (check_identifier_name(key->name, ER_TOO_LONG_IDENT))
836
833
      return true;
837
834
    key_iterator2= alter_info->key_list.begin();
838
835
    if (key->type != Key::FOREIGN_KEY)
845
842
          Then we do not need the generated shorter key.
846
843
        */
847
844
        if ((key2->type != Key::FOREIGN_KEY &&
848
 
             key2->name.str != ignore_key &&
 
845
             key2->name.data() != ignore_key &&
849
846
             !foreign_key_prefix(key, key2)))
850
847
        {
851
848
          /* @todo issue warning message */
853
850
          if (!key2->generated ||
854
851
              (key->generated && key->columns.size() <
855
852
               key2->columns.size()))
856
 
            key->name.str= ignore_key;
 
853
            key->name.assign(ignore_key, 1);
857
854
          else
858
855
          {
859
 
            key2->name.str= ignore_key;
 
856
            key2->name.assign(ignore_key, 1);
860
857
            key_parts-= key2->columns.size();
861
858
            (*key_count)--;
862
859
          }
864
861
        }
865
862
      }
866
863
    }
867
 
    if (key->name.str != ignore_key)
 
864
    if (key->name.data() != ignore_key)
868
865
      key_parts+=key->columns.size();
869
866
    else
870
867
      (*key_count)--;
871
 
    if (key->name.str && !tmp_table && (key->type != Key::PRIMARY) && is_primary_key(key->name.str))
 
868
    if (key->name.data() && !tmp_table && (key->type != Key::PRIMARY) && is_primary_key(key->name.data()))
872
869
    {
873
 
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.str);
 
870
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key->name.data());
874
871
      return true;
875
872
    }
876
873
  }
891
888
    uint32_t key_length=0;
892
889
    Key_part_spec *column;
893
890
 
894
 
    if (key->name.str == ignore_key)
 
891
    if (key->name.data() == ignore_key)
895
892
    {
896
893
      /* ignore redundant keys */
897
894
      do
898
895
        key=key_iterator++;
899
 
      while (key && key->name.str == ignore_key);
 
896
      while (key && key->name.data() == ignore_key);
900
897
      if (!key)
901
898
        break;
902
899
    }
921
918
    key_info->algorithm= key->key_create_info.algorithm;
922
919
 
923
920
    uint32_t tmp_len= system_charset_info->cset->charpos(system_charset_info,
924
 
                                           key->key_create_info.comment.str,
925
 
                                           key->key_create_info.comment.str +
926
 
                                           key->key_create_info.comment.length,
 
921
                                           key->key_create_info.comment.begin(),
 
922
                                           key->key_create_info.comment.end(),
927
923
                                           INDEX_COMMENT_MAXLEN);
928
924
 
929
 
    if (tmp_len < key->key_create_info.comment.length)
 
925
    if (tmp_len < key->key_create_info.comment.size())
930
926
    {
931
 
      my_error(ER_WRONG_STRING_LENGTH, MYF(0),
932
 
               key->key_create_info.comment.str,"INDEX COMMENT",
933
 
               (uint32_t) INDEX_COMMENT_MAXLEN);
 
927
      my_error(ER_WRONG_STRING_LENGTH, MYF(0), key->key_create_info.comment.data(), "INDEX COMMENT", (uint32_t) INDEX_COMMENT_MAXLEN);
934
928
      return -1;
935
929
    }
936
930
 
937
 
    key_info->comment.length= key->key_create_info.comment.length;
938
 
    if (key_info->comment.length > 0)
 
931
    key_info->comment.assign(key_info->comment.data(), key->key_create_info.comment.size());
 
932
    if (key_info->comment.size() > 0)
939
933
    {
940
934
      key_info->flags|= HA_USES_COMMENT;
941
 
      key_info->comment.str= key->key_create_info.comment.str;
 
935
      key_info->comment.assign(key->key_create_info.comment.data(), key_info->comment.size()); // weird
942
936
    }
943
937
 
944
938
    message::Table::Field *protofield= NULL;
954
948
      it= alter_info->create_list.begin();
955
949
      field=0;
956
950
      while ((sql_field=it++) && ++proto_field_nr &&
957
 
             my_strcasecmp(system_charset_info,
958
 
                           column->field_name.str,
959
 
                           sql_field->field_name))
 
951
             system_charset_info->strcasecmp(column->field_name.data(), sql_field->field_name))
960
952
      {
961
 
        field++;
 
953
        field++;
962
954
      }
963
955
 
964
956
      if (!sql_field)
965
957
      {
966
 
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
 
958
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.data());
967
959
        return true;
968
960
      }
969
961
 
970
962
      while ((dup_column= cols2++) != column)
971
963
      {
972
 
        if (!my_strcasecmp(system_charset_info,
973
 
                           column->field_name.str, dup_column->field_name.str))
 
964
        if (!system_charset_info->strcasecmp(column->field_name.data(), dup_column->field_name.data()))
974
965
        {
975
966
          my_printf_error(ER_DUP_FIELDNAME,
976
967
                          ER(ER_DUP_FIELDNAME),MYF(0),
977
 
                          column->field_name.str);
 
968
                          column->field_name.data());
978
969
          return true;
979
970
        }
980
971
      }
990
981
        {
991
982
          if (! (engine->check_flag(HTON_BIT_CAN_INDEX_BLOBS)))
992
983
          {
993
 
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
 
984
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.data());
994
985
            return true;
995
986
          }
996
987
          if (! column->length)
997
988
          {
998
 
            my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.str);
 
989
            my_error(ER_BLOB_KEY_WITHOUT_LENGTH, MYF(0), column->field_name.data());
999
990
            return true;
1000
991
          }
1001
992
        }
1021
1012
            key_info->flags|= HA_NULL_PART_KEY;
1022
1013
            if (! (engine->check_flag(HTON_BIT_NULL_IN_KEY)))
1023
1014
            {
1024
 
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
 
1015
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.data());
1025
1016
              return true;
1026
1017
            }
1027
1018
          }
1078
1069
      }
1079
1070
      else if (length == 0)
1080
1071
      {
1081
 
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.str);
 
1072
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.data());
1082
1073
          return true;
1083
1074
      }
1084
1075
      if (length > engine->max_key_part_length())
1140
1131
          key_name=pkey_name;
1141
1132
          primary_key=1;
1142
1133
        }
1143
 
        else if (!(key_name= key->name.str))
 
1134
        else if (!(key_name= key->name.data()))
1144
1135
          key_name=make_unique_key_name(sql_field->field_name,
1145
1136
                                        *key_info_buffer, key_info);
1146
1137
        if (check_if_keyname_exists(key_name, *key_info_buffer, key_info))
1535
1526
static bool
1536
1527
check_if_keyname_exists(const char *name, KeyInfo *start, KeyInfo *end)
1537
1528
{
1538
 
  for (KeyInfo *key=start ; key != end ; key++)
1539
 
    if (!my_strcasecmp(system_charset_info,name,key->name))
 
1529
  for (KeyInfo *key= start; key != end; key++)
 
1530
  {
 
1531
    if (!system_charset_info->strcasecmp(name, key->name))
1540
1532
      return 1;
 
1533
  }
1541
1534
  return 0;
1542
1535
}
1543
1536
 
1809
1802
      {
1810
1803
        session->getClient()->store(table_name.c_str());
1811
1804
        session->getClient()->store(operator_name);
1812
 
        session->getClient()->store(warning_level_names[err->level].str, warning_level_names[err->level].length);
 
1805
        session->getClient()->store(warning_level_names[err->level].data(), warning_level_names[err->level].size());
1813
1806
        session->getClient()->store(err->msg);
1814
1807
        if (session->getClient()->flush())
1815
1808
          goto err;