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

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

MySQL数据库

开发平台：

Visual C++

DbtupAbort.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>
  23. #define ljam() { jamLine(9000 + __LINE__); }
  24. #define ljamEntry() { jamEntryLine(9000 + __LINE__); }
  26. void Dbtup::freeAllAttrBuffers(Operationrec*  const regOperPtr)
  27. {
  28.   if (regOperPtr->storedProcedureId == ZNIL) {
  29.     ljam();
  30.     freeAttrinbufrec(regOperPtr->firstAttrinbufrec);
  31.   } else {
  32.     StoredProcPtr storedPtr;
  33.     c_storedProcPool.getPtr(storedPtr, (Uint32)regOperPtr->storedProcedureId);
  34.     ndbrequire(storedPtr.p->storedCode == ZSCAN_PROCEDURE);
  35.     ljam();
  36.     storedPtr.p->storedCounter--;
  37.     regOperPtr->storedProcedureId = ZNIL;
  38.   }//if
  39.   regOperPtr->firstAttrinbufrec = RNIL;
  40.   regOperPtr->lastAttrinbufrec = RNIL;
  41. }//Dbtup::freeAllAttrBuffers()
  43. void Dbtup::freeAttrinbufrec(Uint32 anAttrBuf) 
  44. {
  45.   Uint32 Ttemp;
  46.   AttrbufrecPtr localAttrBufPtr;
  47.   Uint32 RnoFree = cnoFreeAttrbufrec;
  48.   localAttrBufPtr.i = anAttrBuf;
  49.   while (localAttrBufPtr.i != RNIL) {
  50.     ljam();
  51.     ptrCheckGuard(localAttrBufPtr, cnoOfAttrbufrec, attrbufrec);
  52.     Ttemp = localAttrBufPtr.p->attrbuf[ZBUF_NEXT];
  53.     localAttrBufPtr.p->attrbuf[ZBUF_NEXT] = cfirstfreeAttrbufrec;
  54.     cfirstfreeAttrbufrec = localAttrBufPtr.i;
  55.     localAttrBufPtr.i = Ttemp;
  56.     RnoFree++;
  57.   }//if
  58.   cnoFreeAttrbufrec = RnoFree;
  59. }//Dbtup::freeAttrinbufrec()
  61. /* ----------------------------------------------------------------- */
  62. /* ----------- ABORT THIS PART OF THE TRANSACTION ------------------ */
  63. /* ----------------------------------------------------------------- */
  64. void Dbtup::execTUP_ABORTREQ(Signal* signal) 
  65. {
  66.   OperationrecPtr regOperPtr;
  67.   FragrecordPtr regFragPtr;
  68.   TablerecPtr regTabPtr;
  70.   ljamEntry();
  71.   regOperPtr.i = signal->theData[0];
  72.   ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec);
  73.   ndbrequire((regOperPtr.p->transstate == STARTED) ||
  74.              (regOperPtr.p->transstate == TOO_MUCH_AI) ||
  75.              (regOperPtr.p->transstate == ERROR_WAIT_TUPKEYREQ) ||
  76.              (regOperPtr.p->transstate == IDLE));
  77.   if (regOperPtr.p->optype == ZREAD) {
  78.     ljam();
  79.     freeAllAttrBuffers(regOperPtr.p);
  80.     initOpConnection(regOperPtr.p, 0);
  81.     return;
  82.   }//if
  84.   regTabPtr.i = regOperPtr.p->tableRef;
  85.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  87.   regFragPtr.i = regOperPtr.p->fragmentPtr;
  88.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  90.   // XXX should be integrated into the code that comes after
  91.   if (!regTabPtr.p->tuxCustomTriggers.isEmpty() &&
  92.       regOperPtr.p->tupleState == NO_OTHER_OP) {
  93.     ljam();
  94.     executeTuxAbortTriggers(signal,
  95.                             regOperPtr.p,
  96.                             regTabPtr.p);
  97.     OperationrecPtr loopOpPtr;
  98.     loopOpPtr.i = regOperPtr.p->prevActiveOp;
  99.     while (loopOpPtr.i != RNIL) {
  100.       ljam();
  101.       ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  102.       if (loopOpPtr.p->tupleState != ALREADY_ABORTED) {
  103.         ljam();
  104.         executeTuxAbortTriggers(signal,
  105.                                 loopOpPtr.p,
  106.                                 regTabPtr.p);
  107.       }
  108.       loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  109.     }
  110.   }
  112.   Uint32 prevActiveOp = regOperPtr.p->prevActiveOp;
  113.   removeActiveOpList(regOperPtr.p);
  114.   if (regOperPtr.p->tupleState == NO_OTHER_OP) {
  115.     if (prevActiveOp == RNIL) {
  116.       ljam();
  117.       abortUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p);
  118.     } else { //prevActiveOp != RNIL
  119.       setTupleStateOnPreviousOps(prevActiveOp);
  120.       if (regOperPtr.p->optype == ZDELETE) {
  121.         ljam();
  122.         OperationrecPtr prevOpPtr;
  123.         prevOpPtr.i = prevActiveOp;
  124.         ptrCheckGuard(prevOpPtr, cnoOfOprec, operationrec);
  125.         ndbrequire(prevOpPtr.p->realPageIdC != RNIL);
  126.         ndbrequire(prevOpPtr.p->optype == ZINSERT);
  127.         abortUpdate(signal, prevOpPtr.p, regFragPtr.p, regTabPtr.p);
  128.       } else {
  129.         jam();
  130.         abortUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p);
  131.       }//if
  132.     }//if
  133.   } else {
  134.     ndbrequire(regOperPtr.p->tupleState == ALREADY_ABORTED);
  135.     commitUpdate(signal, regOperPtr.p, regFragPtr.p, regTabPtr.p);
  136.   }//if
  137.   initOpConnection(regOperPtr.p, regFragPtr.p);
  138. }//execTUP_ABORTREQ()
  140. void Dbtup::setTupleStateOnPreviousOps(Uint32 prevOpIndex)
  141. {
  142.   OperationrecPtr loopOpPtr;
  143.   loopOpPtr.i = prevOpIndex;
  144.   do {
  145.     ljam();
  146.     ptrCheckGuard(loopOpPtr, cnoOfOprec, operationrec);
  147.     loopOpPtr.p->tupleState = ALREADY_ABORTED;
  148.     loopOpPtr.i = loopOpPtr.p->prevActiveOp;
  149.   } while (loopOpPtr.i != RNIL);
  150. }//Dbtup::setTupleStateOnPreviousOps()
  152. /* ---------------------------------------------------------------- */
  153. /* ------------ PERFORM AN ABORT OF AN UPDATE OPERATION ----------- */
  154. /* ---------------------------------------------------------------- */
  155. void Dbtup::abortUpdate(Signal* signal,
  156.                         Operationrec*  const regOperPtr,
  157.                         Fragrecord* const regFragPtr,
  158.                         Tablerec* const regTabPtr)
  159. {
  160.    /* RESTORE THE ORIGINAL DATA */
  161.    /* THE OPER_PTR ALREADY CONTAINS BOTH THE PAGE AND THE COPY PAGE */
  162.   if (regOperPtr->realPageIdC != RNIL) {
  163.     ljam();
  164.          /***********************/
  165.          /* CHECKPOINT SPECIFIC */
  166.          /***********************/
  167.     if (isUndoLoggingNeeded(regFragPtr, regOperPtr->fragPageIdC)) {
  168.       if (regOperPtr->undoLogged) {
  169.         ljam();
  170. /* ---------------------------------------------------------------- */
  171. /*       THE UPDATE WAS MADE AFTER THE LOCAL CHECKPOINT STARTED.    */
  172. /*       THUS THE ORIGINAL TUPLE WILL BE RESTORED BY A LOG RECORD   */
  173. /*       CREATED WHEN UPDATING. THUS IT IS ENOUGH TO LOG THE UNDO   */
  174. /*       OF THE COPY RELEASE == INSERT THE COPY TUPLE HEADER WITH   */
  175. /*       NO DATA.                                                   */
  176. /* ---------------------------------------------------------------- */
  177.         cprAddUndoLogRecord(signal,
  178.                             ZLCPR_TYPE_INSERT_TH_NO_DATA,
  179.                             regOperPtr->fragPageIdC,
  180.                             regOperPtr->pageIndexC,
  181.                             regOperPtr->tableRef,
  182.                             regOperPtr->fragId,
  183.                             regFragPtr->checkpointVersion);
  184.       } else {
  185.         ljam();
  186. /* ---------------------------------------------------------------- */
  187. /*       THE UPDATE WAS MADE BEFORE THE LOCAL CHECKPOINT STARTED.   */
  188. /*       THE TUPLE WILL THUS BE RESTORED BY COPYING FROM THE COPY.  */
  189. /*       THUS WE DO NOT NEED TO RESTORE THE DATA IN THE ORIGINAL.   */
  190. /*       WE DO HOWEVER NEED TO ENSURE THAT THE COPY CONTAINS THE    */
  191. /*       CORRECT DATA.                                              */
  192. /* ---------------------------------------------------------------- */
  193.         cprAddUndoLogRecord(signal,
  194.                             ZLCPR_TYPE_INSERT_TH,
  195.                             regOperPtr->fragPageIdC,
  196.                             regOperPtr->pageIndexC,
  197.                             regOperPtr->tableRef,
  198.                             regOperPtr->fragId,
  199.                             regFragPtr->checkpointVersion);
  200.         cprAddData(signal,
  201.                    regFragPtr,
  202.                    regOperPtr->realPageIdC,
  203.                    regTabPtr->tupheadsize,
  204.                    regOperPtr->pageOffsetC);
  205.       }//if
  206.     }//if
  207.     Uint32 rpid = regOperPtr->realPageId;
  208.     Uint32 rpid_copy = regOperPtr->realPageIdC;
  209.     Uint32 offset = regOperPtr->pageOffset;
  210.     Uint32 offset_copy = regOperPtr->pageOffsetC;
  211.     Uint32 tuple_size = regTabPtr->tupheadsize;
  212.     Uint32 end = offset + tuple_size;
  213.     Uint32 end_copy = offset_copy + tuple_size;
  214.     ndbrequire(rpid < cnoOfPage &&
  215.                rpid_copy < cnoOfPage &&
  216.                end <= ZWORDS_ON_PAGE &&
  217.                end_copy <= ZWORDS_ON_PAGE);
  218.     void* Tdestination = (void*)&page[rpid].pageWord[offset + 1];
  219.     const void* Tsource = (void*)&page[rpid_copy].pageWord[offset_copy + 1];
  220.     MEMCOPY_NO_WORDS(Tdestination, Tsource, (tuple_size - 1));
  221.     {
  222.       PagePtr pagePtr;
  224.       pagePtr.i = rpid_copy;
  225.       ptrAss(pagePtr, page);
  226.       freeTh(regFragPtr,
  227.              regTabPtr,
  228.              signal,
  229.              pagePtr.p,
  230.              offset_copy);
  231.     }
  232.     regOperPtr->realPageIdC = RNIL;
  233.     regOperPtr->fragPageIdC = RNIL;
  234.     regOperPtr->pageOffsetC = ZNIL;
  235.     regOperPtr->pageIndexC = ZNIL;
  236.   }//if
  237. }//Dbtup::abortUpdate()
  239. /* **************************************************************** */
  240. /* ********************** TRANSACTION ERROR MODULE **************** */
  241. /* **************************************************************** */
  242. int Dbtup::TUPKEY_abort(Signal* signal, int error_type)
  243. {
  244.   switch(error_type) {
  245.   case 0:
  246.     ndbrequire(false);
  247.     break;
  248. // Not used currently
  250.   case 1:
  251. //tmupdate_alloc_error:
  252.     ljam();
  253.     break;
  255.   case 2:
  256.     ndbrequire(false);
  257.     break;
  258. // Not used currently
  260.     break;
  262.   case 3:
  263. //tmupdate_alloc_error:
  264.     ljam();
  265.     break;
  267.   case 4:
  268. //Trying to read non-existing attribute identity
  269.     ljam();
  270.     terrorCode = ZATTRIBUTE_ID_ERROR;
  271.     break;
  273.   case 6:
  274.     ljam();
  275.     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
  276.     break;
  278.   case 7:
  279.     ljam();
  280.     terrorCode = ZAI_INCONSISTENCY_ERROR;
  281.     break;
  283.   case 8:
  284.     ljam();
  285.     terrorCode = ZATTR_INTERPRETER_ERROR;
  286.     break;
  288.   case 9:
  289.     ljam();
  290. //Trying to read non-existing attribute identity
  291.     ljam();
  292.     terrorCode = ZATTRIBUTE_ID_ERROR;
  293.     break;
  295.   case 11:
  296.     ljam();
  297.     terrorCode = ZATTR_INTERPRETER_ERROR;
  298.     break;
  300.   case 12:
  301.     ljam();
  302.     ndbrequire(false);
  303.     break;
  305.   case 13:
  306.     ljam();
  307.     ndbrequire(false);
  308.     break;
  310.   case 14:
  311.     ljam();
  312.     terrorCode = ZREGISTER_INIT_ERROR;
  313.     break;
  315.   case 15:
  316.     ljam();
  317.     terrorCode = ZREGISTER_INIT_ERROR;
  318.     break;
  320.   case 16:
  321.     ljam();
  322.     terrorCode = ZTRY_TO_UPDATE_ERROR;
  323.     break;
  325.   case 17:
  326.     ljam();
  327.     terrorCode = ZNO_ILLEGAL_NULL_ATTR;
  328.     break;
  330.   case 18:
  331.     ljam();
  332.     terrorCode = ZNOT_NULL_ATTR;
  333.     break;
  335.   case 19:
  336.     ljam();
  337.     terrorCode = ZTRY_TO_UPDATE_ERROR;
  338.     break;
  340.   case 20:
  341.     ljam();
  342.     terrorCode = ZREGISTER_INIT_ERROR;
  343.     break;
  345.   case 21:
  346.     ljam();
  347.     terrorCode = ZREGISTER_INIT_ERROR;
  348.     break;
  350.   case 22:
  351.     ljam();
  352.     terrorCode = ZTOTAL_LEN_ERROR;
  353.     break;
  355.   case 23:
  356.     ljam();
  357.     terrorCode = ZREGISTER_INIT_ERROR;
  358.     break;
  360.   case 24:
  361.     ljam();
  362.     terrorCode = ZREGISTER_INIT_ERROR;
  363.     break;
  365.   case 25:
  366.     ljam();
  367.     terrorCode = ZREGISTER_INIT_ERROR;
  368.     break;
  370.   case 26:
  371.     ljam();
  372.     terrorCode = ZREGISTER_INIT_ERROR;
  373.     break;
  375.   case 27:
  376.     ljam();
  377.     terrorCode = ZREGISTER_INIT_ERROR;
  378.     break;
  380.   case 28:
  381.     ljam();
  382.     terrorCode = ZREGISTER_INIT_ERROR;
  383.     break;
  385.   case 29:
  386.     ljam();
  387.     break;
  389.   case 30:
  390.     ljam();
  391.     terrorCode = ZCALL_ERROR;
  392.     break;
  394.   case 31:
  395.     ljam();
  396.     terrorCode = ZSTACK_OVERFLOW_ERROR;
  397.     break;
  399.   case 32:
  400.     ljam();
  401.     terrorCode = ZSTACK_UNDERFLOW_ERROR;
  402.     break;
  404.   case 33:
  405.     ljam();
  406.     terrorCode = ZNO_INSTRUCTION_ERROR;
  407.     break;
  409.   case 34:
  410.     ljam();
  411.     terrorCode = ZOUTSIDE_OF_PROGRAM_ERROR;
  412.     break;
  414.   case 35:
  415.     ljam();
  416.     terrorCode = ZTOO_MANY_INSTRUCTIONS_ERROR;
  417.     break;
  419.   case 36:
  420.     ljam();
  421.     terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  422.     break;
  424.   case 37:
  425.     ljam();
  426.     terrorCode = ZTEMPORARY_RESOURCE_FAILURE;
  427.     break;
  429.   case 38:
  430.     ljam();
  431.     terrorCode = ZTEMPORARY_RESOURCE_FAILURE;
  432.     break;
  434.   case 39:
  435.     ljam();
  436.     if (operPtr.p->transstate == TOO_MUCH_AI) {
  437.       ljam();
  438.       terrorCode = ZTOO_MUCH_ATTRINFO_ERROR;
  439.     } else if (operPtr.p->transstate == ERROR_WAIT_TUPKEYREQ) {
  440.       ljam();
  441.       terrorCode = ZSEIZE_ATTRINBUFREC_ERROR;
  442.     } else {
  443.       ndbrequire(false);
  444.     }//if
  445.     break;
  447.   default:
  448.     ndbrequire(false);
  449.     break;
  450.   }//switch
  451.   tupkeyErrorLab(signal);
  452.   return -1;
  453. }//Dbtup::TUPKEY_abort()
  455. void Dbtup::tupkeyErrorLab(Signal* signal) 
  456. {
  457.   Operationrec * const regOperPtr = operPtr.p;
  459.   freeAllAttrBuffers(regOperPtr);
  460.   abortUpdate(signal, regOperPtr, fragptr.p, tabptr.p);
  461.   removeActiveOpList(regOperPtr);
  462.   initOpConnection(regOperPtr, fragptr.p);
  463.   regOperPtr->transstate = IDLE;
  464.   regOperPtr->tupleState = NO_OTHER_OP;
  465.   TupKeyRef * const tupKeyRef = (TupKeyRef *)signal->getDataPtrSend();  
  467.   tupKeyRef->userRef = regOperPtr->userpointer;
  468.   tupKeyRef->errorCode = terrorCode;
  469.   sendSignal(regOperPtr->userblockref, GSN_TUPKEYREF, signal, 
  470.              TupKeyRef::SignalLength, JBB);
  471.   return;
  472. }//Dbtup::tupkeyErrorLab()