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

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

MySQL数据库

开发平台：

Visual C++

DbtuxMeta.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 DBTUX_META_CPP
  18. #include "Dbtux.hpp"
  20. /*
  21.  * Create index.
  22.  *
  23.  * For historical reasons it looks like we are adding random fragments
  24.  * and attributes to existing index.  In fact all fragments must be
  25.  * created at one time and they have identical attributes.
  26.  */
  28. void
  29. Dbtux::execTUXFRAGREQ(Signal* signal)
  30. {
  31.   jamEntry();
  32.   if (signal->theData[0] == (Uint32)-1) {
  33.     jam();
  34.     abortAddFragOp(signal);
  35.     return;
  36.   }
  37.   const TuxFragReq reqCopy = *(const TuxFragReq*)signal->getDataPtr();
  38.   const TuxFragReq* const req = &reqCopy;
  39.   IndexPtr indexPtr;
  40.   indexPtr.i = RNIL;
  41.   FragOpPtr fragOpPtr;
  42.   fragOpPtr.i = RNIL;
  43.   TuxFragRef::ErrorCode errorCode = TuxFragRef::NoError;
  44.   do {
  45.     // get the index record
  46.     if (req->tableId >= c_indexPool.getSize()) {
  47.       jam();
  48.       errorCode = TuxFragRef::InvalidRequest;
  49.       break;
  50.     }
  51.     c_indexPool.getPtr(indexPtr, req->tableId);
  52.     if (indexPtr.p->m_state != Index::NotDefined &&
  53.         indexPtr.p->m_state != Index::Defining) {
  54.       jam();
  55.       errorCode = TuxFragRef::InvalidRequest;
  56.       indexPtr.i = RNIL;        // leave alone
  57.       break;
  58.     }
  59.     // get new operation record
  60.     c_fragOpPool.seize(fragOpPtr);
  61.     ndbrequire(fragOpPtr.i != RNIL);
  62.     new (fragOpPtr.p) FragOp();
  63.     fragOpPtr.p->m_userPtr = req->userPtr;
  64.     fragOpPtr.p->m_userRef = req->userRef;
  65.     fragOpPtr.p->m_indexId = req->tableId;
  66.     fragOpPtr.p->m_fragId = req->fragId;
  67.     fragOpPtr.p->m_fragNo = indexPtr.p->m_numFrags;
  68.     fragOpPtr.p->m_numAttrsRecvd = 0;
  69. #ifdef VM_TRACE
  70.     if (debugFlags & DebugMeta) {
  71.       debugOut << "Seize frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
  72.     }
  73. #endif
  74.     // check if index has place for more fragments
  75.     ndbrequire(indexPtr.p->m_numFrags < MaxIndexFragments);
  76.     // seize new fragment record
  77.     FragPtr fragPtr;
  78.     c_fragPool.seize(fragPtr);
  79.     if (fragPtr.i == RNIL) {
  80.       jam();
  81.       errorCode = TuxFragRef::NoFreeFragment;
  82.       break;
  83.     }
  84.     new (fragPtr.p) Frag(c_scanOpPool);
  85.     fragPtr.p->m_tableId = req->primaryTableId;
  86.     fragPtr.p->m_indexId = req->tableId;
  87.     fragPtr.p->m_fragOff = req->fragOff;
  88.     fragPtr.p->m_fragId = req->fragId;
  89.     fragPtr.p->m_numAttrs = req->noOfAttr;
  90.     fragPtr.p->m_storeNullKey = true;  // not yet configurable
  91.     fragPtr.p->m_tupIndexFragPtrI = req->tupIndexFragPtrI;
  92.     fragPtr.p->m_tupTableFragPtrI[0] = req->tupTableFragPtrI[0];
  93.     fragPtr.p->m_tupTableFragPtrI[1] = req->tupTableFragPtrI[1];
  94.     fragPtr.p->m_accTableFragPtrI[0] = req->accTableFragPtrI[0];
  95.     fragPtr.p->m_accTableFragPtrI[1] = req->accTableFragPtrI[1];
  96.     // add the fragment to the index
  97.     indexPtr.p->m_fragId[indexPtr.p->m_numFrags] = req->fragId;
  98.     indexPtr.p->m_fragPtrI[indexPtr.p->m_numFrags] = fragPtr.i;
  99.     indexPtr.p->m_numFrags++;
  100.     // save under operation
  101.     fragOpPtr.p->m_fragPtrI = fragPtr.i;
  102.     // prepare to receive attributes
  103.     if (fragOpPtr.p->m_fragNo == 0) {
  104.       jam();
  105.       // receiving first fragment
  106.       ndbrequire(
  107.           indexPtr.p->m_state == Index::NotDefined &&
  108.           DictTabInfo::isOrderedIndex(req->tableType) &&
  109.           req->noOfAttr > 0 &&
  110.           req->noOfAttr <= MaxIndexAttributes &&
  111.           indexPtr.p->m_descPage == RNIL);
  112.       indexPtr.p->m_state = Index::Defining;
  113.       indexPtr.p->m_tableType = (DictTabInfo::TableType)req->tableType;
  114.       indexPtr.p->m_tableId = req->primaryTableId;
  115.       indexPtr.p->m_fragOff = req->fragOff;
  116.       indexPtr.p->m_numAttrs = req->noOfAttr;
  117.       indexPtr.p->m_storeNullKey = true;  // not yet configurable
  118.       // allocate attribute descriptors
  119.       if (! allocDescEnt(indexPtr)) {
  120.         jam();
  121.         errorCode = TuxFragRef::NoFreeAttributes;
  122.         break;
  123.       }
  124.     } else {
  125.       // receiving subsequent fragment
  126.       jam();
  127.       ndbrequire(
  128.           indexPtr.p->m_state == Index::Defining &&
  129.           indexPtr.p->m_tableType == (DictTabInfo::TableType)req->tableType &&
  130.           indexPtr.p->m_tableId == req->primaryTableId &&
  131.           indexPtr.p->m_fragOff == req->fragOff &&
  132.           indexPtr.p->m_numAttrs == req->noOfAttr);
  133.     }
  134.     // copy metadata address to each fragment
  135.     fragPtr.p->m_descPage = indexPtr.p->m_descPage;
  136.     fragPtr.p->m_descOff = indexPtr.p->m_descOff;
  137. #ifdef VM_TRACE
  138.     if (debugFlags & DebugMeta) {
  139.       debugOut << "Add frag " << fragPtr.i << " " << *fragPtr.p << endl;
  140.     }
  141. #endif
  142.     // error inserts
  143.     if (ERROR_INSERTED(12001) && fragOpPtr.p->m_fragNo == 0 ||
  144.         ERROR_INSERTED(12002) && fragOpPtr.p->m_fragNo == 1) {
  145.       jam();
  146.       errorCode = (TuxFragRef::ErrorCode)1;
  147.       CLEAR_ERROR_INSERT_VALUE;
  148.       break;
  149.     }
  150.     // success
  151.     TuxFragConf* const conf = (TuxFragConf*)signal->getDataPtrSend();
  152.     conf->userPtr = req->userPtr;
  153.     conf->tuxConnectPtr = fragOpPtr.i;
  154.     conf->fragPtr = fragPtr.i;
  155.     conf->fragId = fragPtr.p->m_fragId;
  156.     sendSignal(req->userRef, GSN_TUXFRAGCONF,
  157.         signal, TuxFragConf::SignalLength, JBB);
  158.     return;
  159.   } while (0);
  160.   // error
  161.   TuxFragRef* const ref = (TuxFragRef*)signal->getDataPtrSend();
  162.   ref->userPtr = req->userPtr;
  163.   ref->errorCode = errorCode;
  164.   sendSignal(req->userRef, GSN_TUXFRAGREF,
  165.       signal, TuxFragRef::SignalLength, JBB);
  166.   if (fragOpPtr.i != RNIL) {
  167. #ifdef VM_TRACE
  168.     if (debugFlags & DebugMeta) {
  169.       debugOut << "Release on frag error frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
  170.     }
  171. #endif
  172.     c_fragOpPool.release(fragOpPtr);
  173.   }
  174.   if (indexPtr.i != RNIL) {
  175.     jam();
  176.     // let DICT drop the unfinished index
  177.   }
  178. }
  180. void
  181. Dbtux::execTUX_ADD_ATTRREQ(Signal* signal)
  182. {
  183.   jamEntry();
  184.   const TuxAddAttrReq reqCopy = *(const TuxAddAttrReq*)signal->getDataPtr();
  185.   const TuxAddAttrReq* const req = &reqCopy;
  186.   // get the records
  187.   FragOpPtr fragOpPtr;
  188.   IndexPtr indexPtr;
  189.   FragPtr fragPtr;
  190.   c_fragOpPool.getPtr(fragOpPtr, req->tuxConnectPtr);
  191.   c_indexPool.getPtr(indexPtr, fragOpPtr.p->m_indexId);
  192.   c_fragPool.getPtr(fragPtr, fragOpPtr.p->m_fragPtrI);
  193.   TuxAddAttrRef::ErrorCode errorCode = TuxAddAttrRef::NoError;
  194.   do {
  195.     // expected attribute id
  196.     const unsigned attrId = fragOpPtr.p->m_numAttrsRecvd++;
  197.     ndbrequire(
  198.         indexPtr.p->m_state == Index::Defining &&
  199.         attrId < indexPtr.p->m_numAttrs &&
  200.         attrId == req->attrId);
  201.     // define the attribute
  202.     DescEnt& descEnt = getDescEnt(indexPtr.p->m_descPage, indexPtr.p->m_descOff);
  203.     DescAttr& descAttr = descEnt.m_descAttr[attrId];
  204.     descAttr.m_attrDesc = req->attrDescriptor;
  205.     descAttr.m_primaryAttrId = req->primaryAttrId;
  206.     descAttr.m_typeId = req->extTypeInfo & 0xFF;
  207.     descAttr.m_charset = (req->extTypeInfo >> 16);
  208. #ifdef VM_TRACE
  209.     if (debugFlags & DebugMeta) {
  210.       debugOut << "Add frag " << fragPtr.i << " attr " << attrId << " " << descAttr << endl;
  211.     }
  212. #endif
  213.     // check that type is valid and has a binary comparison method
  214.     const NdbSqlUtil::Type& type = NdbSqlUtil::getTypeBinary(descAttr.m_typeId);
  215.     if (type.m_typeId == NdbSqlUtil::Type::Undefined ||
  216.         type.m_cmp == 0) {
  217.       jam();
  218.       errorCode = TuxAddAttrRef::InvalidAttributeType;
  219.       break;
  220.     }
  221. #ifdef dbtux_uses_charset
  222.     if (descAttr.m_charset != 0) {
  223.       CHARSET_INFO *cs = get_charset(descAttr.m_charset, MYF(0));
  224.       // here use the non-binary type
  225.       if (! NdbSqlUtil::usable_in_ordered_index(descAttr.m_typeId, cs)) {
  226.         jam();
  227.         errorCode = TuxAddAttrRef::InvalidCharset;
  228.         break;
  229.       }
  230.     }
  231. #endif
  232.     const bool lastAttr = (indexPtr.p->m_numAttrs == fragOpPtr.p->m_numAttrsRecvd);
  233.     if (ERROR_INSERTED(12003) && fragOpPtr.p->m_fragNo == 0 && attrId == 0 ||
  234.         ERROR_INSERTED(12004) && fragOpPtr.p->m_fragNo == 0 && lastAttr ||
  235.         ERROR_INSERTED(12005) && fragOpPtr.p->m_fragNo == 1 && attrId == 0 ||
  236.         ERROR_INSERTED(12006) && fragOpPtr.p->m_fragNo == 1 && lastAttr) {
  237.       errorCode = (TuxAddAttrRef::ErrorCode)1;
  238.       CLEAR_ERROR_INSERT_VALUE;
  239.       break;
  240.     }
  241.     if (lastAttr) {
  242.       jam();
  243.       // initialize tree header
  244.       TreeHead& tree = fragPtr.p->m_tree;
  245.       new (&tree) TreeHead();
  246.       // make these configurable later
  247.       tree.m_nodeSize = MAX_TTREE_NODE_SIZE;
  248.       tree.m_prefSize = MAX_TTREE_PREF_SIZE;
  249.       const unsigned maxSlack = MAX_TTREE_NODE_SLACK;
  250.       // size up to and including first 2 entries
  251.       const unsigned pref = tree.getSize(AccPref);
  252.       if (! (pref <= tree.m_nodeSize)) {
  253.         jam();
  254.         errorCode = TuxAddAttrRef::InvalidNodeSize;
  255.         break;
  256.       }
  257.       const unsigned slots = (tree.m_nodeSize - pref) / TreeEntSize;
  258.       // leave out work space entry
  259.       tree.m_maxOccup = 2 + slots - 1;
  260.       // min occupancy of interior node must be at least 2
  261.       if (! (2 + maxSlack <= tree.m_maxOccup)) {
  262.         jam();
  263.         errorCode = TuxAddAttrRef::InvalidNodeSize;
  264.         break;
  265.       }
  266.       tree.m_minOccup = tree.m_maxOccup - maxSlack;
  267.       // root node does not exist (also set by ctor)
  268.       tree.m_root = NullTupLoc;
  269. #ifdef VM_TRACE
  270.       if (debugFlags & DebugMeta) {
  271.         if (fragOpPtr.p->m_fragNo == 0) {
  272.           debugOut << "Index id=" << indexPtr.i;
  273.           debugOut << " nodeSize=" << tree.m_nodeSize;
  274.           debugOut << " headSize=" << NodeHeadSize;
  275.           debugOut << " prefSize=" << tree.m_prefSize;
  276.           debugOut << " entrySize=" << TreeEntSize;
  277.           debugOut << " minOccup=" << tree.m_minOccup;
  278.           debugOut << " maxOccup=" << tree.m_maxOccup;
  279.           debugOut << endl;
  280.         }
  281.       }
  282. #endif
  283.       // fragment is defined
  284. #ifdef VM_TRACE
  285.       if (debugFlags & DebugMeta) {
  286.         debugOut << "Release frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
  287.       }
  288. #endif
  289.       c_fragOpPool.release(fragOpPtr);
  290.     }
  291.     // success
  292.     TuxAddAttrConf* conf = (TuxAddAttrConf*)signal->getDataPtrSend();
  293.     conf->userPtr = fragOpPtr.p->m_userPtr;
  294.     conf->lastAttr = lastAttr;
  295.     sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRCONF,
  296.         signal, TuxAddAttrConf::SignalLength, JBB);
  297.     return;
  298.   } while (0);
  299.   // error
  300.   TuxAddAttrRef* ref = (TuxAddAttrRef*)signal->getDataPtrSend();
  301.   ref->userPtr = fragOpPtr.p->m_userPtr;
  302.   ref->errorCode = errorCode;
  303.   sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRREF,
  304.       signal, TuxAddAttrRef::SignalLength, JBB);
  305. #ifdef VM_TRACE
  306.     if (debugFlags & DebugMeta) {
  307.       debugOut << "Release on attr error frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
  308.     }
  309. #endif
  310.   c_fragOpPool.release(fragOpPtr);
  311.   // let DICT drop the unfinished index
  312. }
  314. /*
  315.  * LQH aborts on-going create index operation.
  316.  */
  317. void
  318. Dbtux::abortAddFragOp(Signal* signal)
  319. {
  320.   FragOpPtr fragOpPtr;
  321.   IndexPtr indexPtr;
  322.   c_fragOpPool.getPtr(fragOpPtr, signal->theData[1]);
  323.   c_indexPool.getPtr(indexPtr, fragOpPtr.p->m_indexId);
  324. #ifdef VM_TRACE
  325.   if (debugFlags & DebugMeta) {
  326.     debugOut << "Release on abort frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
  327.   }
  328. #endif
  329.   c_fragOpPool.release(fragOpPtr);
  330.   // let DICT drop the unfinished index
  331. }
  333. /*
  334.  * Set index online.  Currently at system restart this arrives before
  335.  * build and is therefore not correct.
  336.  */
  337. void
  338. Dbtux::execALTER_INDX_REQ(Signal* signal)
  339. {
  340.   jamEntry();
  341.   const AlterIndxReq reqCopy = *(const AlterIndxReq*)signal->getDataPtr();
  342.   const AlterIndxReq* const req = &reqCopy;
  343.   // set index online after build
  344.   IndexPtr indexPtr;
  345.   c_indexPool.getPtr(indexPtr, req->getIndexId());
  346.   indexPtr.p->m_state = Index::Online;
  347. #ifdef VM_TRACE
  348.   if (debugFlags & DebugMeta) {
  349.     debugOut << "Online index " << indexPtr.i << " " << *indexPtr.p << endl;
  350.   }
  351. #endif
  352.   // success
  353.   AlterIndxConf* const conf = (AlterIndxConf*)signal->getDataPtrSend();
  354.   conf->setUserRef(reference());
  355.   conf->setConnectionPtr(req->getConnectionPtr());
  356.   conf->setRequestType(req->getRequestType());
  357.   conf->setTableId(req->getTableId());
  358.   conf->setIndexId(req->getIndexId());
  359.   conf->setIndexVersion(req->getIndexVersion());
  360.   sendSignal(req->getUserRef(), GSN_ALTER_INDX_CONF,
  361.       signal, AlterIndxConf::SignalLength, JBB);
  362. }
  364. /*
  365.  * Drop index.
  366.  *
  367.  * Uses same DROP_TAB_REQ signal as normal tables.
  368.  */
  370. void
  371. Dbtux::execDROP_TAB_REQ(Signal* signal)
  372. {
  373.   jamEntry();
  374.   const DropTabReq reqCopy = *(const DropTabReq*)signal->getDataPtr();
  375.   const DropTabReq* const req = &reqCopy;
  376.   IndexPtr indexPtr;
  378.   Uint32 tableId = req->tableId;
  379.   Uint32 senderRef = req->senderRef;
  380.   Uint32 senderData = req->senderData;
  381.   if (tableId >= c_indexPool.getSize()) {
  382.     jam();
  383.     // reply to sender
  384.     DropTabConf* const conf = (DropTabConf*)signal->getDataPtrSend();
  385.     conf->senderRef = reference();
  386.     conf->senderData = senderData;
  387.     conf->tableId = tableId;
  388.     sendSignal(senderRef, GSN_DROP_TAB_CONF,
  389.        signal, DropTabConf::SignalLength, JBB);
  390.     return;
  391.   }
  392.   
  393.   c_indexPool.getPtr(indexPtr, req->tableId);
  394.   // drop works regardless of index state
  395. #ifdef VM_TRACE
  396.   if (debugFlags & DebugMeta) {
  397.     debugOut << "Drop index " << indexPtr.i << " " << *indexPtr.p << endl;
  398.   }
  399. #endif
  400.   ndbrequire(req->senderRef != 0);
  401.   dropIndex(signal, indexPtr, req->senderRef, req->senderData);
  402. }
  404. void
  405. Dbtux::dropIndex(Signal* signal, IndexPtr indexPtr, Uint32 senderRef, Uint32 senderData)
  406. {
  407.   jam();
  408.   indexPtr.p->m_state = Index::Dropping;
  409.   // drop fragments
  410.   while (indexPtr.p->m_numFrags > 0) {
  411.     jam();
  412.     Uint32 i = --indexPtr.p->m_numFrags;
  413.     FragPtr fragPtr;
  414.     c_fragPool.getPtr(fragPtr, indexPtr.p->m_fragPtrI[i]);
  415.     c_fragPool.release(fragPtr);
  416.   }
  417.   // drop attributes
  418.   if (indexPtr.p->m_descPage != RNIL) {
  419.     jam();
  420.     freeDescEnt(indexPtr);
  421.     indexPtr.p->m_descPage = RNIL;
  422.   }
  423.   if (senderRef != 0) {
  424.     jam();
  425.     // reply to sender
  426.     DropTabConf* const conf = (DropTabConf*)signal->getDataPtrSend();
  427.     conf->senderRef = reference();
  428.     conf->senderData = senderData;
  429.     conf->tableId = indexPtr.i;
  430.     sendSignal(senderRef, GSN_DROP_TAB_CONF,
  431.         signal, DropTabConf::SignalLength, JBB);
  432.   }
  433.   new (indexPtr.p) Index();
  434. }
  436. /*
  437.  * Subroutines.
  438.  */
  440. bool
  441. Dbtux::allocDescEnt(IndexPtr indexPtr)
  442. {
  443.   jam();
  444.   const unsigned size = DescHeadSize + indexPtr.p->m_numAttrs * DescAttrSize;
  445.   DescPagePtr pagePtr;
  446.   pagePtr.i = c_descPageList;
  447.   while (pagePtr.i != RNIL) {
  448.     jam();
  449.     c_descPagePool.getPtr(pagePtr);
  450.     if (pagePtr.p->m_numFree >= size) {
  451.       jam();
  452.       break;
  453.     }
  454.     pagePtr.i = pagePtr.p->m_nextPage;
  455.   }
  456.   if (pagePtr.i == RNIL) {
  457.     jam();
  458.     if (! c_descPagePool.seize(pagePtr)) {
  459.       jam();
  460.       return false;
  461.     }
  462.     new (pagePtr.p) DescPage();
  463.     // add in front of list
  464.     pagePtr.p->m_nextPage = c_descPageList;
  465.     c_descPageList = pagePtr.i;
  466.     pagePtr.p->m_numFree = DescPageSize;
  467.   }
  468.   ndbrequire(pagePtr.p->m_numFree >= size);
  469.   indexPtr.p->m_descPage = pagePtr.i;
  470.   indexPtr.p->m_descOff = DescPageSize - pagePtr.p->m_numFree;
  471.   pagePtr.p->m_numFree -= size;
  472.   DescEnt& descEnt = getDescEnt(indexPtr.p->m_descPage, indexPtr.p->m_descOff);
  473.   descEnt.m_descHead.m_indexId = indexPtr.i;
  474.   descEnt.m_descHead.pad1 = 0;
  475.   return true;
  476. }
  478. void
  479. Dbtux::freeDescEnt(IndexPtr indexPtr)
  480. {
  481.   DescPagePtr pagePtr;
  482.   c_descPagePool.getPtr(pagePtr, indexPtr.p->m_descPage);
  483.   Uint32* const data = pagePtr.p->m_data;
  484.   const unsigned size = DescHeadSize + indexPtr.p->m_numAttrs * DescAttrSize;
  485.   unsigned off = indexPtr.p->m_descOff;
  486.   // move the gap to the free area at the top
  487.   while (off + size < DescPageSize - pagePtr.p->m_numFree) {
  488.     jam();
  489.     // next entry to move over the gap
  490.     DescEnt& descEnt2 = *(DescEnt*)&data[off + size];
  491.     Uint32 indexId2 = descEnt2.m_descHead.m_indexId;
  492.     Index& index2 = *c_indexPool.getPtr(indexId2);
  493.     unsigned size2 = DescHeadSize + index2.m_numAttrs * DescAttrSize;
  494.     ndbrequire(
  495.         index2.m_descPage == pagePtr.i &&
  496.         index2.m_descOff == off + size);
  497.     // move the entry (overlapping copy if size < size2)
  498.     unsigned i;
  499.     for (i = 0; i < size2; i++) {
  500.       jam();
  501.       data[off + i] = data[off + size + i];
  502.     }
  503.     off += size2;
  504.     // adjust page offset in index and all fragments
  505.     index2.m_descOff -= size;
  506.     for (i = 0; i < index2.m_numFrags; i++) {
  507.       jam();
  508.       Frag& frag2 = *c_fragPool.getPtr(index2.m_fragPtrI[i]);
  509.       frag2.m_descOff -= size;
  510.       ndbrequire(
  511.           frag2.m_descPage == index2.m_descPage &&
  512.           frag2.m_descOff == index2.m_descOff);
  513.     }
  514.   }
  515.   ndbrequire(off + size == DescPageSize - pagePtr.p->m_numFree);
  516.   pagePtr.p->m_numFree += size;
  517. }