20#include <drizzled/table.h>
21#include <drizzled/error.h>
22#include <drizzled/plugin/transactional_storage_engine.h>
23#include <drizzled/session.h>
28#include <drizzled/message/table.pb.h>
29#include <drizzled/internal/m_string.h>
31#include <drizzled/charset.h>
33#include <unordered_map>
35#include "engine_state_history.h"
42typedef multimap<string, string> state_multimap;
43typedef multimap<string, string>::value_type state_pair;
44typedef multimap<string, string>::iterator state_multimap_iter;
45state_multimap engine_state_transitions;
46state_multimap cursor_state_transitions;
48void load_engine_state_transitions(state_multimap &states);
49void load_cursor_state_transitions(state_multimap &states);
51uint64_t next_cursor_id;
53plugin::TransactionalStorageEngine *realEngine;
71static uint32_t error_injected= 0;
73#include <drizzled/function/math/int.h>
74#include <drizzled/plugin/function.h>
76class SEAPITesterErrorInjectFunc :
public Item_int_func
80 SEAPITesterErrorInjectFunc() :Item_int_func() {}
82 const char *func_name()
const
84 return "seapitester_error_inject";
87 void fix_length_and_dec()
101 assert(
fixed ==
true);
102 uint32_t err_to_inject= args[0]->val_int();
104 error_injected= err_to_inject;
106 return error_injected;
109static plugin::TransactionalStorageEngine *getRealEngine()
111 return down_cast<plugin::TransactionalStorageEngine*>(plugin::StorageEngine::findByName(
"INNODB"));
114static inline void ENGINE_NEW_STATE(
const string &new_state)
116 state_multimap_iter cur= engine_state_transitions.find(engine_state);
117 if (engine_state_transitions.count(engine_state) == 0)
119 std::cerr <<
"ERROR: Invalid engine state: " << engine_state << std::endl
120 <<
"This should *NEVER* happen."
122 <<
"i.e. you've really screwed it up and you should be ashamed of "
123 <<
"yourself." << std::endl;
124 assert(engine_state_transitions.count(engine_state));
127 for(cur= engine_state_transitions.lower_bound(engine_state);
128 cur != engine_state_transitions.upper_bound(engine_state);
131 if (new_state.compare((*cur).second) == 0)
135 if (cur == engine_state_transitions.end()
136 || new_state.compare((*cur).second))
138 std::cerr <<
"ERROR: Invalid Storage Engine state transition!" << std::endl
139 <<
"Cannot go from " << engine_state <<
" to " << new_state << std::endl;
143 engine_state= new_state;
144 engine_state_history.push_back(new_state);
146 std::cerr <<
"\tENGINE STATE : " << engine_state << std::endl;
149static const string engine_name(
"STORAGE_ENGINE_API_TESTER");
159 : Cursor(engine_arg, table_arg)
161 cursor_state=
"Cursor()";
163 id= ++next_cursor_id;
164 CURSOR_NEW_STATE(
"Cursor()");
168 { CURSOR_NEW_STATE(
"~Cursor()");
delete realCursor;}
171 int rnd_next(
unsigned char *buf) {
173 CURSOR_NEW_STATE(
"::rnd_next()");
175 if (error_injected == 3 && (count++ % 2))
177 user_session->markTransactionForRollback(
false);
178 return HA_ERR_LOCK_WAIT_TIMEOUT;
180 return realCursor->rnd_next(buf);
183 int rnd_pos(
unsigned char* buf,
unsigned char* pos) { CURSOR_NEW_STATE(
"::rnd_pos()");
return realCursor->rnd_pos(buf, pos); }
184 void position(
const unsigned char *record);
185 int info(uint32_t flag);
189 void get_auto_increment(uint64_t, uint64_t, uint64_t, uint64_t*, uint64_t*) {}
190 int doStartTableScan(
bool scan) { CURSOR_NEW_STATE(
"::doStartTableScan()");
return realCursor->doStartTableScan(scan); }
191 int doEndTableScan() { CURSOR_NEW_STATE(
"::doEndTableScan()");
return realCursor->doEndTableScan(); }
193 const char *index_type(uint32_t key_number);
195 int doStartIndexScan(uint32_t,
bool);
196 int index_read(
unsigned char *buf,
const unsigned char *key_ptr,
197 uint32_t key_len, drizzled::ha_rkey_function find_flag);
200 const unsigned char * key,
201 drizzled::key_part_map keypart_map,
202 drizzled::ha_rkey_function find_flag);
204 int index_next(
unsigned char * buf);
205 int doEndIndexScan();
206 int index_prev(
unsigned char * buf);
207 int index_first(
unsigned char * buf);
208 int index_last(
unsigned char * buf);
210 bool primary_key_is_clustered()
212 return realCursor->primary_key_is_clustered();
216 int doOpen(
const identifier::Table &identifier,
int mode, uint32_t test_if_locked);
224 int doInsertRecord(
unsigned char *buf)
227 CURSOR_NEW_STATE(
"::doInsertRecord()");
229 if (error_injected == 1 && (i++ % 2))
231 user_session->markTransactionForRollback(
false);
232 return HA_ERR_LOCK_WAIT_TIMEOUT;
235 if (error_injected == 2 && (i++ % 2))
237 user_session->markTransactionForRollback(
true);
238 return HA_ERR_LOCK_DEADLOCK;
241 return realCursor->doInsertRecord(buf);
244 int doUpdateRecord(
const unsigned char *old_row,
unsigned char *new_row)
246 CURSOR_NEW_STATE(
"::doUpdateRecord()");
247 return realCursor->doUpdateRecord(old_row, new_row);
252 CURSOR_NEW_STATE(
"::scan_time()");
253 CURSOR_NEW_STATE(
"locked");
254 return realCursor->scan_time();
257 int extra(
enum ha_extra_function operation)
259 return realCursor->extra(operation);
264 void CURSOR_NEW_STATE(
const string &new_state);
265 Session* user_session;
269int SEAPITesterCursor::doOpen(
const identifier::Table &identifier,
int mode, uint32_t test_if_locked)
271 CURSOR_NEW_STATE(
"::doOpen()");
273 int r= realCursor->doOpen(identifier, mode, test_if_locked);
282 CURSOR_NEW_STATE(
"::reset()");
283 CURSOR_NEW_STATE(
"::doOpen()");
285 return realCursor->reset();
288int SEAPITesterCursor::close()
290 CURSOR_NEW_STATE(
"::close()");
291 CURSOR_NEW_STATE(
"Cursor()");
293 return realCursor->close();
296void SEAPITesterCursor::position(
const unsigned char *record)
298 CURSOR_NEW_STATE(
"::position()");
301 realCursor->ref= ref;
303 realCursor->position(record);
306int SEAPITesterCursor::info(uint32_t flag)
309 CURSOR_NEW_STATE(
"::info()");
310 CURSOR_NEW_STATE(
"locked");
312 r= realCursor->info(flag);
314 if (flag & (HA_STATUS_VARIABLE|HA_STATUS_AUTO|HA_STATUS_CONST))
316 stats= realCursor->stats;
319 if (flag & HA_STATUS_ERRKEY)
320 errkey= realCursor->errkey;
325const char * SEAPITesterCursor::index_type(uint32_t key_number)
327 CURSOR_NEW_STATE(
"::index_type()");
328 return realCursor->index_type(key_number);
331int SEAPITesterCursor::doStartIndexScan(uint32_t keynr,
bool scan)
334 CURSOR_NEW_STATE(
"::doStartIndexScan()");
336 if (error_injected == 4)
338 CURSOR_NEW_STATE(
"::doStartIndexScan() ERROR");
339 CURSOR_NEW_STATE(
"locked");
340 return HA_ERR_LOCK_DEADLOCK;
343 r= realCursor->doStartIndexScan(keynr, scan);
345 active_index= realCursor->get_index();
350int SEAPITesterCursor::index_read(
unsigned char *buf,
351 const unsigned char *key_ptr,
353 drizzled::ha_rkey_function find_flag)
355 CURSOR_NEW_STATE(
"::index_read()");
356 CURSOR_NEW_STATE(
"::doStartIndexScan()");
357 return realCursor->index_read(buf, key_ptr, key_len, find_flag);
362 const unsigned char * key,
363 drizzled::key_part_map keypart_map,
364 drizzled::ha_rkey_function find_flag)
366 CURSOR_NEW_STATE(
"::index_read_idx_map()");
367 CURSOR_NEW_STATE(
"locked");
368 return realCursor->index_read_idx_map(buf, index, key, keypart_map, find_flag);
371int SEAPITesterCursor::index_next(
unsigned char * buf)
373 CURSOR_NEW_STATE(
"::index_next()");
374 CURSOR_NEW_STATE(
"::doStartIndexScan()");
375 return realCursor->index_next(buf);
378int SEAPITesterCursor::doEndIndexScan()
380 CURSOR_NEW_STATE(
"::doEndIndexScan()");
381 CURSOR_NEW_STATE(
"locked");
382 int r= realCursor->doEndIndexScan();
384 active_index= realCursor->get_index();
389int SEAPITesterCursor::index_prev(
unsigned char * buf)
391 CURSOR_NEW_STATE(
"::index_prev()");
392 CURSOR_NEW_STATE(
"::doStartIndexScan()");
393 return realCursor->index_prev(buf);
396int SEAPITesterCursor::index_first(
unsigned char * buf)
398 CURSOR_NEW_STATE(
"::index_first()");
399 CURSOR_NEW_STATE(
"::doStartIndexScan()");
400 return realCursor->index_first(buf);
403int SEAPITesterCursor::index_last(
unsigned char * buf)
405 CURSOR_NEW_STATE(
"::index_last()");
406 CURSOR_NEW_STATE(
"::doStartIndexScan()");
407 return realCursor->index_last(buf);
412 CURSOR_NEW_STATE(
"::external_lock()");
413 CURSOR_NEW_STATE(
"locked");
415 user_session= session;
417 return realCursor->external_lock(session, lock_type);
422 enum thr_lock_type lock_type)
425 CURSOR_NEW_STATE(
"::store_lock()");
427 return realCursor->store_lock(session, to, lock_type);
430void SEAPITesterCursor::CURSOR_NEW_STATE(
const string &new_state)
432 state_multimap_iter cur= cursor_state_transitions.find(cursor_state);
433 if (cursor_state_transitions.count(cursor_state) == 0)
435 std::cerr <<
"ERROR: Invalid Cursor state: " << cursor_state << std::endl
436 <<
"This should *NEVER* happen."
438 <<
"i.e. you've really screwed it up and you should be ashamed of "
439 <<
"yourself." << std::endl;
440 assert(cursor_state_transitions.count(cursor_state));
443 for(cur= cursor_state_transitions.lower_bound(cursor_state);
444 cur != cursor_state_transitions.upper_bound(cursor_state);
447 if (new_state.compare((*cur).second) == 0)
451 if (cur == cursor_state_transitions.end()
452 || new_state.compare((*cur).second))
454 std::cerr <<
"ERROR: Invalid Cursor state transition!" << std::endl
455 <<
"Cursor " <<
this <<
"Cannot go from "
456 << cursor_state <<
" to " << new_state << std::endl;
460 cursor_state= new_state;
462 std::string cursor_state_str(
"Cursor ");
464 snprintf(nr,
sizeof(nr),
"%" PRIu64, this->
id);
465 cursor_state_str.append(nr);
466 cursor_state_str.append(
" ");
467 cursor_state_str.append(cursor_state);
469 engine_state_history.push_back(cursor_state_str);
471 std::cerr <<
"\t\tCursor " <<
this <<
" STATE : " << cursor_state << std::endl;
476static const char *api_tester_exts[] = {
488 SEAPITester(
const string &name_arg)
491 HTON_CAN_INDEX_BLOBS |
492 HTON_PRIMARY_KEY_IN_READ_INDEX |
493 HTON_PARTIAL_COLUMN_READ |
494 HTON_TABLE_SCAN_ON_INDEX |
495 HTON_HAS_FOREIGN_KEYS)
497 ENGINE_NEW_STATE(
"::SEAPITester()");
502 ENGINE_NEW_STATE(
"::~SEAPITester()");
506 return api_tester_exts;
512 Cursor *realCursor= getRealEngine()->create(table);
513 c->realCursor= realCursor;
521 const drizzled::message::Table& create_proto);
528 {
return getRealEngine()->renameTable(session, from, to); }
530 int doGetTableDefinition(
Session& ,
532 drizzled::message::Table &);
538 drizzled::identifier::table::vector &);
540 virtual int doStartTransaction(
Session *session,
541 start_transaction_option_t options);
542 virtual void doStartStatement(
Session *session);
543 virtual void doEndStatement(
Session *session);
548 ENGINE_NEW_STATE(
"SET SAVEPOINT");
549 ENGINE_NEW_STATE(
"In Transaction");
551 virtual int doRollbackToSavepoint(
Session*,
554 ENGINE_NEW_STATE(
"ROLLBACK TO SAVEPOINT");
555 ENGINE_NEW_STATE(
"In Transaction");
557 virtual int doReleaseSavepoint(
Session*,
560 ENGINE_NEW_STATE(
"RELEASE SAVEPOINT");
561 ENGINE_NEW_STATE(
"In Transaction");
567 uint32_t max_supported_record_length(
void)
const {
568 ENGINE_NEW_STATE(
"::max_supported_record_length()");
569 return getRealEngine()->max_supported_record_length();
572 uint32_t max_supported_keys(
void)
const {
573 ENGINE_NEW_STATE(
"::max_supported_keys()");
574 return getRealEngine()->max_supported_keys();
577 uint32_t max_supported_key_parts(
void)
const {
578 ENGINE_NEW_STATE(
"::max_supported_key_parts()");
579 return getRealEngine()->max_supported_key_parts();
582 uint32_t max_supported_key_length(
void)
const {
583 ENGINE_NEW_STATE(
"::max_supported_key_length()");
584 return getRealEngine()->max_supported_key_length();
587 uint32_t max_supported_key_part_length(
void)
const {
588 ENGINE_NEW_STATE(
"::max_supported_key_part_length()");
589 return getRealEngine()->max_supported_key_part_length();
593 uint32_t index_flags(drizzled::message::Table::Index::IndexType)
const
595 return (HA_READ_NEXT |
604bool SEAPITester::doDoesTableExist(Session &session,
const identifier::Table &identifier)
606 return getRealEngine()->doDoesTableExist(session, identifier);
609void SEAPITester::doGetTableIdentifiers(drizzled::CachedDirectory &cd,
610 const drizzled::identifier::Schema &si,
611 drizzled::identifier::table::vector &ti)
613 return getRealEngine()->doGetTableIdentifiers(cd, si, ti);
616int SEAPITester::doCreateTable(Session& session,
618 const drizzled::identifier::Table &identifier,
619 const drizzled::message::Table& create_proto)
621 ENGINE_NEW_STATE(
"::doCreateTable()");
623 int r= getRealEngine()->doCreateTable(session, table, identifier, create_proto);
625 ENGINE_NEW_STATE(
"::SEAPITester()");
631 return getRealEngine()->doDropTable(session, identifier);
634int SEAPITester::doGetTableDefinition(
Session& session,
636 drizzled::message::Table &table)
638 return getRealEngine()->doGetTableDefinition(session, identifier, table);
641int SEAPITester::doStartTransaction(
Session *session,
642 start_transaction_option_t opt)
644 ENGINE_NEW_STATE(
"BEGIN");
645 ENGINE_NEW_STATE(
"In Transaction");
647 return getRealEngine()->startTransaction(session, opt);
650void SEAPITester::doStartStatement(
Session *session)
652 ENGINE_NEW_STATE(
"START STATEMENT");
653 return getRealEngine()->startStatement(session);
656void SEAPITester::doEndStatement(Session *session)
658 ENGINE_NEW_STATE(
"END STATEMENT");
659 return getRealEngine()->endStatement(session);
666 ENGINE_NEW_STATE(
"COMMIT");
667 ENGINE_NEW_STATE(
"::SEAPITester()");
671 ENGINE_NEW_STATE(
"COMMIT STATEMENT");
672 ENGINE_NEW_STATE(
"In Transaction");
674 return getRealEngine()->commit(session, all);
681 ENGINE_NEW_STATE(
"ROLLBACK");
682 ENGINE_NEW_STATE(
"::SEAPITester()");
686 ENGINE_NEW_STATE(
"ROLLBACK STATEMENT");
687 ENGINE_NEW_STATE(
"In Transaction");
690 return getRealEngine()->rollback(session, all);
698 load_engine_state_transitions(engine_state_transitions);
699 load_cursor_state_transitions(cursor_state_transitions);
700 engine_state=
"INIT";
706 engine_state_history_table_initialize(context);
711DRIZZLE_DECLARE_PLUGIN
717 N_(
"StorageEngine module for testing call order"),
723DRIZZLE_DECLARE_PLUGIN_END;
bool check_argument_count(int n)
int doStartTableScan(bool scan)
int external_lock(Session *session, int lock_type)
THR_LOCK_DATA ** store_lock(Session *, THR_LOCK_DATA **to, enum thr_lock_type)
int index_read_idx_map(unsigned char *buf, uint32_t index, const unsigned char *key, drizzled::key_part_map keypart_map, drizzled::ha_rkey_function find_flag)
Positions an index cursor to the index specified in the handle. Fetches the row if available....
virtual int doSetSavepoint(Session *, drizzled::NamedSavepoint &)
const char ** bas_ext() const
virtual int doRollback(Session *, bool)
int doDropTable(Session &, const identifier::Table &identifier)
virtual int doCommit(Session *, bool)
TODO: Rename this file - func.h is stupid.