Below is the list of changes that have just been committed into a local
5.1 repository of jonas. When jonas 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-01-30 19:45:44+01:00, jonas@stripped +12 -0
Merge perch.ndb.mysql.com:/home/jonas/src/51-work
into perch.ndb.mysql.com:/home/jonas/src/mysql-5.1-new-ndb
MERGE: 1.2343.10.36
sql/ha_ndbcluster.cc@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.372.2.1
storage/ndb/include/ndbapi/NdbOperation.hpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.39.1.1
storage/ndb/include/ndbapi/NdbTransaction.hpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.52.1.1
storage/ndb/src/ndbapi/NdbBlob.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.49.1.1
storage/ndb/src/ndbapi/NdbIndexStat.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.5.1.1
storage/ndb/src/ndbapi/NdbOperationDefine.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.24.1.1
storage/ndb/src/ndbapi/NdbOperationExec.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.23.1.1
storage/ndb/src/ndbapi/NdbScanOperation.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.103.1.2
storage/ndb/src/ndbapi/NdbTransaction.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.70.1.2
storage/ndb/test/include/HugoOperations.hpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.18.1.1
storage/ndb/test/ndbapi/testNdbApi.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.23.1.1
storage/ndb/test/src/HugoOperations.cpp@stripped, 2007-01-30 19:45:41+01:00, jonas@stripped +0 -0
Auto merged
MERGE: 1.28.1.1
# 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: jonas
# Host: perch.ndb.mysql.com
# Root: /home/jonas/src/mysql-5.1-new-ndb/RESYNC
--- 1.53/storage/ndb/include/ndbapi/NdbTransaction.hpp 2007-01-30 19:45:49 +01:00
+++ 1.54/storage/ndb/include/ndbapi/NdbTransaction.hpp 2007-01-30 19:45:49 +01:00
@@ -20,6 +20,7 @@
#include "NdbError.hpp"
#include "NdbDictionary.hpp"
#include "Ndb.hpp"
+#include "NdbOperation.hpp"
class NdbTransaction;
class NdbOperation;
@@ -44,11 +45,12 @@
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
enum AbortOption {
- CommitIfFailFree= 0,
- TryCommit= 0,
- AbortOnError= 0,
- CommitAsMuchAsPossible= 2,
- AO_IgnoreError= 2
+ DefaultAbortOption = NdbOperation::DefaultAbortOption,
+ CommitIfFailFree = NdbOperation::AbortOnError,
+ TryCommit = NdbOperation::AbortOnError,
+ AbortOnError= NdbOperation::AbortOnError,
+ CommitAsMuchAsPossible = NdbOperation::AO_IgnoreError,
+ AO_IgnoreError= NdbOperation::AO_IgnoreError
};
enum ExecType {
NoExecTypeDef = -1,
@@ -145,20 +147,6 @@
public:
/**
- * Commit type of transaction
- */
- enum AbortOption {
- AbortOnError= ///< Abort transaction on failed operation
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
- ::AbortOnError
-#endif
- ,AO_IgnoreError= ///< Transaction continues on failed operation
-#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
- ::AO_IgnoreError
-#endif
- };
-
- /**
* Execution type of transaction
*/
enum ExecType {
@@ -316,13 +304,15 @@
* @return 0 if successful otherwise -1.
*/
int execute(ExecType execType,
- AbortOption abortOption = AbortOnError,
+ NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
int force = 0 );
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
int execute(::ExecType execType,
- ::AbortOption abortOption = ::AbortOnError,
- int force = 0 )
- { return execute ((ExecType)execType,(AbortOption)abortOption,force); }
+ ::AbortOption abortOption = ::DefaultAbortOption,
+ int force = 0 ) {
+ return execute ((ExecType)execType,
+ (NdbOperation::AbortOption)abortOption,
+ force); }
#endif
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
@@ -353,14 +343,14 @@
void executeAsynchPrepare(ExecType execType,
NdbAsynchCallback callback,
void* anyObject,
- AbortOption abortOption = AbortOnError);
+ NdbOperation::AbortOption = NdbOperation::DefaultAbortOption);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
void executeAsynchPrepare(::ExecType execType,
NdbAsynchCallback callback,
void* anyObject,
- ::AbortOption abortOption = ::AbortOnError)
- { executeAsynchPrepare((ExecType)execType, callback, anyObject,
- (AbortOption)abortOption); }
+ ::AbortOption ao = ::DefaultAbortOption) {
+ executeAsynchPrepare((ExecType)execType, callback, anyObject,
+ (NdbOperation::AbortOption)ao); }
#endif
/**
@@ -379,14 +369,14 @@
void executeAsynch(ExecType aTypeOfExec,
NdbAsynchCallback aCallback,
void* anyObject,
- AbortOption abortOption = AbortOnError);
+ NdbOperation::AbortOption = NdbOperation::DefaultAbortOption);
#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
void executeAsynch(::ExecType aTypeOfExec,
NdbAsynchCallback aCallback,
void* anyObject,
- ::AbortOption abortOption= ::AbortOnError)
+ ::AbortOption abortOption= ::DefaultAbortOption)
{ executeAsynch((ExecType)aTypeOfExec, aCallback, anyObject,
- (AbortOption)abortOption); }
+ (NdbOperation::AbortOption)abortOption); }
#endif
#endif
/**
@@ -588,7 +578,7 @@
void init(); // Initialize connection object for new transaction
int executeNoBlobs(ExecType execType,
- AbortOption abortOption = AbortOnError,
+ NdbOperation::AbortOption = NdbOperation::DefaultAbortOption,
int force = 0 );
/**
@@ -642,7 +632,7 @@
int sendCOMMIT(); // Send a TC_COMMITREQ signal;
void setGCI(int GCI); // Set the global checkpoint identity
- int OpCompleteFailure(Uint8 abortoption, bool setFailure = true);
+ int OpCompleteFailure(NdbOperation*);
int OpCompleteSuccess();
void CompletedOperations(); // Move active ops to list of completed
@@ -732,7 +722,6 @@
Uint32 theNoOfOpSent; // How many operations have been sent
Uint32 theNoOfOpCompleted; // How many operations have completed
- Uint32 theNoOfOpFetched; // How many operations was actually fetched
Uint32 theMyRef; // Our block reference
Uint32 theTCConPtr; // Transaction Co-ordinator connection pointer.
Uint64 theTransactionId; // theTransactionId of the transaction
@@ -756,7 +745,6 @@
bool theTransactionIsStarted;
bool theInUseState;
bool theSimpleState;
- Uint8 m_abortOption; // Type of commi
enum ListState {
NotInList,
--- 1.40/storage/ndb/include/ndbapi/NdbOperation.hpp 2007-01-30 19:45:49 +01:00
+++ 1.41/storage/ndb/include/ndbapi/NdbOperation.hpp 2007-01-30 19:45:49 +01:00
@@ -98,6 +98,19 @@
};
/**
+ * How should transaction be handled if operation fails
+ *
+ * For READ, default is AO_IgnoreError
+ * DML, default is AbortOnError
+ * CommittedRead does _only_ support AO_IgnoreError
+ */
+ enum AbortOption {
+ DefaultAbortOption = -1,///< Use default as specified by op-type
+ AbortOnError = 0, ///< Abort transaction on failed operation
+ AO_IgnoreError = 2 ///< Transaction continues on failed operation
+ };
+
+ /**
* Define the NdbOperation to be a standard operation of type insertTuple.
* When calling NdbTransaction::execute, this operation
* adds a new tuple to the table.
@@ -776,8 +789,13 @@
*/
LockMode getLockMode() const { return theLockMode; }
+ /**
+ * Get/set abort option
+ */
+ AbortOption getAbortOption() const;
+ int setAbortOption(AbortOption);
+
#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
- void setAbortOption(Int8 ao) { m_abortOption = ao; }
/**
* Set/get partition key
@@ -856,7 +874,8 @@
int doSend(int ProcessorId, Uint32 lastFlag);
virtual int prepareSend(Uint32 TC_ConnectPtr,
- Uint64 TransactionId);
+ Uint64 TransactionId,
+ AbortOption);
virtual void setLastFlag(NdbApiSignal* signal, Uint32 lastFlag);
int prepareSendInterpreted(); // Help routine to prepare*
--- 1.74/storage/ndb/src/ndbapi/NdbTransaction.cpp 2007-01-30 19:45:49 +01:00
+++ 1.75/storage/ndb/src/ndbapi/NdbTransaction.cpp 2007-01-30 19:45:49 +01:00
@@ -56,7 +56,6 @@
theCompletedLastOp(NULL),
theNoOfOpSent(0),
theNoOfOpCompleted(0),
- theNoOfOpFetched(0),
theMyRef(0),
theTCConPtr(0),
theTransactionId(0),
@@ -131,7 +130,6 @@
theNdb->theImpl->m_ndb_cluster_connection.get_latest_trans_gci();
theCommitStatus = Started;
theCompletionStatus = NotCompleted;
- m_abortOption = AbortOnError;
theError.code = 0;
theErrorLine = 0;
@@ -176,12 +174,9 @@
NdbTransaction::setOperationErrorCodeAbort(int error, int abortOption)
{
DBUG_ENTER("NdbTransaction::setOperationErrorCodeAbort");
- if (abortOption == -1)
- abortOption = m_abortOption;
if (theTransactionIsStarted == false) {
theCommitStatus = Aborted;
- } else if ((abortOption == AbortOnError) &&
- (theCommitStatus != Committed) &&
+ } else if ((theCommitStatus != Committed) &&
(theCommitStatus != Aborted)) {
theCommitStatus = NeedAbort;
}//if
@@ -263,8 +258,8 @@
*****************************************************************************/
int
NdbTransaction::execute(ExecType aTypeOfExec,
- AbortOption abortOption,
- int forceSend)
+ NdbOperation::AbortOption abortOption,
+ int forceSend)
{
NdbError savedError= theError;
DBUG_ENTER("NdbTransaction::execute");
@@ -354,40 +349,14 @@
theCompletedLastOp = NULL;
}
- if (executeNoBlobs(tExecType, abortOption, forceSend) == -1)
+ if (executeNoBlobs(tExecType,
+ NdbOperation::DefaultAbortOption,
+ forceSend) == -1)
{
- ret = -1;
if(savedError.code==0)
savedError= theError;
- /**
- * If AO_IgnoreError, error codes arent always set on individual
- * operations, making postExecute impossible
- */
- if (abortOption == AO_IgnoreError)
- {
- if (theCompletedFirstOp != NULL)
- {
- if (tCompletedFirstOp != NULL)
- {
- tCompletedLastOp->next(theCompletedFirstOp);
- theCompletedFirstOp = tCompletedFirstOp;
- }
- }
- else
- {
- theCompletedFirstOp = tCompletedFirstOp;
- theCompletedLastOp = tCompletedLastOp;
- }
- if (tPrepOp != NULL && tRestOp != NULL) {
- if (theFirstOpInList == NULL)
- theFirstOpInList = tRestOp;
- else
- theLastOpInList->next(tRestOp);
- theLastOpInList = tLastOp;
- }
- DBUG_RETURN(-1);
- }
+ DBUG_RETURN(-1);
}
#ifdef ndb_api_crash_on_complex_blob_abort
@@ -447,9 +416,9 @@
}
int
-NdbTransaction::executeNoBlobs(ExecType aTypeOfExec,
- AbortOption abortOption,
- int forceSend)
+NdbTransaction::executeNoBlobs(NdbTransaction::ExecType aTypeOfExec,
+ NdbOperation::AbortOption abortOption,
+ int forceSend)
{
DBUG_ENTER("NdbTransaction::executeNoBlobs");
DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d",
@@ -527,10 +496,10 @@
Remark: Prepare a part of a transaction in an asynchronous manner.
*****************************************************************************/
void
-NdbTransaction::executeAsynchPrepare( ExecType aTypeOfExec,
+NdbTransaction::executeAsynchPrepare(NdbTransaction::ExecType aTypeOfExec,
NdbAsynchCallback aCallback,
void* anyObject,
- AbortOption abortOption)
+ NdbOperation::AbortOption abortOption)
{
DBUG_ENTER("NdbTransaction::executeAsynchPrepare");
DBUG_PRINT("enter", ("aTypeOfExec: %d, aCallback: 0x%lx, anyObject: Ox%lx",
@@ -570,7 +539,6 @@
theReturnStatus = ReturnSuccess;
theCallbackFunction = aCallback;
theCallbackObject = anyObject;
- m_abortOption = abortOption;
m_waitForReply = true;
tNdb->thePreparedTransactionsArray[tnoOfPreparedTransactions] = this;
theTransArrayIndex = tnoOfPreparedTransactions;
@@ -665,8 +633,7 @@
while (tOp) {
int tReturnCode;
NdbOperation* tNextOp = tOp->next();
-
- tReturnCode = tOp->prepareSend(theTCConPtr, theTransactionId);
+ tReturnCode = tOp->prepareSend(theTCConPtr, theTransactionId, abortOption);
if (tReturnCode == -1) {
theSendStatus = sendABORTfail;
DBUG_VOID_RETURN;
@@ -1799,14 +1766,8 @@
}
} else if ((tNoComp >= tNoSent) &&
(theLastExecOpInList->theCommitIndicator == 1)){
-
-
- if (m_abortOption == AO_IgnoreError && theError.code != 0){
- /**
- * There's always a TCKEYCONF when using IgnoreError
- */
- return -1;
- }
+
+
/**********************************************************************/
// We sent the transaction with Commit flag set and received a CONF with
// no Commit flag set. This is clearly an anomaly.
@@ -1980,13 +1941,6 @@
} else if ((tNoComp >= tNoSent) &&
(theLastExecOpInList->theCommitIndicator == 1)){
- if (m_abortOption == AO_IgnoreError && theError.code != 0){
- /**
- * There's always a TCKEYCONF when using IgnoreError
- */
- return -1;
- }
-
/**********************************************************************/
// We sent the transaction with Commit flag set and received a CONF with
// no Commit flag set. This is clearly an anomaly.
@@ -2010,41 +1964,6 @@
return -1;
}//NdbTransaction::receiveTCINDXCONF()
-/*****************************************************************************
-int receiveTCINDXREF( NdbApiSignal* aSignal)
-
-Return Value: Return 0 : send was succesful.
- Return -1: In all other case.
-Parameters: aSignal: the signal object that contains the
- TCINDXREF signal from TC.
-Remark: Handles the reception of the TCINDXREF signal.
-*****************************************************************************/
-int
-NdbTransaction::receiveTCINDXREF( NdbApiSignal* aSignal)
-{
- if(checkState_TransId(aSignal->getDataPtr()+1)){
- theError.code = aSignal->readData(4); // Override any previous errors
-
- /**********************************************************************/
- /* A serious error has occured. This could be due to deadlock or */
- /* lack of resources or simply a programming error in NDB. This */
- /* transaction will be aborted. Actually it has already been */
- /* and we only need to report completion and return with the */
- /* error code to the application. */
- /**********************************************************************/
- theCompletionStatus = NdbTransaction::CompletedFailure;
- theCommitStatus = NdbTransaction::Aborted;
- theReturnStatus = NdbTransaction::ReturnFailure;
- return 0;
- } else {
-#ifdef NDB_NO_DROPPED_SIGNAL
- abort();
-#endif
- }
-
- return -1;
-}//NdbTransaction::receiveTCINDXREF()
-
/*******************************************************************************
int OpCompletedFailure();
@@ -2054,36 +1973,15 @@
Remark: An operation was completed with failure.
*******************************************************************************/
int
-NdbTransaction::OpCompleteFailure(Uint8 abortOption, bool setFailure)
+NdbTransaction::OpCompleteFailure(NdbOperation* op)
{
Uint32 tNoComp = theNoOfOpCompleted;
Uint32 tNoSent = theNoOfOpSent;
- if (setFailure)
- theCompletionStatus = NdbTransaction::CompletedFailure;
+
tNoComp++;
theNoOfOpCompleted = tNoComp;
- if (tNoComp == tNoSent) {
- //------------------------------------------------------------------------
- //If the transaction consists of only simple reads we can set
- //Commit state Aborted. Otherwise this simple operation cannot
- //decide the success of the whole transaction since a simple
- //operation is not really part of that transaction.
- //------------------------------------------------------------------------
- if (abortOption == AO_IgnoreError){
- /**
- * There's always a TCKEYCONF when using IgnoreError
- */
- return -1;
- }
-
- return 0; // Last operation received
- } else if (tNoComp > tNoSent) {
- setOperationErrorCodeAbort(4113); // Too many operations,
- // stop waiting for more
- return 0;
- } else {
- return -1; // Continue waiting for more signals
- }//if
+
+ return (tNoComp == tNoSent) ? 0 : -1;
}//NdbTransaction::OpCompleteFailure()
/******************************************************************************
--- 1.25/storage/ndb/src/ndbapi/NdbOperationDefine.cpp 2007-01-30 19:45:49 +01:00
+++ 1.26/storage/ndb/src/ndbapi/NdbOperationDefine.cpp 2007-01-30 19:45:49 +01:00
@@ -44,6 +44,7 @@
tNdbCon->theSimpleState = 0;
theErrorLine = tErrorLine++;
theLockMode = LM_Exclusive;
+ m_abortOption = AbortOnError;
return 0;
} else {
setErrorCode(4200);
@@ -64,6 +65,7 @@
theOperationType = UpdateRequest;
theErrorLine = tErrorLine++;
theLockMode = LM_Exclusive;
+ m_abortOption = AbortOnError;
return 0;
} else {
setErrorCode(4200);
@@ -84,12 +86,35 @@
theOperationType = WriteRequest;
theErrorLine = tErrorLine++;
theLockMode = LM_Exclusive;
+ m_abortOption = AbortOnError;
return 0;
} else {
setErrorCode(4200);
return -1;
}//if
}//NdbOperation::writeTuple()
+/*****************************************************************************
+ * int deleteTuple();
+ *****************************************************************************/
+int
+NdbOperation::deleteTuple()
+{
+ NdbTransaction* tNdbCon = theNdbCon;
+ int tErrorLine = theErrorLine;
+ if (theStatus == Init) {
+ theStatus = OperationDefined;
+ tNdbCon->theSimpleState = 0;
+ theOperationType = DeleteRequest;
+ theErrorLine = tErrorLine++;
+ theLockMode = LM_Exclusive;
+ m_abortOption = AbortOnError;
+ return 0;
+ } else {
+ setErrorCode(4200);
+ return -1;
+ }//if
+}//NdbOperation::deleteTuple()
+
/******************************************************************************
* int readTuple();
*****************************************************************************/
@@ -124,6 +149,7 @@
theOperationType = ReadRequest;
theErrorLine = tErrorLine++;
theLockMode = LM_Read;
+ m_abortOption = AO_IgnoreError;
return 0;
} else {
setErrorCode(4200);
@@ -131,27 +157,6 @@
}//if
}//NdbOperation::readTuple()
-/*****************************************************************************
- * int deleteTuple();
- *****************************************************************************/
-int
-NdbOperation::deleteTuple()
-{
- NdbTransaction* tNdbCon = theNdbCon;
- int tErrorLine = theErrorLine;
- if (theStatus == Init) {
- theStatus = OperationDefined;
- tNdbCon->theSimpleState = 0;
- theOperationType = DeleteRequest;
- theErrorLine = tErrorLine++;
- theLockMode = LM_Exclusive;
- return 0;
- } else {
- setErrorCode(4200);
- return -1;
- }//if
-}//NdbOperation::deleteTuple()
-
/******************************************************************************
* int readTupleExclusive();
*****************************************************************************/
@@ -166,6 +171,7 @@
theOperationType = ReadExclusive;
theErrorLine = tErrorLine++;
theLockMode = LM_Exclusive;
+ m_abortOption = AO_IgnoreError;
return 0;
} else {
setErrorCode(4200);
@@ -222,6 +228,7 @@
theDirtyIndicator = 1;
theErrorLine = tErrorLine++;
theLockMode = LM_CommittedRead;
+ m_abortOption = AO_IgnoreError;
return 0;
} else {
setErrorCode(4200);
@@ -245,6 +252,7 @@
theDirtyIndicator = 1;
theErrorLine = tErrorLine++;
theLockMode = LM_CommittedRead;
+ m_abortOption = AbortOnError;
return 0;
} else {
setErrorCode(4200);
@@ -268,6 +276,7 @@
theDirtyIndicator = 1;
theErrorLine = tErrorLine++;
theLockMode = LM_CommittedRead;
+ m_abortOption = AbortOnError;
return 0;
} else {
setErrorCode(4200);
@@ -290,6 +299,7 @@
theAI_LenInCurrAI = 25;
theLockMode = LM_Exclusive;
theErrorLine = tErrorLine++;
+ m_abortOption = AbortOnError;
initInterpreter();
return 0;
} else {
@@ -314,6 +324,7 @@
theErrorLine = tErrorLine++;
theAI_LenInCurrAI = 25;
theLockMode = LM_Exclusive;
+ m_abortOption = AbortOnError;
initInterpreter();
return 0;
} else {
--- 1.24/storage/ndb/src/ndbapi/NdbOperationExec.cpp 2007-01-30 19:45:49 +01:00
+++ 1.25/storage/ndb/src/ndbapi/NdbOperationExec.cpp 2007-01-30 19:45:49 +01:00
@@ -99,7 +99,9 @@
Remark: Puts the the data into TCKEYREQ signal and optional KEYINFO and ATTRINFO signals.
***************************************************************************/
int
-NdbOperation::prepareSend(Uint32 aTC_ConnectPtr, Uint64 aTransId)
+NdbOperation::prepareSend(Uint32 aTC_ConnectPtr,
+ Uint64 aTransId,
+ AbortOption ao)
{
Uint32 tTransId1, tTransId2;
Uint32 tReqInfo;
@@ -147,8 +149,8 @@
//-------------------------------------------------------------
TcKeyReq * const tcKeyReq = CAST_PTR(TcKeyReq, theTCREQ->getDataPtrSend());
- Uint32 tTableId = m_currentTable->m_id;
- Uint32 tSchemaVersion = m_currentTable->m_version;
+ Uint32 tTableId = m_accessTable->m_id;
+ Uint32 tSchemaVersion = m_accessTable->m_version;
tcKeyReq->apiConnectPtr = aTC_ConnectPtr;
tcKeyReq->apiOperationPtr = ptr2int();
@@ -198,16 +200,16 @@
OperationType tOperationType = theOperationType;
Uint32 tTupKeyLen = theTupKeyLen;
- Uint8 abortOption =
- m_abortOption != -1 ? m_abortOption : theNdbCon->m_abortOption;
+ Uint8 abortOption = (ao == DefaultAbortOption) ? m_abortOption : ao;
tcKeyReq->setDirtyFlag(tReqInfo, tDirtyIndicator);
tcKeyReq->setOperationType(tReqInfo, tOperationType);
tcKeyReq->setKeyLength(tReqInfo, tTupKeyLen);
// A simple read is always ignore error
- abortOption = tSimpleIndicator ? (Uint8) AO_IgnoreError : abortOption;
+ abortOption = tSimpleState ? AO_IgnoreError : abortOption;
tcKeyReq->setAbortOption(tReqInfo, abortOption);
+ m_abortOption = abortOption;
Uint8 tDistrKeyIndicator = theDistrKeyIndicator_;
Uint8 tScanIndicator = theScanInfo & 1;
@@ -543,21 +545,16 @@
return -1;
}//if
- AbortOption ao = (AbortOption)
- (m_abortOption != -1 ? m_abortOption : theNdbCon->m_abortOption);
+ setErrorCode(aSignal->readData(4));
+ theStatus = Finished;
theReceiver.m_received_result_length = ~0;
- theStatus = Finished;
- // blobs want this
- if (m_abortOption != AO_IgnoreError)
+ // not simple read
+ if(! (theOperationType == ReadRequest && theSimpleIndicator))
{
- theNdbCon->theReturnStatus = NdbTransaction::ReturnFailure;
+ theNdbCon->OpCompleteFailure(this);
+ return -1;
}
- theError.code = aSignal->readData(4);
- theNdbCon->setOperationErrorCodeAbort(aSignal->readData(4), ao);
-
- if(theOperationType != ReadRequest || !theSimpleIndicator) // not simple read
- return theNdbCon->OpCompleteFailure(ao, m_abortOption != AO_IgnoreError);
/**
* If TCKEYCONF has arrived
@@ -565,23 +562,8 @@
*/
if(theReceiver.m_expected_result_length)
{
- return theNdbCon->OpCompleteFailure(AbortOnError);
+ return theNdbCon->OpCompleteFailure(this);
}
return -1;
}
-
-
-void
-NdbOperation::handleFailedAI_ElemLen()
-{
- NdbRecAttr* tRecAttr = theReceiver.theFirstRecAttr;
- while (tRecAttr != NULL) {
- tRecAttr->setNULL();
- tRecAttr = tRecAttr->next();
- }//while
-}//NdbOperation::handleFailedAI_ElemLen()
-
-
-
-
--- 1.105/storage/ndb/src/ndbapi/NdbScanOperation.cpp 2007-01-30 19:45:49 +01:00
+++ 1.106/storage/ndb/src/ndbapi/NdbScanOperation.cpp 2007-01-30 19:45:49 +01:00
@@ -995,6 +995,7 @@
newOp->theTupKeyLen = len;
newOp->theOperationType = opType;
+ newOp->m_abortOption = AbortOnError;
switch (opType) {
case (ReadRequest):
newOp->theLockMode = theLockMode;
--- 1.19/storage/ndb/test/include/HugoOperations.hpp 2007-01-30 19:45:49 +01:00
+++ 1.20/storage/ndb/test/include/HugoOperations.hpp 2007-01-30 19:45:49 +01:00
@@ -106,8 +106,8 @@
NDBT_ResultRow& get_row(Uint32 idx) { return *rows[idx];}
- int execute_async(Ndb*, NdbTransaction::ExecType, NdbTransaction::AbortOption = NdbTransaction::AbortOnError);
- int execute_async_prepare(Ndb*, NdbTransaction::ExecType, NdbTransaction::AbortOption = NdbTransaction::AbortOnError);
+ int execute_async(Ndb*, NdbTransaction::ExecType, NdbOperation::AbortOption = NdbOperation::AbortOnError);
+ int execute_async_prepare(Ndb*, NdbTransaction::ExecType, NdbOperation::AbortOption = NdbOperation::AbortOnError);
int wait_async(Ndb*, int timeout = -1);
--- 1.24/storage/ndb/test/ndbapi/testNdbApi.cpp 2007-01-30 19:45:49 +01:00
+++ 1.25/storage/ndb/test/ndbapi/testNdbApi.cpp 2007-01-30 19:45:49 +01:00
@@ -1249,6 +1249,274 @@
return result;
}
+char pkIdxName[255];
+
+int createPkIndex(NDBT_Context* ctx, NDBT_Step* step){
+ bool orderedIndex = ctx->getProperty("OrderedIndex", (unsigned)0);
+
+ const NdbDictionary::Table* pTab = ctx->getTab();
+ Ndb* pNdb = GETNDB(step);
+
+ bool logged = ctx->getProperty("LoggedIndexes", 1);
+
+ // Create index
+ BaseString::snprintf(pkIdxName, 255, "IDC_PK_%s", pTab->getName());
+ if (orderedIndex)
+ ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "ordered index "
+ << pkIdxName << " (";
+ else
+ ndbout << "Creating " << ((logged)?"logged ": "temporary ") << "unique index "
+ << pkIdxName << " (";
+
+ NdbDictionary::Index pIdx(pkIdxName);
+ pIdx.setTable(pTab->getName());
+ if (orderedIndex)
+ pIdx.setType(NdbDictionary::Index::OrderedIndex);
+ else
+ pIdx.setType(NdbDictionary::Index::UniqueHashIndex);
+ for (int c = 0; c< pTab->getNoOfColumns(); c++){
+ const NdbDictionary::Column * col = pTab->getColumn(c);
+ if(col->getPrimaryKey()){
+ pIdx.addIndexColumn(col->getName());
+ ndbout << col->getName() <<" ";
+ }
+ }
+
+ pIdx.setStoredIndex(logged);
+ ndbout << ") ";
+ if (pNdb->getDictionary()->createIndex(pIdx) != 0){
+ ndbout << "FAILED!" << endl;
+ const NdbError err = pNdb->getDictionary()->getNdbError();
+ ERR(err);
+ return NDBT_FAILED;
+ }
+
+ ndbout << "OK!" << endl;
+ return NDBT_OK;
+}
+
+int createPkIndex_Drop(NDBT_Context* ctx, NDBT_Step* step){
+ const NdbDictionary::Table* pTab = ctx->getTab();
+ Ndb* pNdb = GETNDB(step);
+
+ // Drop index
+ ndbout << "Dropping index " << pkIdxName << " ";
+ if (pNdb->getDictionary()->dropIndex(pkIdxName,
+ pTab->getName()) != 0){
+ ndbout << "FAILED!" << endl;
+ ERR(pNdb->getDictionary()->getNdbError());
+ return NDBT_FAILED;
+ } else {
+ ndbout << "OK!" << endl;
+ }
+
+ return NDBT_OK;
+}
+
+static
+int
+op_row(NdbTransaction* pTrans, HugoOperations& hugoOps,
+ const NdbDictionary::Table* pTab, int op, int row)
+{
+ NdbOperation * pOp = 0;
+ switch(op){
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ pOp = pTrans->getNdbOperation(pTab->getName());
+ break;
+ case 9:
+ return 0;
+ case 6:
+ case 7:
+ case 8:
+ case 10:
+ case 11:
+ pOp = pTrans->getNdbIndexOperation(pkIdxName, pTab->getName());
+ default:
+ break;
+ }
+
+ switch(op){
+ case 0:
+ case 6:
+ pOp->readTuple();
+ break;
+ case 1:
+ case 7:
+ pOp->committedRead();
+ break;
+ case 2:
+ case 8:
+ pOp->readTupleExclusive();
+ break;
+ case 3:
+ case 9:
+ pOp->insertTuple();
+ break;
+ case 4:
+ case 10:
+ pOp->updateTuple();
+ break;
+ case 5:
+ case 11:
+ pOp->deleteTuple();
+ break;
+ default:
+ abort();
+ }
+
+ for(int a = 0; a<pTab->getNoOfColumns(); a++){
+ if (pTab->getColumn(a)->getPrimaryKey() == true){
+ if(hugoOps.equalForAttr(pOp, a, row) != 0){
+ return NDBT_FAILED;
+ }
+ }
+ }
+
+ switch(op){
+ case 0:
+ case 1:
+ case 2:
+ case 6:
+ case 7:
+ case 8:
+ for(int a = 0; a<pTab->getNoOfColumns(); a++){
+ pOp->getValue(a);
+ }
+ break;
+ case 3:
+ case 4:
+ case 10:
+ for(int a = 0; a<pTab->getNoOfColumns(); a++){
+ if (pTab->getColumn(a)->getPrimaryKey() == false){
+ if(hugoOps.setValueForAttr(pOp, a, row, 2) != 0){
+ return NDBT_FAILED;
+ }
+ }
+ }
+ break;
+ case 5:
+ case 11:
+ pOp->deleteTuple();
+ break;
+ case 9:
+ default:
+ abort();
+ }
+
+ return NDBT_OK;
+}
+
+static void print(int op)
+{
+ const char * str = 0;
+ switch(op){
+ case 0: str = "pk read-sh"; break;
+ case 1: str = "pk read-nl"; break;
+ case 2: str = "pk read-ex"; break;
+ case 3: str = "pk insert "; break;
+ case 4: str = "pk update "; break;
+ case 5: str = "pk delete "; break;
+ case 6: str = "uk read-sh"; break;
+ case 7: str = "uk read-nl"; break;
+ case 8: str = "uk read-ex"; break;
+ case 9: str = "noop "; break;
+ case 10: str = "uk update "; break;
+ case 11: str = "uk delete "; break;
+ default:
+ abort();
+ }
+ printf("%s ", str);
+}
+
+int
+runTestIgnoreError(NDBT_Context* ctx, NDBT_Step* step)
+{
+ int result = NDBT_OK;
+ Uint32 loops = ctx->getNumRecords();
+ const NdbDictionary::Table* pTab = ctx->getTab();
+
+ HugoOperations hugoOps(*pTab);
+ HugoTransactions hugoTrans(*pTab);
+
+ Ndb* pNdb = GETNDB(step);
+
+ struct {
+ ExecType et;
+ AbortOption ao;
+ } tests[] = {
+ { Commit, AbortOnError },
+ { Commit, AO_IgnoreError },
+ { NoCommit, AbortOnError },
+ { NoCommit, AO_IgnoreError },
+ };
+
+ printf("case: <op1> <op2> c/nc ao/ie\n");
+ Uint32 tno = 0;
+ for (Uint32 op1 = 0; op1 < 12; op1++)
+ {
+ for (Uint32 op2 = op1; op2 < 12; op2++)
+ {
+ int ret;
+ NdbTransaction* pTrans = 0;
+
+ for (Uint32 i = 0; i<4; i++, tno++)
+ {
+ if (loops != 1000 && loops != tno)
+ continue;
+ ExecType et = tests[i].et;
+ AbortOption ao = tests[i].ao;
+
+ printf("%.3d : ", tno);
+ print(op1);
+ print(op2);
+ switch(et){
+ case Commit: printf("c "); break;
+ case NoCommit: printf("nc "); break;
+ }
+ switch(ao){
+ case AbortOnError: printf("aoe "); break;
+ case AO_IgnoreError: printf("ie "); break;
+ }
+ printf(": ");
+
+
+ hugoTrans.loadTable(pNdb, 1);
+ pTrans = pNdb->startTransaction();
+ op_row(pTrans, hugoOps, pTab, op1, 0);
+ ret = pTrans->execute(et, ao);
+ pTrans->close();
+ printf("%d ", ret);
+ hugoTrans.clearTable(pNdb);
+
+ hugoTrans.loadTable(pNdb, 1);
+ pTrans = pNdb->startTransaction();
+ op_row(pTrans, hugoOps, pTab, op1, 1);
+ ret = pTrans->execute(et, ao);
+ pTrans->close();
+ printf("%d ", ret);
+ hugoTrans.clearTable(pNdb);
+
+ hugoTrans.loadTable(pNdb, 1);
+ pTrans = pNdb->startTransaction();
+ op_row(pTrans, hugoOps, pTab, op1, 0);
+ op_row(pTrans, hugoOps, pTab, op2, 1);
+ ret = pTrans->execute(et, ao);
+ pTrans->close();
+ printf("%d\n", ret);
+ hugoTrans.clearTable(pNdb);
+
+ hugoTrans.clearTable(pNdb);
+ }
+ }
+ }
+ return NDBT_OK;
+}
+
template class Vector<NdbScanOperation*>;
@@ -1341,6 +1609,12 @@
INITIALIZER(runLoadTable);
INITIALIZER(runScan_4006);
FINALIZER(runClearTable);
+}
+TESTCASE("IgnoreError", ""){
+ INITIALIZER(createPkIndex);
+ STEP(runTestIgnoreError);
+ FINALIZER(runClearTable);
+ FINALIZER(createPkIndex_Drop);
}
NDBT_TESTSUITE_END(testNdbApi);
--- 1.29/storage/ndb/test/src/HugoOperations.cpp 2007-01-30 19:45:49 +01:00
+++ 1.30/storage/ndb/test/src/HugoOperations.cpp 2007-01-30 19:45:49 +01:00
@@ -457,7 +457,7 @@
int
HugoOperations::execute_async(Ndb* pNdb, NdbTransaction::ExecType et,
- NdbTransaction::AbortOption eao){
+ NdbOperation::AbortOption eao){
m_async_reply= 0;
pTrans->executeAsynchPrepare(et,
@@ -472,7 +472,7 @@
int
HugoOperations::execute_async_prepare(Ndb* pNdb, NdbTransaction::ExecType et,
- NdbTransaction::AbortOption eao){
+ NdbOperation::AbortOption eao){
m_async_reply= 0;
pTrans->executeAsynchPrepare(et,
--- 1.397/sql/ha_ndbcluster.cc 2007-01-30 19:45:49 +01:00
+++ 1.398/sql/ha_ndbcluster.cc 2007-01-30 19:45:49 +01:00
@@ -261,13 +261,14 @@
int execute_no_commit_ignore_no_key(ha_ndbcluster *h, NdbTransaction *trans)
{
int res= trans->execute(NdbTransaction::NoCommit,
- NdbTransaction::AO_IgnoreError,
+ NdbOperation::AO_IgnoreError,
h->m_force_send);
- if (res == 0)
- return 0;
+ if (res == -1)
+ return -1;
const NdbError &err= trans->getNdbError();
- if (err.classification != NdbError::ConstraintViolation &&
+ if (err.classification != NdbError::NoError &&
+ err.classification != NdbError::ConstraintViolation &&
err.classification != NdbError::NoDataFound)
return res;
@@ -287,7 +288,7 @@
return h->m_ignore_no_key ?
execute_no_commit_ignore_no_key(h,trans) :
trans->execute(NdbTransaction::NoCommit,
- NdbTransaction::AbortOnError,
+ NdbOperation::AbortOnError,
h->m_force_send);
}
@@ -300,7 +301,7 @@
return 0;
#endif
return trans->execute(NdbTransaction::Commit,
- NdbTransaction::AbortOnError,
+ NdbOperation::AbortOnError,
h->m_force_send);
}
@@ -313,7 +314,7 @@
return 0;
#endif
return trans->execute(NdbTransaction::Commit,
- NdbTransaction::AbortOnError,
+ NdbOperation::AbortOnError,
thd->variables.ndb_force_send);
}
@@ -328,7 +329,7 @@
#endif
h->release_completed_operations(trans, force_release);
return trans->execute(NdbTransaction::NoCommit,
- NdbTransaction::AO_IgnoreError,
+ NdbOperation::AO_IgnoreError,
h->m_force_send);
}
@@ -1732,7 +1733,8 @@
ERR_RETURN(trans->getNdbError());
}
- if (execute_no_commit_ie(this,trans,false) != 0)
+ if ((res = execute_no_commit_ie(this,trans,false)) != 0 ||
+ op->getNdbError().code)
{
table->status= STATUS_NOT_FOUND;
DBUG_RETURN(ndb_err(trans));
@@ -2004,7 +2006,8 @@
if ((res= define_read_attrs(buf, op)))
DBUG_RETURN(res);
- if (execute_no_commit_ie(this,trans,false) != 0)
+ if (execute_no_commit_ie(this,trans,false) != 0 ||
+ op->getNdbError().code)
{
table->status= STATUS_NOT_FOUND;
DBUG_RETURN(ndb_err(trans));
@@ -7810,7 +7813,7 @@
(char*)&var_mem);
if (pTrans->execute(NdbTransaction::NoCommit,
- NdbTransaction::AbortOnError,
+ NdbOperation::AbortOnError,
TRUE) == -1)
{
error= pTrans->getNdbError();
@@ -8068,7 +8071,6 @@
!op->readTuple(lm) &&
!set_primary_key(op, multi_range_curr->start_key.key) &&
!define_read_attrs(curr, op) &&
- (op->setAbortOption(AO_IgnoreError), TRUE) &&
(!m_use_partition_function ||
(op->setPartitionId(part_spec.start_part), true)))
curr += reclength;
@@ -8090,8 +8092,7 @@
if ((op= m_active_trans->getNdbIndexOperation(unique_idx, tab)) &&
!op->readTuple(lm) &&
!set_index_key(op, key_info, multi_range_curr->start_key.key) &&
- !define_read_attrs(curr, op) &&
- (op->setAbortOption(AO_IgnoreError), TRUE))
+ !define_read_attrs(curr, op))
curr += reclength;
else
ERR_RETURN(op ? op->getNdbError() : m_active_trans->getNdbError());
--- 1.50/storage/ndb/src/ndbapi/NdbBlob.cpp 2007-01-30 19:45:49 +01:00
+++ 1.51/storage/ndb/src/ndbapi/NdbBlob.cpp 2007-01-30 19:45:49 +01:00
@@ -1133,7 +1133,7 @@
setErrorCode(tOp);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::ReadRequest);
@@ -1169,7 +1169,7 @@
setErrorCode(tOp);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::InsertRequest);
@@ -1193,7 +1193,7 @@
setErrorCode(tOp);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
buf += thePartSize;
n++;
thePendingBlobOps |= (1 << NdbOperation::UpdateRequest);
@@ -1216,7 +1216,7 @@
setErrorCode(tOp);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
n++;
thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
theNdbCon->thePendingBlobOps |= (1 << NdbOperation::DeleteRequest);
@@ -1252,7 +1252,7 @@
setErrorCode(tOp);
DBUG_RETURN(-1);
}
- tOp->m_abortOption= NdbTransaction::AO_IgnoreError;
+ tOp->m_abortOption= NdbOperation::AO_IgnoreError;
n++;
}
DBUG_PRINT("info", ("bat=%u", bat));
@@ -1588,7 +1588,7 @@
DBUG_RETURN(-1);
}
if (isWriteOp()) {
- tOp->m_abortOption = NdbTransaction::AO_IgnoreError;
+ tOp->m_abortOption = NdbOperation::AO_IgnoreError;
}
theHeadInlineReadOp = tOp;
// execute immediately
@@ -1634,7 +1634,7 @@
DBUG_RETURN(-1);
}
if (isWriteOp()) {
- tOp->m_abortOption = NdbTransaction::AO_IgnoreError;
+ tOp->m_abortOption = NdbOperation::AO_IgnoreError;
}
theHeadInlineReadOp = tOp;
// execute immediately
@@ -1807,7 +1807,7 @@
setErrorCode(NdbBlobImpl::ErrAbort);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
DBUG_PRINT("info", ("added op to update head+inline"));
}
DBUG_RETURN(0);
@@ -1837,7 +1837,7 @@
setErrorCode(NdbBlobImpl::ErrAbort);
DBUG_RETURN(-1);
}
- tOp->m_abortOption = NdbTransaction::AbortOnError;
+ tOp->m_abortOption = NdbOperation::AbortOnError;
DBUG_PRINT("info", ("added op to update head+inline"));
}
}
--- 1.6/storage/ndb/src/ndbapi/NdbIndexStat.cpp 2007-01-30 19:45:49 +01:00
+++ 1.7/storage/ndb/src/ndbapi/NdbIndexStat.cpp 2007-01-30 19:45:49 +01:00
@@ -427,7 +427,7 @@
DBUG_RETURN(-1);
}
if (trans->execute(NdbTransaction::NoCommit,
- NdbTransaction::AbortOnError, forceSend) == -1) {
+ NdbOperation::AbortOnError, forceSend) == -1) {
m_error = trans->getNdbError();
DBUG_PRINT("error", ("trans:%d op:%d", trans->getNdbError().code,
op->getNdbError().code));
| Thread |
|---|
| • bk commit into 5.1 tree (jonas:1.2414) | jonas | 30 Jan |
