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

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

MySQL数据库

开发平台：

Visual C++

DbtupExecQuery.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 */
  18. #define DBTUP_C
  19. #include "Dbtup.hpp"
  20. #include <RefConvert.hpp>
  21. #include <ndb_limits.h>
  22. #include <pc.hpp>
  23. #include <AttributeDescriptor.hpp>
  24. #include "AttributeOffset.hpp"
  25. #include <AttributeHeader.hpp>
  26. #include <Interpreter.hpp>
  27. #include <signaldata/TupCommit.hpp>
  28. #include <signaldata/TupKey.hpp>
  29. #include <NdbSqlUtil.hpp>
  31. /* ----------------------------------------------------------------- */
  32. /* -----------       INIT_STORED_OPERATIONREC         -------------- */
  33. /* ----------------------------------------------------------------- */
  34. int Dbtup::initStoredOperationrec(Operationrec* const regOperPtr,
  35.                                   Uint32 storedId) 
  36. {
  37.   jam();
  38.   StoredProcPtr storedPtr;
  39.   c_storedProcPool.getPtr(storedPtr, storedId);
  40.   if (storedPtr.i != RNIL) {
  41.     if (storedPtr.p->storedCode == ZSCAN_PROCEDURE) {
  42.       storedPtr.p->storedCounter++;
  43.       regOperPtr->firstAttrinbufrec = storedPtr.p->storedLinkFirst;
  44.       regOperPtr->lastAttrinbufrec = storedPtr.p->storedLinkLast;
  45.       regOperPtr->attrinbufLen = storedPtr.p->storedProcLength;
  46.       regOperPtr->currentAttrinbufLen = storedPtr.p->storedProcLength;
  47.       return ZOK;
  48.     }//if
  49.   }//if
  50.   terrorCode = ZSTORED_PROC_ID_ERROR;
  51.   return terrorCode;
  52. }//Dbtup::initStoredOperationrec()
  54. void Dbtup::copyAttrinfo(Signal* signal,
  55.                          Operationrec * const regOperPtr,
  56.                          Uint32* inBuffer)
  57. {
  58.   AttrbufrecPtr copyAttrBufPtr;
  59.   Uint32 RnoOfAttrBufrec = cnoOfAttrbufrec;
  60.   int RbufLen;
  61.   Uint32 RinBufIndex = 0;
  62.   Uint32 Rnext;
  63.   Uint32 Rfirst;
  64.   Uint32 TstoredProcedure = (regOperPtr->storedProcedureId != ZNIL);
  65.   Uint32 RnoFree = cnoFreeAttrbufrec;
  67. //-------------------------------------------------------------------------
  68. // As a prelude to the execution of the TUPKEYREQ we will copy the program
  69. // into the inBuffer to enable easy execution without any complex jumping
  70. // between the buffers. In particular this will make the interpreter less
  71. // complex. Hopefully it does also improve performance.
  72. //-------------------------------------------------------------------------
  73.   copyAttrBufPtr.i = regOperPtr->firstAttrinbufrec;
  74.   while (copyAttrBufPtr.i != RNIL) {
  75.     jam();
  76.     ndbrequire(copyAttrBufPtr.i < RnoOfAttrBufrec);
  77.     ptrAss(copyAttrBufPtr, attrbufrec);
  78.     RbufLen = copyAttrBufPtr.p->attrbuf[ZBUF_DATA_LEN];
  79.     Rnext = copyAttrBufPtr.p->attrbuf[ZBUF_NEXT];
  80.     Rfirst = cfirstfreeAttrbufrec;
  81.     MEMCOPY_NO_WORDS(&inBuffer[RinBufIndex],
  82.                      &copyAttrBufPtr.p->attrbuf[0],
  83.                      RbufLen);
  84.     RinBufIndex += RbufLen;
  85.     if (!TstoredProcedure) {
  86.       copyAttrBufPtr.p->attrbuf[ZBUF_NEXT] = Rfirst;
  87.       cfirstfreeAttrbufrec = copyAttrBufPtr.i;
  88.       RnoFree++;
  89.     }//if
  90.     copyAttrBufPtr.i = Rnext;
  91.   }//while
  92.   cnoFreeAttrbufrec = RnoFree;
  93.   if (TstoredProcedure) {
  94.     jam();
  95.     StoredProcPtr storedPtr;
  96.     c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId);
  97.     ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
  98.     storedPtr.p->storedCounter--;
  99.     regOperPtr->storedProcedureId = ZNIL;
  100.   }//if
  101.   // Release the ATTRINFO buffers
  102.   regOperPtr->firstAttrinbufrec = RNIL;
  103.   regOperPtr->lastAttrinbufrec = RNIL;
  104. }//Dbtup::copyAttrinfo()
  106. void Dbtup::handleATTRINFOforTUPKEYREQ(Signal* signal,
  107.                                        Uint32 length,
  108.                                        Operationrec * const regOperPtr) 
  109. {
  110.   AttrbufrecPtr TAttrinbufptr;
  111.   TAttrinbufptr.i = cfirstfreeAttrbufrec;
  112.   if ((cfirstfreeAttrbufrec < cnoOfAttrbufrec) &&
  113.       (cnoFreeAttrbufrec > MIN_ATTRBUF)) {
  114.     ptrAss(TAttrinbufptr, attrbufrec);
  115.     MEMCOPY_NO_WORDS(&TAttrinbufptr.p->attrbuf[0],
  116.                      &signal->theData[3],
  117.                      length);
  118.     Uint32 RnoFree = cnoFreeAttrbufrec;
  119.     Uint32 Rnext = TAttrinbufptr.p->attrbuf[ZBUF_NEXT];
  120.     TAttrinbufptr.p->attrbuf[ZBUF_DATA_LEN] = length;
  121.     TAttrinbufptr.p->attrbuf[ZBUF_NEXT] = RNIL;
  123.     AttrbufrecPtr locAttrinbufptr;
  124.     Uint32 RnewLen = regOperPtr->currentAttrinbufLen;
  126.     locAttrinbufptr.i = regOperPtr->lastAttrinbufrec;
  127.     cfirstfreeAttrbufrec = Rnext;
  128.     cnoFreeAttrbufrec = RnoFree - 1;
  129.     RnewLen += length;
  130.     regOperPtr->lastAttrinbufrec = TAttrinbufptr.i;
  131.     regOperPtr->currentAttrinbufLen = RnewLen;
  132.     if (locAttrinbufptr.i == RNIL) {
  133.       regOperPtr->firstAttrinbufrec = TAttrinbufptr.i;
  134.       return;
  135.     } else {
  136.       jam();
  137.       ptrCheckGuard(locAttrinbufptr, cnoOfAttrbufrec, attrbufrec);
  138.       locAttrinbufptr.p->attrbuf[ZBUF_NEXT] = TAttrinbufptr.i;
  139.     }//if
  140.     if (RnewLen < ZATTR_BUFFER_SIZE) {
  141.       return;
  142.     } else {
  143.       jam();
  144.       regOperPtr->transstate = TOO_MUCH_AI;
  145.       return;
  146.     }//if
  147.   } else if (cnoFreeAttrbufrec <= MIN_ATTRBUF) {
  148.     jam();
  149.     regOperPtr->transstate = ERROR_WAIT_TUPKEYREQ;
  150.   } else {
  151.     ndbrequire(false);
  152.   }//if
  153. }//Dbtup::handleATTRINFOforTUPKEYREQ()
  155. void Dbtup::execATTRINFO(Signal* signal) 
  156. {
  157.   OperationrecPtr regOpPtr;
  158.   Uint32 Rsig0 = signal->theData[0];
  159.   Uint32 Rlen = signal->length();
  160.   regOpPtr.i = Rsig0;
  162.   jamEntry();
  164.   ptrCheckGuard(regOpPtr, cnoOfOprec, operationrec);
  165.   if (regOpPtr.p->transstate == IDLE) {
  166.     handleATTRINFOforTUPKEYREQ(signal, Rlen - 3, regOpPtr.p);
  167.     return;
  168.   } else if (regOpPtr.p->transstate == WAIT_STORED_PROCEDURE_ATTR_INFO) {
  169.     storedProcedureAttrInfo(signal, regOpPtr.p, Rlen - 3, 3, false);
  170.     return;
  171.   }//if
  172.   switch (regOpPtr.p->transstate) {
  173.   case ERROR_WAIT_STORED_PROCREQ:
  174.     jam();
  175.   case TOO_MUCH_AI:
  176.     jam();
  177.   case ERROR_WAIT_TUPKEYREQ:
  178.     jam();
  179.     return; /* IGNORE ATTRINFO IN THOSE STATES, WAITING FOR ABORT SIGNAL */
  180.     break;
  181.   case DISCONNECTED:
  182.     jam();
  183.   case STARTED:
  184.     jam();
  185.   default:
  186.     ndbrequire(false);
  187.   }//switch
  188. }//Dbtup::execATTRINFO()
  190. void Dbtup::execTUP_ALLOCREQ(Signal* signal)
  191. {
  192.   OperationrecPtr regOperPtr;
  193.   TablerecPtr regTabPtr;
  194.   FragrecordPtr regFragPtr;
  196.   jamEntry();
  198.   regOperPtr.i = signal->theData[0];
  199.   regFragPtr.i = signal->theData[1];
  200.   regTabPtr.i = signal->theData[2];
  202.   if (!((regOperPtr.i < cnoOfOprec) &&
  203.         (regFragPtr.i < cnoOfFragrec) &&
  204.         (regTabPtr.i < cnoOfTablerec))) {
  205.     ndbrequire(false);
  206.   }//if
  207.   ptrAss(regOperPtr, operationrec);
  208.   ptrAss(regFragPtr, fragrecord);
  209.   ptrAss(regTabPtr, tablerec);
  211. //---------------------------------------------------
  212. /* --- Allocate a tuple as requested by ACC    --- */
  213. //---------------------------------------------------
  214.   PagePtr pagePtr;
  215.   Uint32 pageOffset;
  216.   if (!allocTh(regFragPtr.p,
  217.                regTabPtr.p,
  218.                NORMAL_PAGE,
  219.                signal,
  220.                pageOffset,
  221.                pagePtr)) {
  222.     signal->theData[0] = terrorCode; // Indicate failure
  223.     return;
  224.   }//if
  225.   Uint32 fragPageId = pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS];
  226.   Uint32 pageIndex = ((pageOffset - ZPAGE_HEADER_SIZE) /
  227.                        regTabPtr.p->tupheadsize) << 1;
  228.   regOperPtr.p->tableRef = regTabPtr.i;
  229.   regOperPtr.p->fragId = regFragPtr.p->fragmentId;
  230.   regOperPtr.p->realPageId = pagePtr.i;
  231.   regOperPtr.p->fragPageId = fragPageId;
  232.   regOperPtr.p->pageOffset = pageOffset;
  233.   regOperPtr.p->pageIndex  = pageIndex;
  234.   /* -------------------------------------------------------------- */
  235.   /* AN INSERT IS UNDONE BY FREEING THE DATA OCCUPIED BY THE INSERT */
  236.   /* THE ONLY DATA WE HAVE TO LOG EXCEPT THE TYPE, PAGE AND INDEX   */
  237.   /* IS THE AMOUNT OF DATA TO FREE                                  */
  238.   /* -------------------------------------------------------------- */
  239.   if (isUndoLoggingNeeded(regFragPtr.p, fragPageId)) {
  240.     jam();
  241.     cprAddUndoLogRecord(signal,
  242.                         ZLCPR_TYPE_DELETE_TH,
  243.                         fragPageId,
  244.                         pageIndex,
  245.                         regTabPtr.i,
  246.                         regFragPtr.p->fragmentId,
  247.                         regFragPtr.p->checkpointVersion);
  248.   }//if
  250.   //---------------------------------------------------------------
  251.   // Initialise Active operation list by setting the list to empty
  252.   //---------------------------------------------------------------
  253.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  254.   pagePtr.p->pageWord[pageOffset] = RNIL;
  256.   signal->theData[0] = 0;
  257.   signal->theData[1] = fragPageId;
  258.   signal->theData[2] = pageIndex;
  259. }//Dbtup::execTUP_ALLOCREQ()
  261. void
  262. Dbtup::setChecksum(Page* const pagePtr, Uint32 tupHeadOffset, Uint32 tupHeadSize)
  263. {
  264.   // 2 == regTabPtr.p->tupChecksumIndex
  265.   pagePtr->pageWord[tupHeadOffset + 2] = 0;
  266.   Uint32 checksum = calculateChecksum(pagePtr, tupHeadOffset, tupHeadSize);
  267.   pagePtr->pageWord[tupHeadOffset + 2] = checksum;
  268. }//Dbtup::setChecksum()
  270. Uint32
  271. Dbtup::calculateChecksum(Page* pagePtr,
  272.                          Uint32 tupHeadOffset,
  273.                          Uint32 tupHeadSize)
  274. {
  275.   Uint32 checksum = 0;
  276.   Uint32 loopStop = tupHeadOffset + tupHeadSize;
  277.   ndbrequire(loopStop <= ZWORDS_ON_PAGE);
  278.   // includes tupVersion
  279.   for (Uint32 i = tupHeadOffset + 1; i < loopStop; i++) {
  280.     checksum ^= pagePtr->pageWord[i];
  281.   }//if
  282.   return checksum;
  283. }//Dbtup::calculateChecksum()
  285. /* ----------------------------------------------------------------- */
  286. /* -----------       INSERT_ACTIVE_OP_LIST            -------------- */
  287. /* ----------------------------------------------------------------- */
  288. void Dbtup::insertActiveOpList(Signal* signal, 
  289.                                OperationrecPtr regOperPtr,
  290.                                Page*  const pagePtr,
  291.                                Uint32 pageOffset) 
  292. {
  293.   OperationrecPtr iaoPrevOpPtr;
  294.   ndbrequire(regOperPtr.p->inActiveOpList == ZFALSE);
  295.   regOperPtr.p->inActiveOpList = ZTRUE;
  296.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  297.   iaoPrevOpPtr.i = pagePtr->pageWord[pageOffset];
  298.   pagePtr->pageWord[pageOffset] = regOperPtr.i;
  299.   regOperPtr.p->prevActiveOp = RNIL;
  300.   regOperPtr.p->nextActiveOp = iaoPrevOpPtr.i;
  301.   if (iaoPrevOpPtr.i == RNIL) {
  302.     return;
  303.   } else {
  304.     jam();
  305.     ptrCheckGuard(iaoPrevOpPtr, cnoOfOprec, operationrec);
  306.     iaoPrevOpPtr.p->prevActiveOp = regOperPtr.i;
  307.     if (iaoPrevOpPtr.p->optype == ZDELETE &&
  308.         regOperPtr.p->optype == ZINSERT) {
  309.       jam();
  310.       // mark both
  311.       iaoPrevOpPtr.p->deleteInsertFlag = 1;
  312.       regOperPtr.p->deleteInsertFlag = 1;
  313.     }
  314.     return;
  315.   }//if
  316. }//Dbtup::insertActiveOpList()
  318. void Dbtup::linkOpIntoFragList(OperationrecPtr regOperPtr,
  319.                                Fragrecord* const regFragPtr) 
  320. {
  321.   OperationrecPtr sopTmpOperPtr;
  322.   Uint32 tail = regFragPtr->lastusedOprec;
  323.   ndbrequire(regOperPtr.p->inFragList == ZFALSE);
  324.   regOperPtr.p->inFragList = ZTRUE;
  325.   regOperPtr.p->prevOprecInList = tail;
  326.   regOperPtr.p->nextOprecInList = RNIL;
  327.   sopTmpOperPtr.i = tail;
  328.   if (tail == RNIL) {
  329.     regFragPtr->firstusedOprec = regOperPtr.i;
  330.   } else {
  331.     jam();
  332.     ptrCheckGuard(sopTmpOperPtr, cnoOfOprec, operationrec);
  333.     sopTmpOperPtr.p->nextOprecInList = regOperPtr.i;
  334.   }//if
  335.   regFragPtr->lastusedOprec = regOperPtr.i;
  336. }//Dbtup::linkOpIntoFragList()
  338. /*
  339. This routine is optimised for use from TUPKEYREQ.
  340. This means that a lot of input data is stored in the operation record.
  341. The routine expects the following data in the operation record to be
  342. set-up properly.
  343. Transaction data
  344. 1) transid1
  345. 2) transid2
  346. 3) savePointId
  348. Operation data
  349. 4) optype
  350. 5) dirtyOp
  352. Tuple address
  353. 6) fragPageId
  354. 7) pageIndex
  356. regFragPtr and regTabPtr are references to the table and fragment data and
  357. is read-only.
  359. The routine will set up the following data in the operation record if
  360. returned with success.
  362. Tuple address data
  363. 1) realPageId
  364. 2) fragPageId
  365. 3) pageOffset
  366. 4) pageIndex
  368. Also the pagePtr is an output variable if the routine returns with success.
  369. It's input value can be undefined.
  370. */
  371. bool
  372. Dbtup::getPage(PagePtr& pagePtr,
  373.                Operationrec* const regOperPtr,
  374.                Fragrecord* const regFragPtr,
  375.                Tablerec* const regTabPtr)
  376. {
  377. /* ------------------------------------------------------------------------- */
  378. // GET THE REFERENCE TO THE TUPLE HEADER BY TRANSLATING THE FRAGMENT PAGE ID
  379. // INTO A REAL PAGE ID AND BY USING THE PAGE INDEX TO DERIVE THE PROPER INDEX
  380. // IN THE REAL PAGE.
  381. /* ------------------------------------------------------------------------- */
  382.   pagePtr.i = getRealpid(regFragPtr, regOperPtr->fragPageId);
  383.   regOperPtr->realPageId = pagePtr.i;
  384.   Uint32 RpageIndex = regOperPtr->pageIndex;
  385.   Uint32 Rtupheadsize = regTabPtr->tupheadsize;
  386.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  387.   Uint32 RpageIndexScaled = RpageIndex >> 1;
  388.   ndbrequire((RpageIndex & 1) == 0);
  389.   regOperPtr->pageOffset = ZPAGE_HEADER_SIZE + 
  390.                            (Rtupheadsize * RpageIndexScaled);
  392.   OperationrecPtr leaderOpPtr;
  393.   ndbrequire(regOperPtr->pageOffset < ZWORDS_ON_PAGE);
  394.   leaderOpPtr.i = pagePtr.p->pageWord[regOperPtr->pageOffset];
  395.   if (leaderOpPtr.i == RNIL) {
  396.     return true;
  397.   }//if
  398.   ptrCheckGuard(leaderOpPtr, cnoOfOprec, operationrec);
  399.   bool dirtyRead = ((regOperPtr->optype == ZREAD) &&
  400.                     (regOperPtr->dirtyOp == 1));
  401.   if (dirtyRead) {
  402.     bool sameTrans = ((regOperPtr->transid1 == leaderOpPtr.p->transid1) &&
  403.                       (regOperPtr->transid2 == leaderOpPtr.p->transid2));
  404.     if (!sameTrans) {
  405.       if (!getPageLastCommitted(regOperPtr, leaderOpPtr.p)) {
  406.         return false;
  407.       }//if
  408.       pagePtr.i = regOperPtr->realPageId;
  409.       ptrCheckGuard(pagePtr, cnoOfPage, page);
  410.       return true;
  411.     }//if
  412.   }//if
  413.   if (regOperPtr->optype == ZREAD) {
  414.     /*
  415.     Read uses savepoint id's to find the correct tuple version.
  416.     */
  417.     if (getPageThroughSavePoint(regOperPtr, leaderOpPtr.p)) {
  418.       jam();
  419.       pagePtr.i = regOperPtr->realPageId;
  420.       ptrCheckGuard(pagePtr, cnoOfPage, page);
  421.       return true;
  422.     }
  423.     return false;
  424.   }
  425. //----------------------------------------------------------------------
  426. // Check that no other operation is already active on the tuple. Also
  427. // that abort or commit is not ongoing.
  428. //----------------------------------------------------------------------
  429.   if (leaderOpPtr.p->tupleState == NO_OTHER_OP) {
  430.     jam();
  431.     if ((leaderOpPtr.p->optype == ZDELETE) &&
  432.         (regOperPtr->optype != ZINSERT)) {
  433.       jam();
  434.       terrorCode = ZTUPLE_DELETED_ERROR;
  435.       return false;
  436.     }//if
  437.     return true;
  438.   } else if (leaderOpPtr.p->tupleState == ALREADY_ABORTED) {
  439.     jam();
  440.     terrorCode = ZMUST_BE_ABORTED_ERROR;
  441.     return false;
  442.   } else {
  443.     ndbrequire(false);
  444.   }//if
  445.   return true;
  446. }//Dbtup::getPage()
  448. bool
  449. Dbtup::getPageThroughSavePoint(Operationrec* regOperPtr,
  450.                                Operationrec* leaderOpPtr)
  451. {
  452.   bool found = false;
  453.   OperationrecPtr loopOpPtr;
  454.   loopOpPtr.p = leaderOpPtr;
  455.   while(true) {
  456.     if (regOperPtr->savePointId > loopOpPtr.p->savePointId) {
  457.       jam();
  458.       found = true;
  459.       break;
  460.     }
  461.     if (loopOpPtr.p->nextActiveOp == RNIL) {
  462.       break;
  463.     }
  464.     loopOpPtr.i = loopOpPtr.p->nextActiveOp;
  465.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  466.     jam();
  467.   }
  468.   if (!found) {
  469.     return getPageLastCommitted(regOperPtr, loopOpPtr.p);
  470.   } else {
  471.     if (loopOpPtr.p->optype == ZDELETE) {
  472.       jam();
  473.       terrorCode = ZTUPLE_DELETED_ERROR;
  474.       return false;
  475.     }
  476.     if (loopOpPtr.p->tupleState == ALREADY_ABORTED) {
  477.       /*
  478.       Requested tuple version has already been aborted
  479.       */
  480.       jam();
  481.       terrorCode = ZMUST_BE_ABORTED_ERROR;
  482.       return false;
  483.     }
  484.     bool use_copy;
  485.     if (loopOpPtr.p->prevActiveOp == RNIL) {
  486.       jam();
  487.       /*
  488.       Use original tuple since we are reading from the last written tuple.
  489.       We are the 
  490.       */
  491.       use_copy = false;
  492.     } else {
  493.       /*
  494.       Go forward in time to find a copy of the tuple which this operation
  495.       produced
  496.       */
  497.       loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  498.       ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  499.       if (loopOpPtr.p->optype == ZDELETE) {
  500.         /*
  501.         This operation was a Delete and thus have no copy tuple attached to
  502.         it. We will move forward to the next that either doesn't exist in
  503.         which case we will return the original tuple of any operation and
  504.         otherwise it must be an insert which contains a copy record.
  505.         */
  506.         if (loopOpPtr.p->prevActiveOp == RNIL) {
  507.           jam();
  508.           use_copy = false;
  509.         } else {
  510.           jam();
  511.           loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  512.           ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  513.           ndbrequire(loopOpPtr.p->optype == ZINSERT);
  514.           use_copy = true;
  515.         }
  516.       } else if (loopOpPtr.p->optype == ZUPDATE) {
  517.         jam();
  518.         /*
  519.         This operation which was the next in time have a copy which was the
  520.         result of the previous operation which we want to use. Thus use
  521.         the copy tuple of this operation.
  522.         */
  523.         use_copy = true;
  524.       } else {
  525.         /*
  526.         This operation was an insert that happened after an insert or update.
  527.         This is not a possible case.
  528.         */
  529.         ndbrequire(false);
  530.         return false;
  531.       }
  532.     }
  533.     if (use_copy) {
  534.       regOperPtr->realPageId = loopOpPtr.p->realPageIdC;
  535.       regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC;
  536.       regOperPtr->pageIndex = loopOpPtr.p->pageIndexC;
  537.       regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC;
  538.     } else {
  539.       regOperPtr->realPageId = loopOpPtr.p->realPageId;
  540.       regOperPtr->fragPageId = loopOpPtr.p->fragPageId;
  541.       regOperPtr->pageIndex = loopOpPtr.p->pageIndex;
  542.       regOperPtr->pageOffset = loopOpPtr.p->pageOffset;
  543.     }
  544.     return true;
  545.   }
  546. }
  548. bool
  549. Dbtup::getPageLastCommitted(Operationrec* const regOperPtr,
  550.                             Operationrec* const leaderOpPtr)
  551. {
  552. //----------------------------------------------------------------------
  553. // Dirty reads wants to read the latest committed tuple. The latest
  554. // tuple value could be not existing or else we have to find the copy
  555. // tuple. Start by finding the end of the list to find the first operation
  556. // on the record in the ongoing transaction.
  557. //----------------------------------------------------------------------
  558.   jam();
  559.   OperationrecPtr loopOpPtr;
  560.   loopOpPtr.p = leaderOpPtr;
  561.   while (loopOpPtr.p->nextActiveOp != RNIL) {
  562.     jam();
  563.     loopOpPtr.i = loopOpPtr.p->nextActiveOp;
  564.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  565.   }//while
  566.   if (loopOpPtr.p->optype == ZINSERT) {
  567.     jam();
  568. //----------------------------------------------------------------------
  569. // With an insert in the start of the list we know that the tuple did not
  570. // exist before this transaction was started. We don't care if the current
  571. // transaction is in the commit phase since the commit is not really
  572. // completed until the operation is gone from TUP.
  573. //----------------------------------------------------------------------
  574.     terrorCode = ZTUPLE_DELETED_ERROR;
  575.     return false;
  576.   } else {
  577. //----------------------------------------------------------------------
  578. // A successful update and delete as first in the queue means that a tuple
  579. // exist in the committed world. We need to find it.
  580. //----------------------------------------------------------------------
  581.     if (loopOpPtr.p->optype == ZUPDATE) {
  582.       jam();
  583. //----------------------------------------------------------------------
  584. // The first operation was a delete we set our tuple reference to the
  585. // copy tuple of this operation.
  586. //----------------------------------------------------------------------
  587.       regOperPtr->realPageId = loopOpPtr.p->realPageIdC;
  588.       regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC;
  589.       regOperPtr->pageIndex  = loopOpPtr.p->pageIndexC;
  590.       regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC;
  591.     } else if ((loopOpPtr.p->optype == ZDELETE) &&
  592.                (loopOpPtr.p->prevActiveOp == RNIL)) {
  593.       jam();
  594. //----------------------------------------------------------------------
  595. // There was only a delete. The original tuple still is ok.
  596. //----------------------------------------------------------------------
  597.     } else {
  598.       jam();
  599. //----------------------------------------------------------------------
  600. // There was another operation after the delete, this must be an insert
  601. // and we have found our copy tuple there.
  602. //----------------------------------------------------------------------
  603.       loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  604.       ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  605.       ndbrequire(loopOpPtr.p->optype == ZINSERT);
  606.       regOperPtr->realPageId = loopOpPtr.p->realPageIdC;
  607.       regOperPtr->fragPageId = loopOpPtr.p->fragPageIdC;
  608.       regOperPtr->pageIndex  = loopOpPtr.p->pageIndexC;
  609.       regOperPtr->pageOffset = loopOpPtr.p->pageOffsetC;
  610.     }//if
  611.   }//if
  612.   return true;
  613. }//Dbtup::getPageLastCommitted()
  615. void Dbtup::execTUPKEYREQ(Signal* signal) 
  616. {
  617.   TupKeyReq * const tupKeyReq = (TupKeyReq *)signal->getDataPtr();
  618.   Uint32 RoperPtr = tupKeyReq->connectPtr;
  619.   Uint32 Rtabptr = tupKeyReq->tableRef;
  620.   Uint32 RfragId = tupKeyReq->fragId;
  621.   Uint32 Rstoredid = tupKeyReq->storedProcedure;
  622.   Uint32 Rfragptr = tupKeyReq->fragPtr;
  624.   Uint32 RnoOfOprec = cnoOfOprec;
  625.   Uint32 RnoOfTablerec = cnoOfTablerec;
  626.   Uint32 RnoOfFragrec = cnoOfFragrec;
  628.   operPtr.i = RoperPtr;
  629.   fragptr.i = Rfragptr;
  630.   tabptr.i = Rtabptr;
  631.   jamEntry();
  633.   ndbrequire(((RoperPtr < RnoOfOprec) &&
  634.         (Rtabptr < RnoOfTablerec) &&
  635.         (Rfragptr < RnoOfFragrec)));
  636.   ptrAss(operPtr, operationrec);
  637.   Operationrec * const regOperPtr = operPtr.p;
  638.   ptrAss(fragptr, fragrecord);
  639.   Fragrecord * const regFragPtr = fragptr.p;
  640.   ptrAss(tabptr, tablerec);
  641.   Tablerec* const regTabPtr = tabptr.p;
  643.   Uint32 TrequestInfo = tupKeyReq->request;
  645.   if (regOperPtr->transstate != IDLE) {
  646.     TUPKEY_abort(signal, 39);
  647.     return;
  648.   }//if
  649. /* ----------------------------------------------------------------- */
  650. // Operation is ZREAD when we arrive here so no need to worry about the
  651. // abort process.
  652. /* ----------------------------------------------------------------- */
  653. /* -----------    INITIATE THE OPERATION RECORD       -------------- */
  654. /* ----------------------------------------------------------------- */
  655.   regOperPtr->fragmentPtr = Rfragptr;
  656.   regOperPtr->dirtyOp = TrequestInfo & 1;
  657.   regOperPtr->opSimple = (TrequestInfo >> 1) & 1;
  658.   regOperPtr->interpretedExec = (TrequestInfo >> 10) & 1;
  659.   regOperPtr->optype = (TrequestInfo >> 6) & 0xf;
  661.   // Attributes needed by trigger execution
  662.   regOperPtr->noFiredTriggers = 0;
  663.   regOperPtr->tableRef = Rtabptr;
  664.   regOperPtr->tcOperationPtr = tupKeyReq->opRef;
  665.   regOperPtr->primaryReplica = tupKeyReq->primaryReplica;
  666.   regOperPtr->coordinatorTC = tupKeyReq->coordinatorTC;
  667.   regOperPtr->tcOpIndex = tupKeyReq->tcOpIndex;
  668.   regOperPtr->savePointId = tupKeyReq->savePointId;
  670.   regOperPtr->fragId = RfragId;
  672.   regOperPtr->fragPageId = tupKeyReq->keyRef1;
  673.   regOperPtr->pageIndex = tupKeyReq->keyRef2;
  674.   regOperPtr->attrinbufLen = regOperPtr->logSize = tupKeyReq->attrBufLen;
  675.   regOperPtr->recBlockref = tupKeyReq->applRef;
  677. // Schema Version in tupKeyReq->schemaVersion not used in this version
  678.   regOperPtr->storedProcedureId = Rstoredid;
  679.   regOperPtr->transid1 = tupKeyReq->transId1;
  680.   regOperPtr->transid2 = tupKeyReq->transId2;
  682.   regOperPtr->attroutbufLen = 0;
  683. /* ----------------------------------------------------------------------- */
  684. // INITIALISE TO DEFAULT VALUE
  685. // INIT THE COPY REFERENCE RECORDS TO RNIL TO ENSURE THAT THEIR VALUES
  686. // ARE VALID IF THEY EXISTS
  687. // NO PENDING CHECKPOINT WHEN COPY CREATED (DEFAULT)
  688. // NO TUPLE HAS BEEN ALLOCATED YET
  689. // NO COPY HAS BEEN CREATED YET
  690. /* ----------------------------------------------------------------------- */
  691.   regOperPtr->undoLogged = false;
  692.   regOperPtr->realPageId = RNIL;
  693.   regOperPtr->realPageIdC = RNIL;
  694.   regOperPtr->fragPageIdC = RNIL;
  696.   regOperPtr->pageOffset = ZNIL;
  697.   regOperPtr->pageOffsetC = ZNIL;
  699.   regOperPtr->pageIndexC = ZNIL;
  701.   // version not yet known
  702.   regOperPtr->tupVersion = ZNIL;
  703.   regOperPtr->deleteInsertFlag = 0;
  705.   regOperPtr->tupleState = TUPLE_BLOCKED;
  706.   regOperPtr->changeMask.clear();
  707.   
  708.   if (Rstoredid != ZNIL) {
  709.     ndbrequire(initStoredOperationrec(regOperPtr, Rstoredid) == ZOK);
  710.   }//if
  711.   copyAttrinfo(signal, regOperPtr, &cinBuffer[0]);
  713.   PagePtr pagePtr;
  714.   if (!getPage(pagePtr, regOperPtr, regFragPtr, regTabPtr)) {
  715.     tupkeyErrorLab(signal);
  716.     return;
  717.   }//if
  719.   Uint32 Roptype = regOperPtr->optype;
  720.   if (Roptype == ZREAD) {
  721.     jam();
  722.     if (handleReadReq(signal, regOperPtr, regTabPtr, pagePtr.p) != -1) {
  723.       sendTUPKEYCONF(signal, regOperPtr, 0);
  724. /* ------------------------------------------------------------------------- */
  725. // Read Operations need not to be taken out of any lists. We also do not
  726. // need to wait for commit since there is no changes to commit. Thus we
  727. // prepare the operation record already now for the next operation.
  728. // Write operations have set the state to STARTED above indicating that
  729. // they are waiting for the Commit or Abort decision.
  730. /* ------------------------------------------------------------------------- */
  731.       regOperPtr->transstate = IDLE;
  732.       regOperPtr->currentAttrinbufLen = 0;
  733.     }//if
  734.     return;
  735.   }//if
  736.   linkOpIntoFragList(operPtr, regFragPtr);
  737.   insertActiveOpList(signal,
  738.                      operPtr,
  739.                      pagePtr.p,
  740.                      regOperPtr->pageOffset);
  741.   if (isUndoLoggingBlocked(regFragPtr)) {
  742.     TUPKEY_abort(signal, 38);
  743.     return;
  744.   }//if
  745. /* ---------------------------------------------------------------------- */
  746. // WE SET THE CURRENT ACTIVE OPERATION IN THE TUPLE TO POINT TO OUR
  747. //OPERATION RECORD. IF SEVERAL OPERATIONS WORK ON THIS TUPLE THEY ARE
  748. // LINKED TO OUR OPERATION RECORD. DIRTY READS CAN ACCESS THE COPY
  749. // TUPLE THROUGH OUR OPERATION RECORD.
  750. /* ---------------------------------------------------------------------- */
  751.   if (Roptype == ZINSERT) {
  752.     jam();
  753.     if (handleInsertReq(signal, regOperPtr,
  754.                         regFragPtr, regTabPtr, pagePtr.p) == -1) {
  755.       return;
  756.     }//if
  757.     if (!regTabPtr->tuxCustomTriggers.isEmpty()) {
  758.       jam();
  759.       if (executeTuxInsertTriggers(signal, regOperPtr, regTabPtr) != 0) {
  760.         jam();
  761.         tupkeyErrorLab(signal);
  762.         return;
  763.       }
  764.     }
  765.     checkImmediateTriggersAfterInsert(signal,
  766.                                       regOperPtr,
  767.                                       regTabPtr);
  768.     sendTUPKEYCONF(signal, regOperPtr, regOperPtr->logSize);
  769.     return;
  770.   }//if
  771.   if (regTabPtr->checksumIndicator &&
  772.       (calculateChecksum(pagePtr.p,
  773.                          regOperPtr->pageOffset,
  774.                          regTabPtr->tupheadsize) != 0)) {
  775.     jam();
  776.     terrorCode = ZTUPLE_CORRUPTED_ERROR;
  777.     tupkeyErrorLab(signal);
  778.     return;
  779.   }//if
  780.   if (Roptype == ZUPDATE) {
  781.     jam();
  782.     if (handleUpdateReq(signal, regOperPtr,
  783.                         regFragPtr, regTabPtr, pagePtr.p) == -1) {
  784.       return;
  785.     }//if
  786.     // If update operation is done on primary, 
  787.     // check any after op triggers
  788.     terrorCode = 0;
  789.     if (!regTabPtr->tuxCustomTriggers.isEmpty()) {
  790.       jam();
  791.       if (executeTuxUpdateTriggers(signal, regOperPtr, regTabPtr) != 0) {
  792.         jam();
  793.         tupkeyErrorLab(signal);
  794.         return;
  795.       }
  796.     }
  797.     checkImmediateTriggersAfterUpdate(signal,
  798.                                       regOperPtr,
  799.                                       regTabPtr);
  800.     // XXX use terrorCode for now since all methods are void
  801.     if (terrorCode != 0) {
  802.       tupkeyErrorLab(signal);
  803.       return;
  804.     }
  805.     sendTUPKEYCONF(signal, regOperPtr, regOperPtr->logSize);
  806.     return;
  807.   } else if (Roptype == ZDELETE) {
  808.     jam();
  809.     if (handleDeleteReq(signal, regOperPtr,
  810.                         regFragPtr, regTabPtr, pagePtr.p) == -1) {
  811.       return;
  812.     }//if
  813.     // If delete operation is done on primary, 
  814.     // check any after op triggers
  815.     if (!regTabPtr->tuxCustomTriggers.isEmpty()) {
  816.       jam();
  817.       if (executeTuxDeleteTriggers(signal, regOperPtr, regTabPtr) != 0) {
  818.         jam();
  819.         tupkeyErrorLab(signal);
  820.         return;
  821.       }
  822.     }
  823.     checkImmediateTriggersAfterDelete(signal,
  824.                                       regOperPtr, 
  825.                                       regTabPtr);
  826.     sendTUPKEYCONF(signal, regOperPtr, 0);
  827.     return;
  828.   } else {
  829.     ndbrequire(false);
  830.   }//if
  831. }//Dbtup::execTUPKEYREQ()
  833. /* ---------------------------------------------------------------- */
  834. /* ------------------------ CONFIRM REQUEST ----------------------- */
  835. /* ---------------------------------------------------------------- */
  836. void Dbtup::sendTUPKEYCONF(Signal* signal, 
  837.                            Operationrec * const regOperPtr, 
  838.                            Uint32 TlogSize) 
  839. {
  840.   TupKeyConf * const tupKeyConf = (TupKeyConf *)signal->getDataPtrSend();  
  842.   Uint32 RuserPointer = regOperPtr->userpointer;
  843.   Uint32 RattroutbufLen = regOperPtr->attroutbufLen;
  844.   Uint32 RnoFiredTriggers = regOperPtr->noFiredTriggers;
  845.   BlockReference Ruserblockref = regOperPtr->userblockref;
  846.   Uint32 lastRow = regOperPtr->lastRow;
  848.   regOperPtr->transstate = STARTED;
  849.   regOperPtr->tupleState = NO_OTHER_OP;
  850.   tupKeyConf->userPtr = RuserPointer;
  851.   tupKeyConf->readLength = RattroutbufLen;
  852.   tupKeyConf->writeLength = TlogSize;
  853.   tupKeyConf->noFiredTriggers = RnoFiredTriggers;
  854.   tupKeyConf->lastRow = lastRow;
  856.   EXECUTE_DIRECT(refToBlock(Ruserblockref), GSN_TUPKEYCONF, signal,
  857.  TupKeyConf::SignalLength);
  858.   return;
  859. }//Dbtup::sendTUPKEYCONF()
  861. /* ---------------------------------------------------------------- */
  862. /* ----------------------------- READ  ---------------------------- */
  863. /* ---------------------------------------------------------------- */
  864. int Dbtup::handleReadReq(Signal* signal,
  865.                          Operationrec* const regOperPtr,
  866.                          Tablerec* const regTabPtr,
  867.                          Page* pagePtr)
  868. {
  869.   Uint32 Ttupheadoffset = regOperPtr->pageOffset;
  870.   const BlockReference sendBref = regOperPtr->recBlockref;
  871.   if (regTabPtr->checksumIndicator &&
  872.       (calculateChecksum(pagePtr, Ttupheadoffset,
  873.                          regTabPtr->tupheadsize) != 0)) {
  874.     jam();
  875.     terrorCode = ZTUPLE_CORRUPTED_ERROR;
  876.     tupkeyErrorLab(signal);
  877.     return -1;
  878.   }//if
  880.   Uint32 * dst = &signal->theData[25];
  881.   Uint32 dstLen = (sizeof(signal->theData) / 4) - 25;
  882.   const Uint32 node = refToNode(sendBref);
  883.   if(node != 0 && node != getOwnNodeId()) {
  884.     ;
  885.   } else {
  886.     jam();
  887.     /**
  888.      * execute direct
  889.      */
  890.     dst = &signal->theData[3];
  891.     dstLen = (sizeof(signal->theData) / 4) - 3;
  892.   }
  893.   
  894.   if (regOperPtr->interpretedExec != 1) {
  895.     jam();
  896.     int ret = readAttributes(pagePtr,
  897.      Ttupheadoffset,
  898.      &cinBuffer[0],
  899.      regOperPtr->attrinbufLen,
  900.      dst,
  901.      dstLen,
  902.      false);
  903.     if (ret != -1) {
  904. /* ------------------------------------------------------------------------- */
  905. // We have read all data into coutBuffer. Now send it to the API.
  906. /* ------------------------------------------------------------------------- */
  907.       jam();
  908.       Uint32 TnoOfDataRead= (Uint32) ret;
  909.       regOperPtr->attroutbufLen = TnoOfDataRead;
  910.       sendReadAttrinfo(signal, TnoOfDataRead, regOperPtr);
  911.       return 0;
  912.     }//if
  913.     jam();
  914.     tupkeyErrorLab(signal);
  915.     return -1;
  916.   } else {
  917.     jam();
  918.     regOperPtr->lastRow = 0;
  919.     if (interpreterStartLab(signal, pagePtr, Ttupheadoffset) != -1) {
  920.       return 0;
  921.     }//if
  922.     return -1;
  923.   }//if
  924. }//Dbtup::handleReadReq()
  926. /* ---------------------------------------------------------------- */
  927. /* ---------------------------- UPDATE ---------------------------- */
  928. /* ---------------------------------------------------------------- */
  929. int Dbtup::handleUpdateReq(Signal* signal,
  930.                            Operationrec* const regOperPtr,
  931.                            Fragrecord* const regFragPtr,
  932.                            Tablerec* const regTabPtr,
  933.                            Page* const pagePtr) 
  934. {
  935.   PagePtr copyPagePtr;
  936.   Uint32 tuple_size = regTabPtr->tupheadsize;
  938. //---------------------------------------------------
  939. /* --- MAKE A COPY OF THIS TUPLE ON A COPY PAGE --- */
  940. //---------------------------------------------------
  941.   Uint32 RpageOffsetC;
  942.   if (!allocTh(regFragPtr,
  943.                regTabPtr,
  944.                COPY_PAGE,
  945.                signal,
  946.                RpageOffsetC,
  947.                copyPagePtr)) {
  948.     TUPKEY_abort(signal, 1);
  949.     return -1;
  950.   }//if
  951.   Uint32 RpageIdC = copyPagePtr.i;
  952.   Uint32 RfragPageIdC = copyPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS];
  953.   Uint32 indexC = ((RpageOffsetC - ZPAGE_HEADER_SIZE) / tuple_size) << 1;
  954.   regOperPtr->pageIndexC = indexC;
  955.   regOperPtr->fragPageIdC = RfragPageIdC;
  956.   regOperPtr->realPageIdC = RpageIdC;
  957.   regOperPtr->pageOffsetC = RpageOffsetC;
  958.   /* -------------------------------------------------------------- */
  959.   /* IF WE HAVE AN ONGING CHECKPOINT WE HAVE TO LOG THE ALLOCATION  */
  960.   /* OF THE TUPLE HEADER TO BE ABLE TO DELETE IT UPON RESTART       */
  961.   /* THE ONLY DATA EXCEPT THE TYPE, PAGE, INDEX IS THE SIZE TO FREE */
  962.   /* -------------------------------------------------------------- */
  963.   if (isUndoLoggingActive(regFragPtr)) {
  964.     if (isPageUndoLogged(regFragPtr, RfragPageIdC)) {
  965.       jam();
  966.       regOperPtr->undoLogged = true;
  967.       cprAddUndoLogRecord(signal,
  968.                           ZLCPR_TYPE_DELETE_TH,
  969.                           RfragPageIdC,
  970.                           indexC,
  971.                           regOperPtr->tableRef,
  972.                           regOperPtr->fragId,
  973.                           regFragPtr->checkpointVersion);
  974.     }//if
  975.     if (isPageUndoLogged(regFragPtr, regOperPtr->fragPageId)) {
  976.       jam();
  977.       cprAddUndoLogRecord(signal,
  978.                           ZLCPR_TYPE_UPDATE_TH,
  979.                           regOperPtr->fragPageId,
  980.                           regOperPtr->pageIndex,
  981.                           regOperPtr->tableRef,
  982.                           regOperPtr->fragId,
  983.                           regFragPtr->checkpointVersion);
  984.       cprAddData(signal,
  985.                  regFragPtr,
  986.                  regOperPtr->realPageId,
  987.                  tuple_size,
  988.                  regOperPtr->pageOffset);
  989.     }//if
  990.   }//if
  991.   Uint32 RwordCount = tuple_size - 1;
  992.   Uint32 end_dest = RpageOffsetC + tuple_size;
  993.   Uint32 offset = regOperPtr->pageOffset;
  994.   Uint32 end_source = offset + tuple_size;
  995.   ndbrequire(end_dest <= ZWORDS_ON_PAGE && end_source <= ZWORDS_ON_PAGE);
  996.   void* Tdestination = (void*)&copyPagePtr.p->pageWord[RpageOffsetC + 1];
  997.   const void* Tsource = (void*)&pagePtr->pageWord[offset + 1];
  998.   MEMCOPY_NO_WORDS(Tdestination, Tsource, RwordCount);
  1000.   Uint32 prev_tup_version;
  1001.   // nextActiveOp is before this op in event order
  1002.   if (regOperPtr->nextActiveOp == RNIL) {
  1003.     jam();
  1004.     prev_tup_version = ((const Uint32*)Tsource)[0];
  1005.   } else {
  1006.     OperationrecPtr prevOperPtr;
  1007.     jam();
  1008.     prevOperPtr.i = regOperPtr->nextActiveOp;
  1009.     ptrCheckGuard(prevOperPtr, cnoOfOprec, operationrec);
  1010.     prev_tup_version = prevOperPtr.p->tupVersion;
  1011.   }//if
  1012.   regOperPtr->tupVersion = (prev_tup_version + 1) &
  1013.                            ((1 << ZTUP_VERSION_BITS) - 1);
  1014.   // global variable alert
  1015.   ndbassert(operationrec + operPtr.i == regOperPtr);
  1016.   copyPagePtr.p->pageWord[RpageOffsetC] = operPtr.i;
  1018.   return updateStartLab(signal, regOperPtr, regTabPtr, pagePtr);
  1019. }//Dbtup::handleUpdateReq()
  1021. /* ---------------------------------------------------------------- */
  1022. /* ----------------------------- INSERT --------------------------- */
  1023. /* ---------------------------------------------------------------- */
  1024. int Dbtup::handleInsertReq(Signal* signal,
  1025.                            Operationrec* const regOperPtr,
  1026.                            Fragrecord* const regFragPtr,
  1027.                            Tablerec* const regTabPtr,
  1028.                            Page* const pagePtr) 
  1029. {
  1030.   Uint32 ret_value;
  1032.   if (regOperPtr->nextActiveOp != RNIL) {
  1033.     jam();
  1034.     OperationrecPtr prevExecOpPtr;
  1035.     prevExecOpPtr.i = regOperPtr->nextActiveOp;
  1036.     ptrCheckGuard(prevExecOpPtr, cnoOfOprec, operationrec);
  1037.     if (prevExecOpPtr.p->optype != ZDELETE) {
  1038.       terrorCode = ZINSERT_ERROR;
  1039.       tupkeyErrorLab(signal);
  1040.       return -1;
  1041.     }//if
  1042.     ret_value = handleUpdateReq(signal, regOperPtr,
  1043.                                 regFragPtr, regTabPtr, pagePtr);
  1044.   } else {
  1045.     jam();
  1046.     regOperPtr->tupVersion = 0;
  1047.     ret_value = updateStartLab(signal, regOperPtr, regTabPtr, pagePtr);
  1048.   }//if
  1049.   if (ret_value != (Uint32)-1) {
  1050.     if (checkNullAttributes(regOperPtr, regTabPtr)) {
  1051.       jam();
  1052.       return 0;
  1053.     }//if
  1054.     TUPKEY_abort(signal, 17);
  1055.   }//if
  1056.   return -1;
  1057. }//Dbtup::handleInsertReq()
  1059. /* ---------------------------------------------------------------- */
  1060. /* ---------------------------- DELETE ---------------------------- */
  1061. /* ---------------------------------------------------------------- */
  1062. int Dbtup::handleDeleteReq(Signal* signal,
  1063.                            Operationrec* const regOperPtr,
  1064.                            Fragrecord* const regFragPtr,
  1065.                            Tablerec* const regTabPtr,
  1066.                            Page* const pagePtr)
  1067. {
  1068.   // delete must set but not increment tupVersion
  1069.   if (regOperPtr->nextActiveOp != RNIL) {
  1070.     OperationrecPtr prevExecOpPtr;
  1071.     prevExecOpPtr.i = regOperPtr->nextActiveOp;
  1072.     ptrCheckGuard(prevExecOpPtr, cnoOfOprec, operationrec);
  1073.     regOperPtr->tupVersion = prevExecOpPtr.p->tupVersion;
  1074.   } else {
  1075.     jam();
  1076.     regOperPtr->tupVersion = pagePtr->pageWord[regOperPtr->pageOffset + 1];
  1077.   }
  1078.   if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageId)) {
  1079.     jam();
  1080.     cprAddUndoLogRecord(signal,
  1081.                         ZINDICATE_NO_OP_ACTIVE,
  1082.                         regOperPtr->fragPageId,
  1083.                         regOperPtr->pageIndex,
  1084.                         regOperPtr->tableRef,
  1085.                         regOperPtr->fragId,
  1086.                         regFragPtr->checkpointVersion);
  1087.   }//if
  1088.   if (regOperPtr->attrinbufLen == 0) {
  1089.     return 0;
  1090.   }//if
  1091. /* ------------------------------------------------------------------------ */
  1092. /* THE APPLICATION WANTS TO READ THE TUPLE BEFORE IT IS DELETED.            */
  1093. /* ------------------------------------------------------------------------ */
  1094.   return handleReadReq(signal, regOperPtr, regTabPtr, pagePtr);
  1095. }//Dbtup::handleDeleteReq()
  1097. int
  1098. Dbtup::updateStartLab(Signal* signal,
  1099.                       Operationrec* const regOperPtr,
  1100.                       Tablerec* const regTabPtr,
  1101.                       Page* const pagePtr)
  1102. {
  1103.   int retValue;
  1104.   if (regOperPtr->optype == ZINSERT) {
  1105.     jam();
  1106.     setNullBits(pagePtr, regTabPtr, regOperPtr->pageOffset);
  1107.   }
  1108.   if (regOperPtr->interpretedExec != 1) {
  1109.     jam();
  1110.     retValue = updateAttributes(pagePtr,
  1111.                                 regOperPtr->pageOffset,
  1112.                                 &cinBuffer[0],
  1113.                                 regOperPtr->attrinbufLen);
  1114.     if (retValue == -1) {
  1115.       tupkeyErrorLab(signal);
  1116.       return -1;
  1117.     }//if
  1118.   } else {
  1119.     jam();
  1120.     retValue = interpreterStartLab(signal, pagePtr, regOperPtr->pageOffset);
  1121.   }//if
  1122.   ndbrequire(regOperPtr->tupVersion != ZNIL);
  1123.   pagePtr->pageWord[regOperPtr->pageOffset + 1] = regOperPtr->tupVersion;
  1124.   if (regTabPtr->checksumIndicator) {
  1125.     jam();
  1126.     setChecksum(pagePtr, regOperPtr->pageOffset, regTabPtr->tupheadsize);
  1127.   }//if
  1128.   return retValue;
  1129. }//Dbtup::updateStartLab()
  1131. void
  1132. Dbtup::setNullBits(Page* const regPage, Tablerec* const regTabPtr, Uint32 pageOffset)
  1133. {
  1134.   Uint32 noOfExtraNullWords = regTabPtr->tupNullWords;
  1135.   Uint32 nullOffsetStart = regTabPtr->tupNullIndex + pageOffset;
  1136.   ndbrequire((noOfExtraNullWords + nullOffsetStart) < ZWORDS_ON_PAGE);
  1137.   for (Uint32 i = 0; i < noOfExtraNullWords; i++) {
  1138.     regPage->pageWord[nullOffsetStart + i] = 0xFFFFFFFF;
  1139.   }//for
  1140. }//Dbtup::setNullBits()
  1142. bool
  1143. Dbtup::checkNullAttributes(Operationrec* const regOperPtr,
  1144.                            Tablerec* const regTabPtr)
  1145. {
  1146. // Implement checking of updating all not null attributes in an insert here.
  1147.   Bitmask<MAXNROFATTRIBUTESINWORDS> attributeMask;  
  1148.   /* 
  1149.    * The idea here is maybe that changeMask is not-null attributes
  1150.    * and must contain notNullAttributeMask.  But:
  1151.    *
  1152.    * 1. changeMask has all bits set on insert
  1153.    * 2. not-null is checked in each UpdateFunction
  1154.    * 3. the code below does not work except trivially due to 1.
  1155.    *
  1156.    * XXX remove or fix
  1157.    */
  1158.   attributeMask.clear();
  1159.   attributeMask.bitOR(regOperPtr->changeMask);
  1160.   attributeMask.bitAND(regTabPtr->notNullAttributeMask);
  1161.   attributeMask.bitXOR(regTabPtr->notNullAttributeMask);
  1162.   if (!attributeMask.isclear()) {
  1163.     return false;
  1164.   }//if
  1165.   return true;
  1166. }//Dbtup::checkNullAttributes()
  1168. /* ---------------------------------------------------------------- */
  1169. /* THIS IS THE START OF THE INTERPRETED EXECUTION OF UPDATES. WE    */
  1170. /* START BY LINKING ALL ATTRINFO'S IN A DOUBLY LINKED LIST (THEY ARE*/
  1171. /* ALREADY IN A LINKED LIST). WE ALLOCATE A REGISTER MEMORY (EQUAL  */
  1172. /* TO AN ATTRINFO RECORD). THE INTERPRETER GOES THROUGH FOUR  PHASES*/
  1173. /* DURING THE FIRST PHASE IT IS ONLY ALLOWED TO READ ATTRIBUTES THAT*/
  1174. /* ARE SENT TO THE CLIENT APPLICATION. DURING THE SECOND PHASE IT IS*/
  1175. /* ALLOWED TO READ FROM ATTRIBUTES INTO REGISTERS, TO UPDATE        */
  1176. /* ATTRIBUTES BASED ON EITHER A CONSTANT VALUE OR A REGISTER VALUE, */
  1177. /* A DIVERSE SET OF OPERATIONS ON REGISTERS ARE AVAILABLE AS WELL.  */
  1178. /* IT IS ALSO POSSIBLE TO PERFORM JUMPS WITHIN THE INSTRUCTIONS THAT*/
  1179. /* BELONGS TO THE SECOND PHASE. ALSO SUBROUTINES CAN BE CALLED IN   */
  1180. /* THIS PHASE. THE THIRD PHASE IS TO AGAIN READ ATTRIBUTES AND      */
  1181. /* FINALLY THE FOURTH PHASE READS SELECTED REGISTERS AND SEND THEM  */
  1182. /* TO THE CLIENT APPLICATION.                                       */
  1183. /* THERE IS A FIFTH REGION WHICH CONTAINS SUBROUTINES CALLABLE FROM */
  1184. /* THE INTERPRETER EXECUTION REGION.                                */
  1185. /* THE FIRST FIVE WORDS WILL GIVE THE LENGTH OF THE FIVEE REGIONS   */
  1186. /*                                                                  */
  1187. /* THIS MEANS THAT FROM THE APPLICATIONS POINT OF VIEW THE DATABASE */
  1188. /* CAN HANDLE SUBROUTINE CALLS WHERE THE CODE IS SENT IN THE REQUEST*/
  1189. /* THE RETURN PARAMETERS ARE FIXED AND CAN EITHER BE GENERATED      */
  1190. /* BEFORE THE EXECUTION OF THE ROUTINE OR AFTER.                    */
  1191. /*                                                                  */
  1192. /* IN LATER VERSIONS WE WILL ADD MORE THINGS LIKE THE POSSIBILITY   */
  1193. /* TO ALLOCATE MEMORY AND USE THIS AS LOCAL STORAGE. IT IS ALSO     */
  1194. /* IMAGINABLE TO HAVE SPECIAL ROUTINES THAT CAN PERFORM CERTAIN     */
  1195. /* OPERATIONS ON BLOB'S DEPENDENT ON WHAT THE BLOB REPRESENTS.      */
  1196. /*                                                                  */
  1197. /*                                                                  */
  1198. /*       -----------------------------------------                  */
  1199. /*       +   INITIAL READ REGION                 +                  */
  1200. /*       -----------------------------------------                  */
  1201. /*       +   INTERPRETED EXECUTE  REGION         +                  */
  1202. /*       -----------------------------------------                  */
  1203. /*       +   FINAL UPDATE REGION                 +                  */
  1204. /*       -----------------------------------------                  */
  1205. /*       +   FINAL READ REGION                   +                  */
  1206. /*       -----------------------------------------                  */
  1207. /*       +   SUBROUTINE REGION                   +                  */
  1208. /*       -----------------------------------------                  */
  1209. /* ---------------------------------------------------------------- */
  1210. /* ---------------------------------------------------------------- */
  1211. /* ----------------- INTERPRETED EXECUTION  ----------------------- */
  1212. /* ---------------------------------------------------------------- */
  1213. int Dbtup::interpreterStartLab(Signal* signal,
  1214.                                Page* const pagePtr,
  1215.                                Uint32 TupHeadOffset) 
  1216. {
  1217.   Operationrec *  const regOperPtr = operPtr.p;
  1218.   Uint32 RtotalLen;
  1219.   int TnoDataRW;
  1221.   Uint32 RinitReadLen = cinBuffer[0];
  1222.   Uint32 RexecRegionLen = cinBuffer[1];
  1223.   Uint32 RfinalUpdateLen = cinBuffer[2];
  1224.   Uint32 RfinalRLen = cinBuffer[3];
  1225.   Uint32 RsubLen = cinBuffer[4];
  1227.   Uint32 RattrinbufLen = regOperPtr->attrinbufLen;
  1228.   const BlockReference sendBref = regOperPtr->recBlockref;
  1230.   Uint32 * dst = &signal->theData[25];
  1231.   Uint32 dstLen = (sizeof(signal->theData) / 4) - 25;
  1232.   const Uint32 node = refToNode(sendBref);
  1233.   if(node != 0 && node != getOwnNodeId()) {
  1234.     ;
  1235.   } else {
  1236.     jam();
  1237.     /**
  1238.      * execute direct
  1239.      */
  1240.     dst = &signal->theData[3];
  1241.     dstLen = (sizeof(signal->theData) / 4) - 3;
  1242.   }
  1243.   
  1244.   RtotalLen = RinitReadLen;
  1245.   RtotalLen += RexecRegionLen;
  1246.   RtotalLen += RfinalUpdateLen;
  1247.   RtotalLen += RfinalRLen;
  1248.   RtotalLen += RsubLen;
  1250.   Uint32 RattroutCounter = 0;
  1251.   Uint32 RinstructionCounter = 5;
  1252.   Uint32 RlogSize = 0;
  1254.   if (((RtotalLen + 5) == RattrinbufLen) &&
  1255.       (RattrinbufLen >= 5) &&
  1256.       (RattrinbufLen < ZATTR_BUFFER_SIZE)) {
  1257.     /* ---------------------------------------------------------------- */
  1258.     // We start by checking consistency. We must have the first five
  1259.     // words of the ATTRINFO to give us the length of the regions. The
  1260.     // size of these regions must be the same as the total ATTRINFO
  1261.     // length and finally the total length must be within the limits.
  1262.     /* ---------------------------------------------------------------- */
  1264.     if (RinitReadLen > 0) {
  1265.       jam();
  1266.       /* ---------------------------------------------------------------- */
  1267.       // The first step that can be taken in the interpreter is to read
  1268.       // data of the tuple before any updates have been applied.
  1269.       /* ---------------------------------------------------------------- */
  1270.       TnoDataRW = readAttributes(pagePtr,
  1271.  TupHeadOffset,
  1272.  &cinBuffer[5],
  1273.  RinitReadLen,
  1274.  &dst[0],
  1275.  dstLen,
  1276.                                  false);
  1277.       if (TnoDataRW != -1) {
  1278. RattroutCounter = TnoDataRW;
  1279. RinstructionCounter += RinitReadLen;
  1280.       } else {
  1281. jam();
  1282. tupkeyErrorLab(signal);
  1283. return -1;
  1284.       }//if
  1285.     }//if
  1286.     if (RexecRegionLen > 0) {
  1287.       jam();
  1288.       /* ---------------------------------------------------------------- */
  1289.       // The next step is the actual interpreted execution. This executes
  1290.       // a register-based virtual machine which can read and write attributes
  1291.       // to and from registers.
  1292.       /* ---------------------------------------------------------------- */
  1293.       Uint32 RsubPC = RinstructionCounter + RfinalUpdateLen + RfinalRLen;     
  1294.       TnoDataRW = interpreterNextLab(signal,
  1295.      pagePtr,
  1296.      TupHeadOffset,
  1297.      &clogMemBuffer[0],
  1298.      &cinBuffer[RinstructionCounter],
  1299.      RexecRegionLen,
  1300.      &cinBuffer[RsubPC],
  1301.      RsubLen,
  1302.      &coutBuffer[0],
  1303.      sizeof(coutBuffer) / 4);
  1304.       if (TnoDataRW != -1) {
  1305. RinstructionCounter += RexecRegionLen;
  1306. RlogSize = TnoDataRW;
  1307.       } else {
  1308. jam();
  1309. return -1;
  1310.       }//if
  1311.     }//if
  1312.     if (RfinalUpdateLen > 0) {
  1313.       jam();
  1314.       /* ---------------------------------------------------------------- */
  1315.       // We can also apply a set of updates without any conditions as part
  1316.       // of the interpreted execution.
  1317.       /* ---------------------------------------------------------------- */
  1318.       if (regOperPtr->optype == ZUPDATE) {
  1319. TnoDataRW = updateAttributes(pagePtr,
  1320.      TupHeadOffset,
  1321.      &cinBuffer[RinstructionCounter],
  1322.      RfinalUpdateLen);
  1323. if (TnoDataRW != -1) {
  1324.   MEMCOPY_NO_WORDS(&clogMemBuffer[RlogSize],
  1325.    &cinBuffer[RinstructionCounter],
  1326.    RfinalUpdateLen);
  1327.   RinstructionCounter += RfinalUpdateLen;
  1328.   RlogSize += RfinalUpdateLen;
  1329. } else {
  1330.   jam();
  1331.   tupkeyErrorLab(signal);
  1332.   return -1;
  1333. }//if
  1334.       } else {
  1335. return TUPKEY_abort(signal, 19);
  1336.       }//if
  1337.     }//if
  1338.     if (RfinalRLen > 0) {
  1339.       jam();
  1340.       /* ---------------------------------------------------------------- */
  1341.       // The final action is that we can also read the tuple after it has
  1342.       // been updated.
  1343.       /* ---------------------------------------------------------------- */
  1344.       TnoDataRW = readAttributes(pagePtr,
  1345.  TupHeadOffset,
  1346.  &cinBuffer[RinstructionCounter],
  1347.  RfinalRLen,
  1348.  &dst[RattroutCounter],
  1349.  (dstLen - RattroutCounter),
  1350.                                  false);
  1351.       if (TnoDataRW != -1) {
  1352. RattroutCounter += TnoDataRW;
  1353.       } else {
  1354. jam();
  1355. tupkeyErrorLab(signal);
  1356. return -1;
  1357.       }//if
  1358.     }//if
  1359.     regOperPtr->logSize = RlogSize;
  1360.     regOperPtr->attroutbufLen = RattroutCounter;
  1361.     sendReadAttrinfo(signal, RattroutCounter, regOperPtr);
  1362.     if (RlogSize > 0) {
  1363.       sendLogAttrinfo(signal, RlogSize, regOperPtr);
  1364.     }//if
  1365.     return 0;
  1366.   } else {
  1367.     return TUPKEY_abort(signal, 22);
  1368.   }//if
  1369. }//Dbtup::interpreterStartLab()
  1371. /* ---------------------------------------------------------------- */
  1372. /*       WHEN EXECUTION IS INTERPRETED WE NEED TO SEND SOME ATTRINFO*/
  1373. /*       BACK TO LQH FOR LOGGING AND SENDING TO BACKUP AND STANDBY  */
  1374. /*       NODES.                                                     */
  1375. /*       INPUT:  LOG_ATTRINFOPTR         WHERE TO FETCH DATA FROM   */
  1376. /*               TLOG_START              FIRST INDEX TO LOG         */
  1377. /*               TLOG_END                LAST INDEX + 1 TO LOG      */
  1378. /* ---------------------------------------------------------------- */
  1379. void Dbtup::sendLogAttrinfo(Signal* signal,
  1380.                             Uint32 TlogSize,
  1381.                             Operationrec *  const regOperPtr)
  1383. {
  1384.   Uint32 TbufferIndex = 0;
  1385.   signal->theData[0] = regOperPtr->userpointer;
  1386.   while (TlogSize > 22) {
  1387.     MEMCOPY_NO_WORDS(&signal->theData[3],
  1388.                      &clogMemBuffer[TbufferIndex],
  1389.                      22);
  1390.     EXECUTE_DIRECT(refToBlock(regOperPtr->userblockref), 
  1391.                    GSN_TUP_ATTRINFO, signal, 25);
  1392.     TbufferIndex += 22;
  1393.     TlogSize -= 22;
  1394.   }//while
  1395.   MEMCOPY_NO_WORDS(&signal->theData[3],
  1396.                    &clogMemBuffer[TbufferIndex],
  1397.                    TlogSize);
  1398.   EXECUTE_DIRECT(refToBlock(regOperPtr->userblockref), 
  1399.                  GSN_TUP_ATTRINFO, signal, 3 + TlogSize);
  1400. }//Dbtup::sendLogAttrinfo()
  1402. inline
  1403. Uint32 
  1404. brancher(Uint32 TheInstruction, Uint32 TprogramCounter)
  1405. {         
  1406.   Uint32 TbranchDirection = TheInstruction >> 31;
  1407.   Uint32 TbranchLength = (TheInstruction >> 16) & 0x7fff;
  1408.   TprogramCounter--;
  1409.   if (TbranchDirection == 1) {
  1410.     jam();
  1411.     /* ---------------------------------------------------------------- */
  1412.     /*       WE JUMP BACKWARDS.                                         */
  1413.     /* ---------------------------------------------------------------- */
  1414.     return (TprogramCounter - TbranchLength);
  1415.   } else {
  1416.     jam();
  1417.     /* ---------------------------------------------------------------- */
  1418.     /*       WE JUMP FORWARD.                                           */
  1419.     /* ---------------------------------------------------------------- */
  1420.     return (TprogramCounter + TbranchLength);
  1421.   }//if
  1422. }//brancher()
  1424. int Dbtup::interpreterNextLab(Signal* signal,
  1425.                               Page* const pagePtr,
  1426.                               Uint32 TupHeadOffset,
  1427.                               Uint32* logMemory,
  1428.                               Uint32* mainProgram,
  1429.                               Uint32 TmainProgLen,
  1430.                               Uint32* subroutineProg,
  1431.                               Uint32 TsubroutineLen,
  1432.       Uint32 * tmpArea,
  1433.       Uint32 tmpAreaSz)
  1434. {
  1435.   register Uint32* TcurrentProgram = mainProgram;
  1436.   register Uint32 TcurrentSize = TmainProgLen;
  1437.   register Uint32 RnoOfInstructions = 0;
  1438.   register Uint32 TprogramCounter = 0;
  1439.   register Uint32 theInstruction;
  1440.   register Uint32 theRegister;
  1441.   Uint32 TdataWritten = 0;
  1442.   Uint32 RstackPtr = 0;
  1443.   union {
  1444.     Uint32 TregMemBuffer[32];
  1445.     Uint64 Tdummy[16];
  1446.   };
  1447.   Uint32 TstackMemBuffer[32];
  1449.   /* ---------------------------------------------------------------- */
  1450.   // Initialise all 8 registers to contain the NULL value.
  1451.   // In this version we can handle 32 and 64 bit unsigned integers.
  1452.   // They are handled as 64 bit values. Thus the 32 most significant
  1453.   // bits are zeroed for 32 bit values.
  1454.   /* ---------------------------------------------------------------- */
  1455.   TregMemBuffer[0] = 0;
  1456.   TregMemBuffer[4] = 0;
  1457.   TregMemBuffer[8] = 0;
  1458.   TregMemBuffer[12] = 0;
  1459.   TregMemBuffer[16] = 0;
  1460.   TregMemBuffer[20] = 0;
  1461.   TregMemBuffer[24] = 0;
  1462.   TregMemBuffer[28] = 0;
  1463.   Uint32 tmpHabitant = ~0;
  1465.   while (RnoOfInstructions < 8000) {
  1466.     /* ---------------------------------------------------------------- */
  1467.     /* EXECUTE THE NEXT INTERPRETER INSTRUCTION.                        */
  1468.     /* ---------------------------------------------------------------- */
  1469.     RnoOfInstructions++;
  1470.     theInstruction = TcurrentProgram[TprogramCounter];
  1471.     theRegister = Interpreter::getReg1(theInstruction) << 2;
  1472.     if (TprogramCounter < TcurrentSize) {
  1473.       TprogramCounter++;
  1474.       switch (Interpreter::getOpCode(theInstruction)) {
  1475.       case Interpreter::READ_ATTR_INTO_REG:
  1476. jam();
  1477. /* ---------------------------------------------------------------- */
  1478. // Read an attribute from the tuple into a register.
  1479. // While reading an attribute we allow the attribute to be an array
  1480. // as long as it fits in the 64 bits of the register.
  1481. /* ---------------------------------------------------------------- */
  1482. {
  1483.   Uint32 theAttrinfo = theInstruction;
  1484.   int TnoDataRW= readAttributes(pagePtr,
  1485. TupHeadOffset,
  1486. &theAttrinfo,
  1487. (Uint32)1,
  1488. &TregMemBuffer[theRegister],
  1489. (Uint32)3,
  1490. false);
  1491.   if (TnoDataRW == 2) {
  1492.     /* ------------------------------------------------------------- */
  1493.     // Two words read means that we get the instruction plus one 32 
  1494.     // word read. Thus we set the register to be a 32 bit register.
  1495.     /* ------------------------------------------------------------- */
  1496.     TregMemBuffer[theRegister] = 0x50;
  1497.             * (Int64*)(TregMemBuffer+theRegister+2) = TregMemBuffer[theRegister+1];
  1498.   } else if (TnoDataRW == 3) {
  1499.     /* ------------------------------------------------------------- */
  1500.     // Three words read means that we get the instruction plus two 
  1501.     // 32 words read. Thus we set the register to be a 64 bit register.
  1502.     /* ------------------------------------------------------------- */
  1503.     TregMemBuffer[theRegister] = 0x60;
  1504.             TregMemBuffer[theRegister+3] = TregMemBuffer[theRegister+2];
  1505.             TregMemBuffer[theRegister+2] = TregMemBuffer[theRegister+1];
  1506.   } else if (TnoDataRW == 1) {
  1507.     /* ------------------------------------------------------------- */
  1508.     // One word read means that we must have read a NULL value. We set
  1509.     // the register to indicate a NULL value.
  1510.     /* ------------------------------------------------------------- */
  1511.     TregMemBuffer[theRegister] = 0;
  1512.     TregMemBuffer[theRegister + 2] = 0;
  1513.     TregMemBuffer[theRegister + 3] = 0;
  1514.   } else if (TnoDataRW == -1) {
  1515.     jam();
  1516.     tupkeyErrorLab(signal);
  1517.     return -1;
  1518.   } else {
  1519.     /* ------------------------------------------------------------- */
  1520.     // Any other return value from the read attribute here is not 
  1521.     // allowed and will lead to a system crash.
  1522.     /* ------------------------------------------------------------- */
  1523.     ndbrequire(false);
  1524.   }//if
  1525.   break;
  1526. }
  1528.       case Interpreter::WRITE_ATTR_FROM_REG:
  1529. jam();
  1530. {
  1531.   Uint32 TattrId = theInstruction >> 16;
  1532.   Uint32 TattrDescrIndex = tabptr.p->tabDescriptor +
  1533.     (TattrId << ZAD_LOG_SIZE);
  1534.   Uint32 TattrDesc1 = tableDescriptor[TattrDescrIndex].tabDescr;
  1535.   Uint32 TregType = TregMemBuffer[theRegister];
  1537.   /* --------------------------------------------------------------- */
  1538.   // Calculate the number of words of this attribute.
  1539.   // We allow writes into arrays as long as they fit into the 64 bit
  1540.   // register size.
  1541.   //TEST_MR See to that TattrNoOfWords can be 
  1542.   // read faster from attribute description.
  1543.   /* --------------------------------------------------------------- */
  1544.   Uint32 TarraySize = (TattrDesc1 >> 16);
  1545.   Uint32 TattrLogLen = (TattrDesc1 >> 4) & 0xf;
  1546.   Uint32 TattrNoOfBits = TarraySize << TattrLogLen;
  1547.   Uint32 TattrNoOfWords = (TattrNoOfBits + 31) >> 5;
  1548.   Uint32 Toptype = operPtr.p->optype;
  1550.   Uint32 TdataForUpdate[3];
  1551.   Uint32 Tlen;
  1553.   AttributeHeader& ah = AttributeHeader::init(&TdataForUpdate[0], 
  1554.       TattrId, TattrNoOfWords);
  1555.   TdataForUpdate[1] = TregMemBuffer[theRegister + 2];
  1556.   TdataForUpdate[2] = TregMemBuffer[theRegister + 3];
  1557.   Tlen = TattrNoOfWords + 1;
  1558.   if (Toptype == ZUPDATE) {
  1559.     if (TattrNoOfWords <= 2) {
  1560.       if (TregType == 0) {
  1561. /* --------------------------------------------------------- */
  1562. // Write a NULL value into the attribute
  1563. /* --------------------------------------------------------- */
  1564. ah.setNULL();
  1565. Tlen = 1;
  1566.       }//if
  1567.       int TnoDataRW= updateAttributes(pagePtr,
  1568.       TupHeadOffset,
  1569.       &TdataForUpdate[0],
  1570.       Tlen);
  1571.       if (TnoDataRW != -1) {
  1572. /* --------------------------------------------------------- */
  1573. // Write the written data also into the log buffer so that it 
  1574. // will be logged.
  1575. /* --------------------------------------------------------- */
  1576. logMemory[TdataWritten + 0] = TdataForUpdate[0];
  1577. logMemory[TdataWritten + 1] = TdataForUpdate[1];
  1578. logMemory[TdataWritten + 2] = TdataForUpdate[2];
  1579. TdataWritten += Tlen;
  1580.       } else {
  1581. tupkeyErrorLab(signal);
  1582. return -1;
  1583.       }//if
  1584.     } else {
  1585.       return TUPKEY_abort(signal, 15);
  1586.     }//if
  1587.   } else {
  1588.     return TUPKEY_abort(signal, 16);
  1589.   }//if
  1590.   break;
  1591. }
  1593.       case Interpreter::LOAD_CONST_NULL:
  1594. jam();
  1595. TregMemBuffer[theRegister] = 0; /* NULL INDICATOR */
  1596. break;
  1598.       case Interpreter::LOAD_CONST16:
  1599. jam();
  1600. TregMemBuffer[theRegister] = 0x50; /* 32 BIT UNSIGNED CONSTANT */
  1601. * (Int64*)(TregMemBuffer+theRegister+2) = theInstruction >> 16;
  1602. break;
  1604.       case Interpreter::LOAD_CONST32:
  1605. jam();
  1606. TregMemBuffer[theRegister] = 0x50; /* 32 BIT UNSIGNED CONSTANT */
  1607. * (Int64*)(TregMemBuffer+theRegister+2) = * 
  1608.   (TcurrentProgram+TprogramCounter);
  1609. TprogramCounter++;
  1610. break;
  1612.       case Interpreter::LOAD_CONST64:
  1613. jam();
  1614. TregMemBuffer[theRegister] = 0x60; /* 64 BIT UNSIGNED CONSTANT */
  1615.         TregMemBuffer[theRegister + 2 ] = * (TcurrentProgram + TprogramCounter++);
  1616.         TregMemBuffer[theRegister + 3 ] = * (TcurrentProgram + TprogramCounter++);
  1617. break;
  1619.       case Interpreter::ADD_REG_REG:
  1620. jam();
  1621. {
  1622.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1623.   Uint32 TdestRegister = Interpreter::getReg3(theInstruction) << 2;
  1625.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1626.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1627.   
  1629.   Uint32 TleftType = TregMemBuffer[theRegister];
  1630.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1631.          
  1632.   if ((TleftType | TrightType) != 0) {
  1633.     Uint64 Tdest0 = Tleft0 + Tright0;
  1634.     * (Int64*)(TregMemBuffer+TdestRegister+2) = Tdest0;
  1635.     TregMemBuffer[TdestRegister] = 0x60;
  1636.   } else {
  1637.     return TUPKEY_abort(signal, 20);
  1638.   }
  1639.   break;
  1640. }
  1642.       case Interpreter::SUB_REG_REG:
  1643. jam();
  1644. {
  1645.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1646.   Uint32 TdestRegister = Interpreter::getReg3(theInstruction) << 2;
  1648.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1649.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1650.   
  1651.   Uint32 TleftType = TregMemBuffer[theRegister];
  1652.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1653.          
  1654.   if ((TleftType | TrightType) != 0) {
  1655.     Int64 Tdest0 = Tleft0 - Tright0;
  1656.     * (Int64*)(TregMemBuffer+TdestRegister+2) = Tdest0;
  1657.     TregMemBuffer[TdestRegister] = 0x60;
  1658.   } else {
  1659.     return TUPKEY_abort(signal, 20);
  1660.   }
  1661.   break;
  1662. }
  1664.       case Interpreter::BRANCH:
  1665. TprogramCounter = brancher(theInstruction, TprogramCounter);
  1666. break;
  1668.       case Interpreter::BRANCH_REG_EQ_NULL:
  1669. if (TregMemBuffer[theRegister] != 0) {
  1670.   jam();
  1671.   continue;
  1672. } else {
  1673.   jam();
  1674.   TprogramCounter = brancher(theInstruction, TprogramCounter);
  1675. }//if
  1676. break;
  1678.       case Interpreter::BRANCH_REG_NE_NULL:
  1679. if (TregMemBuffer[theRegister] == 0) {
  1680.   jam();
  1681.   continue;
  1682. } else {
  1683.   jam();
  1684.   TprogramCounter = brancher(theInstruction, TprogramCounter);
  1685. }//if
  1686. break;
  1689.       case Interpreter::BRANCH_EQ_REG_REG:
  1690. {
  1691.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1693.   Uint32 TleftType = TregMemBuffer[theRegister];
  1694.   Uint32 Tleft0    = TregMemBuffer[theRegister + 2];
  1695.   Uint32 Tleft1    = TregMemBuffer[theRegister + 3];
  1697.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1698.   Uint32 Tright0 = TregMemBuffer[TrightRegister + 2];
  1699.   Uint32 Tright1 = TregMemBuffer[TrightRegister + 3];
  1700.   if ((TrightType | TleftType) != 0) {
  1701.     jam();
  1702.     if ((Tleft0 == Tright0) && (Tleft1 == Tright1)) {
  1703.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1704.     }//if
  1705.   } else {
  1706.     return TUPKEY_abort(signal, 23);
  1707.   }//if
  1708.   break;
  1709. }
  1711.       case Interpreter::BRANCH_NE_REG_REG:
  1712. {
  1713.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1715.   Uint32 TleftType = TregMemBuffer[theRegister];
  1716.   Uint32 Tleft0    = TregMemBuffer[theRegister + 2];
  1717.   Uint32 Tleft1    = TregMemBuffer[theRegister + 3];
  1719.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1720.   Uint32 Tright0 = TregMemBuffer[TrightRegister + 2];
  1721.   Uint32 Tright1 = TregMemBuffer[TrightRegister + 3];
  1722.   if ((TrightType | TleftType) != 0) {
  1723.     jam();
  1724.     if ((Tleft0 != Tright0) || (Tleft1 != Tright1)) {
  1725.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1726.     }//if
  1727.   } else {
  1728.     return TUPKEY_abort(signal, 24);
  1729.   }//if
  1730.   break;
  1731. }
  1733.       case Interpreter::BRANCH_LT_REG_REG:
  1734. {
  1735.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1737.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1738.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1739.   
  1740.   Uint32 TleftType = TregMemBuffer[theRegister];
  1741.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1742.          
  1744.   if ((TrightType | TleftType) != 0) {
  1745.     jam();
  1746.     if (Tleft0 < Tright0) {
  1747.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1748.     }//if
  1749.   } else {
  1750.     return TUPKEY_abort(signal, 24);
  1751.   }//if
  1752.   break;
  1753. }
  1755.       case Interpreter::BRANCH_LE_REG_REG:
  1756. {
  1757.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1759.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1760.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1761.   
  1762.   Uint32 TleftType = TregMemBuffer[theRegister];
  1763.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1764.   
  1766.   if ((TrightType | TleftType) != 0) {
  1767.     jam();
  1768.     if (Tleft0 <= Tright0) {
  1769.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1770.     }//if
  1771.   } else {
  1772.     return TUPKEY_abort(signal, 26);
  1773.   }//if
  1774.   break;
  1775. }
  1777.       case Interpreter::BRANCH_GT_REG_REG:
  1778. {
  1779.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1781.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1782.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1783.   
  1784.   Uint32 TleftType = TregMemBuffer[theRegister];
  1785.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1786.   
  1788.   if ((TrightType | TleftType) != 0) {
  1789.     jam();
  1790.     if (Tleft0 > Tright0){
  1791.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1792.     }//if
  1793.   } else {
  1794.     return TUPKEY_abort(signal, 27);
  1795.   }//if
  1796.   break;
  1797. }
  1799.       case Interpreter::BRANCH_GE_REG_REG:
  1800. {
  1801.   Uint32 TrightRegister = Interpreter::getReg2(theInstruction) << 2;
  1803.   Uint32 TrightType = TregMemBuffer[TrightRegister];
  1804.   Int64 Tright0 = * (Int64*)(TregMemBuffer + TrightRegister + 2);
  1805.   
  1806.   Uint32 TleftType = TregMemBuffer[theRegister];
  1807.   Int64 Tleft0 = * (Int64*)(TregMemBuffer + theRegister + 2);
  1808.   
  1810.   if ((TrightType | TleftType) != 0) {
  1811.     jam();
  1812.     if (Tleft0 >= Tright0){
  1813.       TprogramCounter = brancher(theInstruction, TprogramCounter);
  1814.     }//if
  1815.   } else {
  1816.     return TUPKEY_abort(signal, 28);
  1817.   }//if
  1818.   break;
  1819. }
  1821.       case Interpreter::BRANCH_ATTR_OP_ARG:{
  1822. jam();
  1823. Uint32 cond = Interpreter::getBinaryCondition(theInstruction);
  1824. Uint32 diff = Interpreter::getArrayLengthDiff(theInstruction);
  1825. Uint32 vchr = Interpreter::isVarchar(theInstruction);
  1826.         Uint32 nopad =Interpreter::isNopad(theInstruction);
  1827. Uint32 ins2 = TcurrentProgram[TprogramCounter];
  1828. Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16;
  1829. Uint32 argLen = Interpreter::getBranchCol_Len(ins2);
  1831. if(tmpHabitant != attrId){
  1832.   Int32 TnoDataR = readAttributes(pagePtr,
  1833.   TupHeadOffset,
  1834.   &attrId, 1,
  1835.   tmpArea, tmpAreaSz,
  1836.                                           false);
  1837.   
  1838.   if (TnoDataR == -1) {
  1839.     jam();
  1840.     tupkeyErrorLab(signal);
  1841.     return -1;
  1842.   }
  1843.   tmpHabitant = attrId;
  1844. }
  1846. AttributeHeader ah(tmpArea[0]);
  1848.         const char* s1 = (char*)&tmpArea[1];
  1849.         const char* s2 = (char*)&TcurrentProgram[TprogramCounter+1];
  1850. Uint32 attrLen = (4 * ah.getDataSize()) - diff;
  1851.         if (vchr) {
  1852. #if NDB_VERSION_MAJOR >= 3
  1853.           bool vok = false;
  1854.           if (attrLen >= 2) {
  1855.             Uint32 vlen = (s1[0] << 8) | s1[1]; // big-endian
  1856.             s1 += 2;
  1857.             attrLen -= 2;
  1858.             if (attrLen >= vlen) {
  1859.               attrLen = vlen;
  1860.               vok = true;
  1861.             }
  1862.           }
  1863.           if (!vok) {
  1864.             terrorCode = ZREGISTER_INIT_ERROR;
  1865.             tupkeyErrorLab(signal);
  1866.             return -1;
  1867.           }
  1868. #else
  1869.           Uint32 tmp;
  1870.           if (attrLen >= 2) {
  1871.             unsigned char* ss = (unsigned char*)&s1[attrLen - 2];
  1872.             tmp = (ss[0] << 8) | ss[1];
  1873.             if (tmp <= attrLen - 2)
  1874.               attrLen = tmp;
  1875.           }
  1876.           // XXX handle bad data
  1877. #endif
  1878.         }
  1879.         bool res = false;
  1881.         switch ((Interpreter::BinaryCondition)cond) {
  1882.         case Interpreter::EQ:
  1883.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) == 0;
  1884.           break;
  1885.         case Interpreter::NE:
  1886.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) != 0;
  1887.           break;
  1888.         // note the condition is backwards
  1889.         case Interpreter::LT:
  1890.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) > 0;
  1891.           break;
  1892.         case Interpreter::LE:
  1893.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) >= 0;
  1894.           break;
  1895.         case Interpreter::GT:
  1896.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) < 0;
  1897.           break;
  1898.         case Interpreter::GE:
  1899.           res = NdbSqlUtil::char_compare(s1, attrLen, s2, argLen, !nopad) <= 0;
  1900.           break;
  1901.         case Interpreter::LIKE:
  1902.           res = NdbSqlUtil::char_like(s1, attrLen, s2, argLen, !nopad);
  1903.           break;
  1904.         case Interpreter::NOT_LIKE:
  1905.           res = ! NdbSqlUtil::char_like(s1, attrLen, s2, argLen, !nopad);
  1906.           break;
  1907.         // XXX handle invalid value
  1908.         }
  1909. #ifdef TRACE_INTERPRETER
  1910.   ndbout_c("cond=%u diff=%d vc=%d nopad=%d attr(%d) = >%.*s<(%d) str=>%.*s<(%d) -> res = %d",
  1911.    cond, diff, vchr, nopad,
  1912.    attrId >> 16, attrLen, s1, attrLen, argLen, s2, argLen, res);
  1913. #endif
  1914.         if (res)
  1915.           TprogramCounter = brancher(theInstruction, TprogramCounter);
  1916.         else {
  1917.           Uint32 tmp = (Interpreter::mod4(argLen) >> 2) + 1;
  1918.           TprogramCounter += tmp;
  1919.         }
  1920. break;
  1921.       }
  1923.       case Interpreter::BRANCH_ATTR_EQ_NULL:{
  1924. jam();
  1925. Uint32 ins2 = TcurrentProgram[TprogramCounter];
  1926. Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16;
  1928. if(tmpHabitant != attrId){
  1929.   Int32 TnoDataR = readAttributes(pagePtr,
  1930.   TupHeadOffset,
  1931.   &attrId, 1,
  1932.   tmpArea, tmpAreaSz,
  1933.                                           false);
  1934.   
  1935.   if (TnoDataR == -1) {
  1936.     jam();
  1937.     tupkeyErrorLab(signal);
  1938.     return -1;
  1939.   }
  1940.   tmpHabitant = attrId;
  1941. }
  1943. AttributeHeader ah(tmpArea[0]);
  1944. if(ah.isNULL()){
  1945.   TprogramCounter = brancher(theInstruction, TprogramCounter);
  1946. } else {
  1947.   TprogramCounter ++;
  1948. }
  1949. break;
  1950.       }
  1952.       case Interpreter::BRANCH_ATTR_NE_NULL:{
  1953. jam();
  1954. Uint32 ins2 = TcurrentProgram[TprogramCounter];
  1955. Uint32 attrId = Interpreter::getBranchCol_AttrId(ins2) << 16;
  1957. if(tmpHabitant != attrId){
  1958.   Int32 TnoDataR = readAttributes(pagePtr,
  1959.   TupHeadOffset,
  1960.   &attrId, 1,
  1961.   tmpArea, tmpAreaSz,
  1962.                                           false);
  1963.   
  1964.   if (TnoDataR == -1) {
  1965.     jam();
  1966.     tupkeyErrorLab(signal);
  1967.     return -1;
  1968.   }
  1969.   tmpHabitant = attrId;
  1970. }
  1972. AttributeHeader ah(tmpArea[0]);
  1973. if(ah.isNULL()){
  1974.   TprogramCounter ++;
  1975. } else {
  1976.   TprogramCounter = brancher(theInstruction, TprogramCounter);
  1977. }
  1978. break;
  1979.       }
  1981.       case Interpreter::EXIT_OK:
  1982. jam();
  1983. #ifdef TRACE_INTERPRETER
  1984. ndbout_c(" - exit_ok");
  1985. #endif
  1986. return TdataWritten;
  1988.       case Interpreter::EXIT_OK_LAST:
  1989. jam();
  1990. #ifdef TRACE_INTERPRETER
  1991. ndbout_c(" - exit_ok_last");
  1992. #endif
  1993. operPtr.p->lastRow = 1;
  1994. return TdataWritten;
  1996.       case Interpreter::EXIT_REFUSE:
  1997. jam();
  1998. #ifdef TRACE_INTERPRETER
  1999. ndbout_c(" - exit_nok");
  2000. #endif
  2001. terrorCode = theInstruction >> 16;
  2002. return TUPKEY_abort(signal, 29);
  2004.       case Interpreter::CALL:
  2005. jam();
  2006. RstackPtr++;
  2007. if (RstackPtr < 32) {
  2008.   TstackMemBuffer[RstackPtr] = TprogramCounter + 1;
  2009.   TprogramCounter = theInstruction >> 16;
  2010.   if (TprogramCounter < TsubroutineLen) {
  2011.     TcurrentProgram = subroutineProg;
  2012.     TcurrentSize = TsubroutineLen;
  2013.   } else {
  2014.     return TUPKEY_abort(signal, 30);
  2015.   }//if
  2016. } else {
  2017.   return TUPKEY_abort(signal, 31);
  2018. }//if
  2019. break;
  2021.       case Interpreter::RETURN:
  2022. jam();
  2023. if (RstackPtr > 0) {
  2024.   TprogramCounter = TstackMemBuffer[RstackPtr];
  2025.   RstackPtr--;
  2026.   if (RstackPtr == 0) {
  2027.     jam();
  2028.     /* ------------------------------------------------------------- */
  2029.     // We are back to the main program.
  2030.     /* ------------------------------------------------------------- */
  2031.     TcurrentProgram = mainProgram;
  2032.     TcurrentSize = TmainProgLen;
  2033.   }//if
  2034. } else {
  2035.   return TUPKEY_abort(signal, 32);
  2036. }//if
  2037. break;
  2039.       default:
  2040. return TUPKEY_abort(signal, 33);
  2041.       }//switch
  2042.     } else {
  2043.       return TUPKEY_abort(signal, 34);
  2044.     }//if
  2045.   }//while
  2046.   return TUPKEY_abort(signal, 35);
  2047. }//Dbtup::interpreterNextLab()