Merge lp:~stewart/drizzle/bug720552 into lp:drizzle/7.0

[Stewart Smith]

introduces a test for and fixes one of the places where we weren't handling errors correctly for doStartTableScan().

The test increases what storage_engine_api_tester covers to include index operations and properly support ::info() and ::extra(). This should also be useful in future tests of SE API.

http://hudson.drizzle.org/view/Drizzle-param/job/drizzle-param/747/

=== modified file 'drizzled/optimizer/sum.cc'
--- drizzled/optimizer/sum.cc	2011-02-12 22:27:36 +0000
+++ drizzled/optimizer/sum.cc	2011-02-17 08:09:59 +0000
@@ -266,6 +266,16 @@
                 break;
               }
               error= table->cursor->startIndexScan(static_cast<uint32_t>(ref.key), 1);
+              if (error)
+              {
+                if (table->key_read)
+                {
+                  table->key_read= 0;
+                  table->cursor->extra(HA_EXTRA_NO_KEYREAD);
+                }
+                table->print_error(error, MYF(0));
+                return error;
+              }
 
               if (! ref.key_length)
               {

=== modified file 'plugin/storage_engine_api_tester/cursor_states.cc'
--- plugin/storage_engine_api_tester/cursor_states.cc	2010-12-01 11:16:06 +0000
+++ plugin/storage_engine_api_tester/cursor_states.cc	2011-02-17 08:09:59 +0000
@@ -42,6 +42,10 @@
   states.insert(state_pair("::reset()", "::doOpen()"));
   states.insert(state_pair("::doEndTableScan()", "::reset()"));
   states.insert(state_pair("locked", "::reset()"));
+  states.insert(state_pair("locked", "::scan_time()"));
+  states.insert(state_pair("::scan_time()", "locked"));
+  states.insert(state_pair("::scan_time()", "::scan_time()"));
+
 
   // we can always set a new lock
   states.insert(state_pair("::store_lock()", "::store_lock()"));
@@ -58,6 +62,7 @@
   states.insert(state_pair("locked", "::doStartTableScan()"));
   states.insert(state_pair("::doStartTableScan()", "::rnd_next()"));
   states.insert(state_pair("::doStartTableScan()", "::rnd_pos()"));
+
   states.insert(state_pair("::rnd_pos()", "::rnd_pos()"));
   states.insert(state_pair("::rnd_pos()", "::doUpdateRecord()"));
 
@@ -66,6 +71,7 @@
 
   states.insert(state_pair("::rnd_next()", "::doEndTableScan()"));
   states.insert(state_pair("::rnd_next()", "::rnd_next()"));
+
   states.insert(state_pair("::doEndTableScan()", "::close()"));
   states.insert(state_pair("::doEndTableScan()", "::doStartTableScan()"));
 
@@ -86,4 +92,25 @@
 
   states.insert(state_pair("::doUpdateRecord()", "::doEndTableScan()"));
   states.insert(state_pair("::doUpdateRecord()", "::rnd_next()"));
+
+  states.insert(state_pair("locked", "::doStartIndexScan()"));
+  states.insert(state_pair("::doStartIndexScan()", "::doEndIndexScan()"));
+  states.insert(state_pair("::doEndIndexScan()", "locked"));
+
+  states.insert(state_pair("::doStartIndexScan()", "::index_first()"));
+  states.insert(state_pair("::doStartIndexScan()", "::index_last()"));
+  states.insert(state_pair("::doStartIndexScan()", "::index_next()"));
+  states.insert(state_pair("::doStartIndexScan()", "::index_prev()"));
+  states.insert(state_pair("::index_first()", "::doStartIndexScan()"));
+  states.insert(state_pair("::index_last()", "::doStartIndexScan()"));
+  states.insert(state_pair("::index_next()", "::doStartIndexScan()"));
+  states.insert(state_pair("::index_prev()", "::doStartIndexScan()"));
+  states.insert(state_pair("::doStartIndexScan()", "::doStartIndexScan() ERROR"));
+  states.insert(state_pair("::doStartIndexScan() ERROR", "locked"));
+
+  states.insert(state_pair("::doStartIndexScan()", "::index_read()"));
+  states.insert(state_pair("::doStartIndexScan()", "::index_read_idx_map()"));
+  states.insert(state_pair("::index_read()", "::doStartIndexScan()"));
+  states.insert(state_pair("::index_read_idx_map()", "::doStartIndexScan()"));
+
 }

=== modified file 'plugin/storage_engine_api_tester/engine_states.cc'
--- plugin/storage_engine_api_tester/engine_states.cc	2011-02-11 05:04:11 +0000
+++ plugin/storage_engine_api_tester/engine_states.cc	2011-02-17 08:09:59 +0000
@@ -45,6 +45,7 @@
   states.insert(state_pair("::max_supported_key_part_length()", "::max_supported_key_part_length()"));
   states.insert(state_pair("::max_supported_key_part_length()", "::doCreateTable()"));
 
+  states.insert(state_pair("::max_supported_key_parts()", "::max_supported_key_parts()"));
   states.insert(state_pair("::max_supported_key_parts()", "::max_supported_keys()"));
 
   // what the

=== modified file 'plugin/storage_engine_api_tester/storage_engine_api_tester.cc'
--- plugin/storage_engine_api_tester/storage_engine_api_tester.cc	2011-02-11 23:30:04 +0000
+++ plugin/storage_engine_api_tester/storage_engine_api_tester.cc	2011-02-17 08:09:59 +0000
@@ -53,13 +53,17 @@
    -------------------------------
 
    IF you add a new error injection, document it here!
+   You test via error_injected variable.
 
    Conflicting error inject numbers will lead to tears
    (not Borsch, Vodka and Tears - that's quite nice).
 
+   0 - DISABLED
+
    1 - doInsertRecord(): every 2nd row, LOCK_WAIT_TIMEOUT.
    2 - doInsertRecord(): every 2nd row, DEADLOCK.
    3 - rnd_next(): every 2nd row, LOCK_WAIT_TIMEOUT
+   4 - doStartIndexScan returns an error.
  */
 static uint32_t error_injected= 0;
 
@@ -178,6 +182,29 @@
   int doStartTableScan(bool scan) { CURSOR_NEW_STATE("::doStartTableScan()"); return realCursor->doStartTableScan(scan); }
   int doEndTableScan() { CURSOR_NEW_STATE("::doEndTableScan()"); return realCursor->doEndTableScan(); }
 
+  const char *index_type(uint32_t key_number);
+
+  int doStartIndexScan(uint32_t, bool);
+  int index_read(unsigned char *buf, const unsigned char *key_ptr,
+                 uint32_t key_len, drizzled::ha_rkey_function find_flag);
+  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);
+
+  int index_next(unsigned char * buf);
+  int doEndIndexScan();
+  int index_prev(unsigned char * buf);
+  int index_first(unsigned char * buf);
+  int index_last(unsigned char * buf);
+
+  bool primary_key_is_clustered()
+  {
+    return realCursor->primary_key_is_clustered();
+  }
+
+
   int doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked);
 
   THR_LOCK_DATA **store_lock(Session *,
@@ -212,6 +239,18 @@
     return realCursor->doUpdateRecord(old_row, new_row);
   }
 
+  double scan_time()
+  {
+    CURSOR_NEW_STATE("::scan_time()");
+    CURSOR_NEW_STATE("locked");
+    return realCursor->scan_time();
+  }
+
+  int extra(enum ha_extra_function operation)
+  {
+    return realCursor->extra(operation);
+  }
+
 private:
   string cursor_state;
   void CURSOR_NEW_STATE(const string &new_state);
@@ -257,10 +296,106 @@
 
 int SEAPITesterCursor::info(uint32_t flag)
 {
+  int r;
   CURSOR_NEW_STATE("::info()");
   CURSOR_NEW_STATE("locked");
 
-  return realCursor->info(flag);
+  r= realCursor->info(flag);
+
+  if (flag & (HA_STATUS_VARIABLE|HA_STATUS_AUTO|HA_STATUS_CONST))
+  {
+    stats= realCursor->stats;
+  }
+
+  if (flag & HA_STATUS_ERRKEY)
+    errkey= realCursor->errkey;
+
+  return r;
+}
+
+const char * SEAPITesterCursor::index_type(uint32_t key_number)
+{
+  CURSOR_NEW_STATE("::index_type()");
+  return realCursor->index_type(key_number);
+}
+
+int SEAPITesterCursor::doStartIndexScan(uint32_t keynr, bool scan)
+{
+  int r;
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+
+  if (error_injected == 4)
+  {
+    CURSOR_NEW_STATE("::doStartIndexScan() ERROR");
+    CURSOR_NEW_STATE("locked");
+    return HA_ERR_LOCK_DEADLOCK;
+  }
+
+  r= realCursor->doStartIndexScan(keynr, scan);
+
+  active_index= realCursor->get_index();
+
+  return r;
+}
+
+int SEAPITesterCursor::index_read(unsigned char *buf,
+                                  const unsigned char *key_ptr,
+                                  uint32_t key_len,
+                                  drizzled::ha_rkey_function find_flag)
+{
+  CURSOR_NEW_STATE("::index_read()");
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+  return realCursor->index_read(buf, key_ptr, key_len, find_flag);
+}
+
+int SEAPITesterCursor::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)
+{
+  CURSOR_NEW_STATE("::index_read_idx_map()");
+  CURSOR_NEW_STATE("locked");
+  return realCursor->index_read_idx_map(buf, index, key, keypart_map, find_flag);
+}
+
+int SEAPITesterCursor::index_next(unsigned char * buf)
+{
+  CURSOR_NEW_STATE("::index_next()");
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+  return realCursor->index_next(buf);
+}
+
+int SEAPITesterCursor::doEndIndexScan()
+{
+  CURSOR_NEW_STATE("::doEndIndexScan()");
+  CURSOR_NEW_STATE("locked");
+  int r= realCursor->doEndIndexScan();
+
+  active_index= realCursor->get_index();
+
+  return r;
+}
+
+int SEAPITesterCursor::index_prev(unsigned char * buf)
+{
+  CURSOR_NEW_STATE("::index_prev()");
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+  return realCursor->index_prev(buf);
+}
+
+int SEAPITesterCursor::index_first(unsigned char * buf)
+{
+  CURSOR_NEW_STATE("::index_first()");
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+  return realCursor->index_first(buf);
+}
+
+int SEAPITesterCursor::index_last(unsigned char * buf)
+{
+  CURSOR_NEW_STATE("::index_last()");
+  CURSOR_NEW_STATE("::doStartIndexScan()");
+  return realCursor->index_last(buf);
 }
 
 int SEAPITesterCursor::external_lock(Session *session, int lock_type)
@@ -437,6 +572,16 @@
     return getRealEngine()->max_supported_key_part_length();
   }
 
+  /* just copied from innobase... */
+  uint32_t index_flags(enum  ha_key_alg) const
+  {
+    return (HA_READ_NEXT |
+            HA_READ_PREV |
+            HA_READ_RANGE |
+            HA_READ_ORDER |
+            HA_KEYREAD_ONLY);
+  }
+
 };
 
 bool SEAPITester::doDoesTableExist(Session &session, const identifier::Table &identifier)

=== added file 'plugin/storage_engine_api_tester/tests/r/min_index_scan_error.result'
--- plugin/storage_engine_api_tester/tests/r/min_index_scan_error.result	1970-01-01 00:00:00 +0000
+++ plugin/storage_engine_api_tester/tests/r/min_index_scan_error.result	2011-02-17 08:09:59 +0000
@@ -0,0 +1,35 @@
+create table t1 (a int primary key auto_increment, b int, index(b)) engine=storage_engine_api_tester;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` INT NOT NULL AUTO_INCREMENT,
+  `b` INT DEFAULT NULL,
+  PRIMARY KEY (`a`),
+  KEY `b` (`b`)
+) ENGINE=STORAGE_ENGINE_API_TESTER COLLATE = utf8_general_ci
+insert into t1 (b) values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
+insert into t1 (b) values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
+explain select min(b) from t1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	NULL	NULL	NULL	NULL	NULL	NULL	NULL	Select tables optimized away
+SELECT seapitester_error_inject(4);
+seapitester_error_inject(4)
+4
+select seapitester_clear_engine_state_history();
+seapitester_clear_engine_state_history()
+0
+select min(b) from t1;
+Got one of the listed errors
+select * from data_dictionary.seapitester_engine_state_history;
+STATE
+START STATEMENT
+END STATEMENT
+ROLLBACK
+::SEAPITester()
+select seapitester_clear_engine_state_history();
+seapitester_clear_engine_state_history()
+0
+SELECT seapitester_error_inject(0);
+seapitester_error_inject(0)
+0
+drop table t1;

=== added file 'plugin/storage_engine_api_tester/tests/t/min_index_scan_error.test'
--- plugin/storage_engine_api_tester/tests/t/min_index_scan_error.test	1970-01-01 00:00:00 +0000
+++ plugin/storage_engine_api_tester/tests/t/min_index_scan_error.test	2011-02-17 08:09:59 +0000
@@ -0,0 +1,13 @@
+create table t1 (a int primary key auto_increment, b int, index(b)) engine=storage_engine_api_tester;
+show create table t1;
+insert into t1 (b) values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
+insert into t1 (b) values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10);
+explain select min(b) from t1;
+SELECT seapitester_error_inject(4);
+select seapitester_clear_engine_state_history();
+--error ER_LOCK_DEADLOCK,ER_LOCK_WAIT_TIMEOUT
+select min(b) from t1;
+select * from data_dictionary.seapitester_engine_state_history;
+select seapitester_clear_engine_state_history();
+SELECT seapitester_error_inject(0);
+drop table t1;