dbtuptrigger.cpp

mysql-5.0.22.tar.gz源码包

    attributeMask.bitAND(regOperPtr->changeMask);
    numAttrsToRead = setAttrIds(attributeMask, regTabPtr->noOfAttr, &readBuffer[0]);

  } else if ((regOperPtr->optype == ZDELETE) &&
             (!trigPtr->sendBeforeValues)) {
    ljam();
//--------------------------------------------------------------------
// Delete without sending before values only read Primary Key
//--------------------------------------------------------------------
    return true;
  } else {
    ljam();
//--------------------------------------------------------------------
// All others send all attributes that are monitored
//--------------------------------------------------------------------
    numAttrsToRead = setAttrIds(trigPtr->attributeMask, regTabPtr->noOfAttr, &readBuffer[0]);
  }//if
  ndbrequire(numAttrsToRead < MAX_ATTRIBUTES_IN_TABLE);
//--------------------------------------------------------------------
// Read Main tuple values
//--------------------------------------------------------------------
  if ((regOperPtr->optype != ZDELETE) ||
      (trigPtr->sendBeforeValues)) {
    ljam();
    int ret= readAttributes(pagep.p,
			    tupheadoffset,
			    &readBuffer[0],
			    numAttrsToRead,
			    mainBuffer,
			    ZATTR_BUFFER_SIZE,
			    false);
    ndbrequire(ret != -1);
    noMainWords= ret;
  } else {
    ljam();
    noMainWords = 0;
  }//if
//--------------------------------------------------------------------
// Read Copy tuple values for UPDATE's
//--------------------------------------------------------------------
// Initialise pagep and tuple offset for read of copy tuple
//--------------------------------------------------------------------
  if ((regOperPtr->optype == ZUPDATE) &&
      (trigPtr->sendBeforeValues)) {
    ljam();

    tupheadoffset = regOperPtr->pageOffsetC;
    pagep.i = regOperPtr->realPageIdC;
    ptrCheckGuard(pagep, cnoOfPage, page);

    int ret= readAttributes(pagep.p,
			    tupheadoffset,
			    &readBuffer[0],
			    numAttrsToRead,
			    copyBuffer,
			    ZATTR_BUFFER_SIZE,
			    false);

    ndbrequire(ret != -1);
    noCopyWords = ret;
    if ((noMainWords == noCopyWords) &&
        (memcmp(mainBuffer, copyBuffer, noMainWords << 2) == 0)) {
//--------------------------------------------------------------------
// Although a trigger was fired it was not necessary since the old
// value and the new value was exactly the same
//--------------------------------------------------------------------
      ljam();
      return false;
    }//if
  }//if
  return true;
}//Dbtup::readTriggerInfo()

void Dbtup::sendTrigAttrInfo(Signal* signal, 
                             Uint32* data, 
                             Uint32  dataLen,
                             bool    executeDirect,
                             BlockReference receiverReference)
{
  TrigAttrInfo* const trigAttrInfo = (TrigAttrInfo *)signal->getDataPtrSend();
  Uint32 sigLen;
  Uint32 dataIndex = 0;
  do {
    sigLen = dataLen - dataIndex;
    if (sigLen > TrigAttrInfo::DataLength) {
      ljam();
      sigLen = TrigAttrInfo::DataLength;
    }//if
    MEMCOPY_NO_WORDS(trigAttrInfo->getData(), 
                     data + dataIndex,
                     sigLen);
    if (executeDirect) {
      ljam();
      EXECUTE_DIRECT(receiverReference, 
                     GSN_TRIG_ATTRINFO,
                     signal,
		     TrigAttrInfo::StaticLength + sigLen);
      ljamEntry();
    } else {
      ljam();
      sendSignal(receiverReference, 
                 GSN_TRIG_ATTRINFO, 
                 signal, 
                 TrigAttrInfo::StaticLength + sigLen,
                 JBB);
    }//if
    dataIndex += sigLen;
  } while (dataLen != dataIndex);
}//Dbtup::sendTrigAttrInfo()

void Dbtup::sendFireTrigOrd(Signal* signal, 
                            Operationrec * const regOperPtr, 
                            TupTriggerData* const trigPtr, 
                            Uint32 noPrimKeyWords, 
                            Uint32 noBeforeValueWords, 
                            Uint32 noAfterValueWords)
{
  FireTrigOrd* const fireTrigOrd = (FireTrigOrd *)signal->getDataPtrSend();
  
  fireTrigOrd->setConnectionPtr(regOperPtr->tcOpIndex);
  fireTrigOrd->setTriggerId(trigPtr->triggerId);

  switch(regOperPtr->optype) {
  case(ZINSERT):
    ljam();
    fireTrigOrd->setTriggerEvent(TriggerEvent::TE_INSERT);
    break;
  case(ZDELETE):
    ljam();
    fireTrigOrd->setTriggerEvent(TriggerEvent::TE_DELETE);
    break;
  case(ZUPDATE):
    ljam();
    fireTrigOrd->setTriggerEvent(TriggerEvent::TE_UPDATE);
    break;
  default:
    ndbrequire(false);
    break;
  }//switch

  fireTrigOrd->setNoOfPrimaryKeyWords(noPrimKeyWords);
  fireTrigOrd->setNoOfBeforeValueWords(noBeforeValueWords);
  fireTrigOrd->setNoOfAfterValueWords(noAfterValueWords);

  switch(trigPtr->triggerType) {
  case (TriggerType::SECONDARY_INDEX):
    ljam();
    sendSignal(regOperPtr->coordinatorTC, GSN_FIRE_TRIG_ORD, 
               signal, FireTrigOrd::SignalLength, JBB);
    break;
  case (TriggerType::SUBSCRIPTION_BEFORE): // Only Suma
    ljam();
    // Since only backup uses subscription triggers we 
    // send to backup directly for now
    fireTrigOrd->setGCI(regOperPtr->gci);
    fireTrigOrd->setHashValue(regOperPtr->hashValue);
    EXECUTE_DIRECT(trigPtr->m_receiverBlock,
                   GSN_FIRE_TRIG_ORD,
                   signal,
		   FireTrigOrd::SignalWithHashValueLength);
    break;
  case (TriggerType::SUBSCRIPTION):
    ljam();
    // Since only backup uses subscription triggers we 
    // send to backup directly for now
    fireTrigOrd->setGCI(regOperPtr->gci);
    EXECUTE_DIRECT(trigPtr->m_receiverBlock,
                   GSN_FIRE_TRIG_ORD,
                   signal,
		   FireTrigOrd::SignalWithGCILength);
    break;
  default:
    ndbrequire(false);
    break;
  }//switch
}//Dbtup::sendFireTrigOrd()

/*
 * Ordered index triggers.
 *
 * Insert: add entry to index
 * Update: add entry to index, de|ay remove until commit
 * Delete: do nothing, delay remove until commit
 * Commit: remove entry delayed from update and delete
 * Abort : remove entry added by insert and update
 *
 * See Notes.txt for the details.
 */

int
Dbtup::executeTuxInsertTriggers(Signal* signal,
                                Operationrec* const regOperPtr,
                                Tablerec* const regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  PagePtr pagePtr;
  pagePtr.i = regOperPtr->realPageId;
  ptrCheckGuard(pagePtr, cnoOfPage, page);
  Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
  ndbrequire(tupVersion == regOperPtr->tupVersion);
  // fill in constant part
  req->tableId = regOperPtr->tableRef;
  req->fragId = regOperPtr->fragId;
  req->pageId = regOperPtr->realPageId;
  req->pageOffset = regOperPtr->pageOffset;
  req->tupVersion = tupVersion;
  req->opInfo = TuxMaintReq::OpAdd;
  return addTuxEntries(signal, regOperPtr, regTabPtr);
}

int
Dbtup::executeTuxUpdateTriggers(Signal* signal,
                                Operationrec* const regOperPtr,
                                Tablerec* const regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  PagePtr pagePtr;
  pagePtr.i = regOperPtr->realPageId;
  ptrCheckGuard(pagePtr, cnoOfPage, page);
  Uint32 tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
  ndbrequire(tupVersion == regOperPtr->tupVersion);
  // fill in constant part
  req->tableId = regOperPtr->tableRef;
  req->fragId = regOperPtr->fragId;
  req->pageId = regOperPtr->realPageId;
  req->pageOffset = regOperPtr->pageOffset;
  req->tupVersion = tupVersion;
  req->opInfo = TuxMaintReq::OpAdd;
  return addTuxEntries(signal, regOperPtr, regTabPtr);
}

int
Dbtup::addTuxEntries(Signal* signal,
                     Operationrec* regOperPtr,
                     Tablerec* regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  const ArrayList<TupTriggerData>& triggerList = regTabPtr->tuxCustomTriggers;
  TriggerPtr triggerPtr;
  Uint32 failPtrI;
  triggerList.first(triggerPtr);
  while (triggerPtr.i != RNIL) {
    ljam();
    req->indexId = triggerPtr.p->indexId;
    req->errorCode = RNIL;
    EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
        signal, TuxMaintReq::SignalLength);
    ljamEntry();
    if (req->errorCode != 0) {
      ljam();
      terrorCode = req->errorCode;
      failPtrI = triggerPtr.i;
      goto fail;
    }
    triggerList.next(triggerPtr);
  }
  return 0;
fail:
  req->opInfo = TuxMaintReq::OpRemove;
  triggerList.first(triggerPtr);
  while (triggerPtr.i != failPtrI) {
    ljam();
    req->indexId = triggerPtr.p->indexId;
    req->errorCode = RNIL;
    EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
        signal, TuxMaintReq::SignalLength);
    ljamEntry();
    ndbrequire(req->errorCode == 0);
    triggerList.next(triggerPtr);
  }
#ifdef VM_TRACE
  ndbout << "aborted partial tux update: op " << hex << regOperPtr << endl;
#endif
  return -1;
}

int
Dbtup::executeTuxDeleteTriggers(Signal* signal,
                                Operationrec* const regOperPtr,
                                Tablerec* const regTabPtr)
{
  // do nothing
  return 0;
}

void
Dbtup::executeTuxCommitTriggers(Signal* signal,
                                Operationrec* regOperPtr,
                                Tablerec* const regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  // get version
  Uint32 tupVersion;
  if (regOperPtr->optype == ZINSERT) {
    if (! regOperPtr->deleteInsertFlag)
      return;
    ljam();
    PagePtr pagePtr;
    pagePtr.i = regOperPtr->realPageIdC;
    ptrCheckGuard(pagePtr, cnoOfPage, page);
    tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1];
    ndbrequire(tupVersion != regOperPtr->tupVersion);
  } else if (regOperPtr->optype == ZUPDATE) {
    ljam();
    PagePtr pagePtr;
    pagePtr.i = regOperPtr->realPageIdC;
    ptrCheckGuard(pagePtr, cnoOfPage, page);
    tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffsetC + 1];
    ndbrequire(tupVersion != regOperPtr->tupVersion);
  } else if (regOperPtr->optype == ZDELETE) {
    if (regOperPtr->deleteInsertFlag)
      return;
    ljam();
    PagePtr pagePtr;
    pagePtr.i = regOperPtr->realPageId;
    ptrCheckGuard(pagePtr, cnoOfPage, page);
    tupVersion = pagePtr.p->pageWord[regOperPtr->pageOffset + 1];
    ndbrequire(tupVersion == regOperPtr->tupVersion);
  } else {
    ndbrequire(false);
    tupVersion= 0; // remove warning
  }
  // fill in constant part
  req->tableId = regOperPtr->tableRef;
  req->fragId = regOperPtr->fragId;
  req->pageId = regOperPtr->realPageId;
  req->pageOffset = regOperPtr->pageOffset;
  req->tupVersion = tupVersion;
  req->opInfo = TuxMaintReq::OpRemove;
  removeTuxEntries(signal, regOperPtr, regTabPtr);
}

void
Dbtup::executeTuxAbortTriggers(Signal* signal,
                               Operationrec* regOperPtr,
                               Tablerec* const regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  // get version
  Uint32 tupVersion;
  if (regOperPtr->optype == ZINSERT) {
    ljam();
    tupVersion = regOperPtr->tupVersion;
  } else if (regOperPtr->optype == ZUPDATE) {
    ljam();
    tupVersion = regOperPtr->tupVersion;
  } else if (regOperPtr->optype == ZDELETE) {
    ljam();
    return;
  } else {
    ndbrequire(false);
    tupVersion= 0; // remove warning
  }
  // fill in constant part
  req->tableId = regOperPtr->tableRef;
  req->fragId = regOperPtr->fragId;
  req->pageId = regOperPtr->realPageId;
  req->pageOffset = regOperPtr->pageOffset;
  req->tupVersion = tupVersion;
  req->opInfo = TuxMaintReq::OpRemove;
  removeTuxEntries(signal, regOperPtr, regTabPtr);
}

void
Dbtup::removeTuxEntries(Signal* signal,
                        Operationrec* regOperPtr,
                        Tablerec* regTabPtr)
{
  TuxMaintReq* const req = (TuxMaintReq*)signal->getDataPtrSend();
  const ArrayList<TupTriggerData>& triggerList = regTabPtr->tuxCustomTriggers;
  TriggerPtr triggerPtr;
  triggerList.first(triggerPtr);
  while (triggerPtr.i != RNIL) {
    ljam();
    req->indexId = triggerPtr.p->indexId;
    req->errorCode = RNIL,
    EXECUTE_DIRECT(DBTUX, GSN_TUX_MAINT_REQ,
        signal, TuxMaintReq::SignalLength);
    ljamEntry();
    // must succeed
    ndbrequire(req->errorCode == 0);
    triggerList.next(triggerPtr);
  }
}