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

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

MySQL数据库

开发平台：

Visual C++

DbtupUndoLog.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>
  24. #define ljam() { jamLine(12000 + __LINE__); }
  25. #define ljamEntry() { jamEntryLine(12000 + __LINE__); }
  27. void Dbtup::cprAddData(Signal* signal,
  28.                        Fragrecord* const regFragPtr,
  29.                        Uint32 pageIndex,
  30.                        Uint32 noOfWords,
  31.                        Uint32 startOffset)
  32. {
  33.   UndoPagePtr undoPagePtr;
  34.   PagePtr pagePtr;
  35.   LocalLogInfoPtr regLliPtr;
  37.   regLliPtr.i = regFragPtr->checkpointVersion;
  38.   ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo);
  40.   pagePtr.i = pageIndex;
  41.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  42.   undoPagePtr.i = regLliPtr.p->lliUndoPage;
  43.   ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage);
  45.   startOffset++;
  46.   noOfWords--;
  47.   if ((regLliPtr.p->lliUndoWord + noOfWords) < ZWORDS_ON_PAGE) {
  48.     ljam();
  49.     MEMCOPY_NO_WORDS(&undoPagePtr.p->undoPageWord[regLliPtr.p->lliUndoWord],
  50.                      &pagePtr.p->pageWord[startOffset],
  51.                      noOfWords);
  52.     regLliPtr.p->lliUndoWord += noOfWords;
  53.   } else {
  54.     for (Uint32 i = 0; i < noOfWords; i++) {
  55.       ljam();
  56.       Uint32 undoWord = pagePtr.p->pageWord[startOffset + i];
  57.       cprAddUndoLogWord(signal, regLliPtr.p, undoWord);
  58.     }//for
  59.   }//if
  60. }//Dbtup::cprAddData()
  62. void Dbtup::cprAddLogHeader(Signal* signal,
  63.                             LocalLogInfo* const lliPtr,
  64.                             Uint32 recordType,
  65.                             Uint32 tableId,
  66.                             Uint32 fragId)
  67. {
  68.   Uint32 prevRecId = lliPtr->lliPrevRecordId;
  69.   lliPtr->lliPrevRecordId = lliPtr->lliUndoWord + (lliPtr->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX);
  70.   cprAddUndoLogWord(signal, lliPtr, recordType);
  71.   cprAddUndoLogWord(signal, lliPtr, prevRecId);
  72.   cprAddUndoLogWord(signal, lliPtr, tableId);
  73.   cprAddUndoLogWord(signal, lliPtr, fragId);
  74. }//Dbtup::cprAddLogHeader()
  76. void Dbtup::cprAddGCIUpdate(Signal* signal,
  77.                             Uint32 prevGCI,
  78.                             Fragrecord* const regFragPtr)
  79. {
  80.   LocalLogInfoPtr regLliPtr;
  81.   regLliPtr.i = regFragPtr->checkpointVersion;
  82.   ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo);
  84.   cprAddUndoLogWord(signal, regLliPtr.p, prevGCI);
  85. }//Dbtup::cprAddLogHeader()
  87. void Dbtup::cprAddUndoLogPageHeader(Signal* signal,
  88.                                     Page* const regPagePtr,
  89.                                     Fragrecord* const regFragPtr)
  90. {
  91.   UndoPagePtr regUndoPagePtr;
  92.   LocalLogInfoPtr regLliPtr;
  94.   regLliPtr.i = regFragPtr->checkpointVersion;
  95.   ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo);
  97.   Uint32 prevRecId = regLliPtr.p->lliPrevRecordId;
  98.   Uint32 lliWord = regLliPtr.p->lliUndoWord;
  99.   regLliPtr.p->lliPrevRecordId = lliWord +
  100.                                  (regLliPtr.p->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX);
  101.   if ((lliWord + 7) < ZWORDS_ON_PAGE) {
  102.     ljam();
  103.     regUndoPagePtr.i = regLliPtr.p->lliUndoPage;
  104.     ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  106.     regUndoPagePtr.p->undoPageWord[lliWord] = ZLCPR_UNDO_LOG_PAGE_HEADER;
  107.     regUndoPagePtr.p->undoPageWord[lliWord + 1] = prevRecId;
  108.     regUndoPagePtr.p->undoPageWord[lliWord + 2] = regFragPtr->fragTableId;
  109.     regUndoPagePtr.p->undoPageWord[lliWord + 3] = regFragPtr->fragmentId;
  110.     regUndoPagePtr.p->undoPageWord[lliWord + 4] = regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS];
  111.     regUndoPagePtr.p->undoPageWord[lliWord + 5] = regPagePtr->pageWord[ZPAGE_STATE_POS];
  112.     regUndoPagePtr.p->undoPageWord[lliWord + 6] = regPagePtr->pageWord[ZPAGE_NEXT_POS];
  113.     regLliPtr.p->lliUndoWord = lliWord + 7;
  114.   } else {
  115.     ljam();
  116.     cprAddUndoLogWord(signal, regLliPtr.p, ZLCPR_UNDO_LOG_PAGE_HEADER);
  117.     cprAddUndoLogWord(signal, regLliPtr.p, prevRecId);
  118.     cprAddUndoLogWord(signal, regLliPtr.p, regFragPtr->fragTableId);
  119.     cprAddUndoLogWord(signal, regLliPtr.p, regFragPtr->fragmentId);
  120.     cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_FRAG_PAGE_ID_POS]);
  121.     cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_STATE_POS]);
  122.     cprAddUndoLogWord(signal, regLliPtr.p, regPagePtr->pageWord[ZPAGE_NEXT_POS]);
  123.   }//if
  124. }//Dbtup::cprAddUndoLogPageHeader()
  126. void Dbtup::cprAddUndoLogRecord(Signal* signal,
  127.                                 Uint32 recordType,
  128.                                 Uint32 pageId,
  129.                                 Uint32 pageIndex,
  130.                                 Uint32 tableId,
  131.                                 Uint32 fragId,
  132.                                 Uint32 localLogIndex)
  133. {
  134.   LocalLogInfoPtr regLliPtr;
  135.   UndoPagePtr regUndoPagePtr;
  137.   regLliPtr.i = localLogIndex;
  138.   ptrCheckGuard(regLliPtr, cnoOfParallellUndoFiles, localLogInfo);
  140.   Uint32 prevRecId = regLliPtr.p->lliPrevRecordId;
  141.   Uint32 lliWord = regLliPtr.p->lliUndoWord;
  143.   regLliPtr.p->lliPrevRecordId = lliWord +
  144.                                  (regLliPtr.p->lliLogFilePage << ZUNDO_RECORD_ID_PAGE_INDEX);
  145.   if ((lliWord + 6) < ZWORDS_ON_PAGE) {
  146.     ljam();
  147.     regUndoPagePtr.i = regLliPtr.p->lliUndoPage;
  148.     ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  149.     regUndoPagePtr.p->undoPageWord[lliWord] = recordType;
  150.     regUndoPagePtr.p->undoPageWord[lliWord + 1] = prevRecId;
  151.     regUndoPagePtr.p->undoPageWord[lliWord + 2] = tableId;
  152.     regUndoPagePtr.p->undoPageWord[lliWord + 3] = fragId;
  153.     regUndoPagePtr.p->undoPageWord[lliWord + 4] = pageId;
  154.     regUndoPagePtr.p->undoPageWord[lliWord + 5] = pageIndex;
  156.     regLliPtr.p->lliUndoWord = lliWord + 6;
  157.   } else {
  158.     ljam();
  159.     cprAddUndoLogWord(signal, regLliPtr.p, recordType);
  160.     cprAddUndoLogWord(signal, regLliPtr.p, prevRecId);
  161.     cprAddUndoLogWord(signal, regLliPtr.p, tableId);
  162.     cprAddUndoLogWord(signal, regLliPtr.p, fragId);
  163.     cprAddUndoLogWord(signal, regLliPtr.p, pageId);
  164.     cprAddUndoLogWord(signal, regLliPtr.p, pageIndex);
  165.   }//if
  166. }//Dbtup::cprAddUndoLogRecord()
  168. void Dbtup::cprAddAbortUpdate(Signal* signal,
  169.                               LocalLogInfo* const lliPtr,
  170.                               Operationrec* const regOperPtr) 
  171. {
  172.   Uint32 lliWord = lliPtr->lliUndoWord;
  173.   if ((lliWord + 4) < ZWORDS_ON_PAGE) {
  174.     ljam();
  175.     UndoPagePtr regUndoPagePtr;
  176.     regUndoPagePtr.i = lliPtr->lliUndoPage;
  177.     ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  179.     regUndoPagePtr.p->undoPageWord[lliWord] = regOperPtr->fragPageId;
  180.     regUndoPagePtr.p->undoPageWord[lliWord + 1] = regOperPtr->pageIndex;
  181.     regUndoPagePtr.p->undoPageWord[lliWord + 2] = regOperPtr->fragPageIdC;
  182.     regUndoPagePtr.p->undoPageWord[lliWord + 3] = regOperPtr->pageIndexC;
  183.     lliPtr->lliUndoWord = lliWord + 4;
  184.   } else {
  185.     ljam();
  186.     cprAddUndoLogWord(signal, lliPtr, regOperPtr->fragPageId);
  187.     cprAddUndoLogWord(signal, lliPtr, regOperPtr->pageIndex);
  188.     cprAddUndoLogWord(signal, lliPtr, regOperPtr->fragPageIdC);
  189.     cprAddUndoLogWord(signal, lliPtr, regOperPtr->pageIndexC);
  190.   }//if
  191. }//Dbtup::cprAddAbortUpdate()
  193. void Dbtup::cprAddUndoLogWord(Signal* signal, LocalLogInfo* const lliPtr, Uint32 undoWord) 
  194. {
  195.   DiskBufferSegmentInfoPtr dbsiPtr;
  196.   UndoPagePtr regUndoPagePtr;
  198.   ljam();
  199.   regUndoPagePtr.i = lliPtr->lliUndoPage;
  200.   ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  201.   ndbrequire(lliPtr->lliUndoWord < ZWORDS_ON_PAGE);
  202.   regUndoPagePtr.p->undoPageWord[lliPtr->lliUndoWord] = undoWord;
  204.   lliPtr->lliUndoWord++;
  205.   if (lliPtr->lliUndoWord == ZWORDS_ON_PAGE) {
  206.     ljam();
  207.     lliPtr->lliUndoWord = ZUNDO_PAGE_HEADER_SIZE;
  208.     lliPtr->lliUndoPage++;
  209.     if (clblPageCounter > 0) {
  210.       ljam();
  211.       clblPageCounter--;
  212.     }//if
  213.     dbsiPtr.i = lliPtr->lliUndoBufferSegmentP;
  214.     ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  215.     dbsiPtr.p->pdxNumDataPages++;
  216.     ndbrequire(dbsiPtr.p->pdxNumDataPages < 16);
  217.     lliPtr->lliLogFilePage++;
  218.     if (dbsiPtr.p->pdxNumDataPages == ZUB_SEGMENT_SIZE) {
  219.       ljam();
  220.       lcpWriteUndoSegment(signal, lliPtr, false);
  221.     }//if
  222.   }//if
  223. }//Dbtup::cprAddUndoLogWord()
  225. void Dbtup::lcpWriteUndoSegment(Signal* signal, LocalLogInfo* const lliPtr, bool flushFlag) 
  226. {
  227.   DiskBufferSegmentInfoPtr dbsiPtr;
  229.   dbsiPtr.i = lliPtr->lliUndoBufferSegmentP;
  230.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  231.   Uint32 flags = 1;
  232.   lliPtr->lliUndoPagesToDiskWithoutSynch += dbsiPtr.p->pdxNumDataPages;
  233.   if ((lliPtr->lliUndoPagesToDiskWithoutSynch > MAX_PAGES_WITHOUT_SYNCH) ||
  234.       (flushFlag)) {
  235.     ljam();
  236. /* ---------------------------------------------------------------- */
  237. // To avoid synching too big chunks at a time we synch after writing
  238. // a certain number of data pages. (e.g. 2 MBytes).
  239. /* ---------------------------------------------------------------- */
  240.     lliPtr->lliUndoPagesToDiskWithoutSynch = 0;
  241.     flags |= 0x10; //Set synch flag unconditionally
  242.   }//if
  243.   dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_WRITE;
  244.   signal->theData[0] = lliPtr->lliUndoFileHandle;
  245.   signal->theData[1] = cownref;
  246.   signal->theData[2] = dbsiPtr.i;
  247.   signal->theData[3] = flags;
  248.   signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  249.   signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  250.   signal->theData[6] = dbsiPtr.p->pdxDataPage[0];
  251.   signal->theData[7] = dbsiPtr.p->pdxFilePage;
  252.   sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA);
  254.   DiskBufferSegmentInfoPtr newDbsiPtr;
  255.   UndoPagePtr newUndoPagePtr;
  257.   seizeUndoBufferSegment(signal, newUndoPagePtr);
  258.   seizeDiskBufferSegmentRecord(newDbsiPtr);
  259.   newDbsiPtr.p->pdxBuffertype = UNDO_PAGES;
  260.   for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  261.     newDbsiPtr.p->pdxDataPage[i] = newUndoPagePtr.i + i;
  262.   }//for
  263.   newDbsiPtr.p->pdxFilePage = lliPtr->lliLogFilePage;
  264.   lliPtr->lliUndoPage = newUndoPagePtr.i;
  265.   lliPtr->lliUndoBufferSegmentP = newDbsiPtr.i;
  266. }//Dbtup::lcpWriteUndoSegment()
  268. void Dbtup::seizeUndoBufferSegment(Signal* signal, UndoPagePtr& regUndoPagePtr)
  269. {
  270.   if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) {
  271.     EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1);
  272.     ljamEntry();
  273.   }//if
  274.   cnoFreeUndoSeg--;
  275.   ndbrequire(cnoFreeUndoSeg >= 0);
  276.   ndbrequire(cfirstfreeUndoSeg != RNIL);
  277.   regUndoPagePtr.i = cfirstfreeUndoSeg;
  278.   ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  279.   cfirstfreeUndoSeg = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS];
  280.   regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL;
  281. }//Dbtup::seizeUndoBufferSegment()