bk commit into 5.1 tree (pekka:1.2403)

[pekka]

Below is the list of changes that have just been committed into a local
5.1 repository of pekka. When pekka does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2007-02-06 13:12:58+01:00, pekka@stripped +4 -0
  ndb - wl#3600 support for abort and NF
  keep iterators on the nodes in sync 

  storage/ndb/include/kernel/signaldata/SchemaTransImpl.hpp@stripped, 2007-02-06
13:10:24+01:00, pekka@stripped +42 -32
    wl#3600 keep iterators in sync

  storage/ndb/src/common/debugger/signaldata/SchemaTransImpl.cpp@stripped, 2007-02-06
13:10:24+01:00, pekka@stripped +6 -3
    wl#3600 keep iterators in sync

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp@stripped, 2007-02-06 13:10:24+01:00,
pekka@stripped +334 -116
    wl#3600 keep iterators in sync

  storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp@stripped, 2007-02-06 13:10:25+01:00,
pekka@stripped +92 -40
    wl#3600 keep iterators in sync

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	pekka
# Host:	clam.(none)
# Root:	/export/space/pekka/ndb/version/my52-wl3600-b

--- 1.145/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2007-02-04 22:43:48 +01:00
+++ 1.146/storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp	2007-02-06 13:10:24 +01:00
@@ -3902,7 +3902,9 @@
   &Dbdict::createTable_reply,
   //
   &Dbdict::createTable_prepare,
-  &Dbdict::createTable_commit
+  &Dbdict::createTable_commit,
+  //
+  &Dbdict::createTable_abort
 };
 
 bool
@@ -4294,8 +4296,7 @@
 }
 
 void
-Dbdict::createTable_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                          Uint32 repeat)
+Dbdict::createTable_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
@@ -4329,8 +4330,7 @@
 }
 
 void
-Dbdict::createTable_commit(Signal* signal, SchemaOpPtr op_ptr,
-                         Uint32 repeat)
+Dbdict::createTable_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   CreateTableDataPtr createTabPtr;
@@ -4367,6 +4367,11 @@
 }
 
 void
+Dbdict::createTable_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execBACKUP_FRAGMENT_REQ(Signal* signal)
 {
   jamEntry();
@@ -6198,7 +6203,9 @@
   &Dbdict::alterTable_reply,
   //
   &Dbdict::alterTable_prepare,
-  &Dbdict::alterTable_commit
+  &Dbdict::alterTable_commit,
+  //
+  &Dbdict::alterTable_abort
 };
 
 bool
@@ -6629,9 +6636,11 @@
 }
 
 void
-Dbdict::alterTable_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                           Uint32 repeat)
+Dbdict::alterTable_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   AlterTableDataPtr alterTabPtr;
   getOpData(op_ptr, alterTabPtr);
   const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
@@ -6653,7 +6662,7 @@
   alterTabPtr.p->m_oldTableRecord = *origTablePtr.p;
 
   Uint32 changeMask = impl_req->changeMask;
-  
+
   if (AlterTableReq::getNameFlag(changeMask)) {
     jam();
     // Table rename
@@ -6698,7 +6707,7 @@
   // Set new schema version
   origTablePtr.p->tableVersion = newTablePtr.p->tableVersion;
 
-  schemaTrans_sendConf(signal, op_ptr.p->m_trans_ptr, 0);
+  schemaTrans_sendConf(signal, trans_ptr, 0);
 }
 
 void
@@ -6797,9 +6806,11 @@
 }
 
 void
-Dbdict::alterTable_commit(Signal* signal, SchemaOpPtr op_ptr,
-                          Uint32 repeat)
+Dbdict::alterTable_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   AlterTableDataPtr alterTabPtr;
   getOpData(op_ptr, alterTabPtr);
   const AlterTabReq* impl_req = &alterTabPtr.p->m_request;
@@ -6847,6 +6858,11 @@
 }
 
 void
+Dbdict::alterTable_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::alterTable_backup_mutex_locked(Signal* signal,
 				       Uint32 callbackData,
 				       Uint32 retValue)
@@ -7796,7 +7812,9 @@
   &Dbdict::dropTable_reply,
   //
   &Dbdict::dropTable_prepare,
-  &Dbdict::dropTable_commit
+  &Dbdict::dropTable_commit,
+  //
+  &Dbdict::dropTable_abort
 };
 
 bool
@@ -8064,9 +8082,11 @@
 }
 
 void
-Dbdict::dropTable_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                          Uint32 repeat)
+Dbdict::dropTable_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   DropTableDataPtr dropTabPtr;
   getOpData(op_ptr, dropTabPtr);
 
@@ -8082,9 +8102,11 @@
 }
 
 void
-Dbdict::dropTable_commit(Signal* signal, SchemaOpPtr op_ptr,
-                         Uint32 repeat)
+Dbdict::dropTable_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   DropTableDataPtr dropTabPtr;
   getOpData(op_ptr, dropTabPtr);
 
@@ -8147,6 +8169,11 @@
 }
 
 void
+Dbdict::dropTable_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::dropTable_backup_mutex_locked(Signal* signal, 
 				      Uint32 callbackData,
 				      Uint32 retValue)
@@ -9409,7 +9436,9 @@
   &Dbdict::createIndex_reply,
   //
   &Dbdict::createIndex_prepare,
-  &Dbdict::createIndex_commit
+  &Dbdict::createIndex_commit,
+  //
+  &Dbdict::createIndex_abort
 };
 
 bool
@@ -10147,8 +10176,7 @@
 }
 
 void
-Dbdict::createIndex_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                            Uint32 repeat)
+Dbdict::createIndex_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("createIndex_prepare");
@@ -10157,8 +10185,7 @@
 }
 
 void
-Dbdict::createIndex_commit(Signal* signal, SchemaOpPtr op_ptr,
-                           Uint32 repeat)
+Dbdict::createIndex_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("createIndex_commit");
@@ -10167,6 +10194,11 @@
 }
 
 void
+Dbdict::createIndex_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execCREATE_INDX_CONF(Signal* signal)
 {
   ndbrequire(false);
@@ -10717,7 +10749,9 @@
   &Dbdict::dropIndex_reply,
   //
   &Dbdict::dropIndex_prepare,
-  &Dbdict::dropIndex_commit
+  &Dbdict::dropIndex_commit,
+  //
+  &Dbdict::dropIndex_abort
 };
 
 bool
@@ -11047,9 +11081,11 @@
 }
 
 void
-Dbdict::dropIndex_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                          Uint32 repeat)
+Dbdict::dropIndex_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   DropIndexDataPtr dropIndexPtr;
   getOpData(op_ptr, dropIndexPtr);
 
@@ -11059,9 +11095,11 @@
 }
 
 void
-Dbdict::dropIndex_commit(Signal* signal, SchemaOpPtr op_ptr,
-                         Uint32 repeat)
+Dbdict::dropIndex_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   DropIndexDataPtr dropIndexPtr;
   getOpData(op_ptr, dropIndexPtr);
 
@@ -11071,6 +11109,11 @@
 }
 
 void
+Dbdict::dropIndex_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execDROP_INDX_CONF(Signal* signal)
 {
   ndbrequire(false);
@@ -13638,7 +13681,9 @@
   &Dbdict::alterIndex_reply,
   //
   &Dbdict::alterIndex_prepare,
-  &Dbdict::alterIndex_commit
+  &Dbdict::alterIndex_commit,
+  //
+  &Dbdict::alterIndex_abort
 };
 
 bool
@@ -14364,9 +14409,11 @@
 }
 
 void
-Dbdict::alterIndex_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                          Uint32 repeat)
+Dbdict::alterIndex_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   AlterIndexDataPtr alterIndexPtr;
   getOpData(op_ptr, alterIndexPtr);
   const AlterIndxImplReq* impl_req = &alterIndexPtr.p->m_request;
@@ -14569,10 +14616,12 @@
 }
 
 void
-Dbdict::alterIndex_commit(Signal* signal, SchemaOpPtr op_ptr,
-                         Uint32 repeat)
+Dbdict::alterIndex_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   AlterIndexDataPtr alterIndexPtr;
   getOpData(op_ptr, alterIndexPtr);
 
@@ -14582,6 +14631,11 @@
 }
 
 void
+Dbdict::alterIndex_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execALTER_INDX_IMPL_CONF(Signal* signal)
 {
   jamEntry();
@@ -15242,7 +15296,9 @@
   &Dbdict::buildIndex_reply,
   //
   &Dbdict::buildIndex_prepare,
-  &Dbdict::buildIndex_commit
+  &Dbdict::buildIndex_commit,
+  //
+  &Dbdict::buildIndex_abort
 };
 
 bool
@@ -15515,8 +15571,7 @@
  */
 
 void
-Dbdict::buildIndex_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                            Uint32 repeat)
+Dbdict::buildIndex_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   BuildIndexDataPtr buildIndexPtr;
@@ -15619,9 +15674,11 @@
 }
 
 void
-Dbdict::buildIndex_commit(Signal* signal, SchemaOpPtr op_ptr,
-                           Uint32 repeat)
+Dbdict::buildIndex_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   jam();
   BuildIndexDataPtr buildIndexPtr;
   getOpData(op_ptr, buildIndexPtr);
@@ -15641,6 +15698,11 @@
 }
 
 void
+Dbdict::buildIndex_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::buildIndex_toLocalOnline(Signal* signal, SchemaOpPtr op_ptr)
 {
   BuildIndexDataPtr buildIndexPtr;
@@ -16199,7 +16261,9 @@
   &Dbdict::createTrigger_reply,
   //
   &Dbdict::createTrigger_prepare,
-  &Dbdict::createTrigger_commit
+  &Dbdict::createTrigger_commit,
+  //
+  &Dbdict::createTrigger_abort
 };
 
 bool
@@ -16730,8 +16794,7 @@
 }
 
 void
-Dbdict::createTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                              Uint32 repeat)
+Dbdict::createTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   CreateTriggerDataPtr createTriggerPtr;
@@ -16784,8 +16847,7 @@
 }
 
 void
-Dbdict::createTrigger_commit(Signal* signal, SchemaOpPtr op_ptr,
-                             Uint32 repeat)
+Dbdict::createTrigger_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("createTrigger_commit");
@@ -16794,6 +16856,11 @@
 }
 
 void
+Dbdict::createTrigger_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execCREATE_TRIG_CONF(Signal* signal) 
 {
   jamEntry();
@@ -17185,7 +17252,9 @@
   &Dbdict::dropTrigger_reply,
   //
   &Dbdict::dropTrigger_prepare,
-  &Dbdict::dropTrigger_commit
+  &Dbdict::dropTrigger_commit,
+  //
+  &Dbdict::dropTrigger_abort
 };
 
 bool
@@ -17648,8 +17717,7 @@
 }
 
 void
-Dbdict::dropTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                            Uint32 repeat)
+Dbdict::dropTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("dropTrigger_prepare");
@@ -17658,8 +17726,7 @@
 }
 
 void
-Dbdict::dropTrigger_commit(Signal* signal, SchemaOpPtr op_ptr,
-                           Uint32 repeat)
+Dbdict::dropTrigger_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("dropTrigger_commit");
@@ -17679,6 +17746,11 @@
 }
 
 void
+Dbdict::dropTrigger_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execDROP_TRIG_CONF(Signal* signal) 
 {
   jamEntry();
@@ -17950,7 +18022,9 @@
   &Dbdict::alterTrigger_reply,
   //
   &Dbdict::alterTrigger_prepare,
-  &Dbdict::alterTrigger_commit
+  &Dbdict::alterTrigger_commit,
+  //
+  &Dbdict::alterTrigger_abort
 };
 
 bool
@@ -18239,10 +18313,12 @@
 }
 
 void
-Dbdict::alterTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr,
-                             Uint32 repeat)
+Dbdict::alterTrigger_prepare(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
+  SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   D("alterTrigger_prepare" << V(repeat) << *op_ptr.p);
 
   AlterTriggerDataPtr alterTriggerPtr;
@@ -18445,8 +18521,7 @@
 }
 
 void
-Dbdict::alterTrigger_commit(Signal* signal, SchemaOpPtr op_ptr,
-                            Uint32 repeat)
+Dbdict::alterTrigger_commit(Signal* signal, SchemaOpPtr op_ptr)
 {
   jam();
   D("alterTrigger_commit");
@@ -18475,6 +18550,11 @@
 }
 
 void
+Dbdict::alterTrigger_abort(Signal* signal, SchemaOpPtr op_ptr)
+{
+}
+
+void
 Dbdict::execALTER_TRIG_CONF(Signal* signal) 
 {
   // wl3600_todo template these routines
@@ -22169,9 +22249,6 @@
       trans_ptr.p->trans_key = trans_key;
       if (c_phaseIteratorPool.seize(trans_ptr.p->m_iterator_ptr)) {
         jam();
-        PhaseIterator& it = getIterator(trans_ptr);
-        // set parse phase iterator
-        new (&it) PhaseIterator(0, g_parsePhaseList, trans_ptr.p->m_opList);
         c_schemaTransHash.add(trans_ptr);
         D("seizeSchemaTrans" << V(trans_ptr.i) << *trans_ptr.p);
         return true;
@@ -22232,6 +22309,13 @@
   return *iterator_ptr.p;
 }
 
+Uint32
+Dbdict::getIteratorRepeat(SchemaTransPtr trans_ptr)
+{
+  const PhaseIterator& it = getIterator(trans_ptr);
+  return it.m_repeat;
+}
+
 // client requests
 
 void
@@ -22271,6 +22355,12 @@
       break;
     }
 
+    // initialize iterator in master
+    {
+      PhaseIterator& it = getIterator(trans_ptr);
+      new (&it) PhaseIterator(1, g_defaultPhaseList, trans_ptr.p->m_opList);
+    }
+
     trans_ptr.p->m_clientRef = clientRef;
     trans_ptr.p->m_transId = transId;
     trans_ptr.p->m_initialNodes = c_aliveNodes;
@@ -22335,11 +22425,8 @@
       abortSchemaTrans(signal, trans_ptr);
       return;
     }
-    // wl3600_todo check no parse REFs on ops
 
-    // set iterator and start execution phases
-    PhaseIterator& it = getIterator(trans_ptr);
-    new (&it) PhaseIterator(1, g_execPhaseList, trans_ptr.p->m_opList);
+    // wl3600_todo check no parse REFs on ops
     runSchemaTrans(signal, trans_ptr, SchemaTransImplConf::RF_FIRST);
 
     return;
@@ -22366,7 +22453,7 @@
   const PhaseIterator& it = getIterator(trans_ptr);
   SchemaOpPtr op_ptr = itGetPtr(it);
 
-  Uint32 requestType = trans_ptr.p->m_requestType;
+  const Uint32 requestType = trans_ptr.p->m_requestType;
   Uint32 gsn = 0;
 
   // piggy-backed signal in parse phase
@@ -22393,14 +22480,18 @@
   SchemaTransImplReq::setRequestType(requestInfo, requestType);
   SchemaTransImplReq::setOpDepth(requestInfo, trans_ptr.p->m_opDepth);
   SchemaTransImplReq::setGsn(requestInfo, gsn);
-  SchemaTransImplReq::setListId(requestInfo, it.m_id);
-  SchemaTransImplReq::setListIndex(requestInfo, it.m_index);
-  SchemaTransImplReq::setRepeat(requestInfo, it.m_repeat);
+
+  Uint32 iteratorInfo = 0;
+  SchemaTransImplReq::setListId(iteratorInfo, it.m_id);
+  SchemaTransImplReq::setListIndex(iteratorInfo, it.m_index);
+  SchemaTransImplReq::setRepeat(iteratorInfo, it.m_repeat);
+  SchemaTransImplReq::setAbortMode(iteratorInfo, trans_ptr.p->m_abortMode);
 
   req->senderRef = reference();
   req->transKey = trans_ptr.p->trans_key;
   req->opKey = !op_ptr.isNull() ? op_ptr.p->op_key : RNIL;
   req->requestInfo = requestInfo;
+  req->iteratorInfo = iteratorInfo;
   req->clientRef = trans_ptr.p->m_clientRef;
   req->transId = trans_ptr.p->m_transId;
 
@@ -22652,6 +22743,7 @@
   Uint32 trans_key = req->transKey;
   Uint32 op_key = req->opKey;
   Uint32 requestInfo = req->requestInfo;
+  Uint32 iteratorInfo = req->iteratorInfo;
   Uint32 clientRef = req->clientRef;
   Uint32 transId = req->transId;
 
@@ -22659,9 +22751,12 @@
   Uint32 requestType = SchemaTransImplReq::getRequestType(requestInfo);
   Uint32 opDepth = SchemaTransImplReq::getOpDepth(requestInfo);
   Uint32 gsn = SchemaTransImplReq::getGsn(requestInfo);
-  Uint32 listId = SchemaTransImplReq::getListId(requestInfo);
-  Uint32 listIndex = SchemaTransImplReq::getListIndex(requestInfo);
-  Uint32 repeat = SchemaTransImplReq::getRepeat(requestInfo);
+
+  // unpack iteratorInfo
+  Uint32 listId = SchemaTransImplReq::getListId(iteratorInfo);
+  Uint32 listIndex = SchemaTransImplReq::getListIndex(iteratorInfo);
+  Uint32 repeat = SchemaTransImplReq::getRepeat(iteratorInfo);
+  Uint32 abortMode = SchemaTransImplReq::getAbortMode(iteratorInfo);
 
   D("schemaTrans_recvReq");
 
@@ -22706,9 +22801,19 @@
     }
     trans_ptr.p->m_masterRef = senderRef;
 
+    // iterator on slave will be initialized or advanced
+    PhaseIterator& it = getIterator(trans_ptr);
+
     switch (requestType) {
     case SchemaTransImplReq::RT_BEGIN:
       jam();
+      {
+        // initialize iterator on slave
+        if (!isMaster) {
+          PhaseIterator& it = getIterator(trans_ptr);
+          new (&it) PhaseIterator(1, g_defaultPhaseList, trans_ptr.p->m_opList);
+        }
+      }
       break;
 
     case SchemaTransImplReq::RT_PARSE:
@@ -22727,7 +22832,8 @@
         }
         /*
          * Use internal signal gsn to find operation type.
-         * Create and parse the operation on slaves.
+         * Create and parse the operation on slave participant.
+         * Iterator is advanced in addSchemaOp().
          */
         const OpInfo* info = findOpInfo(gsn);
         ndbrequire(info != 0);
@@ -22744,31 +22850,54 @@
       jam();
     case SchemaTransImplReq::RT_COMMIT_END:
       jam();
-      /*
-       * Simple request i.e. no operation.
-       */
-      {
-        ndbrequire(listId == 1);
-        const PhaseList& pl = g_execPhaseList;
-        ndbrequire(listIndex < pl.m_count);
-        const PhaseEntry& pe = pl.m_entry[listIndex];
-
-        ndbrequire((pe.m_flags & PH_SIMPLE) && pe.m_simple != 0);
-        (this->*(pe.m_simple))(signal, trans_ptr, repeat);
-      }
-      break;
-
     case SchemaTransImplReq::RT_PREPARE:
       jam();
     case SchemaTransImplReq::RT_COMMIT:
       jam();
-      /*
-       * Participants receive current operation key.
-       */
       {
-        SchemaOpPtr op_ptr;
-        findSchemaOp(op_ptr, op_key);
-        runSchemaOp(signal, op_ptr, repeat);
+        // advance iterator on slave
+        if (!isMaster) {
+          jam();
+          if (! repeat) {
+            bool ok = itNext(it);
+            ndbrequire(ok);
+          } else {
+            jam();
+            bool ok = itRepeat(it);
+            ndbrequire(ok);
+          }
+        }
+        ndbrequire(it.m_id == listId);
+        ndbrequire(it.m_index == listIndex);
+        ndbrequire(it.m_repeat == repeat);
+
+        const PhaseList& pl = it.m_phaseList;
+        ndbrequire(listIndex < pl.m_count);
+        const PhaseEntry& pe = pl.m_entry[listIndex];
+
+        // master phase on slave does nothing more
+        if (!isMaster && (pe.m_flags & PH_MASTER)) {
+            jam();
+            schemaTrans_sendConf(signal, trans_ptr, 0);
+            return;
+        }
+
+        if (pe.m_flags & PH_SIMPLE) {
+          jam();
+          ndbrequire(pe.m_simple != 0);
+          (this->*(pe.m_simple))(signal, trans_ptr);
+        } else {
+          jam();
+          SchemaOpPtr op_ptr;
+          findSchemaOp(op_ptr, op_key);
+          ndbrequire(!op_ptr.isNull());
+          {
+            SchemaOpPtr op_ptr2 = itGetPtr(it);
+            ndbrequire(op_ptr.i == op_ptr2.i);
+            ndbrequire(op_ptr.p == op_ptr2.p);
+          }
+          runSchemaOp(signal, op_ptr);
+        }
       }
       break;
 
@@ -22855,13 +22984,17 @@
     bool rf_repeat = (runFlag & SchemaTransImplConf::RF_REPEAT);
     if (rf_first) {
       jam();
-      found = itFirst(it);
+      // at PARSE, at last op
+      ndbrequire(it.m_index == 0);
+      ndbrequire(!itHasNext(it.m_opIterator));
+      found = itNext(it);
     } else if (!rf_repeat) {
       jam();
       found = itNext(it);
     } else {
       jam();
-      itRepeat(it);
+      bool ok = itRepeat(it);
+      ndbrequire(ok);
       found = true;
     }
   }
@@ -22882,8 +23015,11 @@
       ndbrequire(op_ptr.isNull() && pe.m_simple != 0);
 
       if (pe.m_flags & PH_MASTER) {
-        // via signal
-        schemaTrans_sendReq(signal, trans_ptr, true);
+        /*
+         * master phase is sent to all nodes in order to keep
+         * iterators synced.  slaves will not execute it.
+         */
+        schemaTrans_sendReq(signal, trans_ptr, false);
       } else {
         // not yet used
         ndbrequire(false);
@@ -22901,7 +23037,7 @@
 
 // participant
 void
-Dbdict::runSchemaOp(Signal* signal, SchemaOpPtr op_ptr, Uint32 repeat)
+Dbdict::runSchemaOp(Signal* signal, SchemaOpPtr op_ptr)
 {
   SchemaTransPtr trans_ptr = op_ptr.p->m_trans_ptr;
   const OpInfo& info = getOpInfo(op_ptr);
@@ -22911,10 +23047,10 @@
 
   switch (trans_ptr.p->m_requestType) {
   case SchemaTransImplReq::RT_PREPARE:
-    (this->*(info.m_prepare))(signal, op_ptr, repeat);
+    (this->*(info.m_prepare))(signal, op_ptr);
     break;
   case SchemaTransImplReq::RT_COMMIT:
-    (this->*(info.m_commit))(signal, op_ptr, repeat);
+    (this->*(info.m_commit))(signal, op_ptr);
     break;
   default:
     ndbrequire(false);
@@ -22956,12 +23092,42 @@
 }
 
 bool
+Dbdict::itLast(OpIterator& it)
+{
+  LocalDLFifoList<SchemaOp> list(c_schemaOpPool, it.m_opList.m_head);
+  return list.last(it.m_op_ptr);
+}
+
+bool
 Dbdict::itNext(OpIterator& it)
 {
   LocalDLFifoList<SchemaOp> list(c_schemaOpPool, it.m_opList.m_head);
   return list.next(it.m_op_ptr);
 }
 
+bool
+Dbdict::itPrev(OpIterator& it)
+{
+  LocalDLFifoList<SchemaOp> list(c_schemaOpPool, it.m_opList.m_head);
+  return list.prev(it.m_op_ptr);
+}
+
+bool
+Dbdict::itHasNext(OpIterator& it)
+{
+  LocalDLFifoList<SchemaOp> list(c_schemaOpPool, it.m_opList.m_head);
+  return list.hasNext(it.m_op_ptr);
+}
+
+bool
+Dbdict::itHasPrev(OpIterator& it)
+{
+  LocalDLFifoList<SchemaOp> list(c_schemaOpPool, it.m_opList.m_head);
+  return list.hasPrev(it.m_op_ptr);
+}
+
+// phase iterator
+
 Dbdict::SchemaOpPtr
 Dbdict::itGetPtr(const PhaseIterator& it)
 {
@@ -23010,15 +23176,37 @@
 }
 
 bool
+Dbdict::itLast(PhaseIterator& it)
+{
+  D("itLast" << it);
+  it.m_repeat = 0;
+  const PhaseList& pl = it.m_phaseList;
+  for (it.m_index = pl.m_count - 1; it.m_index != (Uint32)-1; it.m_index--) {
+    const PhaseEntry& pe = pl.m_entry[it.m_index];
+    if (pe.m_flags & PH_SIMPLE) {
+      it.m_opIterator.m_op_ptr.setNull();
+      D("itLast [simple]");
+      return true;
+    }
+    if (itLast(it.m_opIterator)) {
+      D("itLast [last op]" << it);
+      return true;
+    }
+    // empty op list is allowed, keep looking for simple phase
+  }
+  return false;
+}
+
+bool
 Dbdict::itNext(PhaseIterator& it)
 {
   D("itNext" << it);
   it.m_repeat = 0;
   const PhaseList& pl = it.m_phaseList;
-  bool first = true;
-  for (; it.m_index < pl.m_count; it.m_index++, first = false) {
+  bool loop_one = true;
+  for (; it.m_index < pl.m_count; it.m_index++, loop_one = false) {
     const PhaseEntry& pe = pl.m_entry[it.m_index];
-    if (first) {
+    if (loop_one) {
       if (pe.m_flags & PH_SIMPLE)
         continue;
       if (itNext(it.m_opIterator)) {
@@ -23041,35 +23229,65 @@
   return false;
 }
 
-void
+bool
+Dbdict::itPrev(PhaseIterator& it)
+{
+  D("itPrev" << it);
+  it.m_repeat = 0;
+  const PhaseList& pl = it.m_phaseList;
+  bool loop_one = true;
+  for (; it.m_index != (Uint32)-1; it.m_index--, loop_one = false) {
+    const PhaseEntry& pe = pl.m_entry[it.m_index];
+    if (loop_one) {
+      if (pe.m_flags & PH_SIMPLE)
+        continue;
+      if (itPrev(it.m_opIterator)) {
+        D("itPrev [prev op]" << it);
+        return true;
+      }
+    } else {
+      if (pe.m_flags & PH_SIMPLE) {
+        it.m_opIterator.m_op_ptr.setNull();
+        D("itPrev [simple]" << it);
+        return true;
+      }
+      if (itLast(it.m_opIterator)) {
+        D("itPrev [last op]" << it);
+        return true;
+      }
+    }
+  }
+  D("itPrev [end]" << it);
+  return false;
+}
+
+bool
 Dbdict::itRepeat(PhaseIterator& it)
 {
-  ndbrequire(itExists(it));
-  it.m_repeat++;
+  if (itExists(it)) {
+    it.m_repeat++;
+    return true;
+  }
+  return false;
 }
 
+// phases
+
 void
-Dbdict::schemaTrans_dummy(Signal* signal, SchemaTransPtr trans_ptr,
-                          Uint32 repeat)
+Dbdict::schemaTrans_dummy(Signal* signal, SchemaTransPtr trans_ptr)
 {
+  jam();
+  Uint32 repeat = getIteratorRepeat(trans_ptr);
+
   D("schemaTrans_dummy");
   ndbrequire(repeat == 0);
   schemaTrans_sendConf(signal, trans_ptr, 0);
 }
 
 const Dbdict::PhaseEntry
-Dbdict::g_parsePhaseEntry[] = {
-  { SchemaTransImplReq::RT_PARSE, 0, 0 }
-};
-
-const Dbdict::PhaseList
-Dbdict::g_parsePhaseList = {
-  g_parsePhaseEntry,
-  sizeof(g_parsePhaseEntry) / sizeof(g_parsePhaseEntry[0])
-};
+Dbdict::g_defaultPhaseEntry[] = {
+  { SchemaTransImplReq::RT_PARSE, 0, 0 },
 
-const Dbdict::PhaseEntry
-Dbdict::g_execPhaseEntry[] = {
   { SchemaTransImplReq::RT_PREPARE_BEGIN,
     PH_SIMPLE | PH_MASTER,
     &Dbdict::schemaTrans_dummy },
@@ -23096,9 +23314,9 @@
 };
 
 const Dbdict::PhaseList
-Dbdict::g_execPhaseList = {
-  g_execPhaseEntry,
-  sizeof(g_execPhaseEntry) / sizeof(g_execPhaseEntry[0])
+Dbdict::g_defaultPhaseList = {
+g_defaultPhaseEntry,
+  sizeof(g_defaultPhaseEntry) / sizeof(g_defaultPhaseEntry[0])
 };
 
 // MODULE: debug

--- 1.71/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2007-02-04 22:43:48 +01:00
+++ 1.72/storage/ndb/src/kernel/blocks/dbdict/Dbdict.hpp	2007-02-06 13:10:25 +01:00
@@ -1273,7 +1273,7 @@
     Uint32 m_impl_req_gsn;
     Uint32 m_impl_req_length;
 
-    // seize / release
+    // seize / release type-specific Data record
     bool (Dbdict::*m_seize)(SchemaOpPtr);
     void (Dbdict::*m_release)(SchemaOpPtr);
 
@@ -1284,11 +1284,13 @@
     void (Dbdict::*m_reply)(Signal*, SchemaOpPtr, ErrorInfo);
 
     // run phases
-    void (Dbdict::*m_prepare)(Signal*, SchemaOpPtr, Uint32 repeat);
-    void (Dbdict::*m_commit)(Signal*, SchemaOpPtr, Uint32 repeat);
+    void (Dbdict::*m_prepare)(Signal*, SchemaOpPtr);
+    void (Dbdict::*m_commit)(Signal*, SchemaOpPtr);
 #if wl3600_todo
-    void (Dbdict::*m_complete)(Signal*, SchemaOpPtr, Uint32 repeat);
+    void (Dbdict::*m_complete)(Signal*, SchemaOpPtr);
 #endif
+    // abort mode
+    void (Dbdict::*m_abort)(Signal*, SchemaOpPtr);
   };
 
   // all OpInfo records
@@ -1327,17 +1329,17 @@
     BitmaskImpl::setField(1, &info, 0, 8, val);
   }
 
-  // byte 1: id in sub-op feedback table
+  // byte 2: id in sub-op feedback table (for client REQ)
   inline
   Uint32 getFeedbackId(const Uint32& info)
   {
-    return BitmaskImpl::getField(1, &info, 8, 8);
+    return BitmaskImpl::getField(1, &info, 16, 8);
   }
   inline
   void setFeedbackId(Uint32& info, Uint32 val)
   {
     ndbrequire(findFeedbackEntry(val) != 0);
-    BitmaskImpl::setField(1, &info, 8, 8, val);
+    BitmaskImpl::setField(1, &info, 16, 8, val);
   }
 
   // OpData
@@ -1625,9 +1627,12 @@
     // list of schema ops under this tx
     OpList m_opList;
 
-    // iterator for parse and execution phases
+    // iterator for all phases
     PhaseIteratorPtr m_iterator_ptr;
 
+    // aborting
+    bool m_abortMode;
+
     ErrorInfo m_error;
 
     SchemaTrans() {
@@ -1639,6 +1644,7 @@
       m_failedNodes.clear();
       m_opDepth = 0;
       m_iterator_ptr.setNull();
+      m_abortMode = false;
     }
 
     SchemaTrans(Uint32 the_trans_key) {
@@ -1659,6 +1665,7 @@
   void releaseSchemaTrans(SchemaTransPtr&);
 
   PhaseIterator& getIterator(SchemaTransPtr trans_ptr);
+  Uint32 getIteratorRepeat(SchemaTransPtr trans_ptr);
 
   // master
   void schemaTrans_sendReq(Signal*, SchemaTransPtr, bool local);
@@ -1677,7 +1684,7 @@
 
   // execution
   void runSchemaTrans(Signal*, SchemaTransPtr, Uint32 runFlag);
-  void runSchemaOp(Signal*, SchemaOpPtr, Uint32 repeat);
+  void runSchemaOp(Signal*, SchemaOpPtr);
 
   // PhaseList
   
@@ -1689,7 +1696,7 @@
   struct PhaseEntry {
     SchemaTransImplReq::RequestType m_requestType;
     Uint32 m_flags;
-    void (Dbdict::*m_simple)(Signal*, SchemaTransPtr, Uint32 repeat);
+    void (Dbdict::*m_simple)(Signal*, SchemaTransPtr);
   };
 
   struct PhaseList {
@@ -1712,9 +1719,36 @@
   void itAddLast(OpIterator&, SchemaOpPtr);
   bool itExists(const OpIterator&);
   bool itFirst(OpIterator&);
+  bool itLast(OpIterator&);
   bool itNext(OpIterator&);
+  bool itPrev(OpIterator&);
+  bool itHasNext(OpIterator&);
+  bool itHasPrev(OpIterator&);
 
-  // PhaseIterator
+  /*
+   * PhaseIterator
+   *
+   * Iterates on 3 levels: 1) phases 2) operations of non-simple
+   * phase 3) repeated executions of same operation or simple phase.
+   *
+   * First phase (in the normal, and only, use-case) is PARSE.  This
+   * builds up operation list.  The iterator stays on the last op
+   * added.  At execute it advances to first execution phase.
+   *
+   * Abort mode runs the iterator backwards.  In particular there
+   * are separate abort-prepare and abort-parse phases.
+   *
+   * The iterator is kept at same position on all nodes (it can be off
+   * by one after master-NF).  The position is described by:
+   *
+   * 0. phase list id (only one list with id 0 now)
+   * 1. phase list index (index of PhaseEntry in phase list)
+   * 2. operation given by op_key (not by index)
+   * 3. operation or simple phase repeat count
+   *
+   * In addition there is mode (normal vs abort).  These are sent
+   * in each SCHEMA_TRANS_IMPL_REQ.
+   */
 
   struct PhaseIterator {
     // ArrayPool
@@ -1748,19 +1782,17 @@
   void itAddLast(PhaseIterator&, SchemaOpPtr);
   bool itExists(const PhaseIterator&);
   bool itFirst(PhaseIterator&);
+  bool itLast(PhaseIterator&);
   bool itNext(PhaseIterator&);
-  void itRepeat(PhaseIterator&);
+  bool itPrev(PhaseIterator&);
+  bool itRepeat(PhaseIterator&);
 
   // a dummy simple phase
-  void schemaTrans_dummy(Signal*, SchemaTransPtr, Uint32 repeat);
+  void schemaTrans_dummy(Signal*, SchemaTransPtr);
 
-  // list 0 - parse phase
-  static const PhaseEntry g_parsePhaseEntry[];
-  static const PhaseList g_parsePhaseList;
-
-  // list 1 - execution phases
-  static const PhaseEntry g_execPhaseEntry[];
-  static const PhaseList g_execPhaseList;
+  // default (and only) phase list
+  static const PhaseEntry g_defaultPhaseEntry[];
+  static const PhaseList g_defaultPhaseList;
 
   // common code for different op types
 
@@ -1912,8 +1944,10 @@
   bool createTable_subOps(Signal*, SchemaOpPtr);
   void createTable_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void createTable_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void createTable_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void createTable_prepare(Signal*, SchemaOpPtr);
+  void createTable_commit(Signal*, SchemaOpPtr);
+  //
+  void createTable_abort(Signal*, SchemaOpPtr);
 
   // MODULE: AlterTable
 
@@ -2004,8 +2038,10 @@
   bool alterTable_subOps(Signal*, SchemaOpPtr);
   void alterTable_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void alterTable_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void alterTable_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void alterTable_prepare(Signal*, SchemaOpPtr);
+  void alterTable_commit(Signal*, SchemaOpPtr);
+  //
+  void alterTable_abort(Signal*, SchemaOpPtr);
 
   // prepare phase
   void alterTable_toLocal(Signal*, SchemaOpPtr);
@@ -2075,8 +2111,10 @@
   bool dropTable_subOps(Signal*, SchemaOpPtr);
   void dropTable_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void dropTable_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void dropTable_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void dropTable_prepare(Signal*, SchemaOpPtr);
+  void dropTable_commit(Signal*, SchemaOpPtr);
+  //
+  void dropTable_abort(Signal*, SchemaOpPtr);
 
   /**
    * Request flags passed in signals along with request type and
@@ -2244,8 +2282,10 @@
   bool createIndex_subOps(Signal*, SchemaOpPtr);
   void createIndex_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void createIndex_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void createIndex_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void createIndex_prepare(Signal*, SchemaOpPtr);
+  void createIndex_commit(Signal*, SchemaOpPtr);
+  //
+  void createIndex_abort(Signal*, SchemaOpPtr);
 
   // sub-ops
   void createIndex_toCreateTable(Signal*, SchemaOpPtr);
@@ -2394,8 +2434,10 @@
   bool dropIndex_subOps(Signal*, SchemaOpPtr);
   void dropIndex_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void dropIndex_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void dropIndex_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void dropIndex_prepare(Signal*, SchemaOpPtr);
+  void dropIndex_commit(Signal*, SchemaOpPtr);
+  //
+  void dropIndex_abort(Signal*, SchemaOpPtr);
 
   // sub-ops
   void dropIndex_toDropTable(Signal*, SchemaOpPtr);
@@ -2590,8 +2632,10 @@
   bool alterIndex_subOps(Signal*, SchemaOpPtr);
   void alterIndex_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void alterIndex_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void alterIndex_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void alterIndex_prepare(Signal*, SchemaOpPtr);
+  void alterIndex_commit(Signal*, SchemaOpPtr);
+  //
+  void alterIndex_abort(Signal*, SchemaOpPtr);
 
   // sub-ops
   void alterIndex_toCreateTrigger(Signal*, SchemaOpPtr);
@@ -2731,8 +2775,10 @@
   bool buildIndex_subOps(Signal*, SchemaOpPtr);
   void buildIndex_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void buildIndex_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void buildIndex_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void buildIndex_prepare(Signal*, SchemaOpPtr);
+  void buildIndex_commit(Signal*, SchemaOpPtr);
+  //
+  void buildIndex_abort(Signal*, SchemaOpPtr);
 
   // prepare phase
   void buildIndex_toLocalBuild(Signal*, SchemaOpPtr);
@@ -2958,8 +3004,10 @@
   bool createTrigger_subOps(Signal*, SchemaOpPtr);
   void createTrigger_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void createTrigger_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void createTrigger_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void createTrigger_prepare(Signal*, SchemaOpPtr);
+  void createTrigger_commit(Signal*, SchemaOpPtr);
+  //
+  void createTrigger_abort(Signal*, SchemaOpPtr);
 
   // sub-ops
   void createTrigger_toAlterTrigger(Signal*, SchemaOpPtr);
@@ -3070,8 +3118,10 @@
   bool dropTrigger_subOps(Signal*, SchemaOpPtr);
   void dropTrigger_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void dropTrigger_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void dropTrigger_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void dropTrigger_prepare(Signal*, SchemaOpPtr);
+  void dropTrigger_commit(Signal*, SchemaOpPtr);
+  //
+  void dropTrigger_abort(Signal*, SchemaOpPtr);
 
   // sub-ops
   void dropTrigger_toAlterTrigger(Signal*, SchemaOpPtr);
@@ -3201,8 +3251,10 @@
   bool alterTrigger_subOps(Signal*, SchemaOpPtr);
   void alterTrigger_reply(Signal*, SchemaOpPtr, ErrorInfo);
   //
-  void alterTrigger_prepare(Signal*, SchemaOpPtr, Uint32 repeat);
-  void alterTrigger_commit(Signal*, SchemaOpPtr, Uint32 repeat);
+  void alterTrigger_prepare(Signal*, SchemaOpPtr);
+  void alterTrigger_commit(Signal*, SchemaOpPtr);
+  //
+  void alterTrigger_abort(Signal*, SchemaOpPtr);
 
   // prepare phase
   void alterTrigger_toCreateLocal(Signal*, SchemaOpPtr);

--- 1.7/storage/ndb/include/kernel/signaldata/SchemaTransImpl.hpp	2007-01-24 15:53:43
+01:00
+++ 1.8/storage/ndb/include/kernel/signaldata/SchemaTransImpl.hpp	2007-02-06 13:10:24
+01:00
@@ -34,55 +34,65 @@
     RT_COMMIT_END = 8,
     RT_END = 9
   };
-  STATIC_CONST( SignalLength = 6 );
+  STATIC_CONST( SignalLength = 7 );
   Uint32 senderRef;
   Uint32 transKey;
   Uint32 opKey;
-  Uint32 requestInfo; // rt | depth | gsn | list id | list index | repeat
+  Uint32 requestInfo;  // request type | depth | piggy-backed gsn
+  Uint32 iteratorInfo; // list id | list index | repeat | abort mode
   Uint32 clientRef;
   Uint32 transId;
 
-  static void setRequestType(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 4));
-    BitmaskImpl::setField(1, &requestInfo, 0, 4, val);
+  // requestInfo
+  static Uint32 getRequestType(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 0, 8);
   }
-  static void setOpDepth(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 4));
-    BitmaskImpl::setField(1, &requestInfo, 4, 4, val);
+  static void setRequestType(Uint32& info, Uint32 val) {
+    assert(val < (1 << 8));
+    BitmaskImpl::setField(1, &info, 0, 8, val);
   }
-  static void setGsn(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 12));
-    BitmaskImpl::setField(1, &requestInfo, 8, 12, val);
+  static Uint32 getOpDepth(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 8, 8);
   }
-  static void setListId(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 4));
-    BitmaskImpl::setField(1, &requestInfo, 20, 4, val);
+  static void setOpDepth(Uint32& info, Uint32 val) {
+    assert(val < (1 << 8));
+    BitmaskImpl::setField(1, &info, 8, 8, val);
   }
-  static void setListIndex(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 4));
-    BitmaskImpl::setField(1, &requestInfo, 24, 4, val);
+  static Uint32 getGsn(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 16, 16);
   }
-  static void setRepeat(Uint32& requestInfo, Uint32 val) {
-    assert(val < (1 << 4));
-    BitmaskImpl::setField(1, &requestInfo, 28, 4, val);
+  static void setGsn(Uint32& info, Uint32 val) {
+    assert(val < (1 << 16));
+    BitmaskImpl::setField(1, &info, 16, 16, val);
   }
-  static Uint32 getRequestType(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 0, 4);
+  // iteratorInfo
+  static Uint32 getListId(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 0, 8);
   }
-  static Uint32 getOpDepth(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 4, 4);
+  static void setListId(Uint32& info, Uint32 val) {
+    assert(val < (1 << 8));
+    BitmaskImpl::setField(1, &info, 0, 8, val);
   }
-  static Uint32 getGsn(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 8, 12);
+  static Uint32 getListIndex(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 8, 8);
   }
-  static Uint32 getListId(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 20, 4);
+  static void setListIndex(Uint32& info, Uint32 val) {
+    assert(val < (1 << 8));
+    BitmaskImpl::setField(1, &info, 8, 8, val);
   }
-  static Uint32 getListIndex(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 24, 4);
+  static Uint32 getRepeat(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 16, 8);
   }
-  static Uint32 getRepeat(const Uint32& requestInfo) {
-    return BitmaskImpl::getField(1, &requestInfo, 28, 4);
+  static void setRepeat(Uint32& info, Uint32 val) {
+    assert(val < (1 << 8));
+    BitmaskImpl::setField(1, &info, 16, 8, val);
+  }
+  static Uint32 getAbortMode(const Uint32& info) {
+    return BitmaskImpl::getField(1, &info, 24, 1);
+  }
+  static void setAbortMode(Uint32& info, Uint32 val) {
+    assert(val < (1 << 1));
+    BitmaskImpl::setField(1, &info, 24, 1, val);
   }
 };
 

--- 1.13/storage/ndb/src/common/debugger/signaldata/SchemaTransImpl.cpp	2007-01-30
12:32:11 +01:00
+++ 1.14/storage/ndb/src/common/debugger/signaldata/SchemaTransImpl.cpp	2007-02-06
13:10:24 +01:00
@@ -44,16 +44,19 @@
                    tmp;
   Uint32 opDepth = SchemaTransImplReq::getOpDepth(sig->requestInfo);
   Uint32 gsn = SchemaTransImplReq::getGsn(sig->requestInfo);
-  Uint32 listId = SchemaTransImplReq::getListId(sig->requestInfo);
-  Uint32 listIndex = SchemaTransImplReq::getListIndex(sig->requestInfo);
-  Uint32 repeat = SchemaTransImplReq::getRepeat(sig->requestInfo);
+  Uint32 listId = SchemaTransImplReq::getListId(sig->iteratorInfo);
+  Uint32 listIndex = SchemaTransImplReq::getListIndex(sig->iteratorInfo);
+  Uint32 repeat = SchemaTransImplReq::getRepeat(sig->iteratorInfo);
+  Uint32 abortMode = SchemaTransImplReq::getAbortMode(sig->iteratorInfo);
   fprintf(output, " requestType: %u", requestType);
   fprintf(output, " [%s]", requestTypeName);
   fprintf(output, " opDepth: %u", opDepth);
   fprintf(output, " gsn: %u", gsn);
+  fprintf(output, "\n");
   fprintf(output, " listId: %u", listId);
   fprintf(output, " listIndex: %u", listIndex);
   fprintf(output, " repeat: %u", repeat);
+  fprintf(output, " abortMode: %u", abortMode);
   fprintf(output, "\n");
   fprintf(output, " clientRef: %x", sig->clientRef);
   fprintf(output, " transId: %x", sig->transId);