Commit a3fafb90 authored by unknown's avatar unknown
Browse files

Merge perch.ndb.mysql.com:/home/jonas/src/51-work 

into  perch.ndb.mysql.com:/home/jonas/src/mysql-5.1-new-ndb


storage/ndb/include/ndbapi/NdbIndexOperation.hpp:
  Auto merged
storage/ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
  Auto merged
storage/ndb/src/ndbapi/Ndb.cpp:
  Auto merged
storage/ndb/src/ndbapi/NdbIndexOperation.cpp:
  Auto merged
storage/ndb/test/ndbapi/testBlobs.cpp:
  Auto merged
parents 87bc4822 faac0f1d

storage/ndb/include/ndbapi/NdbIndexOperation.hpp

+0 −2
Original line number Diff line number Diff line
@@ -181,8 +181,6 @@ private: 
	       const class NdbTableImpl* aTable, 

	       NdbTransaction*);



  int prepareSend(Uint32  TC_ConnectPtr, Uint64  TransactionId);



  // Private attributes

  const NdbIndexImpl* m_theIndex;

  friend struct Ndb_free_list_t<NdbIndexOperation>;

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

+15 −15
Original line number Diff line number Diff line
@@ -2522,7 +2522,7 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
  ApiConnectRecord * const regApiPtr = &localApiConnectRecord[TapiIndex];

  apiConnectptr.p = regApiPtr;



  Uint32 TstartFlag = tcKeyReq->getStartFlag(Treqinfo);

  Uint32 TstartFlag = TcKeyReq::getStartFlag(Treqinfo);

  Uint32 TexecFlag = TcKeyReq::getExecuteFlag(Treqinfo);



  Uint8 isIndexOp = regApiPtr->isIndexOp;
@@ -2692,14 +2692,14 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
  /*                                                                        */

  /* ---------------------------------------------------------------------- */



  UintR TapiVersionNo = tcKeyReq->getAPIVersion(tcKeyReq->attrLen);

  UintR TapiVersionNo = TcKeyReq::getAPIVersion(tcKeyReq->attrLen);

  UintR Tlqhkeyreqrec = regApiPtr->lqhkeyreqrec;

  regApiPtr->lqhkeyreqrec = Tlqhkeyreqrec + 1;

  regCachePtr->apiVersionNo = TapiVersionNo;



  UintR TapiConnectptrIndex = apiConnectptr.i;

  UintR TsenderData = tcKeyReq->senderData;

  UintR TattrLen = tcKeyReq->getAttrinfoLen(tcKeyReq->attrLen);

  UintR TattrLen = TcKeyReq::getAttrinfoLen(tcKeyReq->attrLen);

  UintR TattrinfoCount = c_counters.cattrinfoCount;



  regTcPtr->apiConnect = TapiConnectptrIndex;
@@ -2725,15 +2725,15 @@ void Dbtc::execTCKEYREQ(Signal* signal) 


  UintR TtabptrIndex = localTabptr.i;

  UintR TtableSchemaVersion = tcKeyReq->tableSchemaVersion;

  Uint8 TOperationType = tcKeyReq->getOperationType(Treqinfo);

  Uint8 TOperationType = TcKeyReq::getOperationType(Treqinfo);

  regCachePtr->tableref = TtabptrIndex;

  regCachePtr->schemaVersion = TtableSchemaVersion;

  regTcPtr->operation = TOperationType;



  Uint8 TSimpleFlag         = tcKeyReq->getSimpleFlag(Treqinfo);

  Uint8 TDirtyFlag          = tcKeyReq->getDirtyFlag(Treqinfo);

  Uint8 TInterpretedFlag    = tcKeyReq->getInterpretedFlag(Treqinfo);

  Uint8 TDistrKeyFlag       = tcKeyReq->getDistributionKeyFlag(Treqinfo);

  Uint8 TSimpleFlag         = TcKeyReq::getSimpleFlag(Treqinfo);

  Uint8 TDirtyFlag          = TcKeyReq::getDirtyFlag(Treqinfo);

  Uint8 TInterpretedFlag    = TcKeyReq::getInterpretedFlag(Treqinfo);

  Uint8 TDistrKeyFlag       = TcKeyReq::getDistributionKeyFlag(Treqinfo);

  Uint8 TNoDiskFlag         = TcKeyReq::getNoDiskFlag(Treqinfo);

  Uint8 TexecuteFlag        = TexecFlag;
@@ -2749,10 +2749,10 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
  Uint32 TkeyIndex;

  Uint32* TOptionalDataPtr = (Uint32*)&tcKeyReq->scanInfo;

  {

    Uint32  TDistrGHIndex    = tcKeyReq->getScanIndFlag(Treqinfo);

    Uint32  TDistrGHIndex    = TcKeyReq::getScanIndFlag(Treqinfo);

    Uint32  TDistrKeyIndex   = TDistrGHIndex;



    Uint32 TscanInfo = tcKeyReq->getTakeOverScanInfo(TOptionalDataPtr[0]);

    Uint32 TscanInfo = TcKeyReq::getTakeOverScanInfo(TOptionalDataPtr[0]);



    regCachePtr->scanTakeOverInd = TDistrGHIndex;

    regCachePtr->scanInfo = TscanInfo;
@@ -2774,7 +2774,7 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
  regCachePtr->keydata[2] = Tdata3;

  regCachePtr->keydata[3] = Tdata4;



  TkeyLength = tcKeyReq->getKeyLength(Treqinfo);

  TkeyLength = TcKeyReq::getKeyLength(Treqinfo);

  Uint32 TAIDataIndex;

  if (TkeyLength > 8) {

    TAIDataIndex = TkeyIndex + 8;
@@ -2787,7 +2787,7 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
  }//if

  Uint32* TAIDataPtr = &TOptionalDataPtr[TAIDataIndex];



  titcLenAiInTckeyreq = tcKeyReq->getAIInTcKeyReq(Treqinfo);

  titcLenAiInTckeyreq = TcKeyReq::getAIInTcKeyReq(Treqinfo);

  regCachePtr->keylen = TkeyLength;

  regCachePtr->lenAiInTckeyreq = titcLenAiInTckeyreq;

  regCachePtr->currReclenAi = titcLenAiInTckeyreq;
@@ -2858,14 +2858,14 @@ void Dbtc::execTCKEYREQ(Signal* signal) 
    }//switch

  }//if

  

  Uint32 TabortOption = tcKeyReq->getAbortOption(Treqinfo);

  Uint32 TabortOption = TcKeyReq::getAbortOption(Treqinfo);

  regTcPtr->m_execAbortOption = TabortOption;

  

  /*-------------------------------------------------------------------------

   * Check error handling per operation

   * If CommitFlag is set state accordingly and check for early abort

   *------------------------------------------------------------------------*/

  if (tcKeyReq->getCommitFlag(Treqinfo) == 1) {

  if (TcKeyReq::getCommitFlag(Treqinfo) == 1) {

    ndbrequire(TexecuteFlag);

    regApiPtr->apiConnectstate = CS_REC_COMMITTING;

  } else {
@@ -11491,7 +11491,7 @@ void Dbtc::execTCINDXREQ(Signal* signal) 
  // If operation is readTupleExclusive or updateTuple then read index 

  // table with exclusive lock

  Uint32 indexLength = TcKeyReq::getKeyLength(tcIndxRequestInfo);

  Uint32 attrLength = tcIndxReq->attrLen;

  Uint32 attrLength = TcKeyReq::getAttrinfoLen(tcIndxReq->attrLen);

  indexOp->expectedKeyInfo = indexLength;

  Uint32 includedIndexLength = MIN(indexLength, indexBufSize);

  indexOp->expectedAttrInfo = attrLength;

storage/ndb/src/ndbapi/Ndb.cpp

+4 −4
Original line number Diff line number Diff line
@@ -1077,7 +1077,7 @@ Ndb::opTupleIdOnNdb(const NdbTableImpl* table, 
      tOperation->incValue("NEXTID", opValue);

      tRecAttrResult = tOperation->getValue("NEXTID");



      if (tConnection->execute( Commit ) == -1 )

      if (tConnection->execute( NdbTransaction::Commit ) == -1 )

        goto error_handler;



      tValue = tRecAttrResult->u_64_value();
@@ -1092,7 +1092,7 @@ Ndb::opTupleIdOnNdb(const NdbTableImpl* table, 
      tOperation->equal("SYSKEY_0", aTableId );

      tOperation->setValue("NEXTID", opValue);



      if (tConnection->execute( Commit ) == -1 )

      if (tConnection->execute( NdbTransaction::Commit ) == -1 )

        goto error_handler;



      range.reset();
@@ -1109,7 +1109,7 @@ Ndb::opTupleIdOnNdb(const NdbTableImpl* table, 
      tOperation->def_label(0);

      tOperation->interpret_exit_nok(9999);

      

      if (tConnection->execute( Commit ) == -1)

      if (tConnection->execute( NdbTransaction::Commit ) == -1)

      {

        if (tConnection->theError.code != 9999)

          goto error_handler;
@@ -1126,7 +1126,7 @@ Ndb::opTupleIdOnNdb(const NdbTableImpl* table, 
      tOperation->readTuple();

      tOperation->equal("SYSKEY_0", aTableId );

      tRecAttrResult = tOperation->getValue("NEXTID");

      if (tConnection->execute( Commit ) == -1 )

      if (tConnection->execute( NdbTransaction::Commit ) == -1 )

        goto error_handler;

      opValue = tRecAttrResult->u_64_value(); // out

      break;

storage/ndb/src/ndbapi/NdbIndexOperation.cpp

+0 −233
Original line number Diff line number Diff line
@@ -172,239 +172,6 @@ NdbIndexOperation::getIndex() const 
  return m_theIndex;

}



int 

NdbIndexOperation::prepareSend(Uint32 aTC_ConnectPtr, Uint64  aTransactionId)

{

  Uint32 tTransId1, tTransId2;

  Uint32 tReqInfo;

  Uint32 tSignalCount = 0;

  Uint32 tInterpretInd = theInterpretIndicator;

  

  theErrorLine = 0;



  if (tInterpretInd != 1) {

    OperationType tOpType = theOperationType;

    OperationStatus tStatus = theStatus;

    if ((tOpType == UpdateRequest) ||

         (tOpType == InsertRequest) ||

         (tOpType == WriteRequest)) {

      if (tStatus != SetValue) {

        setErrorCodeAbort(4506);

        return -1;

      }//if

    } else if ((tOpType == ReadRequest) || (tOpType == ReadExclusive) ||

         (tOpType == DeleteRequest)) {

      if (tStatus != GetValue) {

        setErrorCodeAbort(4506);

        return -1;

      }//if

    } else {

      setErrorCodeAbort(4507);      

      return -1;

    }//if

  } else {

    if (prepareSendInterpreted() == -1) {

      return -1;

    }//if

  }//if

  

//-------------------------------------------------------------

// We start by filling in the first 8 unconditional words of the

// TCINDXREQ signal.

//-------------------------------------------------------------

  TcKeyReq * tcKeyReq = 

    CAST_PTR(TcKeyReq, theTCREQ->getDataPtrSend());



  Uint32 tTotalCurrAI_Len = theTotalCurrAI_Len;

  Uint32 tIndexId = m_theIndex->m_id;

  Uint32 tSchemaVersion = m_theIndex->m_version;

  

  tcKeyReq->apiConnectPtr      = aTC_ConnectPtr;

  tcKeyReq->senderData         = ptr2int();

  tcKeyReq->attrLen            = tTotalCurrAI_Len;

  tcKeyReq->tableId            = tIndexId;

  tcKeyReq->tableSchemaVersion = tSchemaVersion;



  tTransId1 = (Uint32) aTransactionId;

  tTransId2 = (Uint32) (aTransactionId >> 32);

  

//-------------------------------------------------------------

// Simple is simple if simple or both start and commit is set.

//-------------------------------------------------------------

// Temporarily disable simple stuff

  Uint8 tSimpleIndicator = 0;

//  Uint8 tSimpleIndicator = theSimpleIndicator;

  Uint8 tCommitIndicator = theCommitIndicator;

  Uint8 tStartIndicator = theStartIndicator;

//  if ((theNdbCon->theLastOpInList == this) && (theCommitIndicator == 0))

//    abort();

// Temporarily disable simple stuff

  Uint8 tSimpleAlt = 0;

//  Uint8 tSimpleAlt = tStartIndicator & tCommitIndicator;

  tSimpleIndicator = tSimpleIndicator | tSimpleAlt;



//-------------------------------------------------------------

// Simple state is set if start and commit is set and it is

// a read request. Otherwise it is set to zero.

//-------------------------------------------------------------

  Uint8 tReadInd = (theOperationType == ReadRequest);

  Uint8 tSimpleState = tReadInd & tSimpleAlt;

  //theNdbCon->theSimpleState = tSimpleState;



  tcKeyReq->transId1           = tTransId1;

  tcKeyReq->transId2           = tTransId2;

  

  tReqInfo = 0;



  if (tTotalCurrAI_Len <= TcKeyReq::MaxAttrInfo) {

    tcKeyReq->setAIInTcKeyReq(tReqInfo, tTotalCurrAI_Len);

  } else {

    tcKeyReq->setAIInTcKeyReq(tReqInfo, TcKeyReq::MaxAttrInfo);

  }//if



  tcKeyReq->setSimpleFlag(tReqInfo, tSimpleIndicator);

  tcKeyReq->setCommitFlag(tReqInfo, tCommitIndicator);

  tcKeyReq->setStartFlag(tReqInfo, tStartIndicator);

  const Uint8 tInterpretIndicator = theInterpretIndicator;

  tcKeyReq->setInterpretedFlag(tReqInfo, tInterpretIndicator);



  Uint8 tDirtyIndicator = theDirtyIndicator;

  OperationType tOperationType = theOperationType;

  Uint32 tIndexLen = theTupKeyLen;

  Uint8 abortOption = theNdbCon->m_abortOption;



  tcKeyReq->setDirtyFlag(tReqInfo, tDirtyIndicator);

  tcKeyReq->setOperationType(tReqInfo, tOperationType);

  tcKeyReq->setKeyLength(tReqInfo, tIndexLen);

  tcKeyReq->setAbortOption(tReqInfo, abortOption);

  

  Uint8 tDistrKeyIndicator = theDistrKeyIndicator_;

  Uint8 tScanIndicator = theScanInfo & 1;



  tcKeyReq->setDistributionKeyFlag(tReqInfo, tDistrKeyIndicator);

  tcKeyReq->setScanIndFlag(tReqInfo, tScanIndicator);



  tcKeyReq->requestInfo  = tReqInfo;



//-------------------------------------------------------------

// The next step is to fill in the upto three conditional words.

//-------------------------------------------------------------

  Uint32* tOptionalDataPtr = &tcKeyReq->scanInfo;

  Uint32 tDistrGHIndex = tScanIndicator;

  Uint32 tDistrKeyIndex = tDistrGHIndex;



  Uint32 tScanInfo = theScanInfo;

  Uint32 tDistrKey = theDistributionKey;



  tOptionalDataPtr[0] = tScanInfo;

  tOptionalDataPtr[tDistrKeyIndex] = tDistrKey;



//-------------------------------------------------------------

// The next is step is to compress the key data part of the

// TCKEYREQ signal.

//-------------------------------------------------------------

  Uint32 tKeyIndex = tDistrKeyIndex + tDistrKeyIndicator;

  Uint32* tKeyDataPtr = &tOptionalDataPtr[tKeyIndex];

  Uint32 Tdata1 = tcKeyReq->keyInfo[0];

  Uint32 Tdata2 = tcKeyReq->keyInfo[1];

  Uint32 Tdata3 = tcKeyReq->keyInfo[2];

  Uint32 Tdata4 = tcKeyReq->keyInfo[3];

  Uint32 Tdata5;



  tKeyDataPtr[0] = Tdata1;

  tKeyDataPtr[1] = Tdata2;

  tKeyDataPtr[2] = Tdata3;

  tKeyDataPtr[3] = Tdata4;

  if (tIndexLen > 4) {

    Tdata1 = tcKeyReq->keyInfo[4];

    Tdata2 = tcKeyReq->keyInfo[5];

    Tdata3 = tcKeyReq->keyInfo[6];

    Tdata4 = tcKeyReq->keyInfo[7];



    tKeyDataPtr[4] = Tdata1;

    tKeyDataPtr[5] = Tdata2;

    tKeyDataPtr[6] = Tdata3;

    tKeyDataPtr[7] = Tdata4;

  }//if

//-------------------------------------------------------------

// Finally we also compress the INDXATTRINFO part of the signal.

// We optimise by using the if-statement for sending INDXKEYINFO

// signals to calculating the new Attrinfo Index.

//-------------------------------------------------------------

  Uint32 tAttrInfoIndex;  



  if (tIndexLen > TcKeyReq::MaxKeyInfo) {

    /**

     *	Set transid and TC connect ptr in the INDXKEYINFO signals

     */

    NdbApiSignal* tSignal = theTCREQ->next();

    Uint32 remainingKey = tIndexLen - TcKeyReq::MaxKeyInfo;



    do {

      Uint32* tSigDataPtr = tSignal->getDataPtrSend();

      NdbApiSignal* tnextSignal = tSignal->next();

      tSignalCount++;

      tSigDataPtr[0] = aTC_ConnectPtr;

      tSigDataPtr[1] = tTransId1;

      tSigDataPtr[2] = tTransId2;

      if (remainingKey > IndxKeyInfo::DataLength) {

	// The signal is full

	tSignal->setLength(IndxKeyInfo::MaxSignalLength);

	remainingKey -= IndxKeyInfo::DataLength;

      }

      else {

	// Last signal

	tSignal->setLength(IndxKeyInfo::HeaderLength + remainingKey);

	remainingKey = 0;

      }

      tSignal = tnextSignal;

    } while (tSignal != NULL);

    tAttrInfoIndex = tKeyIndex + TcKeyReq::MaxKeyInfo;

  } else {

    tAttrInfoIndex = tKeyIndex + tIndexLen;

  }//if



//-------------------------------------------------------------

// Perform the Attrinfo packing in the TCKEYREQ signal started

// above.

//-------------------------------------------------------------

  Uint32* tAIDataPtr = &tOptionalDataPtr[tAttrInfoIndex];

  Tdata1 = tcKeyReq->attrInfo[0];

  Tdata2 = tcKeyReq->attrInfo[1];

  Tdata3 = tcKeyReq->attrInfo[2];

  Tdata4 = tcKeyReq->attrInfo[3];

  Tdata5 = tcKeyReq->attrInfo[4];



  theTCREQ->setLength(tcKeyReq->getAIInTcKeyReq(tReqInfo) + 

                      tAttrInfoIndex + TcKeyReq::StaticLength);

  tAIDataPtr[0] = Tdata1;

  tAIDataPtr[1] = Tdata2;

  tAIDataPtr[2] = Tdata3;

  tAIDataPtr[3] = Tdata4;

  tAIDataPtr[4] = Tdata5;



/***************************************************

*  Send the INDXATTRINFO signals.

***************************************************/

  if (tTotalCurrAI_Len > 5) {

    // Set the last signal's length.

    NdbApiSignal* tSignal = theFirstATTRINFO;

    theCurrentATTRINFO->setLength(theAI_LenInCurrAI);

    do {

      Uint32* tSigDataPtr = tSignal->getDataPtrSend();

      NdbApiSignal* tnextSignal = tSignal->next();

      tSignalCount++;

      tSigDataPtr[0] = aTC_ConnectPtr;

      tSigDataPtr[1] = tTransId1;

      tSigDataPtr[2] = tTransId2;

      tSignal = tnextSignal;

    } while (tSignal != NULL);

  }//if

  theStatus = WaitResponse;

  theReceiver.prepareSend();

  return 0;

}



/***************************************************************************

int receiveTCINDXREF( NdbApiSignal* aSignal)

storage/ndb/test/ndbapi/testBlobs.cpp

+4 −3
Original line number Diff line number Diff line
@@ -734,7 +734,7 @@ verifyHeadInline(const Tup& tup) 
  if (! g_opt.m_oneblob)

    CHK((ra2 = g_opr->getValue("BL2")) != 0);

  if (tup.m_exists) {

    CHK(g_con->execute(Commit) == 0);

    CHK(g_con->execute(Commit, AbortOnError) == 0);

    DBG("verifyHeadInline BL1");

    CHK(verifyHeadInline(g_opt.m_blob1, tup.m_blob1, ra1) == 0);

    if (! g_opt.m_oneblob) {
@@ -742,7 +742,8 @@ verifyHeadInline(const Tup& tup) 
      CHK(verifyHeadInline(g_opt.m_blob2, tup.m_blob2, ra2) == 0);

    }

  } else {

    CHK(g_con->execute(Commit) == -1 && g_con->getNdbError().code == 626);

    CHK(g_con->execute(Commit, AbortOnError) == -1 && 

	g_con->getNdbError().code == 626);

  }

  g_ndb->closeTransaction(g_con);

  g_opr = 0;
@@ -1534,7 +1535,7 @@ testperf() 
  g_dic = g_ndb->getDictionary();

  NdbDictionary::Table tab(g_opt.m_tnameperf);

  if (g_dic->getTable(tab.getName()) != 0)

    CHK(g_dic->dropTable(tab) == 0);

    CHK(g_dic->dropTable(tab.getName()) == 0);

  // col A - pk

  { NdbDictionary::Column col("A");

    col.setType(NdbDictionary::Column::Unsigned);