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

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

MySQL数据库

开发平台：

Visual C++

DbtupMeta.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 <signaldata/TupFrag.hpp>
  24. #include <signaldata/FsConf.hpp>
  25. #include <signaldata/FsRemoveReq.hpp>
  26. #include <signaldata/DropTab.hpp>
  27. #include <signaldata/AlterTab.hpp>
  28. #include <AttributeDescriptor.hpp>
  29. #include "AttributeOffset.hpp"
  30. #include <my_sys.h>
  32. #define ljam() { jamLine(20000 + __LINE__); }
  33. #define ljamEntry() { jamEntryLine(20000 + __LINE__); }
  35. /* ---------------------------------------------------------------- */
  36. /* ---------------------------------------------------------------- */
  37. /* --------------- ADD/DROP FRAGMENT TABLE MODULE ----------------- */
  38. /* ---------------------------------------------------------------- */
  39. /* ---------------------------------------------------------------- */
  40. void Dbtup::execTUPFRAGREQ(Signal* signal)
  41. {
  42.   ljamEntry();
  44.   if (signal->theData[0] == (Uint32)-1) {
  45.     ljam();
  46.     abortAddFragOp(signal);
  47.     return;
  48.   }
  50.   FragoperrecPtr fragOperPtr;
  51.   FragrecordPtr regFragPtr;
  52.   TablerecPtr regTabPtr;
  54.   Uint32 userptr = signal->theData[0];
  55.   Uint32 userblockref = signal->theData[1];
  56.   Uint32 reqinfo = signal->theData[2];
  57.   regTabPtr.i = signal->theData[3];
  58.   Uint32 noOfAttributes = signal->theData[4];
  59.   Uint32 fragId = signal->theData[5];
  60.   Uint32 noOfNullAttr = signal->theData[7];
  61.   /*  Uint32 schemaVersion = signal->theData[8];*/
  62.   Uint32 noOfKeyAttr = signal->theData[9];
  64.   Uint32 noOfNewAttr = (signal->theData[10] & 0xFFFF);
  65.   /* DICT sends number of character sets in upper half */
  66.   Uint32 noOfCharsets = (signal->theData[10] >> 16);
  68.   Uint32 checksumIndicator = signal->theData[11];
  69.   Uint32 noOfAttributeGroups = signal->theData[12];
  70.   Uint32 globalCheckpointIdIndicator = signal->theData[13];
  72. #ifndef VM_TRACE
  73.   // config mismatch - do not crash if release compiled
  74.   if (regTabPtr.i >= cnoOfTablerec) {
  75.     ljam();
  76.     signal->theData[0] = userptr;
  77.     signal->theData[1] = 800;
  78.     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
  79.     return;
  80.   }
  81. #endif
  83.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  84.   if (cfirstfreeFragopr == RNIL) {
  85.     ljam();
  86.     signal->theData[0] = userptr;
  87.     signal->theData[1] = ZNOFREE_FRAGOP_ERROR;
  88.     sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
  89.     return;
  90.   }//if
  91.   seizeFragoperrec(fragOperPtr);
  93.   fragOperPtr.p->nextFragoprec = RNIL;
  94.   fragOperPtr.p->lqhBlockrefFrag = userblockref;
  95.   fragOperPtr.p->lqhPtrFrag = userptr;
  96.   fragOperPtr.p->fragidFrag = fragId;
  97.   fragOperPtr.p->tableidFrag = regTabPtr.i;
  98.   fragOperPtr.p->attributeCount = noOfAttributes;
  99.   fragOperPtr.p->freeNullBit = noOfNullAttr;
  100.   fragOperPtr.p->noOfNewAttrCount = noOfNewAttr;
  101.   fragOperPtr.p->charsetIndex = 0;
  103.   ndbrequire(reqinfo == ZADDFRAG);
  105.   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  106.   if (regFragPtr.i != RNIL) {
  107.     ljam();
  108.     terrorCode = ZEXIST_FRAG_ERROR; /* THE FRAGMENT ALREADY EXIST */
  109.     fragrefuse1Lab(signal, fragOperPtr);
  110.     return;
  111.   }//if
  112.   if (cfirstfreefrag != RNIL) {
  113.     ljam();
  114.     seizeFragrecord(regFragPtr);
  115.   } else {
  116.     ljam();
  117.     terrorCode = ZFULL_FRAGRECORD_ERROR;
  118.     fragrefuse1Lab(signal, fragOperPtr);
  119.     return;
  120.   }//if
  121.   initFragRange(regFragPtr.p);
  122.   if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) {
  123.     ljam();
  124.     terrorCode = ZNO_FREE_TAB_ENTRY_ERROR;
  125.     fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
  126.     return;
  127.   }//if
  128.   if (cfirstfreerange == RNIL) {
  129.     ljam();
  130.     terrorCode = ZNO_FREE_PAGE_RANGE_ERROR;
  131.     fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
  132.     return;
  133.   }//if
  135.   regFragPtr.p->emptyPrimPage = RNIL;
  136.   regFragPtr.p->thFreeFirst = RNIL;
  137.   regFragPtr.p->thFreeCopyFirst = RNIL;
  138.   regFragPtr.p->noCopyPagesAlloc = 0;
  139.   regFragPtr.p->fragTableId = regTabPtr.i;
  140.   regFragPtr.p->fragmentId = fragId;
  141.   regFragPtr.p->checkpointVersion = RNIL;
  143.   Uint32 noAllocatedPages = 2;
  144.   noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);
  146.   if (noAllocatedPages == 0) {
  147.     ljam();
  148.     terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
  149.     fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
  150.     return;
  151.   }//if
  153.   if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
  154.       ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
  155.     ljam();
  156.     terrorCode = 1;
  157.     fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
  158.     CLEAR_ERROR_INSERT_VALUE;
  159.     return;
  160.   }
  162.   if (regTabPtr.p->tableStatus == NOT_DEFINED) {
  163.     ljam();
  164. //-------------------------------------------------------------------------------------
  165. // We are setting up references to the header of the tuple.
  166. // Active operation  This word contains a reference to the operation active on the tuple
  167. //                   at the moment. RNIL means no one active at all.  Not optional.
  168. // Tuple version     Uses only low 16 bits.  Not optional.
  169. // Checksum          The third header word is optional and contains a checksum of the
  170. //                   tuple header.
  171. // Null-bits         A number of words to contain null bits for all non-dynamic attributes.
  172. //                   Each word contains upto 32 null bits. Each time a new word is needed
  173. //                   we allocate the complete word. Zero nullable attributes means that
  174. //                   there is no word at all
  175. // Global Checkpoint id
  176. //                   This word is optional. When used it is stored as a 32-bit unsigned
  177. //                   attribute with attribute identity 0. Thus the kernel assumes that
  178. //                   this is the first word after the header.
  179. //-------------------------------------------------------------------------------------
  180.     fragOperPtr.p->definingFragment = true;
  181.     regTabPtr.p->tableStatus = DEFINING;
  182.     regTabPtr.p->checksumIndicator = (checksumIndicator != 0 ? true : false);
  183.     regTabPtr.p->GCPIndicator = (globalCheckpointIdIndicator != 0 ? true : false);
  185.     regTabPtr.p->tupChecksumIndex = 2;
  186.     regTabPtr.p->tupNullIndex = 2 + (checksumIndicator != 0 ? 1 : 0);
  187.     regTabPtr.p->tupNullWords = (noOfNullAttr + 31) >> 5;
  188.     regTabPtr.p->tupGCPIndex = regTabPtr.p->tupNullIndex + regTabPtr.p->tupNullWords;
  189.     regTabPtr.p->tupheadsize = regTabPtr.p->tupGCPIndex;
  191.     regTabPtr.p->noOfKeyAttr = noOfKeyAttr;
  192.     regTabPtr.p->noOfCharsets = noOfCharsets;
  193.     regTabPtr.p->noOfAttr = noOfAttributes;
  194.     regTabPtr.p->noOfNewAttr = noOfNewAttr;
  195.     regTabPtr.p->noOfNullAttr = noOfNullAttr;
  196.     regTabPtr.p->noOfAttributeGroups = noOfAttributeGroups;
  198.     regTabPtr.p->notNullAttributeMask.clear();
  200.     Uint32 offset[10];
  201.     Uint32 tableDescriptorRef = allocTabDescr(regTabPtr.p, offset);
  202.     if (tableDescriptorRef == RNIL) {
  203.       ljam();
  204.       fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
  205.       return;
  206.     }//if
  207.     setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset);
  208.   } else {
  209.     ljam();
  210.     fragOperPtr.p->definingFragment = false;
  211.   }//if
  212.   signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  213.   signal->theData[1] = fragOperPtr.i;
  214.   signal->theData[2] = regFragPtr.i;
  215.   signal->theData[3] = fragId;
  216.   sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGCONF, signal, 4, JBB);
  217.   return;
  218. }//Dbtup::execTUPFRAGREQ()
  220. /* -------------------------------------------------------------------- */
  221. /* ------------------------- ADDFRAGTOTAB ----------------------------- */
  222. /* PUTS A FRAGMENT POINTER AND FID IN THE TABLE ARRAY OF THE TID RECORD */
  223. /* -------------------------------------------------------------------- */
  224. bool Dbtup::addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex) 
  225. {
  226.   for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
  227.     ljam();
  228.     if (regTabPtr->fragid[i] == RNIL) {
  229.       ljam();
  230.       regTabPtr->fragid[i] = fragId;
  231.       regTabPtr->fragrec[i] = fragIndex;
  232.       return true;
  233.     }//if
  234.   }//for
  235.   return false;
  236. }//Dbtup::addfragtotab()
  238. void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr) 
  239. {
  240.   for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
  241.     ljam();
  242.     if (regTabPtr->fragid[i] == fragId) {
  243.       ljam();
  244. /* ---------------------------------------------------------------- */
  245. /* A FRAGMENT  RECORD HAVE BEEN FOUND FOR THIS OPERATION.           */
  246. /* ---------------------------------------------------------------- */
  247.       regFragPtr.i = regTabPtr->fragrec[i];
  248.       ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  249.       return;
  250.     }//if
  251.   }//for
  252.   regFragPtr.i = RNIL;
  253.   ptrNull(regFragPtr);
  254. }//Dbtup::getFragmentrec()
  256. void Dbtup::seizeFragrecord(FragrecordPtr& regFragPtr) 
  257. {
  258.   regFragPtr.i = cfirstfreefrag;
  259.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  260.   cfirstfreefrag = regFragPtr.p->nextfreefrag;
  261.   regFragPtr.p->nextfreefrag = RNIL;
  262. }//Dbtup::seizeFragrecord()
  264. /* ---------------------------------------------------------------- */
  265. /* SEIZE A FRAGMENT OPERATION RECORD                                */
  266. /* ---------------------------------------------------------------- */
  267. void Dbtup::seizeFragoperrec(FragoperrecPtr& fragOperPtr) 
  268. {
  269.   fragOperPtr.i = cfirstfreeFragopr;
  270.   ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  271.   cfirstfreeFragopr = fragOperPtr.p->nextFragoprec;
  272.   fragOperPtr.p->nextFragoprec = RNIL;
  273.   fragOperPtr.p->inUse = true;
  274. }//Dbtup::seizeFragoperrec()
  276. /* **************************************************************** */
  277. /* **************          TUP_ADD_ATTRREQ       ****************** */
  278. /* **************************************************************** */
  279. void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
  280. {
  281.   FragrecordPtr regFragPtr;
  282.   FragoperrecPtr fragOperPtr;
  283.   TablerecPtr regTabPtr;
  285.   ljamEntry();
  286.   fragOperPtr.i = signal->theData[0];
  287.   ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  288.   Uint32 attrId = signal->theData[2];
  289.   Uint32 attrDescriptor = signal->theData[3];
  290.   // DICT sends extended type (ignored) and charset number
  291.   Uint32 extType = (signal->theData[4] & 0xFF);
  292.   Uint32 csNumber = (signal->theData[4] >> 16);
  294.   regTabPtr.i = fragOperPtr.p->tableidFrag;
  295.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  297.   Uint32 fragId = fragOperPtr.p->fragidFrag;
  299.   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  300.   ndbrequire(regFragPtr.i != RNIL);
  302.   ndbrequire(fragOperPtr.p->attributeCount > 0);
  303.   fragOperPtr.p->attributeCount--;
  304.   const bool lastAttr = (fragOperPtr.p->attributeCount == 0);
  306.   if ((regTabPtr.p->tableStatus == DEFINING) &&
  307.       (fragOperPtr.p->definingFragment)) {
  308.     ljam();
  309.     Uint32 firstTabDesIndex = regTabPtr.p->tabDescriptor + (attrId * ZAD_SIZE);
  310.     setTabDescrWord(firstTabDesIndex, attrDescriptor);
  311.     Uint32 attrLen = AttributeDescriptor::getSize(attrDescriptor);
  312.     Uint32 nullBitPos = 0;                  /* Default pos for NOT NULL attributes */
  313.     if (AttributeDescriptor::getNullable(attrDescriptor)) {
  314.       if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
  315.         ljam();                                                      /* NULL ATTR */
  316.         fragOperPtr.p->freeNullBit--;                            /* STORE NULL BIT POSTITION */
  317.         nullBitPos = fragOperPtr.p->freeNullBit;
  318.         ndbrequire(fragOperPtr.p->freeNullBit < ZNIL);               /* Check not below zero */
  319.       }//if
  320.     } else {
  321.       ljam();
  322.       regTabPtr.p->notNullAttributeMask.set(attrId);
  323.     }//if
  325.     Uint32 attrDes2 = 0;
  326.     if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
  327.       ljam();
  328.       Uint32 attributePos = regTabPtr.p->tupheadsize;
  329.       switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
  330.       case 1:
  331.       case 2:
  332.       {
  333.         ljam();
  334.         Uint32 bitsUsed = AttributeDescriptor::getArraySize(attrDescriptor) * (1 << attrLen);
  335.         regTabPtr.p->tupheadsize += ((bitsUsed + 31) >> 5);
  336.         break;
  337.       }
  338.       default:
  339.         ndbrequire(false);
  340.         break;
  341.       }//switch
  342.       AttributeOffset::setOffset(attrDes2, attributePos);
  343.       AttributeOffset::setNullFlagPos(attrDes2, nullBitPos);
  344.     } else {
  345.       ndbrequire(false);
  346.     }//if
  347.     if (csNumber != 0) { 
  348.       CHARSET_INFO* cs = get_charset(csNumber, MYF(0));
  349.       if (cs == NULL) {
  350.         ljam();
  351.         terrorCode = TupAddAttrRef::InvalidCharset;
  352.         addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
  353.         return;
  354.       }
  355.       Uint32 i = 0;
  356.       while (i < fragOperPtr.p->charsetIndex) {
  357.         ljam();
  358.         if (regTabPtr.p->charsetArray[i] == cs)
  359.           break;
  360.         i++;
  361.       }
  362.       if (i == fragOperPtr.p->charsetIndex) {
  363.         ljam();
  364.         fragOperPtr.p->charsetIndex++;
  365.       }
  366.       ndbrequire(i < regTabPtr.p->noOfCharsets);
  367.       regTabPtr.p->charsetArray[i] = cs;
  368.       AttributeOffset::setCharsetPos(attrDes2, i);
  369.     }
  370.     setTabDescrWord(firstTabDesIndex + 1, attrDes2);
  372.     if (regTabPtr.p->tupheadsize > MAX_TUPLE_SIZE_IN_WORDS) {
  373.       ljam();
  374.       terrorCode = ZTOO_LARGE_TUPLE_ERROR;
  375.       addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
  376.       return;
  377.     }//if
  378.     if (lastAttr && (fragOperPtr.p->freeNullBit != 0)) {
  379.       ljam();
  380.       terrorCode = ZINCONSISTENT_NULL_ATTRIBUTE_COUNT;
  381.       addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
  382.       return;
  383.     }//if
  384.   }//if
  385.   if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId && attrId == 0 ||
  386.       ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId && lastAttr ||
  387.       ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0 ||
  388.       ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId && lastAttr) {
  389.     ljam();
  390.     terrorCode = 1;
  391.     addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
  392.     CLEAR_ERROR_INSERT_VALUE;
  393.     return;
  394.   }
  395. /* **************************************************************** */
  396. /* **************          TUP_ADD_ATTCONF       ****************** */
  397. /* **************************************************************** */
  398.   signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  399.   signal->theData[1] = lastAttr;
  400.   sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, signal, 2, JBB);
  401.   if (! lastAttr) {
  402.     ljam();
  403.     return; /* EXIT AND WAIT FOR MORE */
  404.   }//if
  405.   regFragPtr.p->fragStatus = ACTIVE;
  406.   if (regTabPtr.p->tableStatus == DEFINING) {
  407.     ljam();
  408.     setUpQueryRoutines(regTabPtr.p);
  409.     setUpKeyArray(regTabPtr.p);
  410.     regTabPtr.p->tableStatus = DEFINED;
  411.   }//if
  412.   releaseFragoperrec(fragOperPtr);
  413.   return;
  414. }//Dbtup::execTUP_ADD_ATTRREQ()
  416. /*
  417.  * Descriptor has these parts:
  418.  *
  419.  * 0 readFunctionArray ( one for each attribute )
  420.  * 1 updateFunctionArray ( ditto )
  421.  * 2 charsetArray ( pointers to distinct CHARSET_INFO )
  422.  * 3 readKeyArray ( attribute ids of keys )
  423.  * 4 attributeGroupDescriptor ( currently size 1 but unused )
  424.  * 5 tabDescriptor ( attribute descriptors, each ZAD_SIZE )
  425.  */
  427. void Dbtup::setUpDescriptorReferences(Uint32 descriptorReference,
  428.                                       Tablerec* const regTabPtr,
  429.                                       const Uint32* offset)
  430. {
  431.   Uint32* desc = &tableDescriptor[descriptorReference].tabDescr;
  432.   regTabPtr->readFunctionArray = (ReadFunction*)(desc + offset[0]);
  433.   regTabPtr->updateFunctionArray = (UpdateFunction*)(desc + offset[1]);
  434.   regTabPtr->charsetArray = (CHARSET_INFO**)(desc + offset[2]);
  435.   regTabPtr->readKeyArray = descriptorReference + offset[3];
  436.   regTabPtr->attributeGroupDescriptor = descriptorReference + offset[4];
  437.   regTabPtr->tabDescriptor = descriptorReference + offset[5];
  438. }//Dbtup::setUpDescriptorReferences()
  440. Uint32
  441. Dbtup::sizeOfReadFunction()
  442. {
  443.   ReadFunction* tmp = (ReadFunction*)&tableDescriptor[0];
  444.   TableDescriptor* start = &tableDescriptor[0];
  445.   TableDescriptor * end = (TableDescriptor*)(tmp + 1);
  446.   return (Uint32)(end - start);
  447. }//Dbtup::sizeOfReadFunction()
  449. void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
  450. {
  451.   ndbrequire((regTabPtr->readKeyArray + regTabPtr->noOfKeyAttr) < cnoOfTabDescrRec);
  452.   Uint32* keyArray = &tableDescriptor[regTabPtr->readKeyArray].tabDescr;
  453.   Uint32 countKeyAttr = 0;
  454.   for (Uint32 i = 0; i < regTabPtr->noOfAttr; i++) {
  455.     ljam();
  456.     Uint32 refAttr = regTabPtr->tabDescriptor + (i * ZAD_SIZE);
  457.     Uint32 attrDescriptor = getTabDescrWord(refAttr);
  458.     if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) {
  459.       ljam();
  460.       AttributeHeader::init(&keyArray[countKeyAttr], i, 0);
  461.       countKeyAttr++;
  462.     }//if
  463.   }//for
  464.   ndbrequire(countKeyAttr == regTabPtr->noOfKeyAttr);
  465. }//Dbtup::setUpKeyArray()
  467. void Dbtup::addattrrefuseLab(Signal* signal,
  468.                              FragrecordPtr regFragPtr,
  469.                              FragoperrecPtr fragOperPtr,
  470.                              Tablerec* const regTabPtr,
  471.                              Uint32 fragId) 
  472. {
  473.   releaseFragPages(regFragPtr.p);
  474.   deleteFragTab(regTabPtr, fragId);
  475.   releaseFragrec(regFragPtr);
  476.   releaseTabDescr(regTabPtr);
  477.   initTab(regTabPtr);
  479.   signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  480.   signal->theData[1] = terrorCode;
  481.   sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTRREF, signal, 2, JBB);
  482.   releaseFragoperrec(fragOperPtr);
  483.   return;
  484. }//Dbtup::addattrrefuseLab()
  486. void Dbtup::fragrefuse4Lab(Signal* signal,
  487.                            FragoperrecPtr fragOperPtr,
  488.                            FragrecordPtr regFragPtr,
  489.                            Tablerec* const regTabPtr,
  490.                            Uint32 fragId) 
  491. {
  492.   releaseFragPages(regFragPtr.p);
  493.   fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr, fragId);
  494.   initTab(regTabPtr);
  495.   return;
  496. }//Dbtup::fragrefuse4Lab()
  498. void Dbtup::fragrefuse3Lab(Signal* signal,
  499.                            FragoperrecPtr fragOperPtr,
  500.                            FragrecordPtr regFragPtr,
  501.                            Tablerec* const regTabPtr,
  502.                            Uint32 fragId) 
  503. {
  504.   fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
  505.   deleteFragTab(regTabPtr, fragId);
  506.   return;
  507. }//Dbtup::fragrefuse3Lab()
  509. void Dbtup::fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr) 
  510. {
  511.   fragrefuse1Lab(signal, fragOperPtr);
  512.   releaseFragrec(regFragPtr);
  513.   return;
  514. }//Dbtup::fragrefuse2Lab()
  516. void Dbtup::fragrefuse1Lab(Signal* signal, FragoperrecPtr fragOperPtr) 
  517. {
  518.   fragrefuseLab(signal, fragOperPtr);
  519.   releaseFragoperrec(fragOperPtr);
  520.   return;
  521. }//Dbtup::fragrefuse1Lab()
  523. void Dbtup::fragrefuseLab(Signal* signal, FragoperrecPtr fragOperPtr) 
  524. {
  525.   signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  526.   signal->theData[1] = terrorCode;
  527.   sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGREF, signal, 2, JBB);
  528.   return;
  529. }//Dbtup::fragrefuseLab()
  531. void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr) 
  532. {
  533.   fragOperPtr.p->inUse = false;
  534.   fragOperPtr.p->nextFragoprec = cfirstfreeFragopr;
  535.   cfirstfreeFragopr = fragOperPtr.i;
  536. }//Dbtup::releaseFragoperrec()
  538. void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) 
  539. {
  540.   for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
  541.     ljam();
  542.     if (regTabPtr->fragid[i] == fragId) {
  543.       ljam();
  544.       regTabPtr->fragid[i] = RNIL;
  545.       regTabPtr->fragrec[i] = RNIL;
  546.       return;
  547.     }//if
  548.   }//for
  549.   ndbrequire(false);
  550. }//Dbtup::deleteFragTab()
  552. /*
  553.  * LQH aborts on-going create table operation.  The table is later
  554.  * dropped by DICT.
  555.  */
  556. void Dbtup::abortAddFragOp(Signal* signal)
  557. {
  558.   FragoperrecPtr fragOperPtr;
  560.   fragOperPtr.i = signal->theData[1];
  561.   ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  562.   ndbrequire(fragOperPtr.p->inUse);
  563.   releaseFragoperrec(fragOperPtr);
  564. }
  566. void
  567. Dbtup::execDROP_TAB_REQ(Signal* signal)
  568. {
  569.   ljamEntry();
  570.   DropTabReq* req = (DropTabReq*)signal->getDataPtr();
  571.   
  572.   TablerecPtr tabPtr;
  573.   tabPtr.i = req->tableId;
  574.   ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  575.   
  576.   tabPtr.p->m_dropTable.tabUserRef = req->senderRef;
  577.   tabPtr.p->m_dropTable.tabUserPtr = req->senderData;
  579.   signal->theData[0] = ZREL_FRAG;
  580.   signal->theData[1] = tabPtr.i;
  581.   sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  582. }//Dbtup::execDROP_TAB_REQ()
  584. void Dbtup::releaseTabDescr(Tablerec* const regTabPtr) 
  585. {
  586.   Uint32 descriptor = regTabPtr->readKeyArray;
  587.   if (descriptor != RNIL) {
  588.     ljam();
  589.     Uint32 offset[10];
  590.     getTabDescrOffsets(regTabPtr, offset);
  592.     regTabPtr->tabDescriptor = RNIL;
  593.     regTabPtr->readKeyArray = RNIL;
  594.     regTabPtr->readFunctionArray = NULL;
  595.     regTabPtr->updateFunctionArray = NULL;
  596.     regTabPtr->charsetArray = NULL;
  597.     regTabPtr->attributeGroupDescriptor= RNIL;
  599.     // move to start of descriptor
  600.     descriptor -= offset[3];
  601.     Uint32 retNo = getTabDescrWord(descriptor + ZTD_DATASIZE);
  602.     ndbrequire(getTabDescrWord(descriptor + ZTD_HEADER) == ZTD_TYPE_NORMAL);
  603.     ndbrequire(retNo == getTabDescrWord((descriptor + retNo) - ZTD_TR_SIZE));
  604.     ndbrequire(ZTD_TYPE_NORMAL == getTabDescrWord((descriptor + retNo) - ZTD_TR_TYPE));
  605.     freeTabDescr(descriptor, retNo);
  606.   }//if
  607. }//Dbtup::releaseTabDescr()
  609. void Dbtup::releaseFragment(Signal* signal, Uint32 tableId)
  610. {
  611.   TablerecPtr tabPtr;
  612.   tabPtr.i = tableId;
  613.   ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  614.   Uint32 fragIndex = RNIL;
  615.   Uint32 fragId = RNIL;
  616.   Uint32 i = 0;
  617.   for (i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
  618.     ljam();
  619.     if (tabPtr.p->fragid[i] != RNIL) {
  620.       ljam();
  621.       fragIndex = tabPtr.p->fragrec[i];
  622.       fragId = tabPtr.p->fragid[i];
  623.       break;
  624.     }//if
  625.   }//for
  626.   if (fragIndex != RNIL) {
  627.     ljam();
  628.     
  629.     FragrecordPtr regFragPtr;
  630.     regFragPtr.i = fragIndex;
  631.     ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  632.     releaseFragPages(regFragPtr.p);
  634.     tabPtr.p->fragid[i] = RNIL;
  635.     tabPtr.p->fragrec[i] = RNIL;
  636.     releaseFragrec(regFragPtr);
  638.     signal->theData[0] = ZREL_FRAG;
  639.     signal->theData[1] = tableId;
  640.     sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);  
  641.     return;
  642.   }//if
  643.   
  644.   /**
  645.    * Finished...
  646.    */
  647.   sendFSREMOVEREQ(signal, tabPtr);
  648. }//Dbtup::releaseFragment()
  650. void Dbtup::sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr)
  651. {
  652.   FsRemoveReq * const fsReq = (FsRemoveReq *)signal->getDataPtrSend();
  653.   fsReq->userReference = cownref;
  654.   fsReq->userPointer = tabPtr.i;
  655.   fsReq->fileNumber[0] = tabPtr.i;
  656.   fsReq->fileNumber[1] = (Uint32)-1; // Remove all fragments
  657.   fsReq->fileNumber[2] = (Uint32)-1; // Remove all data files within fragment
  658.   fsReq->fileNumber[3] = 255 |       // No P-value used here
  659.     (5 <<  8) |  // Data-files in D5
  660.     (0 << 16) | // Data-files
  661.     (1 << 24);  // Version 1 of fileNumber
  662.   
  663.   fsReq->directory = 1;
  664.   fsReq->ownDirectory = 1;
  665.   sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, 
  666.      FsRemoveReq::SignalLength, JBA);  
  667. }//Dbtup::sendFSREMOVEREQ()
  668.  
  669. void Dbtup::execFSREMOVECONF(Signal* signal)
  670. {
  671.   ljamEntry();
  672.   
  673.   FsConf * const fsConf = (FsConf *)signal->getDataPtrSend();
  674.   TablerecPtr tabPtr;
  675.   tabPtr.i = fsConf->userPointer;
  676.   ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  678.   
  679.   DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend();
  680.   dropConf->senderRef = reference();
  681.   dropConf->senderData = tabPtr.p->m_dropTable.tabUserPtr;
  682.   dropConf->tableId = tabPtr.i;
  683.   sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF,
  684.              signal, DropTabConf::SignalLength, JBB);
  685.   
  686.   releaseTabDescr(tabPtr.p);
  687.   initTab(tabPtr.p);
  688. }//Dbtup::execFSREMOVECONF()