Merge mysql.com:/home/marty/MySQL/mysql-5.0-ndb

into  mysql.com:/home/marty/MySQL/mysql-5.1-new-ndb


storage/ndb/include/kernel/signaldata/TcKeyRef.hpp:
  Auto merged
storage/ndb/include/kernel/signaldata/TcRollbackRep.hpp:
  Auto merged
storage/ndb/include/ndbapi/NdbDictionary.hpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
  Auto merged
storage/ndb/src/ndbapi/NdbDictionary.cpp:
  Auto merged
storage/ndb/src/ndbapi/NdbTransaction.cpp:
  Auto merged
storage/ndb/src/ndbapi/ndberror.c:
  Auto merged
sql/ha_ndbcluster.cc:
  Merge
storage/ndb/src/ndbapi/NdbOperationExec.cpp:
  Merge

sql/ha_ndbcluster.cc

@@ -588,6 +588,25 @@ int ha_ndbcluster::ndb_err(NdbTransaction *trans)
                       err.code, res));
   if (res == HA_ERR_FOUND_DUPP_KEY)
   {
+    uint error_data= (uint) err.details;
+    uint dupkey= MAX_KEY;
+
+    for (uint i= 0; i < MAX_KEY; i++)
+    {
+      if (m_index[i].type == UNIQUE_INDEX || 
+          m_index[i].type == UNIQUE_ORDERED_INDEX)
+      {
+        const NDBINDEX *unique_index=
+          (const NDBINDEX *) m_index[i].unique_index;
+        if (unique_index &&
+            unique_index->getIndexTable() &&
+            (uint) unique_index->getObjectId() == error_data)
+        {
+          dupkey= i;
+          break;
+        }
+      }
+    }
     if (m_rows_to_insert == 1)
     {
       /*
@@ -595,7 +614,7 @@ int ha_ndbcluster::ndb_err(NdbTransaction *trans)
 	violations here, so we need to return MAX_KEY for non-primary
 	to signal that key is unknown
       */
-      m_dupkey= err.code == 630 ? table_share->primary_key : MAX_KEY; 
+      m_dupkey= err.code == 630 ? table_share->primary_key : dupkey; 
     }
     else
     {

storage/ndb/include/kernel/signaldata/TcKeyRef.hpp

@@ -40,12 +40,13 @@ class TcKeyRef {
   friend bool printTCKEYREF(FILE *, const Uint32 *, Uint32, Uint16);
   
 public:
-  STATIC_CONST( SignalLength = 4 );
+  STATIC_CONST( SignalLength = 5 );
 
 private:
   Uint32 connectPtr;
   Uint32 transId[2];
   Uint32 errorCode;
+  Uint32 errorData;
 };
 
 #endif

storage/ndb/include/kernel/signaldata/TcRollbackRep.hpp

@@ -38,12 +38,13 @@ class TcRollbackRep {
   friend bool printTCROLBACKREP(FILE *, const Uint32 *, Uint32, Uint16);
   
 public:
-  STATIC_CONST( SignalLength = 4 );
+  STATIC_CONST( SignalLength = 5 );
 
 private:
   Uint32 connectPtr;
   Uint32 transId[2];
   Uint32 returnCode;
+  Uint32 errorData;
 };
 
 #endif

storage/ndb/include/ndbapi/NdbDictionary.hpp

@@ -1021,6 +1021,11 @@ public:
      */
     const char * getTable() const;
 
+    /**
+     * Get the table representing the index
+     */
+    const Table * getIndexTable() const;
+
     /**
      * Get the number of columns in the index
      */

storage/ndb/src/kernel/blocks/dbtc/Dbtc.hpp

@@ -734,6 +734,7 @@ public:
     // Index op return context
     UintR indexOp;
     UintR clientData;
+    Uint32 errorData;
     UintR attrInfoLen;
     
     UintR accumulatingIndexOp;

storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp

@@ -5119,6 +5119,7 @@ void Dbtc::releaseDirtyWrite(Signal* signal)
 void Dbtc::execLQHKEYREF(Signal* signal) 
 {
   const LqhKeyRef * const lqhKeyRef = (LqhKeyRef *)signal->getDataPtr();
+  Uint32 indexId = 0;
   jamEntry();
   
   UintR compare_transid1, compare_transid2;
@@ -5170,6 +5171,9 @@ void Dbtc::execLQHKEYREF(Signal* signal)
 	ptrCheckGuard(opPtr, ctcConnectFilesize, localTcConnectRecord);
 	
 	// The operation executed an index trigger
+        TcIndexData* indexData = c_theIndexes.getPtr(currentIndexId);
+        indexId = indexData->indexId;
+        regApiPtr->errorData = indexId;
 	const Uint32 opType = regTcPtr->operation;
 	if (errCode == ZALREADYEXIST)
 	  errCode = terrorCode = ZNOTUNIQUE;
@@ -5182,7 +5186,6 @@ void Dbtc::execLQHKEYREF(Signal* signal)
 	} else {
 	  jam();
 	  /** ZDELETE && NOT_FOUND */
-	  TcIndexData* indexData = c_theIndexes.getPtr(currentIndexId);
 	  if(indexData->indexState == IS_BUILDING && state != CS_ABORTING){
 	    jam();
 	    /**
@@ -5267,12 +5270,14 @@ void Dbtc::execLQHKEYREF(Signal* signal)
         jam();
 	regApiPtr->lqhkeyreqrec--; // Compensate for extra during read
 	tcKeyRef->connectPtr = indexOp;
+        tcKeyRef->errorData = indexId;
 	EXECUTE_DIRECT(DBTC, GSN_TCKEYREF, signal, TcKeyRef::SignalLength);
 	apiConnectptr.i = save;
 	apiConnectptr.p = regApiPtr;
       } else {
         jam();
 	tcKeyRef->connectPtr = clientData;
+        tcKeyRef->errorData = indexId;
 	sendSignal(regApiPtr->ndbapiBlockref, 
 		   GSN_TCKEYREF, signal, TcKeyRef::SignalLength, JBB);
       }//if
@@ -10573,6 +10578,7 @@ void Dbtc::releaseAbortResources(Signal* signal)
       tcRollbackRep->transId[0] = apiConnectptr.p->transid[0];
       tcRollbackRep->transId[1] = apiConnectptr.p->transid[1];
       tcRollbackRep->returnCode = apiConnectptr.p->returncode;
+      tcRollbackRep->errorData = apiConnectptr.p->errorData;
       sendSignal(blockRef, GSN_TCROLLBACKREP, signal, 
 		 TcRollbackRep::SignalLength, JBB);
     }
@@ -11997,6 +12003,7 @@ void Dbtc::execTCKEYCONF(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;    
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12016,6 +12023,7 @@ void Dbtc::execTCKEYCONF(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;    
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12099,6 +12107,7 @@ void Dbtc::execTCKEYREF(Signal* signal)
     tcIndxRef->transId[0] = tcKeyRef->transId[0];
     tcIndxRef->transId[1] = tcKeyRef->transId[1];
     tcIndxRef->errorCode = tcKeyRef->errorCode;
+    tcIndxRef->errorData = 0;
 
     releaseIndexOperation(regApiPtr, indexOp);
 
@@ -12176,6 +12185,7 @@ void Dbtc::execTRANSID_AI(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4000;
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12191,6 +12201,7 @@ void Dbtc::execTRANSID_AI(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12219,6 +12230,7 @@ void Dbtc::execTRANSID_AI(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
                TcKeyRef::SignalLength, JBB);
     */
@@ -12244,6 +12256,7 @@ void Dbtc::execTRANSID_AI(Signal* signal)
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;
+    tcIndxRef->errorData = regApiPtr->errorData;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12297,6 +12310,7 @@ void Dbtc::readIndexTable(Signal* signal,
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4000;    
+    // tcIndxRef->errorData = ??; Where to find indexId
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;
@@ -12443,6 +12457,7 @@ void Dbtc::executeIndexOperation(Signal* signal,
     tcIndxRef->transId[0] = regApiPtr->transid[0];
     tcIndxRef->transId[1] = regApiPtr->transid[1];
     tcIndxRef->errorCode = 4349;    
+    tcIndxRef->errorData = 0;
     sendSignal(regApiPtr->ndbapiBlockref, GSN_TCINDXREF, signal, 
 	       TcKeyRef::SignalLength, JBB);
     return;

storage/ndb/src/ndbapi/NdbDictionary.cpp

@@ -792,6 +792,15 @@ NdbDictionary::Index::getTable() const {
   return m_impl.getTable();
 }
 
+const NdbDictionary::Table *
+NdbDictionary::Index::getIndexTable() const {
+  NdbTableImpl * t = m_impl.m_table;
+  if (t) {
+    return t->m_facade;
+  }
+  return 0;
+}
+
 unsigned
 NdbDictionary::Index::getNoOfColumns() const {
   return m_impl.m_columns.size();

storage/ndb/src/ndbapi/NdbOperationExec.cpp

@@ -24,6 +24,7 @@
 #include "Interpreter.hpp"
 #include <AttributeHeader.hpp>
 #include <signaldata/TcKeyReq.hpp>
+#include <signaldata/TcKeyRef.hpp>
 #include <signaldata/KeyInfo.hpp>
 #include <signaldata/AttrInfo.hpp>
 #include <signaldata/ScanTab.hpp>
@@ -545,6 +546,12 @@ NdbOperation::receiveTCKEYREF( NdbApiSignal* aSignal)
   }//if
 
   setErrorCode(aSignal->readData(4));
+  if (aSignal->getLength() == TcKeyRef::SignalLength)
+  {
+    // Signal may contain additional error data
+    setErrorDetails((char *) aSignal->readData(5));
+  }
+
   theStatus = Finished;
   theReceiver.m_received_result_length = ~0;
 

storage/ndb/src/ndbapi/NdbTransaction.cpp

@@ -30,6 +30,7 @@
 #include <signaldata/TcCommit.hpp>
 #include <signaldata/TcKeyFailConf.hpp>
 #include <signaldata/TcHbRep.hpp>
+#include <signaldata/TcRollbackRep.hpp>
 
 /*****************************************************************************
 NdbTransaction( Ndb* aNdb );
@@ -1729,6 +1730,8 @@ Remark:         Handles the reception of the ROLLBACKREP signal.
 int
 NdbTransaction::receiveTCROLLBACKREP( NdbApiSignal* aSignal)
 {
+  DBUG_ENTER("NdbTransaction::receiveTCROLLBACKREP");
+
   /****************************************************************************
 Check that we are expecting signals from this transaction and that it doesn't
 belong to a transaction already completed. Simply ignore messages from other 
@@ -1736,6 +1739,11 @@ transactions.
   ****************************************************************************/
   if(checkState_TransId(aSignal->getDataPtr() + 1)){
     theError.code = aSignal->readData(4);// Override any previous errors
+    if (aSignal->getLength() == TcRollbackRep::SignalLength)
+    {
+      // Signal may contain additional error data
+      theError.details = (char *) aSignal->readData(5);
+    }
 
     /**********************************************************************/
     /*	A serious error has occured. This could be due to deadlock or */
@@ -1747,14 +1755,14 @@ transactions.
     theCompletionStatus = CompletedFailure;
     theCommitStatus = Aborted;
     theReturnStatus = ReturnFailure;
-    return 0;
+    DBUG_RETURN(0);
   } else {
 #ifdef NDB_NO_DROPPED_SIGNAL
     abort();
 #endif
   }
 
-  return -1;
+  DBUG_RETURN(-1);
 }//NdbTransaction::receiveTCROLLBACKREP()
 
 /*******************************************************************************

storage/ndb/src/ndbapi/ndberror.c

@@ -766,8 +766,6 @@ ndberror_update(ndberror_struct * error){
   if(!found){
     error->status = ST_U;
   }
-
-  error->details = 0;
 }
 
 #if CHECK_ERRORCODES