← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Brian Aker
  • Date: 2009-11-18 06:11:12 UTC
  • mfrom: (1220.1.10 staging)
  • Revision ID: brian@gaz-20091118061112-tyf4qrfr5v7i946b
Monty + Brian Merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
49
49
 
50
50
#include <drizzled/table_proto.h>
51
51
 
 
52
#include <drizzled/hash.h>
 
53
 
 
54
static bool shutdown_has_begun= false; // Once we put in the container for the vector/etc for engines this will go away.
 
55
 
52
56
using namespace std;
53
57
 
54
58
namespace drizzled
55
59
{
56
60
 
57
 
NameMap<plugin::StorageEngine *> all_engines;
58
 
static std::vector<plugin::StorageEngine *> vector_of_engines;
59
 
static std::vector<plugin::StorageEngine *> vector_of_transactional_engines;
 
61
typedef hash_map<std::string, plugin::StorageEngine *> EngineMap;
 
62
typedef std::vector<plugin::StorageEngine *> EngineVector;
 
63
 
 
64
static EngineMap engine_map;
 
65
static EngineVector vector_of_engines;
 
66
static EngineVector vector_of_transactional_engines;
 
67
 
60
68
static std::set<std::string> set_of_table_definition_ext;
61
69
 
62
70
plugin::StorageEngine::StorageEngine(const string name_arg,
191
199
 
192
200
bool plugin::StorageEngine::addPlugin(plugin::StorageEngine *engine)
193
201
{
194
 
  if (all_engines.add(engine))
 
202
  vector<string> aliases= engine->getAliases();
 
203
 
 
204
  string name= engine->getName();
 
205
  transform(name.begin(), name.end(),
 
206
            name.begin(), ::tolower);
 
207
  engine_map.insert(make_pair(name, engine));
 
208
 
 
209
  for (vector<string>::iterator iter= aliases.begin();
 
210
       iter != aliases.end(); iter++)
195
211
  {
196
 
    errmsg_printf(ERRMSG_LVL_ERROR,
197
 
                  _("Couldn't add StorageEngine"));
198
 
    return true;
 
212
    string alias= *iter;
 
213
    transform(alias.begin(), alias.end(),
 
214
              alias.begin(), ::tolower);
 
215
    engine_map.insert(make_pair(alias, engine));
199
216
  }
200
217
 
 
218
 
201
219
  vector_of_engines.push_back(engine);
202
220
 
203
221
  if (engine->check_flag(HTON_BIT_DOES_TRANSACTIONS))
212
230
  return false;
213
231
}
214
232
 
215
 
void plugin::StorageEngine::removePlugin(plugin::StorageEngine *engine)
 
233
void plugin::StorageEngine::removePlugin(plugin::StorageEngine *)
216
234
{
217
 
  all_engines.remove(engine);
218
 
  vector_of_engines.clear();
219
 
  vector_of_transactional_engines.clear();
 
235
  if (shutdown_has_begun == false)
 
236
  {
 
237
    engine_map.clear();
 
238
    vector_of_engines.clear();
 
239
    vector_of_transactional_engines.clear();
 
240
 
 
241
    shutdown_has_begun= true;
 
242
  }
220
243
}
221
244
 
222
245
plugin::StorageEngine *plugin::StorageEngine::findByName(string find_str)
224
247
  transform(find_str.begin(), find_str.end(),
225
248
            find_str.begin(), ::tolower);
226
249
 
227
 
  plugin::StorageEngine *engine= all_engines.find(find_str);
228
 
 
229
 
  if (engine && engine->is_user_selectable())
230
 
    return engine;
 
250
  EngineMap::iterator iter= engine_map.find(find_str);
 
251
  if (iter != engine_map.end())
 
252
  {
 
253
    StorageEngine *engine= (*iter).second;
 
254
    if (engine->is_user_selectable())
 
255
      return engine;
 
256
  }
231
257
 
232
258
  return NULL;
233
259
}
242
268
  if (find_str.compare("default") == 0)
243
269
    return session.getDefaultStorageEngine();
244
270
 
245
 
  plugin::StorageEngine *engine= all_engines.find(find_str);
246
 
 
247
 
  if (engine && engine->is_user_selectable())
248
 
    return engine;
 
271
  EngineMap::iterator iter= engine_map.find(find_str);
 
272
  if (iter != engine_map.end())
 
273
  {
 
274
    StorageEngine *engine= (*iter).second;
 
275
    if (engine->is_user_selectable())
 
276
      return engine;
 
277
  }
249
278
 
250
279
  return NULL;
251
280
}
252
281
 
253
282
class StorageEngineCloseConnection
254
 
  : public unary_function<plugin::StorageEngine *, void>
 
283
: public unary_function<plugin::StorageEngine *, void>
255
284
{
256
285
  Session *session;
257
286
public:
263
292
  inline result_type operator() (argument_type engine)
264
293
  {
265
294
    if (engine->is_enabled() && 
266
 
      session_get_ha_data(session, engine))
 
295
        session_get_ha_data(session, engine))
267
296
    engine->close_connection(session);
268
297
  }
269
298
};
289
318
  vector<int> results;
290
319
  
291
320
  if (commit)
292
 
    transform(all_engines.begin(), all_engines.end(), results.begin(),
 
321
    transform(vector_of_engines.begin(), vector_of_engines.end(), results.begin(),
293
322
              bind2nd(mem_fun(&plugin::StorageEngine::commit_by_xid),xid));
294
323
  else
295
 
    transform(all_engines.begin(), all_engines.end(), results.begin(),
 
324
    transform(vector_of_engines.begin(), vector_of_engines.end(), results.begin(),
296
325
              bind2nd(mem_fun(&plugin::StorageEngine::rollback_by_xid),xid));
297
326
 
298
327
  if (find_if(results.begin(), results.end(), bind2nd(equal_to<int>(),0))
330
359
{
331
360
  if (engine == NULL)
332
361
  {
333
 
    if (find_if(all_engines.begin(), all_engines.end(),
 
362
    if (find_if(vector_of_engines.begin(), vector_of_engines.end(),
334
363
            mem_fun(&plugin::StorageEngine::flush_logs))
335
 
          != all_engines.begin())
 
364
          != vector_of_engines.begin())
336
365
      return true;
337
366
  }
338
367
  else
690
719
 
691
720
  if (error && generate_warning)
692
721
  {
693
 
    TableShare dummy_share;
694
 
    Table dummy_table;
695
 
    Cursor *file= NULL;
696
 
 
697
 
    if (engine)
698
 
    {
699
 
      if ((file= engine->create(dummy_share, session.mem_root)))
700
 
        file->init();
701
 
    }
702
 
    memset(&dummy_table, 0, sizeof(dummy_table));
703
 
    memset(&dummy_share, 0, sizeof(dummy_share));
704
 
    dummy_table.s= &dummy_share;
705
 
 
706
722
    /*
707
 
      Because file->print_error() use my_error() to generate the error message
 
723
      Because engine->print_error() use my_error() to generate the error message
708
724
      we use an internal error Cursor to intercept it and store the text
709
725
      in a temporary buffer. Later the message will be presented to user
710
726
      as a warning.
711
727
    */
712
728
    Ha_delete_table_error_handler ha_delete_table_error_handler;
713
729
 
714
 
    /* Fill up strucutures that print_error may need */
715
 
    dummy_share.path.str= (char*) path;
716
 
    dummy_share.path.length= strlen(path);
717
 
    dummy_share.db.str= (char*) db;
718
 
    dummy_share.db.length= strlen(db);
719
 
    dummy_share.table_name.str= (char*) alias;
720
 
    dummy_share.table_name.length= strlen(alias);
721
 
    dummy_table.alias= alias;
722
 
 
723
 
    if (file != NULL)
724
 
    {
725
 
      file->change_table_ptr(&dummy_table, &dummy_share);
726
 
 
727
 
      session.push_internal_handler(&ha_delete_table_error_handler);
728
 
      file->print_error(error, 0);
729
 
 
730
 
      session.pop_internal_handler();
731
 
    }
732
 
    else
733
 
      error= -1; /* General form of fail. maybe bad FRM */
 
730
    session.push_internal_handler(&ha_delete_table_error_handler);
 
731
    engine->print_error(error, 0);
 
732
 
 
733
    session.pop_internal_handler();
734
734
 
735
735
    /*
736
736
      XXX: should we convert *all* errors to warnings here?
806
806
 
807
807
Cursor *plugin::StorageEngine::getCursor(TableShare &share, MEM_ROOT *alloc)
808
808
{
809
 
  Cursor *file;
810
 
 
811
809
  assert(enabled);
812
 
 
813
 
  if ((file= create(share, alloc)))
814
 
    file->init();
815
 
  return file;
 
810
  return create(share, alloc);
816
811
}
817
812
 
818
813
/**
998
993
}
999
994
 
1000
995
 
 
996
/**
 
997
  Print error that we got from Cursor function.
 
998
 
 
999
  @note
 
1000
    In case of delete table it's only safe to use the following parts of
 
1001
    the 'table' structure:
 
1002
    - table->s->path
 
1003
    - table->alias
 
1004
*/
 
1005
void plugin::StorageEngine::print_error(int error, myf errflag, Table &table)
 
1006
{
 
1007
  print_error(error, errflag, &table);
 
1008
}
 
1009
 
 
1010
void plugin::StorageEngine::print_error(int error, myf errflag, Table *table)
 
1011
{
 
1012
  int textno= ER_GET_ERRNO;
 
1013
  switch (error) {
 
1014
  case EACCES:
 
1015
    textno=ER_OPEN_AS_READONLY;
 
1016
    break;
 
1017
  case EAGAIN:
 
1018
    textno=ER_FILE_USED;
 
1019
    break;
 
1020
  case ENOENT:
 
1021
    textno=ER_FILE_NOT_FOUND;
 
1022
    break;
 
1023
  case HA_ERR_KEY_NOT_FOUND:
 
1024
  case HA_ERR_NO_ACTIVE_RECORD:
 
1025
  case HA_ERR_END_OF_FILE:
 
1026
    textno=ER_KEY_NOT_FOUND;
 
1027
    break;
 
1028
  case HA_ERR_WRONG_MRG_TABLE_DEF:
 
1029
    textno=ER_WRONG_MRG_TABLE;
 
1030
    break;
 
1031
  case HA_ERR_FOUND_DUPP_KEY:
 
1032
  {
 
1033
    assert(table);
 
1034
    uint32_t key_nr= table->get_dup_key(error);
 
1035
    if ((int) key_nr >= 0)
 
1036
    {
 
1037
      const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
 
1038
 
 
1039
      if (key_nr == 0 &&
 
1040
          (table->key_info[0].key_part[0].field->flags &
 
1041
           AUTO_INCREMENT_FLAG)
 
1042
          && (current_session)->lex->sql_command == SQLCOM_ALTER_TABLE)
 
1043
      {
 
1044
        err_msg= ER(ER_DUP_ENTRY_AUTOINCREMENT_CASE);
 
1045
      }
 
1046
 
 
1047
      print_keydup_error(key_nr, err_msg, *table);
 
1048
      return;
 
1049
    }
 
1050
    textno=ER_DUP_KEY;
 
1051
    break;
 
1052
  }
 
1053
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
 
1054
  {
 
1055
    assert(table);
 
1056
    uint32_t key_nr= table->get_dup_key(error);
 
1057
    if ((int) key_nr >= 0)
 
1058
    {
 
1059
      uint32_t max_length;
 
1060
 
 
1061
      /* Write the key in the error message */
 
1062
      char key[MAX_KEY_LENGTH];
 
1063
      String str(key,sizeof(key),system_charset_info);
 
1064
 
 
1065
      /* Table is opened and defined at this point */
 
1066
      key_unpack(&str,table,(uint32_t) key_nr);
 
1067
      max_length= (DRIZZLE_ERRMSG_SIZE-
 
1068
                   (uint32_t) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
 
1069
      if (str.length() >= max_length)
 
1070
      {
 
1071
        str.length(max_length-4);
 
1072
        str.append(STRING_WITH_LEN("..."));
 
1073
      }
 
1074
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table->s->table_name.str,
 
1075
        str.c_ptr(), key_nr+1);
 
1076
      return;
 
1077
    }
 
1078
    textno= ER_DUP_KEY;
 
1079
    break;
 
1080
  }
 
1081
  case HA_ERR_FOUND_DUPP_UNIQUE:
 
1082
    textno=ER_DUP_UNIQUE;
 
1083
    break;
 
1084
  case HA_ERR_RECORD_CHANGED:
 
1085
    textno=ER_CHECKREAD;
 
1086
    break;
 
1087
  case HA_ERR_CRASHED:
 
1088
    textno=ER_NOT_KEYFILE;
 
1089
    break;
 
1090
  case HA_ERR_WRONG_IN_RECORD:
 
1091
    textno= ER_CRASHED_ON_USAGE;
 
1092
    break;
 
1093
  case HA_ERR_CRASHED_ON_USAGE:
 
1094
    textno=ER_CRASHED_ON_USAGE;
 
1095
    break;
 
1096
  case HA_ERR_NOT_A_TABLE:
 
1097
    textno= error;
 
1098
    break;
 
1099
  case HA_ERR_CRASHED_ON_REPAIR:
 
1100
    textno=ER_CRASHED_ON_REPAIR;
 
1101
    break;
 
1102
  case HA_ERR_OUT_OF_MEM:
 
1103
    textno=ER_OUT_OF_RESOURCES;
 
1104
    break;
 
1105
  case HA_ERR_WRONG_COMMAND:
 
1106
    textno=ER_ILLEGAL_HA;
 
1107
    break;
 
1108
  case HA_ERR_OLD_FILE:
 
1109
    textno=ER_OLD_KEYFILE;
 
1110
    break;
 
1111
  case HA_ERR_UNSUPPORTED:
 
1112
    textno=ER_UNSUPPORTED_EXTENSION;
 
1113
    break;
 
1114
  case HA_ERR_RECORD_FILE_FULL:
 
1115
  case HA_ERR_INDEX_FILE_FULL:
 
1116
    textno=ER_RECORD_FILE_FULL;
 
1117
    break;
 
1118
  case HA_ERR_LOCK_WAIT_TIMEOUT:
 
1119
    textno=ER_LOCK_WAIT_TIMEOUT;
 
1120
    break;
 
1121
  case HA_ERR_LOCK_TABLE_FULL:
 
1122
    textno=ER_LOCK_TABLE_FULL;
 
1123
    break;
 
1124
  case HA_ERR_LOCK_DEADLOCK:
 
1125
    textno=ER_LOCK_DEADLOCK;
 
1126
    break;
 
1127
  case HA_ERR_READ_ONLY_TRANSACTION:
 
1128
    textno=ER_READ_ONLY_TRANSACTION;
 
1129
    break;
 
1130
  case HA_ERR_CANNOT_ADD_FOREIGN:
 
1131
    textno=ER_CANNOT_ADD_FOREIGN;
 
1132
    break;
 
1133
  case HA_ERR_ROW_IS_REFERENCED:
 
1134
  {
 
1135
    String str;
 
1136
    get_error_message(error, &str);
 
1137
    my_error(ER_ROW_IS_REFERENCED_2, MYF(0), str.c_ptr_safe());
 
1138
    return;
 
1139
  }
 
1140
  case HA_ERR_NO_REFERENCED_ROW:
 
1141
  {
 
1142
    String str;
 
1143
    get_error_message(error, &str);
 
1144
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
 
1145
    return;
 
1146
  }
 
1147
  case HA_ERR_TABLE_DEF_CHANGED:
 
1148
    textno=ER_TABLE_DEF_CHANGED;
 
1149
    break;
 
1150
  case HA_ERR_NO_SUCH_TABLE:
 
1151
    assert(table);
 
1152
    my_error(ER_NO_SUCH_TABLE, MYF(0), table->s->db.str,
 
1153
             table->s->table_name.str);
 
1154
    return;
 
1155
  case HA_ERR_RBR_LOGGING_FAILED:
 
1156
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
 
1157
    break;
 
1158
  case HA_ERR_DROP_INDEX_FK:
 
1159
  {
 
1160
    assert(table);
 
1161
    const char *ptr= "???";
 
1162
    uint32_t key_nr= table->get_dup_key(error);
 
1163
    if ((int) key_nr >= 0)
 
1164
      ptr= table->key_info[key_nr].name;
 
1165
    my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
 
1166
    return;
 
1167
  }
 
1168
  case HA_ERR_TABLE_NEEDS_UPGRADE:
 
1169
    textno=ER_TABLE_NEEDS_UPGRADE;
 
1170
    break;
 
1171
  case HA_ERR_TABLE_READONLY:
 
1172
    textno= ER_OPEN_AS_READONLY;
 
1173
    break;
 
1174
  case HA_ERR_AUTOINC_READ_FAILED:
 
1175
    textno= ER_AUTOINC_READ_FAILED;
 
1176
    break;
 
1177
  case HA_ERR_AUTOINC_ERANGE:
 
1178
    textno= ER_WARN_DATA_OUT_OF_RANGE;
 
1179
    break;
 
1180
  case HA_ERR_LOCK_OR_ACTIVE_TRANSACTION:
 
1181
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
 
1182
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1183
    return;
 
1184
  default:
 
1185
    {
 
1186
      /* 
 
1187
        The error was "unknown" to this function.
 
1188
        Ask Cursor if it has got a message for this error 
 
1189
      */
 
1190
      bool temporary= false;
 
1191
      String str;
 
1192
      temporary= get_error_message(error, &str);
 
1193
      if (!str.is_empty())
 
1194
      {
 
1195
        const char* engine_name= getName().c_str();
 
1196
        if (temporary)
 
1197
          my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(),
 
1198
                   engine_name);
 
1199
        else
 
1200
          my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine_name);
 
1201
      }
 
1202
      else
 
1203
      {
 
1204
              my_error(ER_GET_ERRNO,errflag,error);
 
1205
      }
 
1206
      return;
 
1207
    }
 
1208
  }
 
1209
  my_error(textno, errflag, table->s->table_name.str, error);
 
1210
}
 
1211
 
 
1212
 
 
1213
/**
 
1214
  Return an error message specific to this Cursor.
 
1215
 
 
1216
  @param error  error code previously returned by Cursor
 
1217
  @param buf    pointer to String where to add error message
 
1218
 
 
1219
  @return
 
1220
    Returns true if this is a temporary error
 
1221
*/
 
1222
bool plugin::StorageEngine::get_error_message(int , String* )
 
1223
{
 
1224
  return false;
 
1225
}
 
1226
 
 
1227
 
 
1228
void plugin::StorageEngine::print_keydup_error(uint32_t key_nr, const char *msg, Table &table)
 
1229
{
 
1230
  /* Write the duplicated key in the error message */
 
1231
  char key[MAX_KEY_LENGTH];
 
1232
  String str(key,sizeof(key),system_charset_info);
 
1233
 
 
1234
  if (key_nr == MAX_KEY)
 
1235
  {
 
1236
    /* Key is unknown */
 
1237
    str.copy("", 0, system_charset_info);
 
1238
    my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(), "*UNKNOWN*");
 
1239
  }
 
1240
  else
 
1241
  {
 
1242
    /* Table is opened and defined at this point */
 
1243
    key_unpack(&str, &table, (uint32_t) key_nr);
 
1244
    uint32_t max_length=DRIZZLE_ERRMSG_SIZE-(uint32_t) strlen(msg);
 
1245
    if (str.length() >= max_length)
 
1246
    {
 
1247
      str.length(max_length-4);
 
1248
      str.append(STRING_WITH_LEN("..."));
 
1249
    }
 
1250
    my_printf_error(ER_DUP_ENTRY, msg,
 
1251
                    MYF(0), str.c_ptr(), table.key_info[key_nr].name);
 
1252
  }
 
1253
}
 
1254
 
 
1255
 
 
1256
 
1001
1257
} /* namespace drizzled */