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

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

MySQL数据库

开发平台：

Visual C++

DbtupPageMap.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(14000 + __LINE__); }
  25. #define ljamEntry() { jamEntryLine(14000 + __LINE__); }
  27. //
  28. // PageMap is a service used by Dbtup to map logical page id's to physical
  29. // page id's. The mapping is needs the fragment and the logical page id to
  30. // provide the physical id.
  31. //
  32. // This is a part of Dbtup which is the exclusive user of a certain set of
  33. // variables on the fragment record and it is the exclusive user of the
  34. // struct for page ranges.
  35. //
  36. //
  37. // The following methods operate on the data handled by the page map class.
  38. //
  39. // Public methods
  40. // insertPageRange(Uint32 startPageId,     # In
  41. //                 Uint32 noPages)         # In
  42. // Inserts a range of pages into the mapping structure.
  43. //
  44. // void releaseFragPages()
  45. // Releases all pages and their mappings belonging to a fragment.
  46. //
  47. // Uint32 allocFragPages(Uint32 tafpNoAllocRequested)
  48. // Allocate a set of pages to the fragment from the page manager
  49. //
  50. // Uint32 getEmptyPage()
  51. // Get an empty page from the pool of empty pages on the fragment.
  52. // It returns the physical page id of the empty page.
  53. // Returns RNIL if no empty page is available.
  54. //
  55. // Uint32 getRealpid(Uint32 logicalPageId)
  56. // Return the physical page id provided the logical page id
  57. //
  58. // void initializePageRange()
  59. // Initialise free list of page ranges and initialise the page raneg records.
  60. //
  61. // void initFragRange()
  62. // Initialise the fragment variables when allocating a fragment to a table.
  63. //
  64. // void initPageRangeSize(Uint32 size)
  65. // Initialise the number of page ranges.
  66. //
  67. // Uint32 getNoOfPages()
  68. // Get the number of pages on the fragment currently.
  69. //
  70. //
  71. // Private methods
  72. // Uint32 leafPageRangeFull(PageRangePtr currPageRangePtr)
  73. //
  74. // void errorHandler()
  75. // Method to crash NDB kernel in case of weird data set-up
  76. //
  77. // void allocMoreFragPages()
  78. // When no more empty pages are attached to the fragment and we need more
  79. // we allocate more pages from the page manager using this method.
  80. //
  81. // Private data
  82. // On the fragment record
  83. // currentPageRange    # The current page range where to insert the next range
  84. // rootPageRange       # The root of the page ranges owned
  85. // nextStartRange      # The next page id to assign when expanding the
  86. //                     # page map
  87. // noOfPages           # The number of pages in the fragment
  88. // emptyPrimPage       # The first page of the empty pages in the fragment
  89. //
  90. // The full page range struct
  92. Uint32 Dbtup::getEmptyPage(Fragrecord* const regFragPtr)
  93. {
  94.   Uint32 logicalPageId = regFragPtr->emptyPrimPage;
  95.   if (logicalPageId == RNIL) {
  96.     ljam();
  97.     allocMoreFragPages(regFragPtr);
  98.     logicalPageId = regFragPtr->emptyPrimPage;
  99.     if (logicalPageId == RNIL) {
  100.       ljam();
  101.       return RNIL;
  102.     }//if
  103.   }//if
  104.   Uint32 physicalPageId = getRealpid(regFragPtr, logicalPageId);
  105.   PagePtr pagePtr;
  106.   pagePtr.i = physicalPageId;
  107.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  108.   regFragPtr->emptyPrimPage = pagePtr.p->pageWord[ZPAGE_NEXT_POS];
  109.   return physicalPageId;
  110. }//Dbtup::getEmptyPage()
  112. Uint32 Dbtup::getRealpid(Fragrecord*  const regFragPtr, Uint32 logicalPageId) 
  113. {
  114.   PageRangePtr grpPageRangePtr;
  115.   Uint32 loopLimit;
  116.   Uint32 loopCount = 0;
  117.   Uint32 pageRangeLimit = cnoOfPageRangeRec;
  119.   grpPageRangePtr.i = regFragPtr->rootPageRange;
  120.   while (true) {
  121.     ndbrequire(loopCount++ < 100);
  122.     ndbrequire(grpPageRangePtr.i < pageRangeLimit);
  123.     ptrAss(grpPageRangePtr, pageRange);
  124.     loopLimit = grpPageRangePtr.p->currentIndexPos;
  125.     ndbrequire(loopLimit <= 3);
  126.     for (Uint32 i = 0; i <= loopLimit; i++) {
  127.       ljam();
  128.       if (grpPageRangePtr.p->startRange[i] <= logicalPageId) {
  129.         if (grpPageRangePtr.p->endRange[i] >= logicalPageId) {
  130.           if (grpPageRangePtr.p->type[i] == ZLEAF) {
  131.             ljam();
  132.             Uint32 realPageId = (logicalPageId - grpPageRangePtr.p->startRange[i]) +
  133.                                  grpPageRangePtr.p->basePageId[i];
  134.             return realPageId;
  135.           } else {
  136.             ndbrequire(grpPageRangePtr.p->type[i] == ZNON_LEAF);
  137.             grpPageRangePtr.i = grpPageRangePtr.p->basePageId[i];
  138.           }//if
  139.         }//if
  140.       }//if
  141.     }//for
  142.   }//while
  143.   return 0;
  144. }//Dbtup::getRealpid()
  146. Uint32 Dbtup::getNoOfPages(Fragrecord* const regFragPtr)
  147. {
  148.   return regFragPtr->noOfPages;
  149. }//Dbtup::getNoOfPages()
  151. void Dbtup::initPageRangeSize(Uint32 size)
  152. {
  153.   cnoOfPageRangeRec = size;
  154. }//Dbtup::initPageRangeSize()
  156. /* ---------------------------------------------------------------- */
  157. /* ----------------------- INSERT_PAGE_RANGE_TAB ------------------ */
  158. /* ---------------------------------------------------------------- */
  159. /*       INSERT A PAGE RANGE INTO THE FRAGMENT                      */
  160. /*                                                                  */
  161. /*       NOTE:   THE METHOD IS ATOMIC. EITHER THE ACTION IS         */
  162. /*               PERFORMED FULLY OR NO ACTION IS PERFORMED AT ALL.  */
  163. /*               TO SUPPORT THIS THE CODE HAS A CLEANUP PART AFTER  */
  164. /*               ERRORS.                                            */
  165. /* ---------------------------------------------------------------- */
  166. bool Dbtup::insertPageRangeTab(Fragrecord*  const regFragPtr,
  167.                                Uint32 startPageId,
  168.                                Uint32 noPages) 
  169. {
  170.   PageRangePtr currPageRangePtr;
  171.   if (cfirstfreerange == RNIL) {
  172.     ljam();
  173.     return false;
  174.   }//if
  175.   currPageRangePtr.i = regFragPtr->currentPageRange;
  176.   if (currPageRangePtr.i == RNIL) {
  177.     ljam();
  178. /* ---------------------------------------------------------------- */
  179. /*       THE FIRST PAGE RANGE IS HANDLED WITH SPECIAL CODE          */
  180. /* ---------------------------------------------------------------- */
  181.     seizePagerange(currPageRangePtr);
  182.     regFragPtr->rootPageRange = currPageRangePtr.i;
  183.     currPageRangePtr.p->currentIndexPos = 0;
  184.     currPageRangePtr.p->parentPtr = RNIL;
  185.   } else {
  186.     ljam();
  187.     ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange);
  188.     if (currPageRangePtr.p->currentIndexPos < 3) {
  189.       ljam();
  190. /* ---------------------------------------------------------------- */
  191. /*       THE SIMPLE CASE WHEN IT IS ONLY NECESSARY TO FILL IN THE   */
  192. /*       NEXT EMPTY POSITION IN THE PAGE RANGE RECORD IS TREATED    */
  193. /*       BY COMMON CODE AT THE END OF THE SUBROUTINE.               */
  194. /* ---------------------------------------------------------------- */
  195.       currPageRangePtr.p->currentIndexPos++;
  196.     } else {
  197.       ljam();
  198.       ndbrequire(currPageRangePtr.p->currentIndexPos == 3);
  199.       currPageRangePtr.i = leafPageRangeFull(regFragPtr, currPageRangePtr);
  200.       if (currPageRangePtr.i == RNIL) {
  201.         return false;
  202.       }//if
  203.       ptrCheckGuard(currPageRangePtr, cnoOfPageRangeRec, pageRange);
  204.     }//if
  205.   }//if
  206.   currPageRangePtr.p->startRange[currPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange;
  207. /* ---------------------------------------------------------------- */
  208. /*       NOW SET THE LEAF LEVEL PAGE RANGE RECORD PROPERLY          */
  209. /*       PAGE_RANGE_PTR REFERS TO LEAF RECORD WHEN ARRIVING HERE    */
  210. /* ---------------------------------------------------------------- */
  211.   currPageRangePtr.p->endRange[currPageRangePtr.p->currentIndexPos] = 
  212.                                                    (regFragPtr->nextStartRange + noPages) - 1;
  213.   currPageRangePtr.p->basePageId[currPageRangePtr.p->currentIndexPos] = startPageId;
  214.   currPageRangePtr.p->type[currPageRangePtr.p->currentIndexPos] = ZLEAF;
  215. /* ---------------------------------------------------------------- */
  216. /*       WE NEED TO UPDATE THE CURRENT PAGE RANGE IN CASE IT HAS    */
  217. /*       CHANGED. WE ALSO NEED TO UPDATE THE NEXT START RANGE       */
  218. /* ---------------------------------------------------------------- */
  219.   regFragPtr->currentPageRange = currPageRangePtr.i;
  220.   regFragPtr->nextStartRange += noPages;
  221. /* ---------------------------------------------------------------- */
  222. /*       WE NEED TO UPDATE THE END RANGE IN ALL PAGE RANGE RECORDS  */
  223. /*       UP TO THE ROOT.                                            */
  224. /* ---------------------------------------------------------------- */
  225.   PageRangePtr loopPageRangePtr;
  226.   loopPageRangePtr = currPageRangePtr;
  227.   while (true) {
  228.     ljam();
  229.     loopPageRangePtr.i = loopPageRangePtr.p->parentPtr;
  230.     if (loopPageRangePtr.i != RNIL) {
  231.       ljam();
  232.       ptrCheckGuard(loopPageRangePtr, cnoOfPageRangeRec, pageRange);
  233.       ndbrequire(loopPageRangePtr.p->currentIndexPos < 4);
  234.       loopPageRangePtr.p->endRange[loopPageRangePtr.p->currentIndexPos] += noPages;
  235.     } else {
  236.       ljam();
  237.       break;
  238.     }//if
  239.   }//while
  240.   regFragPtr->noOfPages += noPages;
  241.   return true;
  242. }//Dbtup::insertPageRangeTab()
  245. void Dbtup::releaseFragPages(Fragrecord* const regFragPtr) 
  246. {
  247.   if (regFragPtr->rootPageRange == RNIL) {
  248.     ljam();
  249.     return;
  250.   }//if
  251.   PageRangePtr regPRPtr;
  252.   regPRPtr.i = regFragPtr->rootPageRange;
  253.   ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
  254.   while (true) {
  255.     ljam();
  256.     const Uint32 indexPos = regPRPtr.p->currentIndexPos;
  257.     ndbrequire(indexPos < 4);
  259.     const Uint32 basePageId = regPRPtr.p->basePageId[indexPos];
  260.     regPRPtr.p->basePageId[indexPos] = RNIL;
  261.     if (basePageId == RNIL) {
  262.       ljam();
  263.       /**
  264.        * Finished with indexPos continue with next
  265.        */
  266.       if (indexPos > 0) {
  267.         ljam();
  268. regPRPtr.p->currentIndexPos--;
  269. continue;
  270.       }//if
  271.       
  272.       /* ---------------------------------------------------------------- */
  273.       /* THE PAGE RANGE REC IS EMPTY. RELEASE IT.                         */
  274.       /*----------------------------------------------------------------- */
  275.       Uint32 parentPtr = regPRPtr.p->parentPtr;
  276.       releasePagerange(regPRPtr);
  277.       
  278.       if (parentPtr != RNIL) {
  279. ljam();
  280. regPRPtr.i = parentPtr;
  281. ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
  282. continue;
  283.       }//if
  285.       ljam();
  286.       ndbrequire(regPRPtr.i == regFragPtr->rootPageRange);
  287.       initFragRange(regFragPtr);
  288.       return;
  289.     } else {
  290.       if (regPRPtr.p->type[indexPos] == ZNON_LEAF) {
  291.         jam();
  292. /* ---------------------------------------------------------------- */
  293. // A non-leaf node, we must release everything below it before we 
  294. // release this node.
  295. /* ---------------------------------------------------------------- */
  296.         regPRPtr.i = basePageId;
  297.         ptrCheckGuard(regPRPtr, cnoOfPageRangeRec, pageRange);
  298.       } else {
  299.         jam();
  300.         ndbrequire(regPRPtr.p->type[indexPos] == ZLEAF);
  301. /* ---------------------------------------------------------------- */
  302. /* PAGE_RANGE_PTR /= RNIL AND THE CURRENT POS IS NOT A CHLED.       */
  303. /*----------------------------------------------------------------- */
  304. const Uint32 start = regPRPtr.p->startRange[indexPos];
  305. const Uint32 stop = regPRPtr.p->endRange[indexPos];
  306. ndbrequire(stop >= start);
  307. const Uint32 retNo = (stop - start + 1);
  308. returnCommonArea(basePageId, retNo);
  309.       }//if
  310.     }//if
  311.   }//while
  312. }//Dbtup::releaseFragPages()
  314. void Dbtup::initializePageRange() 
  315. {
  316.   PageRangePtr regPTRPtr;
  317.   for (regPTRPtr.i = 0;
  318.        regPTRPtr.i < cnoOfPageRangeRec; regPTRPtr.i++) {
  319.     ptrAss(regPTRPtr, pageRange);
  320.     regPTRPtr.p->nextFree = regPTRPtr.i + 1;
  321.   }//for
  322.   regPTRPtr.i = cnoOfPageRangeRec - 1;
  323.   ptrAss(regPTRPtr, pageRange);
  324.   regPTRPtr.p->nextFree = RNIL;
  325.   cfirstfreerange = 0;
  326.   c_noOfFreePageRanges = cnoOfPageRangeRec;
  327. }//Dbtup::initializePageRange()
  329. void Dbtup::initFragRange(Fragrecord* const regFragPtr)
  330. {
  331.   regFragPtr->emptyPrimPage = RNIL;
  332.   regFragPtr->rootPageRange = RNIL;
  333.   regFragPtr->currentPageRange = RNIL;
  334.   regFragPtr->noOfPages = 0;
  335.   regFragPtr->nextStartRange = 0;
  336. }//initFragRange()
  338. Uint32 Dbtup::allocFragPages(Fragrecord* const regFragPtr, Uint32 tafpNoAllocRequested) 
  339. {
  340.   Uint32 tafpPagesAllocated = 0;
  341.   while (true) {
  342.     Uint32 noOfPagesAllocated = 0;
  343.     Uint32 noPagesToAllocate = tafpNoAllocRequested - tafpPagesAllocated;
  344.     Uint32 retPageRef = RNIL;
  345.     allocConsPages(noPagesToAllocate, noOfPagesAllocated, retPageRef);
  346.     if (noOfPagesAllocated == 0) {
  347.       ljam();
  348.       return tafpPagesAllocated;
  349.     }//if
  350. /* ---------------------------------------------------------------- */
  351. /*       IT IS NOW TIME TO PUT THE ALLOCATED AREA INTO THE PAGE     */
  352. /*       RANGE TABLE.                                               */
  353. /* ---------------------------------------------------------------- */
  354.     Uint32 startRange = regFragPtr->nextStartRange;
  355.     if (!insertPageRangeTab(regFragPtr, retPageRef, noOfPagesAllocated)) {
  356.       ljam();
  357.       returnCommonArea(retPageRef, noOfPagesAllocated);
  358.       return tafpPagesAllocated;
  359.     }//if
  360.     tafpPagesAllocated += noOfPagesAllocated;
  361.     Uint32 loopLimit = retPageRef + noOfPagesAllocated;
  362.     PagePtr loopPagePtr;
  363. /* ---------------------------------------------------------------- */
  364. /*       SINCE A NUMBER OF PAGES WERE ALLOCATED FROM COMMON AREA    */
  365. /*       WITH SUCCESS IT IS NOW TIME TO CHANGE THE STATE OF         */
  366. /*       THOSE PAGES TO EMPTY_MM AND LINK THEM INTO THE EMPTY       */
  367. /*       PAGE LIST OF THE FRAGMENT.                                 */
  368. /* ---------------------------------------------------------------- */
  369.     for (loopPagePtr.i = retPageRef; loopPagePtr.i < loopLimit; loopPagePtr.i++) {
  370.       ljam();
  371.       ptrCheckGuard(loopPagePtr, cnoOfPage, page);
  372.       loopPagePtr.p->pageWord[ZPAGE_STATE_POS] = ZEMPTY_MM;
  373.       loopPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] = startRange +
  374.                                                         (loopPagePtr.i - retPageRef);
  375.       loopPagePtr.p->pageWord[ZPAGE_NEXT_POS] = loopPagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] + 1;
  376.     }//for
  377.     loopPagePtr.i = (retPageRef + noOfPagesAllocated) - 1;
  378.     ptrCheckGuard(loopPagePtr, cnoOfPage, page);
  379.     loopPagePtr.p->pageWord[ZPAGE_NEXT_POS] = regFragPtr->emptyPrimPage;
  380.     regFragPtr->emptyPrimPage = startRange;
  381. /* ---------------------------------------------------------------- */
  382. /*       WAS ENOUGH PAGES ALLOCATED OR ARE MORE NEEDED.             */
  383. /* ---------------------------------------------------------------- */
  384.     if (tafpPagesAllocated < tafpNoAllocRequested) {
  385.       ljam();
  386.     } else {
  387.       ndbrequire(tafpPagesAllocated == tafpNoAllocRequested);
  388.       ljam();
  389.       return tafpNoAllocRequested;
  390.     }//if
  391.   }//while
  392. }//Dbtup::allocFragPages()
  394. void Dbtup::allocMoreFragPages(Fragrecord* const regFragPtr) 
  395. {
  396.   Uint32 noAllocPages = regFragPtr->noOfPages >> 3; // 12.5%
  397.   noAllocPages += regFragPtr->noOfPages >> 4; // 6.25%
  398.   noAllocPages += 2;
  399. /* -----------------------------------------------------------------*/
  400. // We will grow by 18.75% plus two more additional pages to grow
  401. // a little bit quicker in the beginning.
  402. /* -----------------------------------------------------------------*/
  403.   allocFragPages(regFragPtr, noAllocPages);
  404. }//Dbtup::allocMoreFragPages()
  406. Uint32 Dbtup::leafPageRangeFull(Fragrecord*  const regFragPtr, PageRangePtr currPageRangePtr)
  407. {
  408. /* ---------------------------------------------------------------- */
  409. /*       THE COMPLEX CASE WHEN THE LEAF NODE IS FULL. GO UP THE TREE*/
  410. /*       TO FIND THE FIRST RECORD WITH A FREE ENTRY. ALLOCATE NEW   */
  411. /*       PAGE RANGE RECORDS THEN ALL THE WAY DOWN TO THE LEAF LEVEL */
  412. /*       AGAIN. THE TREE SHOULD ALWAYS REMAIN BALANCED.             */
  413. /* ---------------------------------------------------------------- */
  414.   PageRangePtr parentPageRangePtr;
  415.   PageRangePtr foundPageRangePtr;
  416.   parentPageRangePtr = currPageRangePtr;
  417.   Uint32 tiprNoLevels = 1;
  418.   while (true) {
  419.     ljam();
  420.     parentPageRangePtr.i = parentPageRangePtr.p->parentPtr;
  421.     if (parentPageRangePtr.i == RNIL) {
  422.       ljam();
  423. /* ---------------------------------------------------------------- */
  424. /*       WE HAVE REACHED THE ROOT. A NEW ROOT MUST BE ALLOCATED.    */
  425. /* ---------------------------------------------------------------- */
  426.       if (c_noOfFreePageRanges < tiprNoLevels) {
  427.         ljam();
  428.         return RNIL;
  429.       }//if
  430.       PageRangePtr oldRootPRPtr;
  431.       PageRangePtr newRootPRPtr;
  432.       oldRootPRPtr.i = regFragPtr->rootPageRange;
  433.       ptrCheckGuard(oldRootPRPtr, cnoOfPageRangeRec, pageRange);
  434.       seizePagerange(newRootPRPtr);
  435.       regFragPtr->rootPageRange = newRootPRPtr.i;
  436.       oldRootPRPtr.p->parentPtr = newRootPRPtr.i;
  438.       newRootPRPtr.p->basePageId[0] = oldRootPRPtr.i;
  439.       newRootPRPtr.p->parentPtr = RNIL;
  440.       newRootPRPtr.p->startRange[0] = 0;
  441.       newRootPRPtr.p->endRange[0] = regFragPtr->nextStartRange - 1;
  442.       newRootPRPtr.p->type[0] = ZNON_LEAF;
  443.       newRootPRPtr.p->startRange[1] = regFragPtr->nextStartRange;
  444.       newRootPRPtr.p->endRange[1] = regFragPtr->nextStartRange - 1;
  445.       newRootPRPtr.p->type[1] = ZNON_LEAF;
  446.       newRootPRPtr.p->currentIndexPos = 1;
  447.       foundPageRangePtr = newRootPRPtr;
  448.       break;
  449.     } else {
  450.       ljam();
  451.       ptrCheckGuard(parentPageRangePtr, cnoOfPageRangeRec, pageRange);
  452.       if (parentPageRangePtr.p->currentIndexPos < 3) {
  453.         ljam();
  454. /* ---------------------------------------------------------------- */
  455. /*       WE HAVE FOUND AN EMPTY ENTRY IN A PAGE RANGE RECORD.       */
  456. /*       ALLOCATE A NEW PAGE RANGE RECORD, FILL IN THE START RANGE, */
  457. /*       ALLOCATE A NEW PAGE RANGE RECORD AND UPDATE THE POINTERS   */
  458. /* ---------------------------------------------------------------- */
  459.         parentPageRangePtr.p->currentIndexPos++;
  460.         parentPageRangePtr.p->startRange[parentPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange;
  461.         parentPageRangePtr.p->endRange[parentPageRangePtr.p->currentIndexPos] = regFragPtr->nextStartRange - 1;
  462.         parentPageRangePtr.p->type[parentPageRangePtr.p->currentIndexPos] = ZNON_LEAF;
  463.         foundPageRangePtr = parentPageRangePtr;
  464.         break;
  465.       } else {
  466.         ljam();
  467.         ndbrequire(parentPageRangePtr.p->currentIndexPos == 3);
  468. /* ---------------------------------------------------------------- */
  469. /*       THE PAGE RANGE RECORD WAS FULL. FIND THE PARENT RECORD     */
  470. /*       AND INCREASE THE NUMBER OF LEVELS WE HAVE TRAVERSED        */
  471. /*       GOING UP THE TREE.                                         */
  472. /* ---------------------------------------------------------------- */
  473.         tiprNoLevels++;
  474.       }//if
  475.     }//if
  476.   }//while
  477. /* ---------------------------------------------------------------- */
  478. /*       REMEMBER THE ERROR LEVEL IN CASE OF ALLOCATION ERRORS      */
  479. /* ---------------------------------------------------------------- */
  480.   PageRangePtr newPageRangePtr;
  481.   PageRangePtr prevPageRangePtr;
  482.   prevPageRangePtr = foundPageRangePtr;
  483.   if (c_noOfFreePageRanges < tiprNoLevels) {
  484.     ljam();
  485.     return RNIL;
  486.   }//if
  487. /* ---------------------------------------------------------------- */
  488. /*       NOW WE HAVE PERFORMED THE SEARCH UPWARDS AND FILLED IN THE */
  489. /*       PROPER FIELDS IN THE PAGE RANGE RECORD WHERE SOME SPACE    */
  490. /*       WAS FOUND. THE NEXT STEP IS TO ALLOCATE PAGE RANGES SO     */
  491. /*       THAT WE KEEP THE B-TREE BALANCED. THE NEW PAGE RANGE       */
  492. /*       ARE ALSO PROPERLY UPDATED ON THE PATH TO THE LEAF LEVEL.   */
  493. /* ---------------------------------------------------------------- */
  494.   while (true) {
  495.     ljam();
  496.     seizePagerange(newPageRangePtr);
  497.     tiprNoLevels--;
  498.     ndbrequire(prevPageRangePtr.p->currentIndexPos < 4);
  499.     prevPageRangePtr.p->basePageId[prevPageRangePtr.p->currentIndexPos] = newPageRangePtr.i;
  500.     newPageRangePtr.p->parentPtr = prevPageRangePtr.i;
  501.     newPageRangePtr.p->currentIndexPos = 0;
  502.     if (tiprNoLevels > 0) {
  503.       ljam();
  504.       newPageRangePtr.p->startRange[0] = regFragPtr->nextStartRange;
  505.       newPageRangePtr.p->endRange[0] = regFragPtr->nextStartRange - 1;
  506.       newPageRangePtr.p->type[0] = ZNON_LEAF;
  507.       prevPageRangePtr = newPageRangePtr;
  508.     } else {
  509.       ljam();
  510.       break;
  511.     }//if
  512.   }//while
  513.   return newPageRangePtr.i;
  514. }//Dbtup::leafPageRangeFull()
  516. void Dbtup::releasePagerange(PageRangePtr regPRPtr) 
  517. {
  518.   regPRPtr.p->nextFree = cfirstfreerange;
  519.   cfirstfreerange = regPRPtr.i;
  520.   c_noOfFreePageRanges++;
  521. }//Dbtup::releasePagerange()
  523. void Dbtup::seizePagerange(PageRangePtr& regPageRangePtr) 
  524. {
  525.   regPageRangePtr.i = cfirstfreerange;
  526.   ptrCheckGuard(regPageRangePtr, cnoOfPageRangeRec, pageRange);
  527.   cfirstfreerange = regPageRangePtr.p->nextFree;
  528.   regPageRangePtr.p->nextFree = RNIL;
  529.   regPageRangePtr.p->currentIndexPos = 0;
  530.   regPageRangePtr.p->parentPtr = RNIL;
  531.   for (Uint32 i = 0; i < 4; i++) {
  532.     regPageRangePtr.p->startRange[i] = 1;
  533.     regPageRangePtr.p->endRange[i] = 0;
  534.     regPageRangePtr.p->type[i] = ZNON_LEAF;
  535.     regPageRangePtr.p->basePageId[i] = (Uint32)-1;
  536.   }//for
  537.   c_noOfFreePageRanges--;
  538. }//Dbtup::seizePagerange()
  540. void Dbtup::errorHandler(Uint32 errorCode)
  541. {
  542.   switch (errorCode) {
  543.   case 0:
  544.     ljam();
  545.     break;
  546.   case 1:
  547.     ljam();
  548.     break;
  549.   case 2:
  550.     ljam();
  551.     break;
  552.   default:
  553.     ljam();
  554.   }
  555.   ndbrequire(false);
  556. }//Dbtup::errorHandler()