32#include <google/protobuf/io/zero_copy_stream.h>
33#include <google/protobuf/io/zero_copy_stream_impl.h>
37#include <drizzled/base.h>
38#include <drizzled/cursor.h>
39#include <drizzled/plugin/storage_engine.h>
40#include <drizzled/session.h>
41#include <drizzled/error.h>
42#include <drizzled/gettext.h>
43#include <drizzled/data_home.h>
44#include <drizzled/errmsg_print.h>
45#include <drizzled/xid.h>
47#include <drizzled/charset.h>
48#include <drizzled/internal/my_sys.h>
49#include <drizzled/table_proto.h>
50#include <drizzled/plugin/event_observer.h>
51#include <drizzled/table/shell.h>
52#include <drizzled/message/cache.h>
53#include <drizzled/key.h>
54#include <drizzled/session/transactions.h>
55#include <drizzled/open_tables_state.h>
57#include <boost/algorithm/string/compare.hpp>
59static bool shutdown_has_begun=
false;
64static EngineVector g_engines;
65static EngineVector g_schema_engines;
67const std::string DEFAULT_STRING(
"default");
68const std::string UNKNOWN_STRING(
"UNKNOWN");
69const std::string DEFAULT_DEFINITION_FILE_EXT(
".dfe");
71static std::set<std::string> set_of_table_definition_ext;
73EngineVector &StorageEngine::getSchemaEngines()
75 return g_schema_engines;
78const std::string defaultTableDefinitionFileExt()
80 return DEFAULT_DEFINITION_FILE_EXT;
83StorageEngine::StorageEngine(
const std::string &name_arg,
84 const std::bitset<HTON_BIT_SIZE> &flags_arg) :
85 Plugin(name_arg,
"StorageEngine"),
91StorageEngine::~StorageEngine()
95void StorageEngine::setTransactionReadWrite(Session& session)
97 TransactionContext &statement_ctx= session.transaction.stmt;
98 statement_ctx.markModifiedNonTransData();
101int StorageEngine::renameTable(Session &session,
const identifier::Table &from,
const identifier::Table &to)
103 setTransactionReadWrite(session);
104 if (DRIZZLE_UNLIKELY(plugin::EventObserver::beforeRenameTable(session, from, to)))
105 return ER_EVENT_OBSERVER_PLUGIN;
106 int error= doRenameTable(session, from, to);
107 if (DRIZZLE_UNLIKELY(plugin::EventObserver::afterRenameTable(session, from, to, error)))
108 error= ER_EVENT_OBSERVER_PLUGIN;
130 int enoent_or_zero= ENOENT;
131 char buff[FN_REFLEN];
133 for (
const char **ext=
bas_ext(); *ext ; ext++)
135 internal::fn_format(buff, identifier.getPath().c_str(),
"", *ext,
136 MY_UNPACK_FILENAME|MY_APPEND_EXT);
137 if (internal::my_delete_with_symlink(buff, MYF(0)))
139 if ((error= errno) != ENOENT)
147 error= enoent_or_zero;
154 g_engines.push_back(&engine);
156 if (engine.getTableDefinitionFileExtension().length())
158 assert(engine.getTableDefinitionFileExtension().length() == plugin::defaultTableDefinitionFileExt().length());
159 set_of_table_definition_ext.insert(engine.getTableDefinitionFileExtension());
162 if (engine.check_flag(HTON_BIT_SCHEMA_DICTIONARY))
163 g_schema_engines.push_back(&engine);
168void StorageEngine::removePlugin(StorageEngine &)
170 if (shutdown_has_begun)
172 shutdown_has_begun=
true;
174 g_schema_engines.clear();
177StorageEngine *StorageEngine::findByName(
const std::string &predicate)
179 for (EngineVector::reference it : g_engines)
181 if (not boost::iequals(it->getName(), predicate))
183 if (it->is_user_selectable())
190StorageEngine *StorageEngine::findByName(Session& session,
const std::string &predicate)
192 if (boost::iequals(predicate, DEFAULT_STRING))
193 return session.getDefaultStorageEngine();
194 return findByName(predicate);
203 for (EngineVector::reference it : g_engines)
205 if (*session.getEngineData(it))
206 it->close_connection(&session);
214 if (std::find_if(g_engines.begin(), g_engines.end(), std::mem_fn(&StorageEngine::flush_logs))
215 != g_engines.begin())
218 else if (engine->flush_logs())
223class StorageEngineGetTableDefinition
227 message::Table &table_message;
228 drizzled::error_t &err;
231 StorageEngineGetTableDefinition(
Session& session_arg,
233 message::Table &table_message_arg,
234 drizzled::error_t &err_arg) :
235 session(session_arg),
236 identifier(identifier_arg),
237 table_message(table_message_arg),
242 int ret= engine->doGetTableDefinition(session, identifier, table_message);
245 err=
static_cast<drizzled::error_t
>(ret);
247 return err ==
static_cast<drizzled::error_t
>(EEXIST) or err !=
static_cast<drizzled::error_t
>(ENOENT);
256 bool include_temporary_tables)
258 if (include_temporary_tables && session.open_tables.doDoesTableExist(identifier))
260 for (EngineVector::reference it : g_engines)
262 if (it->doDoesTableExist(session, identifier))
270 std::cerr <<
" Engine was called for doDoesTableExist() and does not implement it: " << getName() <<
"\n";
275message::table::shared_ptr StorageEngine::getTableMessage(
Session& session,
277 bool include_temporary_tables)
279 drizzled::error_t error=
static_cast<drizzled::error_t
>(ENOENT);
280 if (include_temporary_tables)
282 if (
Table *table= session.open_tables.find_temporary_table(identifier))
284 return message::table::shared_ptr(
new message::Table(*table->getShare()->getTableMessage()));
288 drizzled::message::table::shared_ptr table_ptr;
289 if ((table_ptr= drizzled::message::Cache::singleton().find(identifier)))
294 message::Table message;
295 EngineVector::iterator iter= std::find_if(g_engines.begin(), g_engines.end(),
296 StorageEngineGetTableDefinition(session, identifier, message, error));
298 if (iter == g_engines.end())
300 return message::table::shared_ptr();
302 message::table::shared_ptr table_message(
new message::Table(message));
304 drizzled::message::Cache::singleton().insert(identifier, table_message);
306 return table_message;
309class DropTableByIdentifier
313 drizzled::error_t &error;
317 DropTableByIdentifier(
Session& session_arg,
319 drizzled::error_t &error_arg) :
320 session(session_arg),
321 identifier(identifier_arg),
325 bool operator() (EngineVector::value_type engine)
327 if (not engine->doDoesTableExist(session, identifier))
330 int local_error= engine->doDropTable(session, identifier);
338 case HA_ERR_NO_SUCH_TABLE:
340 error=
static_cast<drizzled::error_t
>(HA_ERR_NO_SUCH_TABLE);
344 error=
static_cast<drizzled::error_t
>(local_error);
351bool StorageEngine::dropTable(
Session& session,
353 drizzled::error_t &error)
357 EngineVector::const_iterator iter= std::find_if(g_engines.begin(), g_engines.end(),
364 else if (iter == g_engines.end())
366 error= ER_BAD_TABLE_ERROR;
370 drizzled::message::Cache::singleton().erase(identifier);
375bool StorageEngine::dropTable(Session& session,
376 const identifier::Table &identifier)
378 drizzled::error_t error;
379 return dropTable(session, identifier, error);
382bool StorageEngine::dropTable(Session& session,
383 StorageEngine &engine,
384 const identifier::Table& identifier,
385 drizzled::error_t &error)
388 engine.setTransactionReadWrite(session);
390 assert(identifier.isTmp());
392 if (DRIZZLE_UNLIKELY(plugin::EventObserver::beforeDropTable(session, identifier)))
394 error= ER_EVENT_OBSERVER_PLUGIN;
398 error=
static_cast<drizzled::error_t
>(engine.doDropTable(session, identifier));
400 if (DRIZZLE_UNLIKELY(plugin::EventObserver::afterDropTable(session, identifier, error)))
402 error= ER_EVENT_OBSERVER_PLUGIN;
405 drizzled::message::Cache::singleton().erase(identifier);
420 message::Table& table_message)
422 drizzled::error_t error= EE_OK;
426 message::Table tmp_proto;
428 if (share.parse_table_proto(session, table_message) || share.open_table_from_share(&session, identifier,
"", 0, 0, table))
433 my_error(ER_CORRUPT_TABLE_DEFINITION_UNKNOWN, identifier);
440 if (table_message.type() == message::Table::TEMPORARY &&
441 share.storage_engine->check_flag(HTON_BIT_TEMPORARY_NOT_SUPPORTED) ==
true)
443 error= HA_ERR_UNSUPPORTED;
445 else if (table_message.type() != message::Table::TEMPORARY &&
446 share.storage_engine->check_flag(HTON_BIT_TEMPORARY_ONLY) ==
true)
448 error= HA_ERR_UNSUPPORTED;
452 share.storage_engine->setTransactionReadWrite(session);
454 error=
static_cast<drizzled::error_t
>(share.storage_engine->doCreateTable(session,
460 if (error == ER_TABLE_PERMISSION_DENIED)
461 my_error(ER_TABLE_PERMISSION_DENIED, identifier);
463 my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), identifier.getSQLPath().c_str(), error);
464 table.delete_table();
466 return(error == EE_OK);
474void StorageEngine::getIdentifiers(
Session &session,
const identifier::Schema &schema_identifier, identifier::table::vector &set_of_identifiers)
476 CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
478 if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
481 else if (schema_identifier == DATA_DICTIONARY_IDENTIFIER)
484 else if (directory.fail())
486 errno= directory.getError();
488 my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), schema_identifier.getSQLPath().c_str());
490 my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
494 for (EngineVector::reference it : g_engines)
495 it->doGetTableIdentifiers(directory, schema_identifier, set_of_identifiers);
497 session.open_tables.doGetTableIdentifiers(directory, schema_identifier, set_of_identifiers);
508 session(session_arg),
514 return engine->doDropTable(session, identifier) == 0;
523void StorageEngine::removeLostTemporaryTables(
Session &session,
const char *directory)
526 identifier::table::vector table_identifiers;
530 errno= dir.getError();
531 my_error(ER_CANT_READ_DIR, MYF(0), directory, errno);
536 CachedDirectory::Entries files= dir.getEntries();
538 for (CachedDirectory::Entries::iterator fileIter= files.begin();
539 fileIter != files.end(); fileIter++)
546 length= entry->filename.length();
547 entry->filename.resize(length - plugin::defaultTableDefinitionFileExt().length());
551 path+= entry->filename;
552 message::Table definition;
553 if (StorageEngine::readTableFile(path, definition))
559 table_identifiers.push_back(identifier);
563 for (EngineVector::reference it : g_engines)
565 table_identifiers.erase(std::remove_if(table_identifiers.begin(), table_identifiers.end(), DropTable(session, it)),
566 table_identifiers.end());
575 std::set<std::string> all_exts= set_of_table_definition_ext;
577 for (EngineVector::iterator iter= g_engines.begin();
578 iter != g_engines.end() ; iter++)
580 for (
const char **ext= (*iter)->bas_ext(); *ext ; ext++)
581 all_exts.insert(*ext);
584 CachedDirectory rescan(directory, all_exts);
586 files= rescan.getEntries();
587 for (CachedDirectory::Entries::iterator fileIter= files.begin();
588 fileIter != files.end(); fileIter++)
591 CachedDirectory::Entry *entry= *fileIter;
595 path+= entry->filename;
597 unlink(path.c_str());
613 drizzled::error_t textno= ER_GET_ERRNO;
616 textno=ER_OPEN_AS_READONLY;
622 textno=ER_FILE_NOT_FOUND;
624 case HA_ERR_KEY_NOT_FOUND:
625 case HA_ERR_NO_ACTIVE_RECORD:
626 case HA_ERR_END_OF_FILE:
627 textno=ER_KEY_NOT_FOUND;
629 case HA_ERR_WRONG_MRG_TABLE_DEF:
630 textno=ER_WRONG_MRG_TABLE;
632 case HA_ERR_FOUND_DUPP_KEY:
634 uint32_t key_nr= table.get_dup_key(error);
635 if ((
int) key_nr >= 0)
637 const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
639 print_keydup_error(key_nr, err_msg, table);
646 case HA_ERR_FOREIGN_DUPLICATE_KEY:
648 uint32_t key_nr= table.get_dup_key(error);
649 if ((
int) key_nr >= 0)
654 char key[MAX_KEY_LENGTH];
655 String str(key,
sizeof(key),system_charset_info);
658 key_unpack(&str, &table,(uint32_t) key_nr);
659 max_length= (DRIZZLE_ERRMSG_SIZE-
660 (uint32_t) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
661 if (str.length() >= max_length)
663 str.length(max_length-4);
664 str.append(STRING_WITH_LEN(
"..."));
666 my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table.getShare()->getTableName(),
667 str.c_ptr(), key_nr+1);
673 case HA_ERR_FOUND_DUPP_UNIQUE:
674 textno=ER_DUP_UNIQUE;
676 case HA_ERR_RECORD_CHANGED:
680 textno=ER_NOT_KEYFILE;
682 case HA_ERR_WRONG_IN_RECORD:
683 textno= ER_CRASHED_ON_USAGE;
685 case HA_ERR_CRASHED_ON_USAGE:
686 textno=ER_CRASHED_ON_USAGE;
688 case HA_ERR_NOT_A_TABLE:
689 textno=
static_cast<drizzled::error_t
>(error);
691 case HA_ERR_CRASHED_ON_REPAIR:
692 textno=ER_CRASHED_ON_REPAIR;
694 case HA_ERR_OUT_OF_MEM:
695 textno=ER_OUT_OF_RESOURCES;
697 case HA_ERR_WRONG_COMMAND:
698 textno=ER_ILLEGAL_HA;
700 case HA_ERR_OLD_FILE:
701 textno=ER_OLD_KEYFILE;
703 case HA_ERR_UNSUPPORTED:
704 textno=ER_UNSUPPORTED_EXTENSION;
706 case HA_ERR_RECORD_FILE_FULL:
707 case HA_ERR_INDEX_FILE_FULL:
708 textno=ER_RECORD_FILE_FULL;
710 case HA_ERR_LOCK_WAIT_TIMEOUT:
711 textno=ER_LOCK_WAIT_TIMEOUT;
713 case HA_ERR_LOCK_TABLE_FULL:
714 textno=ER_LOCK_TABLE_FULL;
716 case HA_ERR_LOCK_DEADLOCK:
717 textno=ER_LOCK_DEADLOCK;
719 case HA_ERR_READ_ONLY_TRANSACTION:
720 textno=ER_READ_ONLY_TRANSACTION;
722 case HA_ERR_CANNOT_ADD_FOREIGN:
723 textno=ER_CANNOT_ADD_FOREIGN;
725 case HA_ERR_ROW_IS_REFERENCED:
729 my_error(ER_ROW_IS_REFERENCED_2, MYF(0), str.c_str());
732 case HA_ERR_NO_REFERENCED_ROW:
736 my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_str());
739 case HA_ERR_TABLE_DEF_CHANGED:
740 textno=ER_TABLE_DEF_CHANGED;
742 case HA_ERR_NO_SUCH_TABLE:
744 my_error(ER_TABLE_UNKNOWN, table.getShare()->getTableIdentifier());
747 case HA_ERR_LOG_ROW_FOR_REPLICATION_FAILED:
748 textno= ER_LOG_ROW_FOR_REPLICATION_FAILED;
750 case HA_ERR_DROP_INDEX_FK:
752 const char *ptr=
"???";
753 uint32_t key_nr= table.get_dup_key(error);
754 if ((
int) key_nr >= 0)
755 ptr= table.key_info[key_nr].name;
756 my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
759 case HA_ERR_TABLE_NEEDS_UPGRADE:
760 textno=ER_TABLE_NEEDS_UPGRADE;
762 case HA_ERR_TABLE_READONLY:
763 textno= ER_OPEN_AS_READONLY;
765 case HA_ERR_AUTOINC_READ_FAILED:
766 textno= ER_AUTOINC_READ_FAILED;
768 case HA_ERR_AUTOINC_ERANGE:
769 textno= ER_WARN_DATA_OUT_OF_RANGE;
771 case HA_ERR_LOCK_OR_ACTIVE_TRANSACTION:
772 my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
780 bool temporary=
false;
785 const char* engine_name= getName().c_str();
787 my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine_name);
789 my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine_name);
793 my_error(ER_GET_ERRNO,errflag,error);
799 my_error(textno, errflag, table.getShare()->getTableName(), error);
818void StorageEngine::print_keydup_error(uint32_t key_nr,
const char *msg,
const Table &table)
const
821 char key[MAX_KEY_LENGTH];
822 String str(key,
sizeof(key),system_charset_info);
824 if (key_nr == MAX_KEY)
827 str.copy(
"", 0, system_charset_info);
828 my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(),
"*UNKNOWN*");
833 key_unpack(&str, &table, (uint32_t) key_nr);
834 uint32_t max_length=DRIZZLE_ERRMSG_SIZE-(uint32_t) strlen(msg);
835 if (str.length() >= max_length)
837 str.length(max_length-4);
838 str.append(STRING_WITH_LEN(
"..."));
840 my_printf_error(ER_DUP_ENTRY, msg,
841 MYF(0), str.c_ptr(), table.key_info[key_nr].name);
846int StorageEngine::deleteDefinitionFromPath(
const identifier::Table &identifier)
848 std::string path(identifier.getPath());
850 path.append(plugin::defaultTableDefinitionFileExt());
852 return internal::my_delete(path.c_str(), MYF(0));
855int StorageEngine::renameDefinitionFromPath(
const identifier::Table &dest,
const identifier::Table &src)
857 message::Table table_message;
858 std::string src_path(src.getPath());
859 std::string dest_path(dest.getPath());
861 src_path.append(plugin::defaultTableDefinitionFileExt());
862 dest_path.append(plugin::defaultTableDefinitionFileExt());
864 bool was_read= StorageEngine::readTableFile(src_path.c_str(), table_message);
871 dest.copyToTableMessage(table_message);
873 int error= StorageEngine::writeDefinitionFromPath(dest, table_message);
877 if (unlink(src_path.c_str()))
878 perror(src_path.c_str());
884int StorageEngine::writeDefinitionFromPath(
const identifier::Table &identifier,
const message::Table &table_message)
886 char definition_file_tmp[FN_REFLEN];
887 std::string file_name(identifier.getPath());
889 file_name.append(plugin::defaultTableDefinitionFileExt());
891 snprintf(definition_file_tmp,
sizeof(definition_file_tmp),
"%sXXXXXX", file_name.c_str());
893 int fd= mkstemp(definition_file_tmp);
897 perror(definition_file_tmp);
901 google::protobuf::io::ZeroCopyOutputStream* output=
902 new google::protobuf::io::FileOutputStream(fd);
908 success= table_message.SerializeToZeroCopyStream(output);
917 my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), identifier.getSQLPath().c_str(), table_message.InitializationErrorString().c_str());
921 perror(definition_file_tmp);
923 if (unlink(definition_file_tmp) == -1)
924 perror(definition_file_tmp);
926 return ER_CORRUPT_TABLE_DEFINITION;
934 perror(definition_file_tmp);
936 if (unlink(definition_file_tmp))
937 perror(definition_file_tmp);
942 if (rename(definition_file_tmp, file_name.c_str()) == -1)
945 perror(definition_file_tmp);
947 if (unlink(definition_file_tmp))
948 perror(definition_file_tmp);
961 for (EngineVector::reference it : g_engines)
963 if (not it->doCanCreateTable(identifier))
969bool StorageEngine::readTableFile(
const std::string &path, message::Table &table_message)
971 std::fstream input(path.c_str(), std::ios::in | std::ios::binary);
976 if (table_message.ParseFromIstream(&input))
980 my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
981 table_message.name().empty() ? path.c_str() : table_message.name().c_str(),
982 table_message.InitializationErrorString().empty() ?
"": table_message.InitializationErrorString().c_str());
986 my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
987 table_message.name().empty() ? path.c_str() : table_message.name().c_str(),
988 table_message.InitializationErrorString().empty() ?
"": table_message.InitializationErrorString().c_str());
993 perror(path.c_str());
999std::ostream& operator<<(std::ostream& output,
const StorageEngine &engine)
1001 return output <<
"StorageEngine:(" << engine.getName() <<
")";
Defines the interface to the CachedDirectory class.
static void closeConnection(Session &)
virtual bool get_error_message(int error, String *buf) const
static bool doesTableExist(Session &session, const drizzled::identifier::Table &identifier, bool include_temporary_tables=true)
virtual const char ** bas_ext() const =0
static bool createTable(Session &session, const identifier::Table &identifier, message::Table &table_message)
static bool canCreateTable(const drizzled::identifier::Table &identifier)
virtual void print_error(int error, myf errflag, const Table &table) const
virtual int doDropTable(Session &session, const drizzled::identifier::Table &identifier)=0
TODO: Rename this file - func.h is stupid.