Merge joreland@bk-internal.mysql.com:/home/bk/mysql-5.0

into  mysql.com:/home/jonas/src/mysql-5.0-push

9 files changed, 435 insertions, 277 deletions

diff --git a/ndb/src/kernel/blocks/ERROR_codes.txt b/ndb/src/kernel/blocks/ERROR_codes.txt
index fedddb58c0d..1a72537a77e 100644
--- a/ndb/src/kernel/blocks/ERROR_codes.txt
+++ b/ndb/src/kernel/blocks/ERROR_codes.txt
@@ -4,9 +4,9 @@ Next NDBFS 2000
 Next DBACC 3002
 Next DBTUP 4013
 Next DBLQH 5042
-Next DBDICT 6006
+Next DBDICT 6007
 Next DBDIH 7174
-Next DBTC 8035
+Next DBTC 8037
 Next CMVMI 9000
 Next BACKUP 10022
 Next DBUTIL 11002
@@ -408,10 +408,12 @@ Drop Table/Index:
 4001: Crash on REL_TABMEMREQ in TUP
 4002: Crash on DROP_TABFILEREQ in TUP
 4003: Fail next trigger create in TUP
+4004: Fail next trigger drop in TUP
 8033: Fail next trigger create in TC
 8034: Fail next index create in TC
-
-
+8035: Fail next trigger drop in TC
+8036: Fail next index drop in TC
+6006: Crash participant in create index
 
 System Restart:
 ---------------
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
index a9114540940..af711c2da3b 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
@@ -6582,6 +6582,9 @@ void
 Dbdict::createIndex_slavePrepare(Signal* signal, OpCreateIndexPtr opPtr)
 {
   jam();
+  if (ERROR_INSERTED(6006) && ! opPtr.p->m_isMaster) {
+    ndbrequire(false);
+  }
 }
 
 void
@@ -6896,14 +6899,16 @@ Dbdict::createIndex_sendReply(Signal* signal, OpCreateIndexPtr opPtr,
   CreateIndxRef* rep = (CreateIndxRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_CREATE_INDX_CONF;
   Uint32 length = CreateIndxConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == CreateIndxReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -6972,11 +6977,8 @@ Dbdict::execDROP_INDX_REQ(Signal* signal)
 	goto error;
       }
 
-      if (tmp.p->indexState == TableRecord::IS_DROPPING){
-	jam();
-	err = DropIndxRef::IndexNotFound;
-	goto error;
-      }
+      if (tmp.p->indexState != TableRecord::IS_ONLINE)
+        req->addRequestFlag(RequestFlag::RF_FORCE);
 
       tmp.p->indexState = TableRecord::IS_DROPPING;
 
@@ -7239,14 +7241,16 @@ Dbdict::dropIndex_sendReply(Signal* signal, OpDropIndexPtr opPtr,
   DropIndxRef* rep = (DropIndxRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_DROP_INDX_CONF;
   Uint32 length = DropIndxConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == DropIndxReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -9763,7 +9767,7 @@ Dbdict::alterIndex_fromCreateTc(Signal* signal, OpAlterIndexPtr opPtr)
 {
   jam();
   // mark created in local TC
-  if (! opPtr.p->hasError()) {
+  if (! opPtr.p->hasLastError()) {
     TableRecordPtr indexPtr;
     c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId());
     indexPtr.p->indexLocal |= TableRecord::IL_CREATED_TC;
@@ -9779,9 +9783,10 @@ Dbdict::alterIndex_toDropTc(Signal* signal, OpAlterIndexPtr opPtr)
   jam();
   TableRecordPtr indexPtr;
   c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId());
-  // broken index
+  // broken index allowed if force
   if (! (indexPtr.p->indexLocal & TableRecord::IL_CREATED_TC)) {
     jam();
+    ndbassert(opPtr.p->m_requestFlag & RequestFlag::RF_FORCE);
     alterIndex_sendReply(signal, opPtr, false);
     return;
   }
@@ -9803,8 +9808,8 @@ Dbdict::alterIndex_fromDropTc(Signal* signal, OpAlterIndexPtr opPtr)
 {
   jam();
   ndbrequire(opPtr.p->m_requestType == AlterIndxReq::RT_DICT_TC);
-  if (! opPtr.p->hasError()) {
-    // mark dropped in local TC
+  // mark dropped locally
+  if (! opPtr.p->hasLastError()) {
     TableRecordPtr indexPtr;
     c_tableRecordPool.getPtr(indexPtr, opPtr.p->m_request.getIndexId());
     indexPtr.p->indexLocal &= ~TableRecord::IL_CREATED_TC;
@@ -9942,51 +9947,46 @@ Dbdict::alterIndex_toDropTrigger(Signal* signal, OpAlterIndexPtr opPtr)
   req->setUserRef(reference());
   req->setConnectionPtr(opPtr.p->key);
   req->setRequestType(DropTrigReq::RT_ALTER_INDEX);
+  req->addRequestFlag(opPtr.p->m_requestFlag);
   req->setTableId(opPtr.p->m_request.getTableId());
   req->setIndexId(opPtr.p->m_request.getIndexId());
   req->setTriggerInfo(0);       // not used
   opPtr.p->m_triggerCounter = 0;
-  // insert
-  if (indexPtr.p->insertTriggerId != RNIL) {
+  if (indexPtr.p->isHashIndex()) {
+    // insert
     req->setTriggerId(indexPtr.p->insertTriggerId);
     sendSignal(reference(), GSN_DROP_TRIG_REQ, 
         signal, DropTrigReq::SignalLength, JBB);
     opPtr.p->m_triggerCounter++;
-  }
-  // update
-  if (indexPtr.p->updateTriggerId != RNIL) {
+    // update
     req->setTriggerId(indexPtr.p->updateTriggerId);
     sendSignal(reference(), GSN_DROP_TRIG_REQ, 
         signal, DropTrigReq::SignalLength, JBB);
     opPtr.p->m_triggerCounter++;
-  }
-  // delete
-  if (indexPtr.p->deleteTriggerId != RNIL) {
+    // delete
     req->setTriggerId(indexPtr.p->deleteTriggerId);
     sendSignal(reference(), GSN_DROP_TRIG_REQ, 
         signal, DropTrigReq::SignalLength, JBB);
     opPtr.p->m_triggerCounter++;
+    // build
+    if (indexPtr.p->buildTriggerId != RNIL) {
+      req->setTriggerId(indexPtr.p->buildTriggerId);
+      sendSignal(reference(), GSN_DROP_TRIG_REQ, 
+          signal, DropTrigReq::SignalLength, JBB);
+      opPtr.p->m_triggerCounter++;
+    }
+    return;
   }
-  // custom
-  if (indexPtr.p->customTriggerId != RNIL) {
+  if (indexPtr.p->isOrderedIndex()) {
+    // custom
+    req->addRequestFlag(RequestFlag::RF_NOTCTRIGGER);
     req->setTriggerId(indexPtr.p->customTriggerId);
     sendSignal(reference(), GSN_DROP_TRIG_REQ, 
         signal, DropTrigReq::SignalLength, JBB);
     opPtr.p->m_triggerCounter++;
+    return;
   }
-  // build
-  if (indexPtr.p->buildTriggerId != RNIL) {
-    req->setTriggerId(indexPtr.p->buildTriggerId);
-    sendSignal(reference(), GSN_DROP_TRIG_REQ, 
-        signal, DropTrigReq::SignalLength, JBB);
-    opPtr.p->m_triggerCounter++;
-  }
-  if (opPtr.p->m_triggerCounter == 0) {
-    // drop in each TC
-    jam();
-    opPtr.p->m_requestType = AlterIndxReq::RT_DICT_TC;
-    alterIndex_sendSlaveReq(signal, opPtr);
-  }
+  ndbrequire(false);
 }
 
 void
@@ -10104,14 +10104,16 @@ Dbdict::alterIndex_sendReply(Signal* signal, OpAlterIndexPtr opPtr,
   AlterIndxRef* rep = (AlterIndxRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_ALTER_INDX_CONF;
   Uint32 length = AlterIndxConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == AlterIndxReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -10524,8 +10526,10 @@ Dbdict::buildIndex_toOnline(Signal* signal, OpBuildIndexPtr opPtr)
   req->setUserRef(reference());
   req->setConnectionPtr(opPtr.p->key);
   if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TC) {
+    jam();
     req->setRequestType(AlterIndxReq::RT_TC);
   } else if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TUX) {
+    jam();
     req->setRequestType(AlterIndxReq::RT_TUX);
   } else {
     ndbrequire(false);
@@ -10536,8 +10540,10 @@ Dbdict::buildIndex_toOnline(Signal* signal, OpBuildIndexPtr opPtr)
   req->setOnline(true);
   BlockReference blockRef = 0;
   if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TC) {
+    jam();
     blockRef = calcTcBlockRef(getOwnNodeId());
   } else if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_TUX) {
+    jam();
     blockRef = calcTuxBlockRef(getOwnNodeId());
   } else {
     ndbrequire(false);
@@ -10564,15 +10570,14 @@ Dbdict::buildIndex_sendSlaveReq(Signal* signal, OpBuildIndexPtr opPtr)
   req->setConnectionPtr(opPtr.p->key);
   req->setRequestType(opPtr.p->m_requestType);
   req->addRequestFlag(opPtr.p->m_requestFlag);
-  if(opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL)
-  {
+  if(opPtr.p->m_requestFlag & RequestFlag::RF_LOCAL) {
+    jam();
     opPtr.p->m_signalCounter.clearWaitingFor();
     opPtr.p->m_signalCounter.setWaitingFor(getOwnNodeId());
     sendSignal(reference(), GSN_BUILDINDXREQ,
 	       signal, BuildIndxReq::SignalLength, JBB);
-  }
-  else
-  {
+  } else {
+    jam();
     opPtr.p->m_signalCounter = c_aliveNodes;
     NodeReceiverGroup rg(DBDICT, c_aliveNodes);
     sendSignal(rg, GSN_BUILDINDXREQ,
@@ -10587,14 +10592,16 @@ Dbdict::buildIndex_sendReply(Signal* signal, OpBuildIndexPtr opPtr,
   BuildIndxRef* rep = (BuildIndxRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_BUILDINDXCONF;
   Uint32 length = BuildIndxConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == BuildIndxReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -11081,14 +11088,16 @@ Dbdict::createTrigger_sendReply(Signal* signal, OpCreateTriggerPtr opPtr,
   CreateTrigRef* rep = (CreateTrigRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_CREATE_TRIG_CONF;
   Uint32 length = CreateTrigConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == CreateTrigReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -11176,8 +11185,10 @@ Dbdict::execDROP_TRIG_REQ(Signal* signal)
 	OpDropTrigger opBad;
 	opPtr.p = &opBad;
 	opPtr.p->save(req);
-	opPtr.p->m_errorCode = DropTrigRef::TriggerNotFound;
-	opPtr.p->m_errorLine = __LINE__;
+        if (! (req->getRequestFlag() & RequestFlag::RF_FORCE)) {
+          opPtr.p->m_errorCode = DropTrigRef::TriggerNotFound;
+          opPtr.p->m_errorLine = __LINE__;
+        }
 	dropTrigger_sendReply(signal,  opPtr, true);
 	return;
       }
@@ -11344,6 +11355,7 @@ Dbdict::dropTrigger_toAlterTrigger(Signal* signal, OpDropTriggerPtr opPtr)
   req->setUserRef(reference());
   req->setConnectionPtr(opPtr.p->key);
   req->setRequestType(AlterTrigReq::RT_DROP_TRIGGER);
+  req->addRequestFlag(opPtr.p->m_requestFlag);
   req->setTableId(opPtr.p->m_request.getTableId());
   req->setTriggerId(opPtr.p->m_request.getTriggerId());
   req->setTriggerInfo(0);       // not used
@@ -11439,14 +11451,16 @@ Dbdict::dropTrigger_sendReply(Signal* signal, OpDropTriggerPtr opPtr,
   DropTrigRef* rep = (DropTrigRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_DROP_TRIG_CONF;
   Uint32 length = DropTrigConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
     if (opPtr.p->m_requestType == DropTrigReq::RT_DICT_ABORT)
       sendRef = false;
   } else {
+    sendRef = opPtr.p->hasError();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
     rep->setRequestType(opPtr.p->m_request.getRequestType());
@@ -11670,28 +11684,37 @@ Dbdict::alterTrigger_recvReply(Signal* signal, const AlterTrigConf* conf,
   if (! (opPtr.p->m_request.getRequestFlag() & RequestFlag::RF_NOTCTRIGGER)) {
     if (requestType == AlterTrigReq::RT_DICT_PREPARE) {
       jam();
-      if (opPtr.p->m_request.getOnline())
+      if (opPtr.p->m_request.getOnline()) {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_TC;
-      else
+      } else {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_LQH;
+      }
       alterTrigger_sendSlaveReq(signal, opPtr);
       return;
     }
     if (requestType == AlterTrigReq::RT_DICT_TC) {
       jam();
-      if (opPtr.p->m_request.getOnline())
+      if (opPtr.p->m_request.getOnline()) {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_LQH;
-      else
+      } else {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_COMMIT;
+      }
       alterTrigger_sendSlaveReq(signal, opPtr);
       return;
     }
     if (requestType == AlterTrigReq::RT_DICT_LQH) {
       jam();
-      if (opPtr.p->m_request.getOnline())
+      if (opPtr.p->m_request.getOnline()) {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_COMMIT;
-      else
+      } else {
+        jam();
         opPtr.p->m_requestType = AlterTrigReq::RT_DICT_TC;
+      }
       alterTrigger_sendSlaveReq(signal, opPtr);
       return;
     }
@@ -11751,8 +11774,10 @@ Dbdict::alterTrigger_toCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr)
   req->setUserRef(reference());
   req->setConnectionPtr(opPtr.p->key);
   if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
+    jam();
     req->setRequestType(CreateTrigReq::RT_TC);
   } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
+    jam();
     req->setRequestType(CreateTrigReq::RT_LQH);
   } else {
     ndbassert(false);
@@ -11769,8 +11794,10 @@ Dbdict::alterTrigger_toCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr)
   req->setReceiverRef(opPtr.p->m_request.getReceiverRef());
   BlockReference blockRef = 0;
   if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
+    jam();
     blockRef = calcTcBlockRef(getOwnNodeId());
   } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
+    jam();
     blockRef = calcLqhBlockRef(getOwnNodeId());
   } else {
     ndbassert(false);
@@ -11784,13 +11811,15 @@ void
 Dbdict::alterTrigger_fromCreateLocal(Signal* signal, OpAlterTriggerPtr opPtr)
 {
   jam();
-  if (! opPtr.p->hasError()) {
+  if (! opPtr.p->hasLastError()) {
     // mark created locally
     TriggerRecordPtr triggerPtr;
     c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId());
     if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
+      jam();
       triggerPtr.p->triggerLocal |= TriggerRecord::TL_CREATED_TC;
     } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
+      jam();
       triggerPtr.p->triggerLocal |= TriggerRecord::TL_CREATED_LQH;
     } else {
       ndbrequire(false);
@@ -11810,17 +11839,21 @@ Dbdict::alterTrigger_toDropLocal(Signal* signal, OpAlterTriggerPtr opPtr)
   req->setUserRef(reference());
   req->setConnectionPtr(opPtr.p->key);
   if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
-    // broken trigger
+    jam();
+    // broken trigger allowed if force
     if (! (triggerPtr.p->triggerLocal & TriggerRecord::TL_CREATED_TC)) {
       jam();
+      ndbassert(opPtr.p->m_requestFlag & RequestFlag::RF_FORCE);
       alterTrigger_sendReply(signal, opPtr, false);
       return;
     }
     req->setRequestType(DropTrigReq::RT_TC);
   } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
-    // broken trigger
+    jam();
+    // broken trigger allowed if force
     if (! (triggerPtr.p->triggerLocal & TriggerRecord::TL_CREATED_LQH)) {
       jam();
+      ndbassert(opPtr.p->m_requestFlag & RequestFlag::RF_FORCE);
       alterTrigger_sendReply(signal, opPtr, false);
       return;
     }
@@ -11838,8 +11871,10 @@ Dbdict::alterTrigger_toDropLocal(Signal* signal, OpAlterTriggerPtr opPtr)
   req->setMonitorAllAttributes(triggerPtr.p->monitorAllAttributes);
   BlockReference blockRef = 0;
   if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
+    jam();
     blockRef = calcTcBlockRef(getOwnNodeId());
   } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
+    jam();
     blockRef = calcLqhBlockRef(getOwnNodeId());
   } else {
     ndbassert(false);
@@ -11852,13 +11887,15 @@ void
 Dbdict::alterTrigger_fromDropLocal(Signal* signal, OpAlterTriggerPtr opPtr)
 {
   jam();
-  if (! opPtr.p->hasError()) {
+  if (! opPtr.p->hasLastError()) {
     // mark dropped locally
     TriggerRecordPtr triggerPtr;
     c_triggerRecordPool.getPtr(triggerPtr, opPtr.p->m_request.getTriggerId());
     if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_TC) {
+      jam();
       triggerPtr.p->triggerLocal &= ~TriggerRecord::TL_CREATED_TC;
     } else if (opPtr.p->m_requestType == AlterTrigReq::RT_DICT_LQH) {
+      jam();
       triggerPtr.p->triggerLocal &= ~TriggerRecord::TL_CREATED_LQH;
     } else {
       ndbrequire(false);
@@ -11915,8 +11952,9 @@ Dbdict::alterTrigger_sendReply(Signal* signal, OpAlterTriggerPtr opPtr,
   AlterTrigRef* rep = (AlterTrigRef*)signal->getDataPtrSend();
   Uint32 gsn = GSN_ALTER_TRIG_CONF;
   Uint32 length = AlterTrigConf::InternalLength;
-  bool sendRef = opPtr.p->hasError();
+  bool sendRef;
   if (! toUser) {
+    sendRef = opPtr.p->hasLastError();
     rep->setUserRef(opPtr.p->m_coordinatorRef);
     rep->setConnectionPtr(opPtr.p->key);
     rep->setRequestType(opPtr.p->m_requestType);
@@ -11927,6 +11965,7 @@ Dbdict::alterTrigger_sendReply(Signal* signal, OpAlterTriggerPtr opPtr,
       jam();
     }
   } else {
+    sendRef = opPtr.p->hasError();
     jam();
     rep->setUserRef(opPtr.p->m_request.getUserRef());
     rep->setConnectionPtr(opPtr.p->m_request.getConnectionPtr());
diff --git a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
index e6d2fe44b04..95efb2ec3fd 100644
--- a/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
+++ b/ndb/src/kernel/blocks/dbdict/Dbdict.hpp
@@ -956,7 +956,8 @@ private:
     enum {
       RF_LOCAL = 1 << 0,        // create on local node only
       RF_NOBUILD = 1 << 1,      // no need to build index
-      RF_NOTCTRIGGER = 1 << 2   // alter trigger: no trigger in TC
+      RF_NOTCTRIGGER = 1 << 2,  // alter trigger: no trigger in TC
+      RF_FORCE = 1 << 4         // force drop
     };
   };
 
@@ -976,6 +977,7 @@ private:
     CreateIndxReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    CreateIndxRef::ErrorCode m_lastError;
     CreateIndxRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -987,6 +989,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = CreateIndxReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = CreateIndxRef::NoError;
       m_errorCode = CreateIndxRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -996,34 +999,49 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != CreateIndxRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != CreateIndxRef::NoError;
     }
     void setError(const CreateIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = CreateIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const CreateTableRef* ref) {
-      if (ref != 0 && ! hasError()) {
+      m_lastError = CreateIndxRef::NoError;
+      if (ref != 0) {
         switch (ref->getErrorCode()) {
         case CreateTableRef::TableAlreadyExist:
-          m_errorCode = CreateIndxRef::IndexExists;
+          m_lastError = CreateIndxRef::IndexExists;
           break;
         default:
-          m_errorCode = (CreateIndxRef::ErrorCode)ref->getErrorCode();
+          m_lastError = (CreateIndxRef::ErrorCode)ref->getErrorCode();
           break;
         }
-        m_errorLine = ref->getErrorLine();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+        }
       }
     }
     void setError(const AlterIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (CreateIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = CreateIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (CreateIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
@@ -1042,6 +1060,7 @@ private:
     DropIndxReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    DropIndxRef::ErrorCode m_lastError;
     DropIndxRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1053,6 +1072,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = DropIndxReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = DropIndxRef::NoError;
       m_errorCode = DropIndxRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1062,44 +1082,59 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != DropIndxRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != DropIndxRef::NoError;
     }
     void setError(const DropIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = DropIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = ref->getErrorCode();
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const AlterIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (DropIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = DropIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (DropIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const DropTableRef* ref) {
-      if (ref != 0 && ! hasError()) {
-	switch(ref->errorCode) {
-	case(DropTableRef::Busy):
-	  m_errorCode = DropIndxRef::Busy;
+      m_lastError = DropIndxRef::NoError;
+      if (ref != 0) {
+	switch (ref->errorCode) {
+	case DropTableRef::Busy:
+	  m_lastError = DropIndxRef::Busy;
 	  break;
-	case(DropTableRef::NoSuchTable):
-	  m_errorCode = DropIndxRef::IndexNotFound;
+	case DropTableRef::NoSuchTable:
+	  m_lastError = DropIndxRef::IndexNotFound;
 	  break;
-	case(DropTableRef::DropInProgress):
-	  m_errorCode = DropIndxRef::Busy;
+	case DropTableRef::DropInProgress:
+	  m_lastError = DropIndxRef::Busy;
 	  break;
-	case(DropTableRef::NoDropTableRecordAvailable):
-	  m_errorCode = DropIndxRef::Busy;
+	case DropTableRef::NoDropTableRecordAvailable:
+	  m_lastError = DropIndxRef::Busy;
 	  break;
 	default:
-	  m_errorCode = (DropIndxRef::ErrorCode)ref->errorCode;
+	  m_lastError = (DropIndxRef::ErrorCode)ref->errorCode;
 	  break;
 	}
-        //m_errorLine = ref->getErrorLine();
-        //m_errorNode = ref->getErrorNode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = 0;
+          m_errorNode = 0;
+        }
       }
     }
   };
@@ -1120,6 +1155,7 @@ private:
     AlterIndxReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    AlterIndxRef::ErrorCode m_lastError;
     AlterIndxRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1132,6 +1168,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = AlterIndxReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = AlterIndxRef::NoError;
       m_errorCode = AlterIndxRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1142,47 +1179,76 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != AlterIndxRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != AlterIndxRef::NoError;
     }
     void setError(const AlterIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const CreateIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const DropIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const BuildIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = 0;
+          m_errorNode = 0;
+        }
       }
     }
     void setError(const CreateTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const DropTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
@@ -1204,6 +1270,7 @@ private:
     Uint32 m_requestFlag;
     Uint32 m_constrTriggerId;
     // error info
+    BuildIndxRef::ErrorCode m_lastError;
     BuildIndxRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1215,7 +1282,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = BuildIndxReq::RT_UNDEFINED;
       m_requestFlag = 0;
-//      Uint32 m_constrTriggerId = RNIL;
+      m_lastError = BuildIndxRef::NoError;
       m_errorCode = BuildIndxRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1225,33 +1292,54 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != BuildIndxRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != BuildIndxRef::NoError;
     }
     void setError(const BuildIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
+      m_lastError = BuildIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = 0;
+          m_errorNode = 0;
+        }
       }
     }
     void setError(const AlterIndxRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = BuildIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const CreateTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = BuildIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const DropTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (BuildIndxRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = BuildIndxRef::NoError;
+      if (ref != 0) {
+        m_lastError = (BuildIndxRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
@@ -1384,6 +1472,7 @@ private:
     CreateTrigReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    CreateTrigRef::ErrorCode m_lastError;
     CreateTrigRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1395,6 +1484,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = CreateTrigReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = CreateTrigRef::NoError;
       m_errorCode = CreateTrigRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1404,21 +1494,32 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != CreateTrigRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != CreateTrigRef::NoError;
     }
     void setError(const CreateTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = CreateTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const AlterTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (CreateTrigRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = CreateTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = (CreateTrigRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
@@ -1437,6 +1538,7 @@ private:
     DropTrigReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    DropTrigRef::ErrorCode m_lastError;
     DropTrigRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1448,6 +1550,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = DropTrigReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = DropTrigRef::NoError;
       m_errorCode = DropTrigRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1457,21 +1560,32 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != DropTrigRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != DropTrigRef::NoError;
     }
     void setError(const DropTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = DropTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const AlterTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (DropTrigRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = DropTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = (DropTrigRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
@@ -1492,6 +1606,7 @@ private:
     AlterTrigReq::RequestType m_requestType;
     Uint32 m_requestFlag;
     // error info
+    AlterTrigRef::ErrorCode m_lastError;
     AlterTrigRef::ErrorCode m_errorCode;
     Uint32 m_errorLine;
     Uint32 m_errorNode;
@@ -1503,6 +1618,7 @@ private:
       m_coordinatorRef = 0;
       m_requestType = AlterTrigReq::RT_UNDEFINED;
       m_requestFlag = 0;
+      m_lastError = AlterTrigRef::NoError;
       m_errorCode = AlterTrigRef::NoError;
       m_errorLine = 0;
       m_errorNode = 0;
@@ -1512,28 +1628,43 @@ private:
       m_requestType = req->getRequestType();
       m_requestFlag = req->getRequestFlag();
     }
+    bool hasLastError() {
+      return m_lastError != AlterTrigRef::NoError;
+    }
     bool hasError() {
       return m_errorCode != AlterTrigRef::NoError;
     }
     void setError(const AlterTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const CreateTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
     void setError(const DropTrigRef* ref) {
-      if (ref != 0 && ! hasError()) {
-        m_errorCode = (AlterTrigRef::ErrorCode)ref->getErrorCode();
-        m_errorLine = ref->getErrorLine();
-        m_errorNode = ref->getErrorNode();
+      m_lastError = AlterTrigRef::NoError;
+      if (ref != 0) {
+        m_lastError = (AlterTrigRef::ErrorCode)ref->getErrorCode();
+        if (! hasError()) {
+          m_errorCode = m_lastError;
+          m_errorLine = ref->getErrorLine();
+          m_errorNode = ref->getErrorNode();
+        }
       }
     }
   };
diff --git a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
index e4cce29ba30..07a85b705fb 100644
--- a/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
+++ b/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
@@ -11043,6 +11043,7 @@ void Dbtc::execCREATE_TRIG_REQ(Signal* signal)
   if (ERROR_INSERTED(8033) ||
       !c_theDefinedTriggers.seizeId(triggerPtr, 
 				    createTrigReq->getTriggerId())) {
+    jam();
     CLEAR_ERROR_INSERT_VALUE;
     // Failed to allocate trigger record
     CreateTrigRef * const createTrigRef =  
@@ -11077,8 +11078,10 @@ void Dbtc::execDROP_TRIG_REQ(Signal* signal)
   DropTrigReq * const dropTrigReq =  (DropTrigReq *)&signal->theData[0];
   BlockReference sender = signal->senderBlockRef();
 
-  if ((c_theDefinedTriggers.getPtr(dropTrigReq->getTriggerId())) == NULL) {
+  if (ERROR_INSERTED(8035) ||
+      (c_theDefinedTriggers.getPtr(dropTrigReq->getTriggerId())) == NULL) {
     jam();
+    CLEAR_ERROR_INSERT_VALUE;
     // Failed to find find trigger record
     DropTrigRef * const dropTrigRef =  (DropTrigRef *)&signal->theData[0];
 
@@ -11110,6 +11113,7 @@ void Dbtc::execCREATE_INDX_REQ(Signal* signal)
   
   if (ERROR_INSERTED(8034) ||
       !c_theIndexes.seizeId(indexPtr, createIndxReq->getIndexId())) {
+    jam();
     CLEAR_ERROR_INSERT_VALUE;
     // Failed to allocate index record
      CreateIndxRef * const createIndxRef =  
@@ -11321,8 +11325,10 @@ void Dbtc::execDROP_INDX_REQ(Signal* signal)
   TcIndexData* indexData;
   BlockReference sender = signal->senderBlockRef();
   
-  if ((indexData = c_theIndexes.getPtr(dropIndxReq->getIndexId())) == NULL) {
+  if (ERROR_INSERTED(8036) ||
+      (indexData = c_theIndexes.getPtr(dropIndxReq->getIndexId())) == NULL) {
     jam();
+    CLEAR_ERROR_INSERT_VALUE;
     // Failed to find index record
     DropIndxRef * const dropIndxRef =  
       (DropIndxRef *)signal->getDataPtrSend();
diff --git a/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
index 2b65a8402c2..750d3959068 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupTrigger.cpp
@@ -305,6 +305,10 @@ Dbtup::primaryKey(Tablerec* const regTabPtr, Uint32 attrId)
 Uint32
 Dbtup::dropTrigger(Tablerec* table, const DropTrigReq* req)
 {
+  if (ERROR_INSERTED(4004)) {
+    CLEAR_ERROR_INSERT_VALUE;
+    return 9999;
+  }
   Uint32 triggerId = req->getTriggerId();
 
   TriggerType::Value ttype = req->getTriggerType();
diff --git a/ndb/src/kernel/vm/Makefile.am b/ndb/src/kernel/vm/Makefile.am
index d9e57ce9dd6..0dce9285ae3 100644
--- a/ndb/src/kernel/vm/Makefile.am
+++ b/ndb/src/kernel/vm/Makefile.am
@@ -18,8 +18,7 @@ libkernel_a_SOURCES = \
         SimplePropertiesSection.cpp \
         SectionReader.cpp \
 	MetaData.cpp \
-        Mutex.cpp SafeCounter.cpp \
-	SuperPool.cpp
+        Mutex.cpp SafeCounter.cpp
 
 INCLUDES_LOC = -I$(top_srcdir)/ndb/src/mgmapi
 
diff --git a/ndb/src/mgmsrv/ConfigInfo.cpp b/ndb/src/mgmsrv/ConfigInfo.cpp
index b1fe0735612..34a2d8c1302 100644
--- a/ndb/src/mgmsrv/ConfigInfo.cpp
+++ b/ndb/src/mgmsrv/ConfigInfo.cpp
@@ -62,8 +62,6 @@ ConfigInfo::m_sectionNames[]={
   DB_TOKEN,
   MGM_TOKEN,
   API_TOKEN,
-  "REP",
-  "EXTERNAL REP",
 
   "TCP",
   "SCI",
@@ -100,6 +98,7 @@ static bool saveInConfigValues(InitConfigFileParser::Context & ctx, const char *
 static bool fixFileSystemPath(InitConfigFileParser::Context & ctx, const char * data);
 static bool fixBackupDataDir(InitConfigFileParser::Context & ctx, const char * data);
 static bool fixShmUniqueId(InitConfigFileParser::Context & ctx, const char * data);
+static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx, const char * data);
 
 const ConfigInfo::SectionRule 
 ConfigInfo::m_SectionRules[] = {
@@ -110,8 +109,6 @@ ConfigInfo::m_SectionRules[] = {
   { DB_TOKEN,   transformNode, 0 },
   { API_TOKEN,  transformNode, 0 },
   { MGM_TOKEN,  transformNode, 0 },
-  { "REP",  transformNode, 0 },
-  { "EXTERNAL REP",  transformExtNode, 0 },
 
   { MGM_TOKEN,  fixShmUniqueId, 0 },
 
@@ -128,8 +125,6 @@ ConfigInfo::m_SectionRules[] = {
   { DB_TOKEN,   fixNodeHostname, 0 },
   { API_TOKEN,  fixNodeHostname, 0 },
   { MGM_TOKEN,  fixNodeHostname, 0 },
-  { "REP",  fixNodeHostname, 0 },
-  //{ "EXTERNAL REP",  fixNodeHostname, 0 },
 
   { "TCP",  fixNodeId, "NodeId1" },
   { "TCP",  fixNodeId, "NodeId2" },
@@ -168,6 +163,10 @@ ConfigInfo::m_SectionRules[] = {
   { "*",    fixDepricated, 0 },
   { "*",    applyDefaultValues, "system" },
 
+  { DB_TOKEN,   checkLocalhostHostnameMix, 0 },
+  { API_TOKEN,  checkLocalhostHostnameMix, 0 },
+  { MGM_TOKEN,  checkLocalhostHostnameMix, 0 },
+
   { DB_TOKEN,   fixFileSystemPath, 0 },
   { DB_TOKEN,   fixBackupDataDir, 0 },
 
@@ -193,7 +192,6 @@ ConfigInfo::m_SectionRules[] = {
   { DB_TOKEN,   saveInConfigValues, 0 },
   { API_TOKEN,  saveInConfigValues, 0 },
   { MGM_TOKEN,  saveInConfigValues, 0 },
-  { "REP",  saveInConfigValues, 0 },
 
   { "TCP",  saveInConfigValues, 0 },
   { "SHM",  saveInConfigValues, 0 },
@@ -345,17 +343,6 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     0, 0 },
   
   {
-    CFG_SYS_REPLICATION_ROLE,
-    "ReplicationRole",
-    "SYSTEM",
-    "Role in Global Replication (None, Primary, or Standby)",
-    ConfigInfo::CI_USED,
-    false,
-    ConfigInfo::CI_STRING,
-    UNDEFINED,
-    0, 0 },
-  
-  {
     CFG_SYS_PRIMARY_MGM_NODE,
     "PrimaryMGMNode",
     "SYSTEM",
@@ -402,7 +389,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     ConfigInfo::CI_INTERNAL,
     false,
     ConfigInfo::CI_STRING,
-    UNDEFINED,
+    "localhost",
     0, 0 },
 
   {
@@ -1219,78 +1206,6 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     STR_VALUE(MAX_INT_RNIL) },
 
   /***************************************************************************
-   * REP
-   ***************************************************************************/
-  {
-    CFG_SECTION_NODE,
-    "REP",
-    "REP",
-    "Node section",
-    ConfigInfo::CI_USED,
-    false,
-    ConfigInfo::CI_SECTION,
-    (const char *)NODE_TYPE_REP, 
-    0, 0
-  },
-
-  {
-    CFG_NODE_HOST,
-    "HostName",
-    "REP",
-    "Name of computer for this node",
-    ConfigInfo::CI_INTERNAL,
-    false,
-    ConfigInfo::CI_STRING,
-    UNDEFINED,
-    0, 0 },
-
-  {
-    CFG_NODE_SYSTEM,
-    "System",
-    "REP",
-    "Name of system for this node",
-    ConfigInfo::CI_INTERNAL,
-    false,
-    ConfigInfo::CI_STRING,
-    UNDEFINED,
-    0, 0 },
-
-  {
-    CFG_NODE_ID,
-    "Id",
-    "REP",
-    "Number identifying replication node (REP)",
-    ConfigInfo::CI_USED,
-    false,
-    ConfigInfo::CI_INT,
-    MANDATORY,
-    "1",
-    STR_VALUE(MAX_NODES) },
-
-  {
-    KEY_INTERNAL,
-    "ExecuteOnComputer",
-    "REP",
-    "String referencing an earlier defined COMPUTER",
-    ConfigInfo::CI_USED,
-    false,
-    ConfigInfo::CI_STRING,
-    MANDATORY,
-    0, 0 },
-
-  {
-    CFG_REP_HEARTBEAT_INTERVAL,
-    "HeartbeatIntervalRepRep",
-    "REP",
-    "Time between REP-REP heartbeats. Connection closed after 3 missed HBs",
-    ConfigInfo::CI_USED,
-    true,
-    ConfigInfo::CI_INT,
-    "3000",
-    "100",
-    STR_VALUE(MAX_INT_RNIL) },
-
-  /***************************************************************************
    * API
    ***************************************************************************/
   {
@@ -1313,7 +1228,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     ConfigInfo::CI_INTERNAL,
     false,
     ConfigInfo::CI_STRING,
-    UNDEFINED,
+    "",
     0, 0 },
 
   {
@@ -1433,7 +1348,7 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     ConfigInfo::CI_INTERNAL,
     false,
     ConfigInfo::CI_STRING,
-    UNDEFINED,
+    "",
     0, 0 },
 
   {
@@ -2464,7 +2379,15 @@ ConfigInfo::isSection(const char * section) const {
 }
 
 const char*
-ConfigInfo::getAlias(const char * section) const {
+ConfigInfo::nameToAlias(const char * name) {
+  for (int i = 0; m_sectionNameAliases[i].name != 0; i++)
+    if(!strcasecmp(name, m_sectionNameAliases[i].name))
+      return m_sectionNameAliases[i].alias;
+  return 0;
+}
+
+const char*
+ConfigInfo::getAlias(const char * section) {
   for (int i = 0; m_sectionNameAliases[i].name != 0; i++)
     if(!strcasecmp(section, m_sectionNameAliases[i].alias))
       return m_sectionNameAliases[i].name;
@@ -2623,7 +2546,7 @@ transformNode(InitConfigFileParser::Context & ctx, const char * data){
   return true;
 }
 
-static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx)
+static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx, const char * data)
 {
   DBUG_ENTER("checkLocalhostHostnameMix");
   const char * hostname= 0;
@@ -2643,7 +2566,7 @@ static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx)
   }
 
   if (localhost_used) {
-    ctx.reportError("Mixing of localhost with other hostname(%s) is illegal",
+    ctx.reportError("Mixing of localhost (default for [NDBD]HostName) with other hostname(%s) is illegal",
 		    hostname);
     DBUG_RETURN(false);
   }
@@ -2652,21 +2575,17 @@ static bool checkLocalhostHostnameMix(InitConfigFileParser::Context & ctx)
 }
 
 bool
-fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data){
-  
+fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data)
+{
   const char * hostname;
+  DBUG_ENTER("fixNodeHostname");
+
   if (ctx.m_currentSection->get("HostName", &hostname))
-    return checkLocalhostHostnameMix(ctx);
+    DBUG_RETURN(checkLocalhostHostnameMix(ctx,0));
 
   const char * compId;
-  if(!ctx.m_currentSection->get("ExecuteOnComputer", &compId)){
-    const char * type;
-    if(ctx.m_currentSection->get("Type", &type) && strcmp(type,DB_TOKEN) == 0)
-      require(ctx.m_currentSection->put("HostName", "localhost"));
-    else
-      require(ctx.m_currentSection->put("HostName", ""));
-    return checkLocalhostHostnameMix(ctx);
-  }
+  if(!ctx.m_currentSection->get("ExecuteOnComputer", &compId))
+    DBUG_RETURN(true);
   
   const Properties * computer;
   char tmp[255];
@@ -2675,18 +2594,18 @@ fixNodeHostname(InitConfigFileParser::Context & ctx, const char * data){
     ctx.reportError("Computer \"%s\" not declared"
 		    "- [%s] starting at line: %d",
 		    compId, ctx.fname, ctx.m_sectionLineno);
-    return false;
+    DBUG_RETURN(false);
   }
   
   if(!computer->get("HostName", &hostname)){
     ctx.reportError("HostName missing in [COMPUTER] (Id: %d) "
 		    " - [%s] starting at line: %d",
 		    compId, ctx.fname, ctx.m_sectionLineno);
-    return false;
+    DBUG_RETURN(false);
   }
   
   require(ctx.m_currentSection->put("HostName", hostname));
-  return checkLocalhostHostnameMix(ctx);
+  DBUG_RETURN(checkLocalhostHostnameMix(ctx,0));
 }
 
 bool
@@ -2870,7 +2789,7 @@ transformComputer(InitConfigFileParser::Context & ctx, const char * data){
     return true;
   }
   
-  return checkLocalhostHostnameMix(ctx);
+  return checkLocalhostHostnameMix(ctx,0);
 }
 
 /**
@@ -2878,7 +2797,9 @@ transformComputer(InitConfigFileParser::Context & ctx, const char * data){
  */
 void 
 applyDefaultValues(InitConfigFileParser::Context & ctx,
-		   const Properties * defaults){
+		   const Properties * defaults)
+{
+  DBUG_ENTER("applyDefaultValues");
   if(defaults != NULL){
     Properties::Iterator it(defaults);
 
@@ -2891,26 +2812,58 @@ applyDefaultValues(InitConfigFileParser::Context & ctx,
 	  Uint32 val = 0;
 	  ::require(defaults->get(name, &val));
 	  ctx.m_currentSection->put(name, val);
+          DBUG_PRINT("info",("%s=%d #default",name,val));
 	  break;
 	}
 	case ConfigInfo::CI_INT64:{
 	  Uint64 val = 0;
 	  ::require(defaults->get(name, &val));
 	  ctx.m_currentSection->put64(name, val);
+          DBUG_PRINT("info",("%s=%lld #default",name,val));
 	  break;
 	}
 	case ConfigInfo::CI_STRING:{
 	  const char * val;
 	  ::require(defaults->get(name, &val));
 	  ctx.m_currentSection->put(name, val);
+          DBUG_PRINT("info",("%s=%s #default",name,val));
 	  break;
 	}
 	case ConfigInfo::CI_SECTION:
 	  break;
 	}
       }
+#ifndef DBUG_OFF
+      else
+      {
+        switch (ctx.m_info->getType(ctx.m_currentInfo, name)){
+        case ConfigInfo::CI_INT:
+        case ConfigInfo::CI_BOOL:{
+          Uint32 val = 0;
+          ::require(ctx.m_currentSection->get(name, &val));
+          DBUG_PRINT("info",("%s=%d",name,val));
+          break;
+        }
+        case ConfigInfo::CI_INT64:{
+          Uint64 val = 0;
+          ::require(ctx.m_currentSection->get(name, &val));
+          DBUG_PRINT("info",("%s=%lld",name,val));
+          break;
+        }
+        case ConfigInfo::CI_STRING:{
+          const char * val;
+          ::require(ctx.m_currentSection->get(name, &val));
+          DBUG_PRINT("info",("%s=%s",name,val));
+          break;
+        }
+        case ConfigInfo::CI_SECTION:
+          break;
+        }
+      }
+#endif
     }
   }
+  DBUG_VOID_RETURN;
 }
 
 bool
@@ -3482,6 +3435,8 @@ fixDepricated(InitConfigFileParser::Context & ctx, const char * data){
   return true;
 }
 
+extern int g_print_full_config;
+
 static bool
 saveInConfigValues(InitConfigFileParser::Context & ctx, const char * data){
   const Properties * sec;
@@ -3503,6 +3458,12 @@ saveInConfigValues(InitConfigFileParser::Context & ctx, const char * data){
       break;
     }
     
+    if (g_print_full_config)
+    {
+      const char *alias= ConfigInfo::nameToAlias(ctx.fname);
+      printf("[%s]\n", alias ? alias : ctx.fname);
+    }
+
     Uint32 no = 0;
     ctx.m_userProperties.get("$Section", id, &no);
     ctx.m_userProperties.put("$Section", id, no+1, true);
@@ -3530,18 +3491,24 @@ saveInConfigValues(InitConfigFileParser::Context & ctx, const char * data){
 	Uint32 val;
 	require(ctx.m_currentSection->get(n, &val));
 	ok = ctx.m_configValues.put(id, val);
+	if (g_print_full_config)
+	  printf("%s=%u\n", n, val);
 	break;
       }
       case PropertiesType_Uint64:{
 	Uint64 val;
 	require(ctx.m_currentSection->get(n, &val));
 	ok = ctx.m_configValues.put64(id, val);
+	if (g_print_full_config)
+	  printf("%s=%llu\n", n, val);
 	break;
       }
       case PropertiesType_char:{
 	const char * val;
 	require(ctx.m_currentSection->get(n, &val));
 	ok = ctx.m_configValues.put(id, val);
+	if (g_print_full_config)
+	  printf("%s=%s\n", n, val);
 	break;
       }
       default:
diff --git a/ndb/src/mgmsrv/ConfigInfo.hpp b/ndb/src/mgmsrv/ConfigInfo.hpp
index dff8b34bf4a..871ee62040e 100644
--- a/ndb/src/mgmsrv/ConfigInfo.hpp
+++ b/ndb/src/mgmsrv/ConfigInfo.hpp
@@ -105,7 +105,8 @@ public:
    *   @note Result is not defined if section/name are wrong!
    */
   bool verify(const Properties* secti, const char* fname, Uint64 value) const;
-  const char* getAlias(const char*) const;
+  static const char* nameToAlias(const char*);
+  static const char* getAlias(const char*);
   bool isSection(const char*) const;
 
   const char*  getDescription(const Properties * sec, const char* fname) const;
diff --git a/ndb/src/mgmsrv/main.cpp b/ndb/src/mgmsrv/main.cpp
index 07b369d4ebc..ec20101493e 100644
--- a/ndb/src/mgmsrv/main.cpp
+++ b/ndb/src/mgmsrv/main.cpp
@@ -121,6 +121,7 @@ struct MgmGlobals {
 };
 
 int g_no_nodeid_checks= 0;
+int g_print_full_config;
 static MgmGlobals *glob= 0;
 
 /******************************************************************************
@@ -147,6 +148,9 @@ static struct my_option my_long_options[] =
   { "config-file", 'f', "Specify cluster configuration file",
     (gptr*) &opt_config_filename, (gptr*) &opt_config_filename, 0,
     GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0 },
+  { "print-full-config", 'P', "Print full config and exit",
+    (gptr*) &g_print_full_config, (gptr*) &g_print_full_config, 0,
+    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0 },
   { "daemon", 'd', "Run ndb_mgmd in daemon mode (default)",
     (gptr*) &opt_daemon, (gptr*) &opt_daemon, 0,
     GET_BOOL, NO_ARG, 1, 0, 0, 0, 0, 0 },
@@ -208,7 +212,8 @@ int main(int argc, char** argv)
     exit(ho_error);
 
   if (opt_interactive ||
-      opt_non_interactive) {
+      opt_non_interactive ||
+      g_print_full_config) {
     opt_daemon= 0;
   }
 
@@ -220,6 +225,9 @@ int main(int argc, char** argv)
 				opt_config_filename,
 				opt_connect_str);
 
+  if (g_print_full_config)
+    goto the_end;
+
   if (glob->mgmObject->init())
     goto error_end;
 
@@ -358,6 +366,7 @@ int main(int argc, char** argv)
   glob->mgmObject->get_config_retriever()->disconnect();
   glob->socketServer->stopSessions(true);
   g_eventLogger.info("Shutdown complete");
+ the_end:
   delete glob;
   ndb_end(opt_endinfo ? MY_CHECK_ERROR | MY_GIVE_INFO : 0);
   return 0;