25 #include <drizzled/error.h>
26 #include <drizzled/charset.h>
27 #include <drizzled/field.h>
28 #include <drizzled/table.h>
29 #include <drizzled/field/varstring.h>
30 #include <drizzled/internal/my_sys.h>
40 #include "ha_innodb.h"
51 const unsigned char* data,
56 unsigned char* dest = field->
ptr;
66 for (ptr = dest + len; ptr != dest; ) {
70 if (!(field->flags & UNSIGNED_FLAG)) {
71 ((byte*) dest)[len - 1] ^= 0x80;
81 if (field->type() == DRIZZLE_TYPE_VARCHAR) {
87 dest, len, flen - field->key_length());
91 memcpy(dest, data, len);
108 memcpy(dest, data, len);
127 memcpy(dest, data, len);
140 const ulint* offsets)
143 uint n_fields = table->getShare()->sizeFields();
148 for (i = 0; i < n_fields; i++) {
149 Field* field = table->getField(i);
152 const unsigned char* ifield;
156 ipos = dict_index_get_nth_col_pos(index, i);
158 if (UNIV_UNLIKELY(ipos == ULINT_UNDEFINED)) {
164 ifield = rec_get_nth_field(rec, offsets, ipos, &ilen);
167 if (ilen == UNIV_SQL_NULL) {
168 ut_ad(field->real_maybe_null());
172 field->set_notnull();
176 dict_index_get_nth_field(index, ipos)),
177 ifield, ilen, field);
189 uint n_fields = table->getShare()->sizeFields();
192 for (i = 0; i < n_fields; i++) {
193 table->getField(i)->set_default();
197 #if 0 // This is a part of the fast index code.
202 innobase_convert_tablename(
207 char* slash = strchr(s,
'/');
213 strncpy(s, s, slash - s + 1);
221 strncpy(t, slash, slash - t + strlen(slash));
231 innobase_check_index_keys(
243 for (key_num = 0; key_num < num_of_keys; key_num++) {
244 const KeyInfo& key = key_info[key_num];
249 for (ulint i = 0; i < key_num; i++) {
250 const KeyInfo& key2 = key_info[i];
252 if (0 == strcmp(key.name, key2.name)) {
253 my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0),
256 return(ER_WRONG_NAME_FOR_INDEX);
263 = dict_table_get_first_index(table);
264 index; index = dict_table_get_next_index(index)) {
266 if (0 == strcmp(key.name, index->
name)) {
267 my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0),
270 return(ER_WRONG_NAME_FOR_INDEX);
278 for (ulint i = 0; i < key.key_parts; i++) {
286 &is_unsigned, field)) {
293 if (field->type() == DRIZZLE_TYPE_VARCHAR) {
307 my_error(ER_WRONG_KEY_COLUMN, MYF(0),
309 return(ER_WRONG_KEY_COLUMN);
312 for (ulint j = 0; j < i; j++) {
321 my_error(ER_WRONG_KEY_COLUMN, MYF(0),
323 return(ER_WRONG_KEY_COLUMN);
335 innobase_create_index_field_def(
349 field = key_part->field;
354 if (DATA_BLOB == col_type
356 && field->type() != DRIZZLE_TYPE_VARCHAR)
357 || (field->type() == DRIZZLE_TYPE_VARCHAR
375 innobase_create_index_def(
389 ulint n_fields = key->key_parts;
393 heap, n_fields *
sizeof *index->
fields);
397 len = strlen(key->name) + 1;
401 if (UNIV_LIKELY(!new_primary)) {
405 memcpy(index_name, key->name, len);
407 if (key->flags & HA_NOSAME) {
415 for (i = 0; i < n_fields; i++) {
416 innobase_create_index_field_def(&key->key_part[i], heap,
427 innobase_copy_index_field_def(
432 assert(field != NULL);
433 assert(index_field != NULL);
445 innobase_copy_index_def(
461 heap, n_fields *
sizeof *new_index->
fields);
469 for (i = 0; i < n_fields; i++) {
470 innobase_copy_index_field_def(&index->
fields[i],
497 innobase_create_key_def(
519 new_primary = !system_charset_info->strcasecmp(key_info->name,
"PRIMARY");
526 if (!new_primary && (key_info->flags & HA_NOSAME)
527 && (!(key_info->flags & HA_KEY_HAS_PART_KEY_SEG))
529 uint key_part = key_info->key_parts;
534 if (key_info->key_part[key_part].null_bit == 0) {
545 innobase_create_index_def(&key_info[i++], TRUE, TRUE,
548 row_mysql_lock_data_dictionary(trx);
550 index = dict_table_get_first_index(table);
558 || !system_charset_info->strcasecmp(index->
name,
"PRIMARY"))
560 index = dict_table_get_next_index(index);
564 innobase_copy_index_def(index, indexdef++, heap);
565 index = dict_table_get_next_index(index);
574 innobase_create_index_def(&key_info[i++], new_primary, FALSE,
578 n_keys = indexdef - indexdefs;
588 innobase_create_temporary_tablename(
592 const char* table_name)
596 static const char suffix[] =
"@0023 ";
598 len = strlen(table_name);
601 memcpy(name, table_name, len);
602 memcpy(name + len, suffix,
sizeof suffix);
603 name[len + (
sizeof suffix - 2)] =
id;
614 ha_innobase::add_index(
628 ulint num_created = 0;
629 ibool dict_locked = FALSE;
637 if (srv_created_new_raw || srv_force_recovery) {
638 return(HA_ERR_WRONG_COMMAND);
655 innodb_table = indexed_table
658 if (UNIV_UNLIKELY(!innodb_table)) {
659 error = HA_ERR_NO_SUCH_TABLE;
664 if (innobase_index_name_is_reserved(trx, key_info, num_of_keys)) {
668 error = innobase_check_index_keys(key_info, num_of_keys,
672 if (UNIV_UNLIKELY(error)) {
685 num_of_idx = num_of_keys;
687 index_defs = innobase_create_key_def(
688 trx, innodb_table, heap, key_info, num_of_idx);
695 heap, num_of_idx *
sizeof *index);
703 new_primary ? LOCK_X : LOCK_S);
705 if (UNIV_UNLIKELY(error != DB_SUCCESS)) {
713 row_mysql_lock_data_dictionary(trx);
716 ut_d(dict_table_check_for_dup_indexes(innodb_table, FALSE));
721 if (UNIV_UNLIKELY(new_primary)) {
726 char* new_table_name = innobase_create_temporary_tablename(
727 heap,
'1', innodb_table->
name);
732 new_table_name, index_defs, innodb_table, trx);
734 if (!indexed_table) {
737 case DB_TABLESPACE_ALREADY_EXISTS:
738 case DB_DUPLICATE_KEY:
739 innobase_convert_tablename(new_table_name);
740 my_error(HA_ERR_TABLE_EXIST, MYF(0),
742 error = HA_ERR_TABLE_EXIST;
750 ut_d(dict_table_check_for_dup_indexes(innodb_table,
761 for (ulint i = 0; i < num_of_idx; i++) {
774 ut_ad(error == DB_SUCCESS);
790 if (UNIV_UNLIKELY(new_primary)) {
793 ut_ad(indexed_table != innodb_table);
798 if (UNIV_UNLIKELY(error != DB_SUCCESS)) {
807 innodb_table, indexed_table,
808 index, num_of_idx, i_table);
816 const char* old_name;
820 row_mysql_lock_data_dictionary(trx);
828 if (error != DB_SUCCESS) {
840 old_name = innodb_table->
name;
841 tmp_name = innobase_create_temporary_tablename(heap,
'2',
847 if (error != DB_SUCCESS) {
852 case DB_TABLESPACE_ALREADY_EXISTS:
853 case DB_DUPLICATE_KEY:
854 innobase_convert_tablename(tmp_name);
855 my_error(HA_ERR_TABLE_EXIST, MYF(0), tmp_name);
856 error = HA_ERR_TABLE_EXIST;
871 innodb_table = indexed_table;
874 case DB_TOO_BIG_RECORD:
875 my_error(HA_ERR_TO_BIG_ROW, MYF(0));
877 case DB_PRIMARY_KEY_IS_NULL:
878 my_error(ER_PRIMARY_CANT_HAVE_NULL, MYF(0));
880 case DB_DUPLICATE_KEY:
888 if (indexed_table != innodb_table) {
893 row_mysql_lock_data_dictionary(trx);
902 if (error == DB_SUCCESS) {
922 ut_d(dict_table_check_for_dup_indexes(innodb_table, FALSE));
939 ha_innobase::prepare_drop_index(
953 if (srv_created_new_raw || srv_force_recovery) {
954 return(HA_ERR_WRONG_COMMAND);
964 row_mysql_lock_data_dictionary(trx);
974 index = dict_table_get_next_index(index);
978 for (n_key = 0; n_key < num_of_keys; n_key++) {
982 key = i_table->
key_info + key_num[n_key];
983 index = dict_table_get_index_on_name_and_min_id(
987 errmsg_printf(ERRMSG_LVL_ERROR,
"InnoDB could not find key n:o %u "
988 "with name %s for table %s",
990 key ? key->name :
"NULL",
993 err = HA_ERR_KEY_NOT_FOUND;
1003 my_error(ER_REQUIRES_PRIMARY_KEY, MYF(0));
1024 if (trx->check_foreigns
1025 && session_sql_command(
user_session) != SQLCOM_CREATE_INDEX) {
1030 index = dict_table_get_next_index(index)) {
1039 foreign = dict_table_get_referenced_constraint(
1046 "Index needed in foreign key "
1051 err = HA_ERR_DROP_INDEX_FK;
1056 foreign = dict_table_get_foreign_constraint(
1065 if (!dict_foreign_find_equiv_index(
1073 }
else if (session_sql_command(
user_session) == SQLCOM_CREATE_INDEX) {
1083 index = dict_table_get_next_index(index)) {
1092 foreign = dict_table_get_foreign_constraint(
1095 if (foreign == NULL) {
1106 if (!dict_foreign_find_equiv_index(foreign)) {
1109 "Index needed in foreign key "
1114 err = HA_ERR_DROP_INDEX_FK;
1128 index = dict_table_get_next_index(index);
1143 ha_innobase::final_drop_index(
1152 if (srv_created_new_raw || srv_force_recovery) {
1153 return(HA_ERR_WRONG_COMMAND);
1176 row_mysql_lock_data_dictionary(trx);
1179 if (UNIV_UNLIKELY(err)) {
1183 index; index = dict_table_get_next_index(index)) {
1198 next_index = dict_table_get_next_index(index);
1210 index; index = dict_table_get_next_index(index)) {