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

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

MySQL数据库

开发平台：

Visual C++

DbtupCommit.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. #define DBTUP_C
  18. #include "Dbtup.hpp"
  19. #include <RefConvert.hpp>
  20. #include <ndb_limits.h>
  21. #include <pc.hpp>
  22. #include <signaldata/TupCommit.hpp>
  24. #define ljam() { jamLine(5000 + __LINE__); }
  25. #define ljamEntry() { jamEntryLine(5000 + __LINE__); }
  27. void Dbtup::execTUP_WRITELOG_REQ(Signal* signal)
  28. {
  29.   jamEntry();
  30.   OperationrecPtr loopOpPtr;
  31.   loopOpPtr.i = signal->theData[0];
  32.   Uint32 gci = signal->theData[1];
  33.   ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  34.   while (loopOpPtr.p->nextActiveOp != RNIL) {
  35.     ljam();
  36.     loopOpPtr.i = loopOpPtr.p->nextActiveOp;
  37.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  38.   }//while
  39.   do {
  40.     Uint32 blockNo = refToBlock(loopOpPtr.p->userblockref);
  41.     ndbrequire(loopOpPtr.p->transstate == STARTED);
  42.     signal->theData[0] = loopOpPtr.p->userpointer;
  43.     signal->theData[1] = gci;
  44.     if (loopOpPtr.p->prevActiveOp == RNIL) {
  45.       ljam();
  46.       EXECUTE_DIRECT(blockNo, GSN_LQH_WRITELOG_REQ, signal, 2);
  47.       return;
  48.     }//if
  49.     ljam();
  50.     EXECUTE_DIRECT(blockNo, GSN_LQH_WRITELOG_REQ, signal, 2);
  51.     jamEntry();
  52.     loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  53.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  54.   } while (true);
  55. }//Dbtup::execTUP_WRITELOG_REQ()
  57. void Dbtup::execTUP_DEALLOCREQ(Signal* signal)
  58. {
  59.   TablerecPtr regTabPtr;
  60.   FragrecordPtr regFragPtr;
  62.   jamEntry();
  64.   Uint32 fragId = signal->theData[0];
  65.   regTabPtr.i = signal->theData[1];
  66.   Uint32 fragPageId = signal->theData[2];
  67.   Uint32 pageIndex = signal->theData[3];
  69.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  70.   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  71.   ndbrequire(regFragPtr.p != NULL);
  73.   PagePtr pagePtr;
  74.   pagePtr.i = getRealpid(regFragPtr.p, fragPageId);
  75.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  76.   Uint32 pageIndexScaled = pageIndex >> 1;
  77.   ndbrequire((pageIndex & 1) == 0);
  78.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + 
  79.                      (regTabPtr.p->tupheadsize * pageIndexScaled);
  80. //---------------------------------------------------
  81. /* --- Deallocate a tuple as requested by ACC  --- */
  82. //---------------------------------------------------
  83.   if (isUndoLoggingNeeded(regFragPtr.p, fragPageId)) {
  84.     ljam();
  85.     cprAddUndoLogRecord(signal,
  86.                         ZLCPR_TYPE_INSERT_TH,
  87.                         fragPageId,
  88.                         pageIndex,
  89.                         regTabPtr.i,
  90.                         fragId,
  91.                         regFragPtr.p->checkpointVersion);
  92.     cprAddData(signal,
  93.                regFragPtr.p,
  94.                pagePtr.i,
  95.                regTabPtr.p->tupheadsize,
  96.                pageOffset);
  97.   }//if
  98.   {
  99.     freeTh(regFragPtr.p,
  100.            regTabPtr.p,
  101.            signal,
  102.            pagePtr.p,
  103.            pageOffset);
  104.   }
  105. }
  107. /* ---------------------------------------------------------------- */
  108. /* ------------ PERFORM A COMMIT ON AN UPDATE OPERATION  ---------- */
  109. /* ---------------------------------------------------------------- */
  110. void Dbtup::commitUpdate(Signal* signal,
  111.                          Operationrec*  const regOperPtr,
  112.                          Fragrecord* const regFragPtr,
  113.                          Tablerec* const regTabPtr)
  114. {
  115.   if (regOperPtr->realPageIdC != RNIL) {
  116.     if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageIdC)) {
  117. /* ------------------------------------------------------------------------ */
  118. /* IF THE COPY WAS CREATED WITHIN THIS CHECKPOINT WE ONLY HAVE              */
  119. /* TO LOG THE CREATION OF THE COPY. IF HOWEVER IT WAS CREATED BEFORE  SAVE  */
  120. /* THIS CHECKPOINT, WE HAVE TO THE DATA AS WELL.                            */
  121. /* ------------------------------------------------------------------------ */
  122.       if (regOperPtr->undoLogged) {
  123.         ljam();
  124.         cprAddUndoLogRecord(signal,
  125.                             ZLCPR_TYPE_INSERT_TH_NO_DATA,
  126.                             regOperPtr->fragPageIdC,
  127.                             regOperPtr->pageIndexC,
  128.                             regOperPtr->tableRef,
  129.                             regOperPtr->fragId,
  130.                             regFragPtr->checkpointVersion);
  131.       } else {
  132.         ljam();
  133.         cprAddUndoLogRecord(signal,
  134.                             ZLCPR_TYPE_INSERT_TH,
  135.                             regOperPtr->fragPageIdC,
  136.                             regOperPtr->pageIndexC,
  137.                             regOperPtr->tableRef,
  138.                             regOperPtr->fragId,
  139.                             regFragPtr->checkpointVersion);
  140.         cprAddData(signal,
  141.                    regFragPtr,
  142.                    regOperPtr->realPageIdC,
  143.                    regTabPtr->tupheadsize,
  144.                    regOperPtr->pageOffsetC);
  145.       }//if
  146.     }//if
  148.     PagePtr copyPagePtr;
  149.     copyPagePtr.i = regOperPtr->realPageIdC;
  150.     ptrCheckGuard(copyPagePtr, cnoOfPage, page);
  151.     freeTh(regFragPtr,
  152.            regTabPtr,
  153.            signal,
  154.            copyPagePtr.p,
  155.            (Uint32)regOperPtr->pageOffsetC);
  156.     regOperPtr->realPageIdC = RNIL;
  157.     regOperPtr->fragPageIdC = RNIL;
  158.     regOperPtr->pageOffsetC = ZNIL;
  159.     regOperPtr->pageIndexC = ZNIL;
  160.   }//if
  161. }//Dbtup::commitUpdate()
  163. void
  164. Dbtup::commitSimple(Signal* signal,
  165.                     Operationrec* const regOperPtr,
  166.                     Fragrecord* const regFragPtr,
  167.                     Tablerec* const regTabPtr)
  168. {
  169.   operPtr.p = regOperPtr;
  170.   fragptr.p = regFragPtr;
  171.   tabptr.p = regTabPtr;
  173.   // Checking detached triggers
  174.   checkDetachedTriggers(signal,
  175.                         regOperPtr,
  176.                         regTabPtr);
  178.   removeActiveOpList(regOperPtr);
  179.   if (regOperPtr->optype == ZUPDATE) {
  180.     ljam();
  181.     commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr);
  182.     if (regTabPtr->GCPIndicator) {
  183.       updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr);
  184.     }//if
  185.   } else if (regOperPtr->optype == ZINSERT) {
  186.     ljam();
  187.     if (regTabPtr->GCPIndicator) {
  188.       updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr);
  189.     }//if
  190.   } else {
  191.     ndbrequire(regOperPtr->optype == ZDELETE);
  192.   }//if
  193. }//Dbtup::commitSimple()
  195. void Dbtup::removeActiveOpList(Operationrec*  const regOperPtr)
  196. {
  197.   if (regOperPtr->inActiveOpList == ZTRUE) {
  198.     OperationrecPtr raoOperPtr;
  199.     regOperPtr->inActiveOpList = ZFALSE;
  200.     if (regOperPtr->prevActiveOp != RNIL) {
  201.       ljam();
  202.       raoOperPtr.i = regOperPtr->prevActiveOp;
  203.       ptrCheckGuard(raoOperPtr, cnoOfOprec, operationrec);
  204.       raoOperPtr.p->nextActiveOp = regOperPtr->nextActiveOp;
  205.     } else {
  206.       ljam();
  207.       PagePtr pagePtr;
  208.       pagePtr.i = regOperPtr->realPageId;
  209.       ptrCheckGuard(pagePtr, cnoOfPage, page);
  210.       ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE);
  211.       pagePtr.p->pageWord[regOperPtr->pageOffset] = regOperPtr->nextActiveOp;
  212.     }//if
  213.     if (regOperPtr->nextActiveOp != RNIL) {
  214.       ljam();
  215.       raoOperPtr.i = regOperPtr->nextActiveOp;
  216.       ptrCheckGuard(raoOperPtr, cnoOfOprec, operationrec);
  217.       raoOperPtr.p->prevActiveOp = regOperPtr->prevActiveOp;
  218.     }//if
  219.     regOperPtr->prevActiveOp = RNIL;
  220.     regOperPtr->nextActiveOp = RNIL;
  221.   }//if
  222. }//Dbtup::removeActiveOpList()
  224. /* ---------------------------------------------------------------- */
  225. /* INITIALIZATION OF ONE CONNECTION RECORD TO PREPARE FOR NEXT OP.  */
  226. /* ---------------------------------------------------------------- */
  227. void Dbtup::initOpConnection(Operationrec* regOperPtr,
  228.      Fragrecord * fragPtrP)
  229. {
  230.   Uint32 RinFragList = regOperPtr->inFragList;
  231.   regOperPtr->transstate = IDLE;
  232.   regOperPtr->currentAttrinbufLen = 0;
  233.   regOperPtr->optype = ZREAD;
  234.   if (RinFragList == ZTRUE) {
  235.     OperationrecPtr tropNextLinkPtr;
  236.     OperationrecPtr tropPrevLinkPtr;
  237. /*----------------------------------------------------------------- */
  238. /*       TO ENSURE THAT WE HAVE SUCCESSFUL ABORTS OF FOLLOWING      */
  239. /*       OPERATIONS WHICH NEVER STARTED WE SET THE OPTYPE TO READ.  */
  240. /*----------------------------------------------------------------- */
  241. /*       REMOVE IT FROM THE DOUBLY LINKED LIST ON THE FRAGMENT      */
  242. /*----------------------------------------------------------------- */
  243.     tropPrevLinkPtr.i = regOperPtr->prevOprecInList;
  244.     tropNextLinkPtr.i = regOperPtr->nextOprecInList;
  245.     regOperPtr->inFragList = ZFALSE;
  246.     if (tropPrevLinkPtr.i == RNIL) {
  247.       ljam();
  248.       fragPtrP->firstusedOprec = tropNextLinkPtr.i;
  249.     } else {
  250.       ljam();
  251.       ptrCheckGuard(tropPrevLinkPtr, cnoOfOprec, operationrec);
  252.       tropPrevLinkPtr.p->nextOprecInList = tropNextLinkPtr.i;
  253.     }//if
  254.     if (tropNextLinkPtr.i == RNIL) {
  255.       fragPtrP->lastusedOprec = tropPrevLinkPtr.i;
  256.     } else {
  257.       ptrCheckGuard(tropNextLinkPtr, cnoOfOprec, operationrec);
  258.       tropNextLinkPtr.p->prevOprecInList = tropPrevLinkPtr.i;
  259.     }
  260.     regOperPtr->prevOprecInList = RNIL;
  261.     regOperPtr->nextOprecInList = RNIL;
  262.   }//if
  263. }//Dbtup::initOpConnection()
  265. /* ----------------------------------------------------------------- */
  266. /* --------------- COMMIT THIS PART OF A TRANSACTION --------------- */
  267. /* ----------------------------------------------------------------- */
  268. void Dbtup::execTUP_COMMITREQ(Signal* signal) 
  269. {
  270.   FragrecordPtr regFragPtr;
  271.   OperationrecPtr regOperPtr;
  272.   TablerecPtr regTabPtr;
  274.   TupCommitReq * const tupCommitReq = (TupCommitReq *)signal->getDataPtr();
  276.   ljamEntry();
  277.   regOperPtr.i = tupCommitReq->opPtr;
  278.   ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec);
  280.   ndbrequire(regOperPtr.p->transstate == STARTED);
  281.   regOperPtr.p->gci = tupCommitReq->gci;
  282.   regOperPtr.p->hashValue = tupCommitReq->hashValue;
  284.   regFragPtr.i = regOperPtr.p->fragmentPtr;
  285.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  287.   regTabPtr.i = regOperPtr.p->tableRef;
  288.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  290.   if (!regTabPtr.p->tuxCustomTriggers.isEmpty()) {
  291.     ljam();
  292.     executeTuxCommitTriggers(signal,
  293.                              regOperPtr.p,
  294.                              regTabPtr.p);
  295.   }
  297.   if (regOperPtr.p->tupleState == NO_OTHER_OP) {
  298.     if ((regOperPtr.p->prevActiveOp == RNIL) &&
  299.         (regOperPtr.p->nextActiveOp == RNIL)) {
  300.       ljam();
  301. /* ---------------------------------------------------------- */
  302. // We handle the simple case separately as an optimisation
  303. /* ---------------------------------------------------------- */
  304.       commitSimple(signal,
  305.                    regOperPtr.p,
  306.                    regFragPtr.p,
  307.                    regTabPtr.p);
  308.     } else {
  309. /* ---------------------------------------------------------- */
  310. // This is the first commit message of this record in this
  311. // transaction. We will commit this record completely for this
  312. // transaction. If there are other operations they will be
  313. // responsible to release their own resources. Also commit of
  314. // a delete is postponed until the last operation is committed
  315. // on the tuple.
  316. //
  317. // As part of this commitRecord we will also handle detached
  318. // triggers and release of resources for this operation.
  319. /* ---------------------------------------------------------- */
  320.       ljam();
  321.       commitRecord(signal,
  322.                    regOperPtr.p,
  323.                    regFragPtr.p,
  324.                    regTabPtr.p);
  325.       removeActiveOpList(regOperPtr.p);
  326.     }//if
  327.   } else {
  328.     ljam();
  329. /* ---------------------------------------------------------- */
  330. // Release any copy tuples
  331. /* ---------------------------------------------------------- */
  332.     ndbrequire(regOperPtr.p->tupleState == TO_BE_COMMITTED);
  333.     commitUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p);
  334.     removeActiveOpList(regOperPtr.p);
  335.   }//if
  336.   initOpConnection(regOperPtr.p, regFragPtr.p);
  337. }//execTUP_COMMITREQ()
  339. void
  340. Dbtup::updateGcpId(Signal* signal,
  341.                    Operationrec* const regOperPtr,
  342.                    Fragrecord* const regFragPtr,
  343.                    Tablerec* const regTabPtr)
  344. {
  345.   PagePtr pagePtr;
  346.   ljam();
  347. //--------------------------------------------------------------------
  348. // Is this code safe for UNDO logging. Not sure currently. RONM
  349. //--------------------------------------------------------------------
  350.   pagePtr.i = regOperPtr->realPageId;
  351.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  352.   Uint32 temp = regOperPtr->pageOffset + regTabPtr->tupGCPIndex;
  353.   ndbrequire((temp < ZWORDS_ON_PAGE) &&
  354.              (regTabPtr->tupGCPIndex < regTabPtr->tupheadsize));
  355.   if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageId)) {
  356.     Uint32 prevGCI = pagePtr.p->pageWord[temp];
  357.     ljam();
  358.     cprAddUndoLogRecord(signal,
  359.                         ZLCPR_TYPE_UPDATE_GCI,
  360.                         regOperPtr->fragPageId,
  361.                         regOperPtr->pageIndex,
  362.                         regOperPtr->tableRef,
  363.                         regOperPtr->fragId,
  364.                         regFragPtr->checkpointVersion);
  365.     cprAddGCIUpdate(signal,
  366.                     prevGCI,
  367.                     regFragPtr);
  368.   }//if
  369.   pagePtr.p->pageWord[temp] = regOperPtr->gci;
  370.   if (regTabPtr->checksumIndicator) {
  371.     ljam();
  372.     setChecksum(pagePtr.p, regOperPtr->pageOffset, regTabPtr->tupheadsize);
  373.   }//if
  374. }//Dbtup::updateGcpId()
  376. void
  377. Dbtup::commitRecord(Signal* signal,
  378.                     Operationrec* const regOperPtr,
  379.                     Fragrecord* const regFragPtr,
  380.                     Tablerec* const regTabPtr)
  381. {
  382.   Uint32 opType;
  383.   OperationrecPtr firstOpPtr;
  384.   PagePtr pagePtr;
  386.   pagePtr.i = regOperPtr->realPageId;
  387.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  389.   setTupleStatesSetOpType(regOperPtr, pagePtr.p, opType, firstOpPtr);
  391.   fragptr.p = regFragPtr;
  392.   tabptr.p = regTabPtr;
  394.   if (opType == ZINSERT_DELETE) {
  395.     ljam();
  396. //--------------------------------------------------------------------
  397. // We started by inserting the tuple and ended by deleting. Seen from
  398. // transactions point of view no changes were made.
  399. //--------------------------------------------------------------------
  400.     commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr);
  401.     return;
  402.   } else if (opType == ZINSERT) {
  403.     ljam();
  404. //--------------------------------------------------------------------
  405. // We started by inserting whereafter we made several changes to the
  406. // tuple that could include updates, deletes and new inserts. The final
  407. // state of the tuple is the original tuple. This is reached from this
  408. // operation. We change the optype on this operation to ZINSERT to
  409. // ensure proper operation of the detached trigger.
  410. // We restore the optype after executing triggers although not really
  411. // needed.
  412. //--------------------------------------------------------------------
  413.     Uint32 saveOpType = regOperPtr->optype;
  414.     regOperPtr->optype = ZINSERT;
  415.     operPtr.p = regOperPtr;
  417.     checkDetachedTriggers(signal,
  418.                           regOperPtr,
  419.                           regTabPtr);
  421.     regOperPtr->optype = saveOpType;
  422.   } else if (opType == ZUPDATE) {
  423.     ljam();
  424. //--------------------------------------------------------------------
  425. // We want to use the first operation which contains a copy tuple
  426. // reference. This operation contains the before value of this record
  427. // for this transaction. Then this operation is used for executing
  428. // triggers with optype set to update.
  429. //--------------------------------------------------------------------
  430.     OperationrecPtr befOpPtr;
  431.     findBeforeValueOperation(befOpPtr, firstOpPtr);
  433.     Uint32 saveOpType = befOpPtr.p->optype;
  434.     Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;
  435.     Bitmask<MAXNROFATTRIBUTESINWORDS> saveAttributeMask;
  437.     calculateChangeMask(pagePtr.p,
  438.                         regTabPtr,
  439.                         befOpPtr.p->pageOffset,
  440.                         attributeMask);
  442.     saveAttributeMask.clear();
  443.     saveAttributeMask.bitOR(befOpPtr.p->changeMask);
  444.     befOpPtr.p->changeMask.clear();
  445.     befOpPtr.p->changeMask.bitOR(attributeMask);
  446.     befOpPtr.p->gci = regOperPtr->gci;
  447.     
  448.     operPtr.p = befOpPtr.p;
  449.     checkDetachedTriggers(signal,
  450.                           befOpPtr.p,
  451.                           regTabPtr);
  453.     befOpPtr.p->changeMask.clear();
  454.     befOpPtr.p->changeMask.bitOR(saveAttributeMask);
  456.     befOpPtr.p->optype = saveOpType;
  457.   } else if (opType == ZDELETE) {
  458.     ljam();
  459. //--------------------------------------------------------------------
  460. // We want to use the first operation which contains a copy tuple.
  461. // We benefit from the fact that we know that it cannot be a simple
  462. // delete and it cannot be an insert followed by a delete. Thus there
  463. // must either be an update or a insert following a delete. In both
  464. // cases we will find a before value in a copy tuple.
  465. //
  466. // An added complexity is that the trigger handling assumes that the
  467. // before value is located in the original tuple so we have to move the
  468. // copy tuple reference to the original tuple reference and afterwards
  469. // restore it again.
  470. //--------------------------------------------------------------------
  471.     OperationrecPtr befOpPtr;
  472.     findBeforeValueOperation(befOpPtr, firstOpPtr);
  473.     Uint32 saveOpType = befOpPtr.p->optype;
  475.     Uint32 realPageId = befOpPtr.p->realPageId;
  476.     Uint32 pageOffset = befOpPtr.p->pageOffset;
  477.     Uint32 fragPageId = befOpPtr.p->fragPageId;
  478.     Uint32 pageIndex  = befOpPtr.p->pageIndex;
  480.     befOpPtr.p->realPageId = befOpPtr.p->realPageIdC;
  481.     befOpPtr.p->pageOffset = befOpPtr.p->pageOffsetC;
  482.     befOpPtr.p->fragPageId = befOpPtr.p->fragPageIdC;
  483.     befOpPtr.p->pageIndex  = befOpPtr.p->pageIndexC;
  484.     befOpPtr.p->gci = regOperPtr->gci;
  486.     operPtr.p = befOpPtr.p;
  487.     checkDetachedTriggers(signal,
  488.                           befOpPtr.p,
  489.                           regTabPtr);
  491.     befOpPtr.p->realPageId = realPageId;
  492.     befOpPtr.p->pageOffset = pageOffset;
  493.     befOpPtr.p->fragPageId = fragPageId;
  494.     befOpPtr.p->pageIndex  = pageIndex;
  495.     befOpPtr.p->optype     = saveOpType;
  496.   } else {
  497.     ndbrequire(false);
  498.   }//if
  500.   commitUpdate(signal, regOperPtr, regFragPtr, regTabPtr);
  501.   if (regTabPtr->GCPIndicator) {
  502.     updateGcpId(signal, regOperPtr, regFragPtr, regTabPtr);
  503.   }//if
  504. }//Dbtup::commitRecord()
  506. void
  507. Dbtup::setTupleStatesSetOpType(Operationrec* const regOperPtr,
  508.                                Page* const pagePtr,
  509.                                Uint32& opType,
  510.                                OperationrecPtr& firstOpPtr)
  511. {
  512.   OperationrecPtr loopOpPtr;
  513.   OperationrecPtr lastOpPtr;
  515.   ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE);
  516.   loopOpPtr.i = pagePtr->pageWord[regOperPtr->pageOffset];
  517.   ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  518.   lastOpPtr = loopOpPtr;
  519.   if (loopOpPtr.p->optype == ZDELETE) {
  520.     ljam();
  521.     opType = ZDELETE;
  522.   } else {
  523.     ljam();
  524.     opType = ZUPDATE;
  525.   }//if
  526.   do {
  527.     ljam();
  528.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  529.     firstOpPtr = loopOpPtr;
  530.     loopOpPtr.p->tupleState = TO_BE_COMMITTED;
  531.     loopOpPtr.i = loopOpPtr.p->nextActiveOp;
  532.   } while (loopOpPtr.i != RNIL);
  533.   if (opType == ZDELETE) {
  534.     ljam();
  535.     if (firstOpPtr.p->optype == ZINSERT) {
  536.       ljam();
  537.       opType = ZINSERT_DELETE;
  538.     }//if
  539.   } else {
  540.     ljam();
  541.     if (firstOpPtr.p->optype == ZINSERT) {
  542.       ljam();
  543.       opType = ZINSERT;
  544.     }//if
  545.   }///if
  546. }//Dbtup::setTupleStatesSetOpType()
  548. void Dbtup::findBeforeValueOperation(OperationrecPtr& befOpPtr,
  549.                                      OperationrecPtr firstOpPtr)
  550. {
  551.   befOpPtr = firstOpPtr;
  552.   if (befOpPtr.p->realPageIdC != RNIL) {
  553.     ljam();
  554.     return;
  555.   } else {
  556.     ljam();
  557.     befOpPtr.i = befOpPtr.p->prevActiveOp;
  558.     ptrCheckGuard(befOpPtr, cnoOfOprec, operationrec);
  559.     ndbrequire(befOpPtr.p->realPageIdC != RNIL);
  560.   }//if
  561. }//Dbtup::findBeforeValueOperation()
  563. void
  564. Dbtup::calculateChangeMask(Page* const pagePtr,
  565.                            Tablerec* const regTabPtr,
  566.                            Uint32 pageOffset,
  567.                            Bitmask<MAXNROFATTRIBUTESINWORDS>& attributeMask)
  568. {
  569.   OperationrecPtr loopOpPtr;
  571.   attributeMask.clear();
  572.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  573.   loopOpPtr.i = pagePtr->pageWord[pageOffset];
  574.   do {
  575.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  576.     if (loopOpPtr.p->optype == ZUPDATE) {
  577.       ljam();
  578.       attributeMask.bitOR(loopOpPtr.p->changeMask);
  579.     } else if (loopOpPtr.p->optype == ZINSERT) {
  580.       ljam();
  581.       attributeMask.set();
  582.       return;
  583.     } else {
  584.       ndbrequire(loopOpPtr.p->optype == ZDELETE);
  585.     }//if
  586.     loopOpPtr.i = loopOpPtr.p->nextActiveOp;
  587.   } while (loopOpPtr.i != RNIL);
  588. }//Dbtup::calculateChangeMask()