开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbConnection.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：68k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbConnection.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <ndb_global.h>
  18. #include <NdbOut.hpp>
  19. #include <NdbConnection.hpp>
  20. #include <NdbOperation.hpp>
  21. #include <NdbScanOperation.hpp>
  22. #include <NdbIndexScanOperation.hpp>
  23. #include <NdbIndexOperation.hpp>
  24. #include "NdbApiSignal.hpp"
  25. #include "TransporterFacade.hpp"
  26. #include "API.hpp"
  27. #include "NdbBlob.hpp"
  28. #include <ndb_limits.h>
  30. #include <signaldata/TcKeyConf.hpp>
  31. #include <signaldata/TcIndx.hpp>
  32. #include <signaldata/TcCommit.hpp>
  33. #include <signaldata/TcKeyFailConf.hpp>
  34. #include <signaldata/TcHbRep.hpp>
  36. /*****************************************************************************
  37. NdbConnection( Ndb* aNdb );
  39. Return Value:  None
  40. Parameters:    aNdb: Pointers to the Ndb object 
  41. Remark:        Creates a connection object. 
  42. *****************************************************************************/
  43. NdbConnection::NdbConnection( Ndb* aNdb ) :
  44.   theSendStatus(NotInit),
  45.   theCallbackFunction(NULL),
  46.   theCallbackObject(NULL),
  47.   theTransArrayIndex(0),
  48.   theStartTransTime(0),
  49.   theErrorLine(0),
  50.   theErrorOperation(NULL),
  51.   theNdb(aNdb),
  52.   theNext(NULL),
  53.   theFirstOpInList(NULL),
  54.   theLastOpInList(NULL),
  55.   theFirstExecOpInList(NULL),
  56.   theLastExecOpInList(NULL),
  57.   theCompletedFirstOp(NULL),
  58.   theCompletedLastOp(NULL),
  59.   theNoOfOpSent(0),
  60.   theNoOfOpCompleted(0),
  61.   theNoOfOpFetched(0),
  62.   theMyRef(0),
  63.   theTCConPtr(0),
  64.   theTransactionId(0),
  65.   theGlobalCheckpointId(0),
  66.   theStatus(NotConnected),
  67.   theCompletionStatus(NotCompleted), 
  68.   theCommitStatus(NotStarted),
  69.   theMagicNumber(0xFE11DC),
  70.   theTransactionIsStarted(false),
  71.   theDBnode(0),
  72.   theReleaseOnClose(false),
  73.   // Scan operations
  74.   m_waitForReply(true),
  75.   m_theFirstScanOperation(NULL),
  76.   m_theLastScanOperation(NULL),
  77.   m_firstExecutedScanOp(NULL),
  78.   // Scan operations
  79.   theScanningOp(NULL),
  80.   theBuddyConPtr(0xFFFFFFFF),
  81.   theBlobFlag(false),
  82.   thePendingBlobOps(0)
  83. {
  84.   theListState = NotInList;
  85.   theError.code = 0;
  86.   theId = theNdb->theImpl->theNdbObjectIdMap.map(this);
  88. #define CHECK_SZ(mask, sz) assert((sizeof(mask)/sizeof(mask[0])) == sz)
  90.   CHECK_SZ(m_db_nodes, NdbNodeBitmask::Size);
  91.   CHECK_SZ(m_failed_db_nodes, NdbNodeBitmask::Size);
  92. }//NdbConnection::NdbConnection()
  94. /*****************************************************************************
  95. ~NdbConnection();
  97. Remark:        Deletes the connection object. 
  98. *****************************************************************************/
  99. NdbConnection::~NdbConnection()
  100. {
  101.   DBUG_ENTER("NdbConnection::~NdbConnection");
  102.   theNdb->theImpl->theNdbObjectIdMap.unmap(theId, this);
  103.   DBUG_VOID_RETURN;
  104. }//NdbConnection::~NdbConnection()
  106. /*****************************************************************************
  107. void init();
  109. Remark:         Initialise connection object for new transaction. 
  110. *****************************************************************************/
  111. void
  112. NdbConnection::init()
  113. {
  114.   theListState            = NotInList;
  115.   theInUseState           = true;
  116.   theTransactionIsStarted = false;
  117.   theNext   = NULL;
  119.   theFirstOpInList   = NULL;
  120.   theLastOpInList   = NULL;
  122.   theScanningOp            = NULL;
  124.   theFirstExecOpInList   = NULL;
  125.   theLastExecOpInList   = NULL;
  127.   theCompletedFirstOp   = NULL;
  128.   theCompletedLastOp   = NULL;
  130.   theGlobalCheckpointId   = 0;
  131.   theCommitStatus         = Started;
  132.   theCompletionStatus     = NotCompleted;
  133.   m_abortOption           = AbortOnError;
  135.   theError.code   = 0;
  136.   theErrorLine   = 0;
  137.   theErrorOperation   = NULL;
  139.   theReleaseOnClose       = false;
  140.   theSimpleState          = true;
  141.   theSendStatus           = InitState;
  142.   theMagicNumber          = 0x37412619;
  143.   // Scan operations
  144.   m_waitForReply            = true;
  145.   m_theFirstScanOperation = NULL;
  146.   m_theLastScanOperation  = NULL;
  147.   m_firstExecutedScanOp   = 0;
  148.   theBuddyConPtr            = 0xFFFFFFFF;
  149.   //
  150.   theBlobFlag = false;
  151.   thePendingBlobOps = 0;
  152. }//NdbConnection::init()
  154. /*****************************************************************************
  155. setOperationErrorCode(int error);
  157. Remark:        Sets an error code on the connection object from an 
  158.                operation object. 
  159. *****************************************************************************/
  160. void
  161. NdbConnection::setOperationErrorCode(int error)
  162. {
  163.   DBUG_ENTER("NdbConnection::setOperationErrorCode");
  164.   setErrorCode(error);
  165.   DBUG_VOID_RETURN;
  166. }
  168. /*****************************************************************************
  169. setOperationErrorCodeAbort(int error);
  171. Remark:        Sets an error code on the connection object from an 
  172.                operation object. 
  173. *****************************************************************************/
  174. void
  175. NdbConnection::setOperationErrorCodeAbort(int error, int abortOption)
  176. {
  177.   DBUG_ENTER("NdbConnection::setOperationErrorCodeAbort");
  178.   if (abortOption == -1)
  179.     abortOption = m_abortOption;
  180.   if (theTransactionIsStarted == false) {
  181.     theCommitStatus = Aborted;
  182.   } else if ((abortOption == AbortOnError) && 
  183.      (theCommitStatus != Committed) &&
  184.              (theCommitStatus != Aborted)) {
  185.     theCommitStatus = NeedAbort;
  186.   }//if
  187.   setErrorCode(error);
  188.   DBUG_VOID_RETURN;
  189. }
  191. /*****************************************************************************
  192. setErrorCode(int anErrorCode);
  194. Remark:        Sets an error indication on the connection object. 
  195. *****************************************************************************/
  196. void
  197. NdbConnection::setErrorCode(int error)
  198. {
  199.   DBUG_ENTER("NdbConnection::setErrorCode");
  200.   DBUG_PRINT("enter", ("error: %d, theError.code: %d", error, theError.code));
  202.   if (theError.code == 0)
  203.     theError.code = error;
  205.   DBUG_VOID_RETURN;
  206. }//NdbConnection::setErrorCode()
  208. int
  209. NdbConnection::restart(){
  210.   DBUG_ENTER("NdbConnection::restart");
  211.   if(theCompletionStatus == CompletedSuccess){
  212.     releaseCompletedOperations();
  213.     Uint64 tTransid = theNdb->theFirstTransId;
  214.     theTransactionId = tTransid;
  215.     if ((tTransid & 0xFFFFFFFF) == 0xFFFFFFFF) {
  216.       theNdb->theFirstTransId = (tTransid >> 32) << 32;
  217.     } else {
  218.       theNdb->theFirstTransId = tTransid + 1;
  219.     }
  220.     theCommitStatus = Started;
  221.     theCompletionStatus = NotCompleted;
  222.     theTransactionIsStarted = false;
  223.     DBUG_RETURN(0);
  224.   }
  225.   DBUG_PRINT("error",("theCompletionStatus != CompletedSuccess"));
  226.   DBUG_RETURN(-1);
  227. }
  229. /*****************************************************************************
  230. void handleExecuteCompletion(void);
  232. Remark:        Handle time-out on a transaction object. 
  233. *****************************************************************************/
  234. void
  235. NdbConnection::handleExecuteCompletion()
  236. {
  237.   
  238.   if (theCompletionStatus == CompletedFailure) {
  239.     NdbOperation* tOpTemp = theFirstExecOpInList;
  240.     while (tOpTemp != NULL) {
  241. /*****************************************************************************
  242.  * Ensure that all executing operations report failed for each 
  243.  *      read attribute when failure occurs. 
  244.  *      We do not want any operations to report both failure and 
  245.  *      success on different read attributes.
  246.  ****************************************************************************/
  247.       tOpTemp->handleFailedAI_ElemLen();
  248.       tOpTemp = tOpTemp->next();
  249.     }//while
  250.     theReturnStatus = ReturnFailure;
  251.   }//if
  252.   /***************************************************************************
  253.    *   Move the NdbOperation objects from the list of executing 
  254.    *      operations to list of completed
  255.    **************************************************************************/
  256.   NdbOperation* tFirstExecOp = theFirstExecOpInList;
  257.   NdbOperation* tLastExecOp = theLastExecOpInList;
  258.   if (tLastExecOp != NULL) {
  259.     tLastExecOp->next(theCompletedFirstOp);
  260.     theCompletedFirstOp = tFirstExecOp;
  261.     if (theCompletedLastOp == NULL)
  262.       theCompletedLastOp = tLastExecOp;
  263.     theFirstExecOpInList = NULL;
  264.     theLastExecOpInList = NULL;
  265.   }//if
  266.   theSendStatus = InitState;
  267.   return;
  268. }//NdbConnection::handleExecuteCompletion()
  270. /*****************************************************************************
  271. int execute(ExecType aTypeOfExec, CommitType aTypeOfCommit, int forceSend);
  273. Return Value:  Return 0 : execute was successful.
  274.                Return -1: In all other case.  
  275. Parameters :   aTypeOfExec: Type of execute.
  276. Remark:        Initialise connection object for new transaction. 
  277. *****************************************************************************/
  278. int 
  279. NdbConnection::execute(ExecType aTypeOfExec, 
  280.        AbortOption abortOption,
  281.        int forceSend)
  282. {
  283.   NdbError savedError= theError;
  284.   DBUG_ENTER("NdbConnection::execute");
  285.   DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d", 
  286.        aTypeOfExec, abortOption));
  288.   if (! theBlobFlag)
  289.     DBUG_RETURN(executeNoBlobs(aTypeOfExec, abortOption, forceSend));
  291.   /*
  292.    * execute prepared ops in batches, as requested by blobs
  293.    * - blob error does not terminate execution
  294.    * - blob error sets error on operation
  295.    * - if error on operation skip blob calls
  296.    */
  298.   ExecType tExecType;
  299.   NdbOperation* tPrepOp;
  300.   NdbOperation* tCompletedFirstOp = NULL;
  301.   NdbOperation* tCompletedLastOp = NULL;
  303.   int ret = 0;
  304.   do {
  305.     tExecType = aTypeOfExec;
  306.     tPrepOp = theFirstOpInList;
  307.     while (tPrepOp != NULL) {
  308.       if (tPrepOp->theError.code == 0) {
  309.         bool batch = false;
  310.         NdbBlob* tBlob = tPrepOp->theBlobList;
  311.         while (tBlob != NULL) {
  312.           if (tBlob->preExecute(tExecType, batch) == -1)
  313.   {
  314.             ret = -1;
  315.     if(savedError.code==0)
  316.       savedError= theError;
  317.   }
  318.           tBlob = tBlob->theNext;
  319.         }
  320.         if (batch) {
  321.           // blob asked to execute all up to here now
  322.           tExecType = NoCommit;
  323.           break;
  324.         }
  325.       }
  326.       tPrepOp = tPrepOp->next();
  327.     }
  329.     // save rest of prepared ops if batch
  330.     NdbOperation* tRestOp= 0;
  331.     NdbOperation* tLastOp= 0;
  332.     if (tPrepOp != NULL) {
  333.       tRestOp = tPrepOp->next();
  334.       tPrepOp->next(NULL);
  335.       tLastOp = theLastOpInList;
  336.       theLastOpInList = tPrepOp;
  337.     }
  339.     if (tExecType == Commit) {
  340.       NdbOperation* tOp = theCompletedFirstOp;
  341.       while (tOp != NULL) {
  342.         if (tOp->theError.code == 0) {
  343.           NdbBlob* tBlob = tOp->theBlobList;
  344.           while (tBlob != NULL) {
  345.             if (tBlob->preCommit() == -1)
  346.     {
  347.       ret = -1;
  348.       if(savedError.code==0)
  349. savedError= theError;
  350.     }
  351.             tBlob = tBlob->theNext;
  352.           }
  353.         }
  354.         tOp = tOp->next();
  355.       }
  356.     }
  358.     // completed ops are in unspecified order
  359.     if (theCompletedFirstOp != NULL) {
  360.       if (tCompletedFirstOp == NULL) {
  361.         tCompletedFirstOp = theCompletedFirstOp;
  362.         tCompletedLastOp = theCompletedLastOp;
  363.       } else {
  364.         tCompletedLastOp->next(theCompletedFirstOp);
  365.         tCompletedLastOp = theCompletedLastOp;
  366.       }
  367.       theCompletedFirstOp = NULL;
  368.       theCompletedLastOp = NULL;
  369.     }
  371.     if (executeNoBlobs(tExecType, abortOption, forceSend) == -1)
  372.     {
  373.       ret = -1;
  374.       if(savedError.code==0)
  375. savedError= theError;
  376.     }
  378. #ifdef ndb_api_crash_on_complex_blob_abort
  379.     assert(theFirstOpInList == NULL && theLastOpInList == NULL);
  380. #else
  381.     theFirstOpInList = theLastOpInList = NULL;
  382. #endif
  384.     {
  385.       NdbOperation* tOp = theCompletedFirstOp;
  386.       while (tOp != NULL) {
  387.         if (tOp->theError.code == 0) {
  388.           NdbBlob* tBlob = tOp->theBlobList;
  389.           while (tBlob != NULL) {
  390.             // may add new operations if batch
  391.             if (tBlob->postExecute(tExecType) == -1)
  392.     {
  393.               ret = -1;
  394.       if(savedError.code==0)
  395. savedError= theError;
  396.     }
  397.             tBlob = tBlob->theNext;
  398.           }
  399.         }
  400.         tOp = tOp->next();
  401.       }
  402.     }
  404.     // add saved prepared ops if batch
  405.     if (tPrepOp != NULL && tRestOp != NULL) {
  406.       if (theFirstOpInList == NULL)
  407.         theFirstOpInList = tRestOp;
  408.       else
  409.         theLastOpInList->next(tRestOp);
  410.       theLastOpInList = tLastOp;
  411.     }
  412.     assert(theFirstOpInList == NULL || tExecType == NoCommit);
  413.   } while (theFirstOpInList != NULL || tExecType != aTypeOfExec);
  415.   if (tCompletedFirstOp != NULL) {
  416.     tCompletedLastOp->next(theCompletedFirstOp);
  417.     theCompletedFirstOp = tCompletedFirstOp;
  418.     if (theCompletedLastOp == NULL)
  419.       theCompletedLastOp = tCompletedLastOp;
  420.   }
  421. #if ndb_api_count_completed_ops_after_blob_execute
  422.   { NdbOperation* tOp; unsigned n = 0;
  423.     for (tOp = theCompletedFirstOp; tOp != NULL; tOp = tOp->next()) n++;
  424.     ndbout << "completed ops: " << n << endl;
  425.   }
  426. #endif
  428.   if(savedError.code!=0 && theError.code==4350) // Trans already aborted
  429.       theError= savedError;
  431.   DBUG_RETURN(ret);
  432. }
  434. int 
  435. NdbConnection::executeNoBlobs(ExecType aTypeOfExec, 
  436.                               AbortOption abortOption,
  437.                               int forceSend)
  438. {
  439.   DBUG_ENTER("NdbConnection::executeNoBlobs");
  440.   DBUG_PRINT("enter", ("aTypeOfExec: %d, abortOption: %d", 
  441.        aTypeOfExec, abortOption));
  443. //------------------------------------------------------------------------
  444. // We will start by preparing all operations in the transaction defined
  445. // since last execute or since beginning. If this works ok we will continue
  446. // by calling the poll with wait method. This method will return when
  447. // the NDB kernel has completed its task or when 10 seconds have passed.
  448. // The NdbConnectionCallBack-method will receive the return code of the
  449. // transaction. The normal methods of reading error codes still apply.
  450. //------------------------------------------------------------------------
  451.   Ndb* tNdb = theNdb;
  453.   m_waitForReply = false;
  454.   executeAsynchPrepare(aTypeOfExec, NULL, NULL, abortOption);
  455.   if (m_waitForReply){
  456.     while (1) {
  457.       int noOfComp = tNdb->sendPollNdb((3 * WAITFOR_RESPONSE_TIMEOUT),
  458.                                        1, forceSend);
  459.       if (noOfComp == 0) {
  460.         /** 
  461.          * This timeout situation can occur if NDB crashes.
  462.          */
  463.         ndbout << "This timeout should never occur, execute(..)" << endl;
  464.         setOperationErrorCodeAbort(4012);  // Error code for "Cluster Failure"
  465.         DBUG_RETURN(-1);
  466.       }//if
  468.       /*
  469.        * Check that the completed transactions include this one.  There
  470.        * could be another thread running asynchronously.  Even in pure
  471.        * async case rollback is done synchronously.
  472.        */
  473.       if (theListState != NotInList)
  474.         continue;
  475. #ifdef VM_TRACE
  476.       unsigned anyway = 0;
  477.       for (unsigned i = 0; i < theNdb->theNoOfPreparedTransactions; i++)
  478.         anyway += theNdb->thePreparedTransactionsArray[i] == this;
  479.       for (unsigned i = 0; i < theNdb->theNoOfSentTransactions; i++)
  480.         anyway += theNdb->theSentTransactionsArray[i] == this;
  481.       for (unsigned i = 0; i < theNdb->theNoOfCompletedTransactions; i++)
  482.         anyway += theNdb->theCompletedTransactionsArray[i] == this;
  483.       if (anyway) {
  484.         theNdb->printState("execute %x", this);
  485.         abort();
  486.       }
  487. #endif
  488.       if (theReturnStatus == ReturnFailure) {
  489.         DBUG_RETURN(-1);
  490.       }//if
  491.       break;
  492.     }
  493.   }
  494.   thePendingBlobOps = 0;
  495.   DBUG_RETURN(0);
  496. }//NdbConnection::execute()
  498. /*****************************************************************************
  499. void executeAsynchPrepare(ExecType           aTypeOfExec,
  500.                           NdbAsynchCallback  callBack,
  501.                           void*              anyObject,
  502.                           CommitType         aTypeOfCommit);
  504. Return Value:  No return value
  505. Parameters :   aTypeOfExec:   Type of execute.
  506.                anyObject:     An object provided in the callback method
  507.                callBack:      The callback method
  508.                aTypeOfCommit: What to do when read/updated/deleted records 
  509.                               are missing or inserted records already exist.
  511. Remark:        Prepare a part of a transaction in an asynchronous manner. 
  512. *****************************************************************************/
  513. void 
  514. NdbConnection::executeAsynchPrepare( ExecType           aTypeOfExec,
  515.                                      NdbAsynchCallback  aCallback,
  516.                                      void*              anyObject,
  517.                                      AbortOption abortOption)
  518. {
  519.   DBUG_ENTER("NdbConnection::executeAsynchPrepare");
  520.   DBUG_PRINT("enter", ("aTypeOfExec: %d, aCallback: %x, anyObject: %x", 
  521.        aTypeOfExec, aCallback, anyObject));
  523.   /**
  524.    * Reset error.code on execute
  525.    */
  526.   if (theError.code != 0)
  527.     DBUG_PRINT("enter", ("Resetting error %d on execute", theError.code));
  528.   theError.code = 0;
  529.   NdbScanOperation* tcOp = m_theFirstScanOperation;
  530.   if (tcOp != 0){
  531.     // Execute any cursor operations
  532.     while (tcOp != NULL) {
  533.       int tReturnCode;
  534.       tReturnCode = tcOp->executeCursor(theDBnode);
  535.       if (tReturnCode == -1) {
  536.         DBUG_VOID_RETURN;
  537.       }//if
  538.       tcOp = (NdbScanOperation*)tcOp->next();
  539.     } // while
  540.     m_theLastScanOperation->next(m_firstExecutedScanOp);
  541.     m_firstExecutedScanOp = m_theFirstScanOperation;
  542.     // Discard cursor operations, since these are also
  543.     // in the complete operations list we do not need
  544.     // to release them.
  545.     m_theFirstScanOperation = m_theLastScanOperation = NULL;
  546.   }
  548.   bool tTransactionIsStarted = theTransactionIsStarted;
  549.   NdbOperation* tLastOp = theLastOpInList;
  550.   Ndb* tNdb = theNdb;
  551.   CommitStatusType tCommitStatus = theCommitStatus;
  552.   Uint32 tnoOfPreparedTransactions = tNdb->theNoOfPreparedTransactions;
  554.   theReturnStatus     = ReturnSuccess;
  555.   theCallbackFunction = aCallback;
  556.   theCallbackObject   = anyObject;
  557.   m_abortOption   = abortOption;
  558.   m_waitForReply = true;
  559.   tNdb->thePreparedTransactionsArray[tnoOfPreparedTransactions] = this;
  560.   theTransArrayIndex = tnoOfPreparedTransactions;
  561.   theListState = InPreparedList;
  562.   tNdb->theNoOfPreparedTransactions = tnoOfPreparedTransactions + 1;
  564.   if ((tCommitStatus != Started) ||
  565.       (aTypeOfExec == Rollback)) {
  566. /*****************************************************************************
  567.  * Rollback have been ordered on a started transaction. Call rollback.
  568.  *      Could also be state problem or previous problem which leads to the 
  569.  *      same action.
  570.  ****************************************************************************/
  571.     if (aTypeOfExec == Rollback) {
  572.       if (theTransactionIsStarted == false || theSimpleState) {
  573. theCommitStatus = Aborted;
  574. theSendStatus = sendCompleted;
  575.       } else {
  576. theSendStatus = sendABORT;
  577.       }
  578.     } else {
  579.       theSendStatus = sendABORTfail;
  580.     }//if
  581.     if (theCommitStatus == Aborted){
  582.       DBUG_PRINT("exit", ("theCommitStatus: Aborted"));
  583.       setErrorCode(4350);
  584.     }
  585.     DBUG_VOID_RETURN;
  586.   }//if
  587.   if (tTransactionIsStarted == true) {
  588.     if (tLastOp != NULL) {
  589.       if (aTypeOfExec == Commit) {
  590. /*****************************************************************************
  591.  * Set commit indicator on last operation when commit has been ordered
  592.  *      and also a number of operations.
  593. ******************************************************************************/
  594.         tLastOp->theCommitIndicator = 1;
  595.       }//if
  596.     } else {
  597.       if (aTypeOfExec == Commit && !theSimpleState) {
  598. /**********************************************************************
  599.  *   A Transaction have been started and no more operations exist. 
  600.  *   We will use the commit method.
  601.  *********************************************************************/
  602.         theSendStatus = sendCOMMITstate;
  603. DBUG_VOID_RETURN;
  604.       } else {
  605. /**********************************************************************
  606.  * We need to put it into the array of completed transactions to 
  607.  * ensure that we report the completion in a proper way. 
  608.  * We cannot do this here since that would endanger the completed
  609.  * transaction array since that is also updated from the receiver 
  610.  * thread and thus we need to do it under mutex lock and thus we 
  611.  * set the sendStatus to ensure that the send method will
  612.  * put it into the completed array.
  613.  **********************************************************************/
  614.         theSendStatus = sendCompleted;
  615. DBUG_VOID_RETURN; // No Commit with no operations is OK
  616.       }//if
  617.     }//if
  618.   } else if (tTransactionIsStarted == false) {
  619.     NdbOperation* tFirstOp = theFirstOpInList;
  620.     if (tLastOp != NULL) {
  621.       tFirstOp->setStartIndicator();
  622.       if (aTypeOfExec == Commit) {
  623.         tLastOp->theCommitIndicator = 1;
  624.       }//if
  625.     } else {
  626.       /***********************************************************************
  627.        *    No operations are defined and we have not started yet. 
  628.        *    Simply return OK. Set commit status if Commit.
  629.        ***********************************************************************/
  630.       if (aTypeOfExec == Commit) {
  631.         theCommitStatus = Committed;
  632.       }//if
  633.       /***********************************************************************
  634.        * We need to put it into the array of completed transactions to
  635.        * ensure that we report the completion in a proper way. We
  636.        * cannot do this here since that would endanger the completed
  637.        * transaction array since that is also updated from the
  638.        * receiver thread and thus we need to do it under mutex lock
  639.        * and thus we set the sendStatus to ensure that the send method
  640.        * will put it into the completed array.
  641.        ***********************************************************************/
  642.       theSendStatus = sendCompleted;
  643.       DBUG_VOID_RETURN;
  644.     }//if
  645.   }
  647.   NdbOperation* tOp = theFirstOpInList;
  648.   theCompletionStatus = NotCompleted;
  649.   while (tOp) {
  650.     int tReturnCode;
  651.     NdbOperation* tNextOp = tOp->next();
  653.     tReturnCode = tOp->prepareSend(theTCConPtr, theTransactionId);
  654.     if (tReturnCode == -1) {
  655.       theSendStatus = sendABORTfail;
  656.       DBUG_VOID_RETURN;
  657.     }//if
  659.     /*************************************************************************
  660.      * Now that we have successfully prepared the send of this operation we 
  661.      * move it to the list of executing operations and remove it from the 
  662.      * list of defined operations.
  663.      ************************************************************************/
  664.     tOp = tNextOp;
  665.   } 
  667.   NdbOperation* tLastOpInList = theLastOpInList;
  668.   NdbOperation* tFirstOpInList = theFirstOpInList;
  670.   theFirstOpInList = NULL;
  671.   theLastOpInList = NULL;
  672.   theFirstExecOpInList = tFirstOpInList;
  673.   theLastExecOpInList = tLastOpInList;
  675.   theCompletionStatus = CompletedSuccess;
  676.   theNoOfOpSent = 0;
  677.   theNoOfOpCompleted = 0;
  678.   theSendStatus = sendOperations;
  679.   NdbNodeBitmask::clear(m_db_nodes);
  680.   NdbNodeBitmask::clear(m_failed_db_nodes);
  681.   DBUG_VOID_RETURN;
  682. }//NdbConnection::executeAsynchPrepare()
  684. void NdbConnection::close()
  685. {
  686.   theNdb->closeTransaction(this);
  687. }
  689. int NdbConnection::refresh(){
  690.   return sendTC_HBREP();
  691. }
  693. /*****************************************************************************
  694. int sendTC_HBREP();
  696. Return Value:  No return value.  
  697. Parameters :   None.
  698. Remark:        Order NDB to refresh the timeout counter of the transaction. 
  699. ******************************************************************************/
  700. int 
  701. NdbConnection::sendTC_HBREP() // Send a TC_HBREP signal;
  702. {
  703.   NdbApiSignal* tSignal;
  704.   Ndb* tNdb = theNdb;
  705.   Uint32 tTransId1, tTransId2;
  707.   tSignal = tNdb->getSignal();
  708.   if (tSignal == NULL) {
  709.     return -1;
  710.   }
  712.   if (tSignal->setSignal(GSN_TC_HBREP) == -1) {
  713.     return -1;
  714.   }
  716.   TcHbRep * const tcHbRep = CAST_PTR(TcHbRep, tSignal->getDataPtrSend());
  717.   
  718.   tcHbRep->apiConnectPtr = theTCConPtr;    
  719.   
  720.   tTransId1 = (Uint32) theTransactionId;
  721.   tTransId2 = (Uint32) (theTransactionId >> 32);
  722.   tcHbRep->transId1      = tTransId1;
  723.   tcHbRep->transId2      = tTransId2;
  724.  
  725.   TransporterFacade *tp = TransporterFacade::instance();
  726.   tp->lock_mutex(); 
  727.   const int res = tp->sendSignal(tSignal,theDBnode);
  728.   tp->unlock_mutex(); 
  729.   tNdb->releaseSignal(tSignal);
  731.   if (res == -1){
  732.     return -1;
  733.   }    
  734.   
  735.   return 0;
  736. }//NdbConnection::sendTC_HBREP()
  738. /*****************************************************************************
  739. int doSend();
  741. Return Value:  Return 0 : send was successful.
  742.                Return -1: In all other case.  
  743. Remark:        Send all operations belonging to this connection.
  744.                The caller of this method has the responsibility to remove the
  745.                object from the prepared transactions array on the Ndb-object.
  746. *****************************************************************************/
  747. int
  748. NdbConnection::doSend()
  749. {
  750.   DBUG_ENTER("NdbConnection::doSend");
  752.   /*
  753.   This method assumes that at least one operation have been defined. This
  754.   is ensured by the caller of this routine (=execute).
  755.   */
  757.   switch(theSendStatus){
  758.   case sendOperations: {
  759.     NdbOperation * tOp = theFirstExecOpInList;
  760.     do {
  761.       NdbOperation* tNextOp = tOp->next();
  762.       const Uint32 lastFlag = ((tNextOp == NULL) ? 1 : 0);
  763.       const int tReturnCode = tOp->doSend(theDBnode, lastFlag);
  764.       if (tReturnCode == -1) {
  765.         theReturnStatus = ReturnFailure;
  766.         break;
  767.       }//if
  768.       tOp = tNextOp;
  769.     } while (tOp != NULL);
  770.     Ndb* tNdb = theNdb;
  771.     theSendStatus = sendTC_OP;
  772.     theTransactionIsStarted = true;
  773.     tNdb->insert_sent_list(this);
  774.     DBUG_RETURN(0);
  775.   }//case
  776.   case sendABORT:
  777.   case sendABORTfail:{
  778.   /***********************************************************************
  779.    * Rollback have been ordered on a not started transaction. 
  780.    * Simply return OK and set abort status.
  781.    ***********************************************************************/
  782.     if (theSendStatus == sendABORTfail) {
  783.       theReturnStatus = ReturnFailure;
  784.     }//if
  785.     if (sendROLLBACK() == 0) {
  786.       DBUG_RETURN(0);
  787.     }//if
  788.     break;
  789.   }//case
  790.   case sendCOMMITstate:
  791.     if (sendCOMMIT() == 0) {
  792.       DBUG_RETURN(0);
  793.     }//if
  794.     break;
  795.   case sendCompleted:
  796.     theNdb->insert_completed_list(this); 
  797.     DBUG_RETURN(0);
  798.   default:
  799.     ndbout << "Inconsistent theSendStatus = "
  800.    << (Uint32) theSendStatus << endl;
  801.     abort();
  802.     break;
  803.   }//switch
  804.   setOperationErrorCodeAbort(4002);
  805.   theReleaseOnClose = true;
  806.   theTransactionIsStarted = false;
  807.   theCommitStatus = Aborted;
  808.   DBUG_RETURN(-1);
  809. }//NdbConnection::doSend()
  811. /**************************************************************************
  812. int sendROLLBACK();
  814. Return Value:  Return -1 if send unsuccessful.  
  815. Parameters :   None.
  816. Remark:        Order NDB to rollback the transaction. 
  817. **************************************************************************/
  818. int 
  819. NdbConnection::sendROLLBACK()      // Send a TCROLLBACKREQ signal;
  820. {
  821.   Ndb* tNdb = theNdb;
  822.   if ((theTransactionIsStarted == true) &&
  823.       (theCommitStatus != Committed) &&
  824.       (theCommitStatus != Aborted)) {
  825. /**************************************************************************
  826.  * The user did not perform any rollback but simply closed the
  827.  *      transaction. We must rollback Ndb since Ndb have been contacted.
  828.  *************************************************************************/
  829.     NdbApiSignal tSignal(tNdb->theMyRef);
  830.     Uint32 tTransId1, tTransId2;
  831.     TransporterFacade *tp = TransporterFacade::instance();
  832.     int   tReturnCode;
  834.     tTransId1 = (Uint32) theTransactionId;
  835.     tTransId2 = (Uint32) (theTransactionId >> 32);
  836.     tSignal.setSignal(GSN_TCROLLBACKREQ);
  837.     tSignal.setData(theTCConPtr, 1);
  838.     tSignal.setData(tTransId1, 2);
  839.     tSignal.setData(tTransId2, 3);
  840.     tReturnCode = tp->sendSignal(&tSignal,theDBnode);
  841.     if (tReturnCode != -1) {
  842.       theSendStatus = sendTC_ROLLBACK;
  843.       tNdb->insert_sent_list(this);
  844.       return 0;
  845.     }//if
  846.    /*********************************************************************
  847.     * It was not possible to abort the transaction towards the NDB kernel
  848.     * and thus we put it into the array of completed transactions that
  849.     * are ready for reporting to the application.
  850.     *********************************************************************/
  851.     return -1;
  852.   } else {
  853.     /*
  854.      It is not necessary to abort the transaction towards the NDB kernel and
  855.      thus we put it into the array of completed transactions that are ready
  856.      for reporting to the application.
  857.      */
  858.     theSendStatus = sendCompleted;
  859.     tNdb->insert_completed_list(this);
  860.     return 0;
  861.     ;
  862.   }//if
  863. }//NdbConnection::sendROLLBACK()
  865. /***************************************************************************
  866. int sendCOMMIT();
  868. Return Value:  Return 0 : send was successful.
  869.                Return -1: In all other case.  
  870. Parameters :   None.
  871. Remark:        Order NDB to commit the transaction. 
  872. ***************************************************************************/
  873. int 
  874. NdbConnection::sendCOMMIT()    // Send a TC_COMMITREQ signal;
  875. {
  876.   NdbApiSignal tSignal(theNdb->theMyRef);
  877.   Uint32 tTransId1, tTransId2;
  878.   TransporterFacade *tp = TransporterFacade::instance(); 
  879.   int   tReturnCode;
  881.   tTransId1 = (Uint32) theTransactionId;
  882.   tTransId2 = (Uint32) (theTransactionId >> 32);
  883.   tSignal.setSignal(GSN_TC_COMMITREQ);
  884.   tSignal.setData(theTCConPtr, 1);
  885.   tSignal.setData(tTransId1, 2);
  886.   tSignal.setData(tTransId2, 3);
  887.       
  888.   tReturnCode = tp->sendSignal(&tSignal,theDBnode);
  889.   if (tReturnCode != -1) {
  890.     theSendStatus = sendTC_COMMIT;
  891.     theNdb->insert_sent_list(this);
  892.     return 0;
  893.   } else {
  894.     return -1;
  895.   }//if
  896. }//NdbConnection::sendCOMMIT()
  898. /******************************************************************************
  899. void release();
  901. Remark:         Release all operations.
  902. ******************************************************************************/
  903. void 
  904. NdbConnection::release(){
  905.   releaseOperations();
  906.   if ( (theTransactionIsStarted == true) &&
  907.        ((theCommitStatus != Committed) &&
  908. (theCommitStatus != Aborted))) {
  909.     /************************************************************************
  910.      * The user did not perform any rollback but simply closed the
  911.      *      transaction. We must rollback Ndb since Ndb have been contacted.
  912.      ************************************************************************/
  913.     execute(Rollback);
  914.   }//if
  915.   theMagicNumber = 0xFE11DC;
  916.   theInUseState = false;
  917. #ifdef VM_TRACE
  918.   if (theListState != NotInList) {
  919.     theNdb->printState("release %x", this);
  920.     abort();
  921.   }
  922. #endif
  923. }//NdbConnection::release()
  925. void
  926. NdbConnection::releaseOps(NdbOperation* tOp){
  927.   while (tOp != NULL) {
  928.     NdbOperation* tmp = tOp;
  929.     tOp->release();
  930.     tOp = tOp->next();
  931.     theNdb->releaseOperation(tmp);
  932.   }//while
  933. }
  935. /******************************************************************************
  936. void releaseOperations();
  938. Remark:         Release all operations.
  939. ******************************************************************************/
  940. void 
  941. NdbConnection::releaseOperations()
  942. {
  943.   // Release any open scans
  944.   releaseScanOperations(m_theFirstScanOperation);
  945.   releaseScanOperations(m_firstExecutedScanOp);
  946.   
  947.   releaseOps(theCompletedFirstOp);
  948.   releaseOps(theFirstOpInList);
  949.   releaseOps(theFirstExecOpInList);
  951.   theCompletedFirstOp = NULL;
  952.   theCompletedLastOp = NULL;
  953.   theFirstOpInList = NULL;
  954.   theFirstExecOpInList = NULL;
  955.   theLastOpInList = NULL;
  956.   theLastExecOpInList = NULL;
  957.   theScanningOp = NULL;
  958.   m_theFirstScanOperation = NULL;
  959.   m_theLastScanOperation = NULL;
  960.   m_firstExecutedScanOp = NULL;
  961. }//NdbConnection::releaseOperations()
  963. void 
  964. NdbConnection::releaseCompletedOperations()
  965. {
  966.   releaseOps(theCompletedFirstOp);
  967.   theCompletedFirstOp = NULL;
  968.   theCompletedLastOp = NULL;
  969. }//NdbConnection::releaseOperations()
  971. /******************************************************************************
  972. void releaseScanOperations();
  974. Remark:         Release all cursor operations. 
  975.                 (NdbScanOperation and NdbIndexOperation)
  976. ******************************************************************************/
  977. void 
  978. NdbConnection::releaseScanOperations(NdbIndexScanOperation* cursorOp)
  979. {
  980.   while(cursorOp != 0){
  981.     NdbIndexScanOperation* next = (NdbIndexScanOperation*)cursorOp->next();
  982.     cursorOp->release();
  983.     theNdb->releaseScanOperation(cursorOp);
  984.     cursorOp = next;
  985.   }
  986. }//NdbConnection::releaseScanOperations()
  988. /*****************************************************************************
  989. void releaseExecutedScanOperation();
  991. Remark:         Release scan op when hupp'ed trans closed (save memory)
  992. ******************************************************************************/
  993. void 
  994. NdbConnection::releaseExecutedScanOperation(NdbIndexScanOperation* cursorOp)
  995. {
  996.   DBUG_ENTER("NdbConnection::releaseExecutedScanOperation");
  997.   DBUG_PRINT("enter", ("this=0x%x op=0x%x", (UintPtr)this, (UintPtr)cursorOp))
  999.   // here is one reason to make op lists doubly linked
  1000.   if (m_firstExecutedScanOp == cursorOp) {
  1001.     m_firstExecutedScanOp = (NdbIndexScanOperation*)cursorOp->theNext;
  1002.     cursorOp->release();
  1003.     theNdb->releaseScanOperation(cursorOp);
  1004.   } else if (m_firstExecutedScanOp != NULL) {
  1005.     NdbIndexScanOperation* tOp = m_firstExecutedScanOp;
  1006.     while (tOp->theNext != NULL) {
  1007.       if (tOp->theNext == cursorOp) {
  1008.         tOp->theNext = cursorOp->theNext;
  1009.         cursorOp->release();
  1010.         theNdb->releaseScanOperation(cursorOp);
  1011.         break;
  1012.       }
  1013.       tOp = (NdbIndexScanOperation*)tOp->theNext;
  1014.     }
  1015.   }
  1016.   DBUG_VOID_RETURN;
  1017. }//NdbConnection::releaseExecutedScanOperation()
  1019. /*****************************************************************************
  1020. NdbOperation* getNdbOperation(const char* aTableName);
  1022. Return Value    Return a pointer to a NdbOperation object if getNdbOperation 
  1023.                 was succesful.
  1024.                 Return NULL : In all other case. 
  1025. Parameters:     aTableName : Name of the database table. 
  1026. Remark:         Get an operation from NdbOperation idlelist and get the 
  1027.                 NdbConnection object 
  1028. who was fetch by startTransaction pointing to this  operation  
  1029. getOperation will set the theTableId in the NdbOperation object.
  1030.                 synchronous
  1031. ******************************************************************************/
  1032. NdbOperation*
  1033. NdbConnection::getNdbOperation(const char* aTableName)
  1034. {
  1035.   if (theCommitStatus == Started){
  1036.     NdbTableImpl* table = theNdb->theDictionary->getTable(aTableName);
  1037.     if (table != 0){
  1038.       return getNdbOperation(table);
  1039.     } else {
  1040.       setErrorCode(theNdb->theDictionary->getNdbError().code);
  1041.       return NULL;
  1042.     }//if
  1043.   }
  1045.   setOperationErrorCodeAbort(4114);
  1046.   
  1047.   return NULL;
  1048. }//NdbConnection::getNdbOperation()
  1050. /*****************************************************************************
  1051. NdbOperation* getNdbOperation(int aTableId);
  1053. Return Value    Return a pointer to a NdbOperation object if getNdbOperation 
  1054.                 was succesful.
  1055.                 Return NULL: In all other case. 
  1056. Parameters:     tableId : Id of the database table beeing deleted.
  1057. Remark:         Get an operation from NdbOperation object idlelist and 
  1058.                 get the NdbConnection object who was fetch by 
  1059.                 startTransaction pointing to this operation 
  1060.            getOperation will set the theTableId in the NdbOperation 
  1061.                 object, synchronous.
  1062. *****************************************************************************/
  1063. NdbOperation*
  1064. NdbConnection::getNdbOperation(const NdbTableImpl * tab, NdbOperation* aNextOp)
  1065. { 
  1066.   NdbOperation* tOp;
  1068.   if (theScanningOp != NULL){
  1069.     setErrorCode(4607);
  1070.     return NULL;
  1071.   }
  1072.   
  1073.   tOp = theNdb->getOperation();
  1074.   if (tOp == NULL)
  1075.     goto getNdbOp_error1;
  1076.   if (aNextOp == NULL) {
  1077.     if (theLastOpInList != NULL) {
  1078.        theLastOpInList->next(tOp);
  1079.        theLastOpInList = tOp;
  1080.     } else {
  1081.        theLastOpInList = tOp;
  1082.        theFirstOpInList = tOp;
  1083.     }//if
  1084.     tOp->next(NULL);
  1085.   } else {
  1086.     // add before the given op
  1087.     if (theFirstOpInList == aNextOp) {
  1088.       theFirstOpInList = tOp;
  1089.     } else {
  1090.       NdbOperation* aLoopOp = theFirstOpInList;
  1091.       while (aLoopOp != NULL && aLoopOp->next() != aNextOp)
  1092.         aLoopOp = aLoopOp->next();
  1093.       assert(aLoopOp != NULL);
  1094.       aLoopOp->next(tOp);
  1095.     }
  1096.     tOp->next(aNextOp);
  1097.   }
  1098.   if (tOp->init(tab, this) != -1) {
  1099.     return tOp;
  1100.   } else {
  1101.     theNdb->releaseOperation(tOp);
  1102.   }//if
  1103.   return NULL;
  1104.   
  1105.  getNdbOp_error1:
  1106.   setOperationErrorCodeAbort(4000);
  1107.   return NULL;
  1108. }//NdbConnection::getNdbOperation()
  1110. NdbOperation* NdbConnection::getNdbOperation(const NdbDictionary::Table * table)
  1111. {
  1112.   if (table)
  1113.     return getNdbOperation(& NdbTableImpl::getImpl(*table));
  1114.   else
  1115.     return NULL;
  1116. }//NdbConnection::getNdbOperation()
  1118. // NdbScanOperation
  1119. /*****************************************************************************
  1120. NdbScanOperation* getNdbScanOperation(const char* aTableName);
  1122. Return Value    Return a pointer to a NdbScanOperation object if getNdbScanOperation was succesful.
  1123.                 Return NULL : In all other case. 
  1124. Parameters:     aTableName : Name of the database table. 
  1125. Remark:         Get an operation from NdbScanOperation idlelist and get the NdbConnection object 
  1126. who was fetch by startTransaction pointing to this  operation  
  1127. getOperation will set the theTableId in the NdbOperation object.synchronous
  1128. ******************************************************************************/
  1129. NdbScanOperation*
  1130. NdbConnection::getNdbScanOperation(const char* aTableName)
  1131. {
  1132.   if (theCommitStatus == Started){
  1133.     NdbTableImpl* tab = theNdb->theDictionary->getTable(aTableName);
  1134.     if (tab != 0){
  1135.       return getNdbScanOperation(tab);
  1136.     } else {
  1137.       setOperationErrorCodeAbort(theNdb->theDictionary->m_error.code);
  1138.       return NULL;
  1139.     }//if
  1140.   } 
  1141.   
  1142.   setOperationErrorCodeAbort(4114);
  1143.   return NULL;
  1144. }//NdbConnection::getNdbScanOperation()
  1146. /*****************************************************************************
  1147. NdbScanOperation* getNdbScanOperation(const char* anIndexName, const char* aTableName);
  1149. Return Value    Return a pointer to a NdbScanOperation object if getNdbScanOperation was succesful.
  1150.                 Return NULL : In all other case. 
  1151. Parameters:     anIndexName : Name of the index to use. 
  1152.                 aTableName : Name of the database table. 
  1153. Remark:         Get an operation from NdbScanOperation idlelist and get the NdbConnection object 
  1154. who was fetch by startTransaction pointing to this  operation  
  1155. getOperation will set the theTableId in the NdbOperation object.synchronous
  1156. ******************************************************************************/
  1157. NdbIndexScanOperation*
  1158. NdbConnection::getNdbIndexScanOperation(const char* anIndexName, 
  1159. const char* aTableName)
  1160. {
  1161.   NdbIndexImpl* index = 
  1162.     theNdb->theDictionary->getIndex(anIndexName, aTableName);
  1163.   NdbTableImpl* table = theNdb->theDictionary->getTable(aTableName);
  1165.   return getNdbIndexScanOperation(index, table);
  1166. }
  1168. NdbIndexScanOperation*
  1169. NdbConnection::getNdbIndexScanOperation(const NdbIndexImpl* index,
  1170. const NdbTableImpl* table)
  1171. {
  1172.   if (theCommitStatus == Started){
  1173.     const NdbTableImpl * indexTable = index->getIndexTable();
  1174.     if (indexTable != 0){
  1175.       NdbIndexScanOperation* tOp = 
  1176. getNdbScanOperation((NdbTableImpl *) indexTable);
  1177.       if(tOp)
  1178.       {
  1179. tOp->m_currentTable = table;
  1180. tOp->m_cursor_type = NdbScanOperation::IndexCursor;
  1181.       }
  1182.       return tOp;
  1183.     } else {
  1184.       setOperationErrorCodeAbort(theNdb->theError.code);
  1185.       return NULL;
  1186.     }//if
  1187.   } 
  1188.   
  1189.   setOperationErrorCodeAbort(4114);
  1190.   return NULL;
  1191. }//NdbConnection::getNdbIndexScanOperation()
  1193. NdbIndexScanOperation* 
  1194. NdbConnection::getNdbIndexScanOperation(const NdbDictionary::Index * index,
  1195. const NdbDictionary::Table * table)
  1196. {
  1197.   if (index && table)
  1198.     return getNdbIndexScanOperation(& NdbIndexImpl::getImpl(*index),
  1199.     & NdbTableImpl::getImpl(*table));
  1200.   else
  1201.     return NULL;
  1202. }//NdbConnection::getNdbIndexScanOperation()
  1204. /*****************************************************************************
  1205. NdbScanOperation* getNdbScanOperation(int aTableId);
  1207. Return Value    Return a pointer to a NdbOperation object if getNdbOperation was succesful.
  1208.                 Return NULL: In all other case. 
  1209. Parameters:     tableId : Id of the database table beeing deleted.
  1210. Remark:         Get an operation from NdbScanOperation object idlelist and get the NdbConnection 
  1211.                 object who was fetch by startTransaction pointing to this  operation 
  1212.            getOperation will set the theTableId in the NdbOperation object, synchronous.
  1213. *****************************************************************************/
  1214. NdbIndexScanOperation*
  1215. NdbConnection::getNdbScanOperation(const NdbTableImpl * tab)
  1216. { 
  1217.   NdbIndexScanOperation* tOp;
  1218.   
  1219.   tOp = theNdb->getScanOperation();
  1220.   if (tOp == NULL)
  1221.     goto getNdbOp_error1;
  1222.   
  1223.   if (tOp->init(tab, this) != -1) {
  1224.     define_scan_op(tOp);
  1225.     return tOp;
  1226.   } else {
  1227.     theNdb->releaseScanOperation(tOp);
  1228.   }//if
  1229.   return NULL;
  1231. getNdbOp_error1:
  1232.   setOperationErrorCodeAbort(4000);
  1233.   return NULL;
  1234. }//NdbConnection::getNdbScanOperation()
  1236. void
  1237. NdbConnection::remove_list(NdbOperation*& list, NdbOperation* op){
  1238.   NdbOperation* tmp= list;
  1239.   if(tmp == op)
  1240.     list = op->next();
  1241.   else {
  1242.     while(tmp && tmp->next() != op) tmp = tmp->next();
  1243.     if(tmp)
  1244.       tmp->next(op->next());
  1245.   }
  1246.   op->next(NULL);
  1247. }
  1249. void
  1250. NdbConnection::define_scan_op(NdbIndexScanOperation * tOp){
  1251.   // Link scan operation into list of cursor operations
  1252.   if (m_theLastScanOperation == NULL)
  1253.     m_theFirstScanOperation = m_theLastScanOperation = tOp;
  1254.   else {
  1255.     m_theLastScanOperation->next(tOp);
  1256.     m_theLastScanOperation = tOp;
  1257.   }
  1258.   tOp->next(NULL);
  1259. }
  1261. NdbScanOperation* 
  1262. NdbConnection::getNdbScanOperation(const NdbDictionary::Table * table)
  1263. {
  1264.   if (table)
  1265.     return getNdbScanOperation(& NdbTableImpl::getImpl(*table));
  1266.   else
  1267.     return NULL;
  1268. }//NdbConnection::getNdbScanOperation()
  1271. // IndexOperation
  1272. /*****************************************************************************
  1273. NdbIndexOperation* getNdbIndexOperation(const char* anIndexName,
  1274. const char* aTableName);
  1276. Return Value    Return a pointer to a NdbOperation object if getNdbScanOperation was succesful.
  1277.                 Return NULL : In all other case. 
  1278. Parameters:     aTableName : Name of the database table. 
  1279. Remark:         Get an operation from NdbScanOperation idlelist and get the NdbConnection object 
  1280. who was fetch by startTransaction pointing to this  operation  
  1281. getOperation will set the theTableId in the NdbScanOperation object.synchronous
  1282. ******************************************************************************/
  1283. NdbIndexOperation*
  1284. NdbConnection::getNdbIndexOperation(const char* anIndexName, 
  1285.                                     const char* aTableName)
  1286. {
  1287.   if (theCommitStatus == Started) {
  1288.     NdbTableImpl * table = theNdb->theDictionary->getTable(aTableName);
  1289.     NdbIndexImpl * index = theNdb->theDictionary->getIndex(anIndexName,
  1290.    aTableName);
  1291.     if(table != 0 && index != 0){
  1292.       return getNdbIndexOperation(index, table);
  1293.     }
  1294.     
  1295.     if(index == 0){
  1296.       setOperationErrorCodeAbort(4243);
  1297.       return NULL;
  1298.     }
  1300.     // table == 0
  1301.     setOperationErrorCodeAbort(theNdb->theError.code);
  1302.     return NULL;
  1303.   } 
  1304.   
  1305.   setOperationErrorCodeAbort(4114);
  1306.   return 0;
  1307. }//NdbConnection::getNdbIndexOperation()
  1309. /*****************************************************************************
  1310. NdbIndexOperation* getNdbIndexOperation(int anIndexId, int aTableId);
  1312. Return Value    Return a pointer to a NdbIndexOperation object if getNdbIndexOperation was succesful.
  1313.                 Return NULL: In all other case. 
  1314. Parameters:     tableId : Id of the database table beeing deleted.
  1315. Remark:         Get an operation from NdbIndexOperation object idlelist and get the NdbConnection 
  1316.                 object who was fetch by startTransaction pointing to this  operation 
  1317.            getOperation will set the theTableId in the NdbIndexOperation object, synchronous.
  1318. *****************************************************************************/
  1319. NdbIndexOperation*
  1320. NdbConnection::getNdbIndexOperation(const NdbIndexImpl * anIndex, 
  1321.     const NdbTableImpl * aTable,
  1322.                                     NdbOperation* aNextOp)
  1323. { 
  1324.   NdbIndexOperation* tOp;
  1325.   
  1326.   tOp = theNdb->getIndexOperation();
  1327.   if (tOp == NULL)
  1328.     goto getNdbOp_error1;
  1329.   if (aNextOp == NULL) {
  1330.     if (theLastOpInList != NULL) {
  1331.        theLastOpInList->next(tOp);
  1332.        theLastOpInList = tOp;
  1333.     } else {
  1334.        theLastOpInList = tOp;
  1335.        theFirstOpInList = tOp;
  1336.     }//if
  1337.     tOp->next(NULL);
  1338.   } else {
  1339.     // add before the given op
  1340.     if (theFirstOpInList == aNextOp) {
  1341.       theFirstOpInList = tOp;
  1342.     } else {
  1343.       NdbOperation* aLoopOp = theFirstOpInList;
  1344.       while (aLoopOp != NULL && aLoopOp->next() != aNextOp)
  1345.         aLoopOp = aLoopOp->next();
  1346.       assert(aLoopOp != NULL);
  1347.       aLoopOp->next(tOp);
  1348.     }
  1349.     tOp->next(aNextOp);
  1350.   }
  1351.   if (tOp->indxInit(anIndex, aTable, this)!= -1) {
  1352.     return tOp;
  1353.   } else {
  1354.     theNdb->releaseOperation(tOp);
  1355.   }//if
  1356.   return NULL;
  1357.   
  1358.  getNdbOp_error1:
  1359.   setOperationErrorCodeAbort(4000);
  1360.   return NULL;
  1361. }//NdbConnection::getNdbIndexOperation()
  1363. NdbIndexOperation* 
  1364. NdbConnection::getNdbIndexOperation(const NdbDictionary::Index * index,
  1365.     const NdbDictionary::Table * table)
  1366. {
  1367.   if (index && table)
  1368.     return getNdbIndexOperation(& NdbIndexImpl::getImpl(*index),
  1369. & NdbTableImpl::getImpl(*table));
  1370.   else
  1371.     return NULL;
  1372. }//NdbConnection::getNdbIndexOperation()
  1375. /*******************************************************************************
  1376. int  receiveDIHNDBTAMPER(NdbApiSignal* aSignal)
  1378. Return Value:  Return 0 : receiveDIHNDBTAMPER was successful.
  1379.                Return -1: In all other case.
  1380. Parameters:    aSignal: The signal object pointer.
  1381. Remark:        Sets theRestartGCI in the NDB object. 
  1382. *******************************************************************************/
  1383. int
  1384. NdbConnection::receiveDIHNDBTAMPER(NdbApiSignal* aSignal)
  1385. {
  1386.   if (theStatus != Connecting) {
  1387.     return -1;
  1388.   } else {
  1389.     theNdb->RestartGCI((Uint32)aSignal->readData(2));
  1390.     theStatus = Connected;
  1391.   }//if
  1392.   return 0;  
  1393. }//NdbConnection::receiveDIHNDBTAMPER()
  1395. /*******************************************************************************
  1396. int  receiveTCSEIZECONF(NdbApiSignal* aSignal);
  1398. Return Value:  Return 0 : receiveTCSEIZECONF was successful.
  1399.                Return -1: In all other case.
  1400. Parameters:    aSignal: The signal object pointer.
  1401. Remark:        Sets TC Connect pointer at reception of TCSEIZECONF. 
  1402. *******************************************************************************/
  1403. int
  1404. NdbConnection::receiveTCSEIZECONF(NdbApiSignal* aSignal)
  1405. {
  1406.   if (theStatus != Connecting)
  1407.   {
  1408.     return -1;
  1409.   } else
  1410.   {
  1411.     theTCConPtr = (Uint32)aSignal->readData(2);
  1412.     theStatus = Connected;
  1413.   }
  1414.   return 0;
  1415. }//NdbConnection::receiveTCSEIZECONF()
  1417. /*******************************************************************************
  1418. int  receiveTCSEIZEREF(NdbApiSignal* aSignal);
  1420. Return Value:  Return 0 : receiveTCSEIZEREF was successful.
  1421.                Return -1: In all other case.
  1422. Parameters:    aSignal: The signal object pointer.
  1423. Remark:        Sets TC Connect pointer. 
  1424. *******************************************************************************/
  1425. int
  1426. NdbConnection::receiveTCSEIZEREF(NdbApiSignal* aSignal)
  1427. {
  1428.   if (theStatus != Connecting)
  1429.   {
  1430.     return -1;
  1431.   } else
  1432.   {
  1433.     theStatus = ConnectFailure;
  1434.     theNdb->theError.code = aSignal->readData(2);
  1435.     return 0;
  1436.   }
  1437. }//NdbConnection::receiveTCSEIZEREF()
  1439. /*******************************************************************************
  1440. int  receiveTCRELEASECONF(NdbApiSignal* aSignal);
  1442. Return Value:  Return 0 : receiveTCRELEASECONF was successful.
  1443.                Return -1: In all other case.
  1444. Parameters:    aSignal: The signal object pointer.
  1445. Remark:         DisConnect TC Connect pointer to NDBAPI. 
  1446. *******************************************************************************/
  1447. int
  1448. NdbConnection::receiveTCRELEASECONF(NdbApiSignal* aSignal)
  1449. {
  1450.   if (theStatus != DisConnecting)
  1451.   {
  1452.     return -1;
  1453.   } else
  1454.   {
  1455.     theStatus = NotConnected;
  1456.   }
  1457.   return 0;
  1458. }//NdbConnection::receiveTCRELEASECONF()
  1460. /*******************************************************************************
  1461. int  receiveTCRELEASEREF(NdbApiSignal* aSignal);
  1463. Return Value:  Return 0 : receiveTCRELEASEREF was successful.
  1464.                Return -1: In all other case.
  1465. Parameters:    aSignal: The signal object pointer.
  1466. Remark:        DisConnect TC Connect pointer to NDBAPI Failure. 
  1467. *******************************************************************************/
  1468. int
  1469. NdbConnection::receiveTCRELEASEREF(NdbApiSignal* aSignal)
  1470. {
  1471.   if (theStatus != DisConnecting) {
  1472.     return -1;
  1473.   } else {
  1474.     theStatus = ConnectFailure;
  1475.     theNdb->theError.code = aSignal->readData(2);
  1476.     return 0;
  1477.   }//if
  1478. }//NdbConnection::receiveTCRELEASEREF()
  1480. /******************************************************************************
  1481. int  receiveTC_COMMITCONF(NdbApiSignal* aSignal);
  1483. Return Value:  Return 0 : receiveTC_COMMITCONF was successful.
  1484.                Return -1: In all other case.
  1485. Parameters:    aSignal: The signal object pointer.
  1486. Remark:        
  1487. ******************************************************************************/
  1488. int
  1489. NdbConnection::receiveTC_COMMITCONF(const TcCommitConf * commitConf)
  1490. { 
  1491.   if(checkState_TransId(&commitConf->transId1)){
  1492.     theCommitStatus = Committed;
  1493.     theCompletionStatus = CompletedSuccess;
  1494.     return 0;
  1495.   } else {
  1496. #ifdef NDB_NO_DROPPED_SIGNAL
  1497.     abort();
  1498. #endif
  1499.   }
  1500.   return -1;
  1501. }//NdbConnection::receiveTC_COMMITCONF()
  1503. /******************************************************************************
  1504. int  receiveTC_COMMITREF(NdbApiSignal* aSignal);
  1506. Return Value:  Return 0 : receiveTC_COMMITREF was successful.
  1507.                Return -1: In all other case.
  1508. Parameters:    aSignal: The signal object pointer.
  1509. Remark:        
  1510. ******************************************************************************/
  1511. int
  1512. NdbConnection::receiveTC_COMMITREF(NdbApiSignal* aSignal)
  1513. {
  1514.   const TcCommitRef * ref = CAST_CONSTPTR(TcCommitRef, aSignal->getDataPtr());
  1515.   if(checkState_TransId(&ref->transId1)){
  1516.     setOperationErrorCodeAbort(ref->errorCode);
  1517.     theCommitStatus = Aborted;
  1518.     theCompletionStatus = CompletedFailure;
  1519.     return 0;
  1520.   } else {
  1521. #ifdef NDB_NO_DROPPED_SIGNAL
  1522.     abort();
  1523. #endif
  1524.   }
  1526.   return -1;
  1527. }//NdbConnection::receiveTC_COMMITREF()
  1529. /******************************************************************************
  1530. int  receiveTCROLLBACKCONF(NdbApiSignal* aSignal);
  1532. Return Value:  Return 0 : receiveTCROLLBACKCONF was successful.
  1533.                Return -1: In all other case.
  1534. Parameters:    aSignal: The signal object pointer.
  1535. Remark:        
  1536. ******************************************************************************/
  1537. int
  1538. NdbConnection::receiveTCROLLBACKCONF(NdbApiSignal* aSignal)
  1539. {
  1540.   if(checkState_TransId(aSignal->getDataPtr() + 1)){
  1541.     theCommitStatus = Aborted;
  1542.     theCompletionStatus = CompletedSuccess;
  1543.     return 0;
  1544.   } else {
  1545. #ifdef NDB_NO_DROPPED_SIGNAL
  1546.     abort();
  1547. #endif
  1548.   }
  1550.   return -1;
  1551. }//NdbConnection::receiveTCROLLBACKCONF()
  1553. /*******************************************************************************
  1554. int  receiveTCROLLBACKREF(NdbApiSignal* aSignal);
  1556. Return Value:  Return 0 : receiveTCROLLBACKREF was successful.
  1557.                Return -1: In all other case.
  1558. Parameters:    aSignal: The signal object pointer.
  1559. Remark:        
  1560. *******************************************************************************/
  1561. int
  1562. NdbConnection::receiveTCROLLBACKREF(NdbApiSignal* aSignal)
  1563. {
  1564.   if(checkState_TransId(aSignal->getDataPtr() + 1)){
  1565.     setOperationErrorCodeAbort(aSignal->readData(4));
  1566.     theCommitStatus = Aborted;
  1567.     theCompletionStatus = CompletedFailure;
  1568.     return 0;
  1569.   } else {
  1570. #ifdef NDB_NO_DROPPED_SIGNAL
  1571.     abort();
  1572. #endif
  1573.   }
  1575.   return -1;
  1576. }//NdbConnection::receiveTCROLLBACKREF()
  1578. /*****************************************************************************
  1579. int receiveTCROLLBACKREP( NdbApiSignal* aSignal)
  1581. Return Value:   Return 0 : send was succesful.
  1582.                 Return -1: In all other case.   
  1583. Parameters:     aSignal: the signal object that contains the 
  1584.                 TCROLLBACKREP signal from TC.
  1585. Remark:         Handles the reception of the ROLLBACKREP signal.
  1586. *****************************************************************************/
  1587. int
  1588. NdbConnection::receiveTCROLLBACKREP( NdbApiSignal* aSignal)
  1589. {
  1590.   /****************************************************************************
  1591. Check that we are expecting signals from this transaction and that it doesn't
  1592. belong to a transaction already completed. Simply ignore messages from other 
  1593. transactions.
  1594.   ****************************************************************************/
  1595.   if(checkState_TransId(aSignal->getDataPtr() + 1)){
  1596.     theError.code = aSignal->readData(4);// Override any previous errors
  1598.     /**********************************************************************/
  1599.     /* A serious error has occured. This could be due to deadlock or */
  1600.     /* lack of resources or simply a programming error in NDB. This  */
  1601.     /* transaction will be aborted. Actually it has already been     */
  1602.     /* and we only need to report completion and return with the     */
  1603.     /* error code to the application.       */
  1604.     /**********************************************************************/
  1605.     theCompletionStatus = CompletedFailure;
  1606.     theCommitStatus = Aborted;
  1607.     return 0;
  1608.   } else {
  1609. #ifdef NDB_NO_DROPPED_SIGNAL
  1610.     abort();
  1611. #endif
  1612.   }
  1614.   return -1;
  1615. }//NdbConnection::receiveTCROLLBACKREP()
  1617. /*******************************************************************************
  1618. int  receiveTCKEYCONF(NdbApiSignal* aSignal, Uint32 long_short_ind);
  1620. Return Value:  Return 0 : receiveTCKEYCONF was successful.
  1621.                Return -1: In all other case.
  1622. Parameters:    aSignal: The signal object pointer.
  1623. Remark:        
  1624. *******************************************************************************/
  1625. int
  1626. NdbConnection::receiveTCKEYCONF(const TcKeyConf * keyConf, Uint32 aDataLength)
  1627. {
  1628.   NdbReceiver* tOp;
  1629.   const Uint32 tTemp = keyConf->confInfo;
  1630.   /***************************************************************************
  1631. Check that we are expecting signals from this transaction and that it
  1632. doesn't belong to a transaction already completed. Simply ignore messages
  1633. from other transactions.
  1634.   ***************************************************************************/
  1635.   if(checkState_TransId(&keyConf->transId1)){
  1637.     const Uint32 tNoOfOperations = TcKeyConf::getNoOfOperations(tTemp);
  1638.     const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
  1640.     const Uint32* tPtr = (Uint32 *)&keyConf->operations[0];
  1641.     Uint32 tNoComp = theNoOfOpCompleted;
  1642.     for (Uint32 i = 0; i < tNoOfOperations ; i++) {
  1643.       tOp = theNdb->void2rec(theNdb->int2void(*tPtr++));
  1644.       const Uint32 tAttrInfoLen = *tPtr++;
  1645.       if (tOp && tOp->checkMagicNumber()) {
  1646. Uint32 done = tOp->execTCOPCONF(tAttrInfoLen);
  1647. if(tAttrInfoLen > TcKeyConf::SimpleReadBit){
  1648.   Uint32 node = tAttrInfoLen & (~TcKeyConf::SimpleReadBit);
  1649.   NdbNodeBitmask::set(m_db_nodes, node);
  1650.   if(NdbNodeBitmask::get(m_failed_db_nodes, node) && !done)
  1651.   {
  1652.     done = 1;
  1653.     tOp->setErrorCode(4119);
  1654.     theCompletionStatus = CompletedFailure;
  1655.   }     
  1656. }
  1657. tNoComp += done;
  1658.       } else {
  1659.   return -1;
  1660.       }//if
  1661.     }//for
  1662.     Uint32 tNoSent = theNoOfOpSent;
  1663.     theNoOfOpCompleted = tNoComp;
  1664.     Uint32 tGCI    = keyConf->gci;
  1665.     if (tCommitFlag == 1) {
  1666.       theCommitStatus = Committed;
  1667.       theGlobalCheckpointId = tGCI;
  1668.     } else if ((tNoComp >= tNoSent) &&
  1669.                (theLastExecOpInList->theCommitIndicator == 1)){
  1672.       if (m_abortOption == AO_IgnoreError && theError.code != 0){
  1673. /**
  1674.  * There's always a TCKEYCONF when using IgnoreError
  1675.  */
  1676. return -1;
  1677.       }
  1678. /**********************************************************************/
  1679. // We sent the transaction with Commit flag set and received a CONF with
  1680. // no Commit flag set. This is clearly an anomaly.
  1681. /**********************************************************************/
  1682.       theError.code = 4011;
  1683.       theCompletionStatus = CompletedFailure;
  1684.       theCommitStatus = Aborted;
  1685.       return 0;
  1686.     }//if
  1687.     if (tNoComp >= tNoSent) {
  1688.       return 0; // No more operations to wait for
  1689.     }//if
  1690.      // Not completed the reception yet.
  1691.   } else {
  1692. #ifdef NDB_NO_DROPPED_SIGNAL
  1693.     abort();
  1694. #endif
  1695.   }
  1696.   
  1697.   return -1;
  1698. }//NdbConnection::receiveTCKEYCONF()
  1700. /*****************************************************************************
  1701. int receiveTCKEY_FAILCONF( NdbApiSignal* aSignal)
  1703. Return Value:   Return 0 : receive was completed.
  1704.                 Return -1: In all other case.   
  1705. Parameters:     aSignal: the signal object that contains the 
  1706.                 TCKEY_FAILCONF signal from TC.
  1707. Remark:         Handles the reception of the TCKEY_FAILCONF signal.
  1708. *****************************************************************************/
  1709. int
  1710. NdbConnection::receiveTCKEY_FAILCONF(const TcKeyFailConf * failConf)
  1711. {
  1712.   NdbOperation* tOp;
  1713.   /*
  1714.     Check that we are expecting signals from this transaction and that it 
  1715.     doesn't belong  to a transaction already completed. Simply ignore 
  1716.     messages from other transactions.
  1717.   */
  1718.   if(checkState_TransId(&failConf->transId1)){
  1719.     /*
  1720.       A node failure of the TC node occured. The transaction has
  1721.       been committed.
  1722.     */
  1723.     theCommitStatus = Committed;
  1724.     tOp = theFirstExecOpInList;
  1725.     while (tOp != NULL) {
  1726.       /*
  1727.        * Check if the transaction expected read values...
  1728.        * If it did some of them might have gotten lost even if we succeeded
  1729.        * in committing the transaction.
  1730.        */
  1731.       switch(tOp->theOperationType){
  1732.       case NdbOperation::UpdateRequest:
  1733.       case NdbOperation::InsertRequest:
  1734.       case NdbOperation::DeleteRequest:
  1735.       case NdbOperation::WriteRequest:
  1736. tOp = tOp->next();
  1737. break;
  1738.       case NdbOperation::ReadRequest:
  1739.       case NdbOperation::ReadExclusive:
  1740.       case NdbOperation::OpenScanRequest:
  1741.       case NdbOperation::OpenRangeScanRequest:
  1742. theCompletionStatus = CompletedFailure;
  1743. setOperationErrorCodeAbort(4115);
  1744. tOp = NULL;
  1745. break;
  1746.       case NdbOperation::NotDefined:
  1747.       case NdbOperation::NotDefined2:
  1748. assert(false);
  1749. break;
  1750.       }//if
  1751.     }//while   
  1752.     theReleaseOnClose = true;
  1753.     return 0;
  1754.   } else {
  1755. #ifdef VM_TRACE
  1756.     ndbout_c("Recevied TCKEY_FAILCONF wo/ operation");
  1757. #endif
  1758.   }
  1759.   return -1;
  1760. }//NdbConnection::receiveTCKEY_FAILCONF()
  1762. /*************************************************************************
  1763. int receiveTCKEY_FAILREF( NdbApiSignal* aSignal)
  1765. Return Value:   Return 0 : receive was completed.
  1766.                 Return -1: In all other case.   
  1767. Parameters:     aSignal: the signal object that contains the 
  1768.                 TCKEY_FAILREF signal from TC.
  1769. Remark:         Handles the reception of the TCKEY_FAILREF signal.
  1770. **************************************************************************/
  1771. int
  1772. NdbConnection::receiveTCKEY_FAILREF(NdbApiSignal* aSignal)
  1773. {
  1774.   /*
  1775.     Check that we are expecting signals from this transaction and
  1776.     that it doesn't belong to a transaction already
  1777.     completed. Simply ignore messages from other transactions.
  1778.   */
  1779.   if(checkState_TransId(aSignal->getDataPtr()+1)){
  1780.     /*
  1781.       We received an indication of that this transaction was aborted due to a
  1782.       node failure.
  1783.     */
  1784.     if (theSendStatus == NdbConnection::sendTC_ROLLBACK) {
  1785.       /*
  1786. We were in the process of sending a rollback anyways. We will
  1787. report it as a success.
  1788.       */
  1789.       theCompletionStatus = NdbConnection::CompletedSuccess;
  1790.     } else {
  1791.       theCompletionStatus = NdbConnection::CompletedFailure;
  1792.       theError.code = 4031;
  1793.     }//if
  1794.     theReleaseOnClose = true;
  1795.     theCommitStatus = NdbConnection::Aborted;
  1796.     return 0;
  1797.   } else {
  1798. #ifdef VM_TRACE
  1799.     ndbout_c("Recevied TCKEY_FAILREF wo/ operation");
  1800. #endif
  1801.   }
  1802.   return -1;
  1803. }//NdbConnection::receiveTCKEY_FAILREF()
  1805. /******************************************************************************
  1806. int  receiveTCINDXCONF(NdbApiSignal* aSignal, Uint32 long_short_ind);
  1808. Return Value:  Return 0 : receiveTCINDXCONF was successful.
  1809.                Return -1: In all other case.
  1810. Parameters:    aSignal: The signal object pointer.
  1811. Remark:        
  1812. ******************************************************************************/
  1813. int
  1814. NdbConnection::receiveTCINDXCONF(const TcIndxConf * indxConf, 
  1815.  Uint32 aDataLength)
  1816. {
  1817.   if(checkState_TransId(&indxConf->transId1)){
  1818.     const Uint32 tTemp = indxConf->confInfo;
  1819.     const Uint32 tNoOfOperations = TcIndxConf::getNoOfOperations(tTemp);
  1820.     const Uint32 tCommitFlag = TcKeyConf::getCommitFlag(tTemp);
  1821.     
  1822.     const Uint32* tPtr = (Uint32 *)&indxConf->operations[0];
  1823.     Uint32 tNoComp = theNoOfOpCompleted;
  1824.     for (Uint32 i = 0; i < tNoOfOperations ; i++) {
  1825.       NdbReceiver* tOp = theNdb->void2rec(theNdb->int2void(*tPtr));
  1826.       tPtr++;
  1827.       const Uint32 tAttrInfoLen = *tPtr;
  1828.       tPtr++;
  1829.       if (tOp && tOp->checkMagicNumber()) {
  1830. tNoComp += tOp->execTCOPCONF(tAttrInfoLen);
  1831.       } else {
  1832. return -1;
  1833.       }//if
  1834.     }//for
  1835.     Uint32 tNoSent = theNoOfOpSent;
  1836.     Uint32 tGCI    = indxConf->gci;
  1837.     theNoOfOpCompleted = tNoComp;
  1838.     if (tCommitFlag == 1) {
  1839.       theCommitStatus = Committed;
  1840.       theGlobalCheckpointId = tGCI;
  1841.     } else if ((tNoComp >= tNoSent) &&
  1842.                (theLastExecOpInList->theCommitIndicator == 1)){
  1843.       /**********************************************************************/
  1844.       // We sent the transaction with Commit flag set and received a CONF with
  1845.       // no Commit flag set. This is clearly an anomaly.
  1846.       /**********************************************************************/
  1847.       theError.code = 4011;
  1848.       theCompletionStatus = NdbConnection::CompletedFailure;
  1849.       theCommitStatus = NdbConnection::Aborted;
  1850.       return 0;
  1851.     }//if
  1852.     if (tNoComp >= tNoSent) {
  1853.       return 0; // No more operations to wait for
  1854.     }//if
  1855.      // Not completed the reception yet.
  1856.   } else {
  1857. #ifdef NDB_NO_DROPPED_SIGNAL
  1858.     abort();
  1859. #endif
  1860.   }
  1862.   return -1;
  1863. }//NdbConnection::receiveTCINDXCONF()
  1865. /*****************************************************************************
  1866. int receiveTCINDXREF( NdbApiSignal* aSignal)
  1868. Return Value:   Return 0 : send was succesful.
  1869.                 Return -1: In all other case.   
  1870. Parameters:     aSignal: the signal object that contains the 
  1871.                 TCINDXREF signal from TC.
  1872. Remark:         Handles the reception of the TCINDXREF signal.
  1873. *****************************************************************************/
  1874. int
  1875. NdbConnection::receiveTCINDXREF( NdbApiSignal* aSignal)
  1876. {
  1877.   if(checkState_TransId(aSignal->getDataPtr()+1)){
  1878.     theError.code = aSignal->readData(4); // Override any previous errors
  1880.     /**********************************************************************/
  1881.     /* A serious error has occured. This could be due to deadlock or */
  1882.     /* lack of resources or simply a programming error in NDB. This  */
  1883.     /* transaction will be aborted. Actually it has already been     */
  1884.     /* and we only need to report completion and return with the     */
  1885.     /* error code to the application.       */
  1886.     /**********************************************************************/
  1887.     theCompletionStatus = NdbConnection::CompletedFailure;
  1888.     theCommitStatus = NdbConnection::Aborted;
  1889.     return 0;
  1890.   } else {
  1891. #ifdef NDB_NO_DROPPED_SIGNAL
  1892.     abort();
  1893. #endif
  1894.   }
  1896.   return -1;
  1897. }//NdbConnection::receiveTCINDXREF()
  1899. /*******************************************************************************
  1900. int OpCompletedFailure();
  1902. Return Value:  Return 0 : OpCompleteSuccess was successful.
  1903.                Return -1: In all other case.
  1904. Parameters:    aErrorCode: The error code.
  1905. Remark:        An operation was completed with failure.
  1906. *******************************************************************************/
  1907. int 
  1908. NdbConnection::OpCompleteFailure(Uint8 abortOption, bool setFailure)
  1909. {
  1910.   Uint32 tNoComp = theNoOfOpCompleted;
  1911.   Uint32 tNoSent = theNoOfOpSent;
  1912.   if (setFailure)
  1913.     theCompletionStatus = NdbConnection::CompletedFailure;
  1914.   tNoComp++;
  1915.   theNoOfOpCompleted = tNoComp;
  1916.   if (tNoComp == tNoSent) {
  1917.     //------------------------------------------------------------------------
  1918.     //If the transaction consists of only simple reads we can set
  1919.     //Commit state Aborted.  Otherwise this simple operation cannot
  1920.     //decide the success of the whole transaction since a simple
  1921.     //operation is not really part of that transaction.
  1922.     //------------------------------------------------------------------------
  1923.     if (abortOption == AO_IgnoreError){
  1924.       /**
  1925.        * There's always a TCKEYCONF when using IgnoreError
  1926.        */
  1927.       return -1;
  1928.     }
  1929.     
  1930.     return 0; // Last operation received
  1931.   } else if (tNoComp > tNoSent) {
  1932.     setOperationErrorCodeAbort(4113); // Too many operations, 
  1933.                                         // stop waiting for more
  1934.     return 0;
  1935.   } else {
  1936.     return -1; // Continue waiting for more signals
  1937.   }//if
  1938. }//NdbConnection::OpCompleteFailure()
  1940. /******************************************************************************
  1941. int OpCompleteSuccess();
  1943. Return Value:  Return 0 : OpCompleteSuccess was successful.
  1944.                Return -1: In all other case.  
  1945. Remark:        An operation was completed with success.
  1946. *******************************************************************************/
  1947. int 
  1948. NdbConnection::OpCompleteSuccess()
  1949. {
  1950.   Uint32 tNoComp = theNoOfOpCompleted;
  1951.   Uint32 tNoSent = theNoOfOpSent;
  1952.   tNoComp++;
  1953.   theNoOfOpCompleted = tNoComp;
  1954.   if (tNoComp == tNoSent) { // Last operation completed
  1955.     return 0;
  1956.   } else if (tNoComp < tNoSent) {
  1957.     return -1; // Continue waiting for more signals
  1958.   } else {
  1959.     setOperationErrorCodeAbort(4113); // Too many operations, 
  1960.                                         // stop waiting for more
  1961.     theCompletionStatus = NdbConnection::CompletedFailure;
  1962.     return 0;
  1963.   }//if
  1964. }//NdbConnection::OpCompleteSuccess()
  1966. /******************************************************************************
  1967.  int            getGCI();
  1969. Remark: Get global checkpoint identity of the transaction
  1970. *******************************************************************************/
  1971. int
  1972. NdbConnection::getGCI()
  1973. {
  1974.   if (theCommitStatus == NdbConnection::Committed) {
  1975.     return theGlobalCheckpointId;
  1976.   }//if
  1977.   return 0;
  1978. }//NdbConnection::getGCI()
  1980. /*******************************************************************************
  1981. Uint64 getTransactionId(void);
  1983. Remark:        Get the transaction identity. 
  1984. *******************************************************************************/
  1985. Uint64
  1986. NdbConnection::getTransactionId()
  1987. {
  1988.   return theTransactionId;
  1989. }//NdbConnection::getTransactionId()
  1991. NdbConnection::CommitStatusType
  1992. NdbConnection::commitStatus()
  1993. {
  1994.   return theCommitStatus;
  1995. }//NdbConnection::commitStatus()
  1997. int 
  1998. NdbConnection::getNdbErrorLine()
  1999. {
  2000.   return theErrorLine;
  2001. }
  2003. NdbOperation*
  2004. NdbConnection::getNdbErrorOperation()
  2005. {
  2006.   return theErrorOperation;
  2007. }//NdbConnection::getNdbErrorOperation()
  2009. const NdbOperation * 
  2010. NdbConnection::getNextCompletedOperation(const NdbOperation * current) const {
  2011.   if(current == 0)
  2012.     return theCompletedFirstOp;
  2013.   return current->theNext;
  2014. }
  2016. #ifdef VM_TRACE
  2017. #define CASE(x) case x: ndbout << " " << #x; break
  2018. void
  2019. NdbConnection::printState()
  2020. {
  2021.   ndbout << "con=" << hex << this << dec;
  2022.   ndbout << " node=" << getConnectedNodeId();
  2023.   switch (theStatus) {
  2024.   CASE(NotConnected);
  2025.   CASE(Connecting);
  2026.   CASE(Connected);
  2027.   CASE(DisConnecting);
  2028.   CASE(ConnectFailure);
  2029.   default: ndbout << (Uint32) theStatus;
  2030.   }
  2031.   switch (theListState) {
  2032.   CASE(NotInList);
  2033.   CASE(InPreparedList);
  2034.   CASE(InSendList);
  2035.   CASE(InCompletedList);
  2036.   default: ndbout << (Uint32) theListState;
  2037.   }
  2038.   switch (theSendStatus) {
  2039.   CASE(NotInit);
  2040.   CASE(InitState);
  2041.   CASE(sendOperations);
  2042.   CASE(sendCompleted);
  2043.   CASE(sendCOMMITstate);
  2044.   CASE(sendABORT);
  2045.   CASE(sendABORTfail);
  2046.   CASE(sendTC_ROLLBACK);
  2047.   CASE(sendTC_COMMIT);
  2048.   CASE(sendTC_OP);
  2049.   default: ndbout << (Uint32) theSendStatus;
  2050.   }
  2051.   switch (theCommitStatus) {
  2052.   CASE(NotStarted);
  2053.   CASE(Started);
  2054.   CASE(Committed);
  2055.   CASE(Aborted);
  2056.   CASE(NeedAbort);
  2057.   default: ndbout << (Uint32) theCommitStatus;
  2058.   }
  2059.   switch (theCompletionStatus) {
  2060.   CASE(NotCompleted);
  2061.   CASE(CompletedSuccess);
  2062.   CASE(CompletedFailure);
  2063.   CASE(DefinitionFailure);
  2064.   default: ndbout << (Uint32) theCompletionStatus;
  2065.   }
  2066.   ndbout << endl;
  2067. }
  2068. #undef CASE
  2069. #endif
  2071. int
  2072. NdbConnection::report_node_failure(Uint32 id){
  2073.   NdbNodeBitmask::set(m_failed_db_nodes, id);
  2074.   if(!NdbNodeBitmask::get(m_db_nodes, id))
  2075.   {
  2076.     return 0;
  2077.   }
  2078.   
  2079.   /**
  2080.    *   Arrived
  2081.    *   TCKEYCONF   TRANSIDAI
  2082.    * 1)   -           -
  2083.    * 2)   -           X
  2084.    * 3)   X           -
  2085.    * 4)   X           X
  2086.    */
  2087.   NdbOperation* tmp = theFirstExecOpInList;
  2088.   const Uint32 len = TcKeyConf::SimpleReadBit | id;
  2089.   Uint32 tNoComp = theNoOfOpCompleted;
  2090.   Uint32 tNoSent = theNoOfOpSent;
  2091.   while(tmp != 0)
  2092.   {
  2093.     if(tmp->theReceiver.m_expected_result_length == len && 
  2094.        tmp->theReceiver.m_received_result_length == 0)
  2095.     {
  2096.       tNoComp++;
  2097.       tmp->theError.code = 4119;
  2098.     }
  2099.     tmp = tmp->next();
  2100.   }
  2101.   theNoOfOpCompleted = tNoComp;
  2102.   if(tNoComp == tNoSent)
  2103.   {
  2104.     theError.code = 4119;
  2105.     theCompletionStatus = NdbConnection::CompletedFailure;    
  2106.     return 1;
  2107.   }
  2108.   return 0;
  2109. }