dbtupmeta.cpp

mysql-5.0.22.tar.gz源码包

      if(nullBitPos + bitCount + 1 >= MAX_NULL_BITS)
      {
	terrorCode = TupAddAttrRef::TooManyBitsUsed;
        addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
	return;
      }
      AttributeOffset::setOffset(attrDes2, attributePos);
      AttributeOffset::setNullFlagPos(attrDes2, nullBitPos);
    } else {
      ndbrequire(false);
    }//if
    if (csNumber != 0) { 
      CHARSET_INFO* cs = all_charsets[csNumber];
      ndbrequire(cs != NULL);
      Uint32 i = 0;
      while (i < fragOperPtr.p->charsetIndex) {
        ljam();
        if (regTabPtr.p->charsetArray[i] == cs)
          break;
        i++;
      }
      if (i == fragOperPtr.p->charsetIndex) {
        ljam();
        fragOperPtr.p->charsetIndex++;
      }
      ndbrequire(i < regTabPtr.p->noOfCharsets);
      regTabPtr.p->charsetArray[i] = cs;
      AttributeOffset::setCharsetPos(attrDes2, i);
    }
    setTabDescrWord(firstTabDesIndex + 1, attrDes2);

    if (regTabPtr.p->tupheadsize > MAX_TUPLE_SIZE_IN_WORDS) {
      ljam();
      terrorCode = ZTOO_LARGE_TUPLE_ERROR;
      addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
      return;
    }//if
    if (lastAttr && 
	(fragOperPtr.p->currNullBit != fragOperPtr.p->noOfNullBits))
    {
      ljam();
      terrorCode = ZINCONSISTENT_NULL_ATTRIBUTE_COUNT;
      addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
      return;
    }//if
  }//if
  if (ERROR_INSERTED(4009) && regTabPtr.p->fragid[0] == fragId && attrId == 0 ||
      ERROR_INSERTED(4010) && regTabPtr.p->fragid[0] == fragId && lastAttr ||
      ERROR_INSERTED(4011) && regTabPtr.p->fragid[1] == fragId && attrId == 0 ||
      ERROR_INSERTED(4012) && regTabPtr.p->fragid[1] == fragId && lastAttr) {
    ljam();
    terrorCode = 1;
    addattrrefuseLab(signal, regFragPtr, fragOperPtr, regTabPtr.p, fragId);
    CLEAR_ERROR_INSERT_VALUE;
    return;
  }
/* **************************************************************** */
/* **************          TUP_ADD_ATTCONF       ****************** */
/* **************************************************************** */
  signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  signal->theData[1] = lastAttr;
  sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTCONF, signal, 2, JBB);
  if (! lastAttr) {
    ljam();
    return;	/* EXIT AND WAIT FOR MORE */
  }//if
  regFragPtr.p->fragStatus = ACTIVE;
  if (regTabPtr.p->tableStatus == DEFINING) {
    ljam();
    setUpQueryRoutines(regTabPtr.p);
    setUpKeyArray(regTabPtr.p);
    regTabPtr.p->tableStatus = DEFINED;
  }//if
  releaseFragoperrec(fragOperPtr);
  return;
}//Dbtup::execTUP_ADD_ATTRREQ()

/*
 * Descriptor has these parts:
 *
 * 0 readFunctionArray ( one for each attribute )
 * 1 updateFunctionArray ( ditto )
 * 2 charsetArray ( pointers to distinct CHARSET_INFO )
 * 3 readKeyArray ( attribute ids of keys )
 * 4 attributeGroupDescriptor ( currently size 1 but unused )
 * 5 tabDescriptor ( attribute descriptors, each ZAD_SIZE )
 */

void Dbtup::setUpDescriptorReferences(Uint32 descriptorReference,
                                      Tablerec* const regTabPtr,
                                      const Uint32* offset)
{
  Uint32* desc = &tableDescriptor[descriptorReference].tabDescr;
  regTabPtr->readFunctionArray = (ReadFunction*)(desc + offset[0]);
  regTabPtr->updateFunctionArray = (UpdateFunction*)(desc + offset[1]);
  regTabPtr->charsetArray = (CHARSET_INFO**)(desc + offset[2]);
  regTabPtr->readKeyArray = descriptorReference + offset[3];
  regTabPtr->attributeGroupDescriptor = descriptorReference + offset[4];
  regTabPtr->tabDescriptor = descriptorReference + offset[5];
}//Dbtup::setUpDescriptorReferences()

Uint32
Dbtup::sizeOfReadFunction()
{
  ReadFunction* tmp = (ReadFunction*)&tableDescriptor[0];
  TableDescriptor* start = &tableDescriptor[0];
  TableDescriptor * end = (TableDescriptor*)(tmp + 1);
  return (Uint32)(end - start);
}//Dbtup::sizeOfReadFunction()

void Dbtup::setUpKeyArray(Tablerec* const regTabPtr)
{
  ndbrequire((regTabPtr->readKeyArray + regTabPtr->noOfKeyAttr) < cnoOfTabDescrRec);
  Uint32* keyArray = &tableDescriptor[regTabPtr->readKeyArray].tabDescr;
  Uint32 countKeyAttr = 0;
  for (Uint32 i = 0; i < regTabPtr->noOfAttr; i++) {
    ljam();
    Uint32 refAttr = regTabPtr->tabDescriptor + (i * ZAD_SIZE);
    Uint32 attrDescriptor = getTabDescrWord(refAttr);
    if (AttributeDescriptor::getPrimaryKey(attrDescriptor)) {
      ljam();
      AttributeHeader::init(&keyArray[countKeyAttr], i, 0);
      countKeyAttr++;
    }//if
  }//for
  ndbrequire(countKeyAttr == regTabPtr->noOfKeyAttr);
}//Dbtup::setUpKeyArray()

void Dbtup::addattrrefuseLab(Signal* signal,
                             FragrecordPtr regFragPtr,
                             FragoperrecPtr fragOperPtr,
                             Tablerec* const regTabPtr,
                             Uint32 fragId) 
{
  releaseFragPages(regFragPtr.p);
  deleteFragTab(regTabPtr, fragId);
  releaseFragrec(regFragPtr);
  releaseTabDescr(regTabPtr);
  initTab(regTabPtr);

  signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  signal->theData[1] = terrorCode;
  sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUP_ADD_ATTRREF, signal, 2, JBB);
  releaseFragoperrec(fragOperPtr);
  return;
}//Dbtup::addattrrefuseLab()

void Dbtup::fragrefuse4Lab(Signal* signal,
                           FragoperrecPtr fragOperPtr,
                           FragrecordPtr regFragPtr,
                           Tablerec* const regTabPtr,
                           Uint32 fragId) 
{
  releaseFragPages(regFragPtr.p);
  fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr, fragId);
  initTab(regTabPtr);
  return;
}//Dbtup::fragrefuse4Lab()

void Dbtup::fragrefuse3Lab(Signal* signal,
                           FragoperrecPtr fragOperPtr,
                           FragrecordPtr regFragPtr,
                           Tablerec* const regTabPtr,
                           Uint32 fragId) 
{
  fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
  deleteFragTab(regTabPtr, fragId);
  return;
}//Dbtup::fragrefuse3Lab()

void Dbtup::fragrefuse2Lab(Signal* signal, FragoperrecPtr fragOperPtr, FragrecordPtr regFragPtr) 
{
  fragrefuse1Lab(signal, fragOperPtr);
  releaseFragrec(regFragPtr);
  return;
}//Dbtup::fragrefuse2Lab()

void Dbtup::fragrefuse1Lab(Signal* signal, FragoperrecPtr fragOperPtr) 
{
  fragrefuseLab(signal, fragOperPtr);
  releaseFragoperrec(fragOperPtr);
  return;
}//Dbtup::fragrefuse1Lab()

void Dbtup::fragrefuseLab(Signal* signal, FragoperrecPtr fragOperPtr) 
{
  signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  signal->theData[1] = terrorCode;
  sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGREF, signal, 2, JBB);
  return;
}//Dbtup::fragrefuseLab()

void Dbtup::releaseFragoperrec(FragoperrecPtr fragOperPtr) 
{
  fragOperPtr.p->inUse = false;
  fragOperPtr.p->nextFragoprec = cfirstfreeFragopr;
  cfirstfreeFragopr = fragOperPtr.i;
}//Dbtup::releaseFragoperrec()

void Dbtup::deleteFragTab(Tablerec* const regTabPtr, Uint32 fragId) 
{
  for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
    ljam();
    if (regTabPtr->fragid[i] == fragId) {
      ljam();
      regTabPtr->fragid[i] = RNIL;
      regTabPtr->fragrec[i] = RNIL;
      return;
    }//if
  }//for
  ndbrequire(false);
}//Dbtup::deleteFragTab()

/*
 * LQH aborts on-going create table operation.  The table is later
 * dropped by DICT.
 */
void Dbtup::abortAddFragOp(Signal* signal)
{
  FragoperrecPtr fragOperPtr;

  fragOperPtr.i = signal->theData[1];
  ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  ndbrequire(fragOperPtr.p->inUse);
  releaseFragoperrec(fragOperPtr);
}

void
Dbtup::execDROP_TAB_REQ(Signal* signal)
{
  ljamEntry();
  DropTabReq* req = (DropTabReq*)signal->getDataPtr();
  
  TablerecPtr tabPtr;
  tabPtr.i = req->tableId;
  ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  
  tabPtr.p->m_dropTable.tabUserRef = req->senderRef;
  tabPtr.p->m_dropTable.tabUserPtr = req->senderData;

  signal->theData[0] = ZREL_FRAG;
  signal->theData[1] = tabPtr.i;
  sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
}//Dbtup::execDROP_TAB_REQ()

void Dbtup::releaseTabDescr(Tablerec* const regTabPtr) 
{
  Uint32 descriptor = regTabPtr->readKeyArray;
  if (descriptor != RNIL) {
    ljam();
    Uint32 offset[10];
    getTabDescrOffsets(regTabPtr, offset);

    regTabPtr->tabDescriptor = RNIL;
    regTabPtr->readKeyArray = RNIL;
    regTabPtr->readFunctionArray = NULL;
    regTabPtr->updateFunctionArray = NULL;
    regTabPtr->charsetArray = NULL;
    regTabPtr->attributeGroupDescriptor= RNIL;

    // move to start of descriptor
    descriptor -= offset[3];
    Uint32 retNo = getTabDescrWord(descriptor + ZTD_DATASIZE);
    ndbrequire(getTabDescrWord(descriptor + ZTD_HEADER) == ZTD_TYPE_NORMAL);
    ndbrequire(retNo == getTabDescrWord((descriptor + retNo) - ZTD_TR_SIZE));
    ndbrequire(ZTD_TYPE_NORMAL == getTabDescrWord((descriptor + retNo) - ZTD_TR_TYPE));
    freeTabDescr(descriptor, retNo);
  }//if
}//Dbtup::releaseTabDescr()

void Dbtup::releaseFragment(Signal* signal, Uint32 tableId)
{
  TablerecPtr tabPtr;
  tabPtr.i = tableId;
  ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
  Uint32 fragIndex = RNIL;
  Uint32 fragId = RNIL;
  Uint32 i = 0;
  for (i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
    ljam();
    if (tabPtr.p->fragid[i] != RNIL) {
      ljam();
      fragIndex = tabPtr.p->fragrec[i];
      fragId = tabPtr.p->fragid[i];
      break;
    }//if
  }//for
  if (fragIndex != RNIL) {
    ljam();
    
    FragrecordPtr regFragPtr;
    regFragPtr.i = fragIndex;
    ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
    releaseFragPages(regFragPtr.p);

    tabPtr.p->fragid[i] = RNIL;
    tabPtr.p->fragrec[i] = RNIL;
    releaseFragrec(regFragPtr);

    signal->theData[0] = ZREL_FRAG;
    signal->theData[1] = tableId;
    sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);  
    return;
  }//if
  
  /**
   * Finished...
   */
  sendFSREMOVEREQ(signal, tabPtr);
}//Dbtup::releaseFragment()

void Dbtup::sendFSREMOVEREQ(Signal* signal, TablerecPtr tabPtr)
{
  FsRemoveReq * const fsReq = (FsRemoveReq *)signal->getDataPtrSend();
  fsReq->userReference = cownref;
  fsReq->userPointer = tabPtr.i;
  fsReq->fileNumber[0] = tabPtr.i;
  fsReq->fileNumber[1] = (Uint32)-1; // Remove all fragments
  fsReq->fileNumber[2] = (Uint32)-1; // Remove all data files within fragment
  fsReq->fileNumber[3] = 255 |       // No P-value used here
    (5 <<  8) |  // Data-files in D5
    (0 << 16) | // Data-files
    (1 << 24);  // Version 1 of fileNumber
  
  fsReq->directory = 1;
  fsReq->ownDirectory = 1;
  sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, 
	     FsRemoveReq::SignalLength, JBA);  
}//Dbtup::sendFSREMOVEREQ()
 
void Dbtup::execFSREMOVECONF(Signal* signal)
{
  ljamEntry();
  
  FsConf * const fsConf = (FsConf *)signal->getDataPtrSend();
  TablerecPtr tabPtr;
  tabPtr.i = fsConf->userPointer;
  ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);

  
  DropTabConf * const dropConf = (DropTabConf *)signal->getDataPtrSend();
  dropConf->senderRef = reference();
  dropConf->senderData = tabPtr.p->m_dropTable.tabUserPtr;
  dropConf->tableId = tabPtr.i;
  sendSignal(tabPtr.p->m_dropTable.tabUserRef, GSN_DROP_TAB_CONF,
             signal, DropTabConf::SignalLength, JBB);
  
  releaseTabDescr(tabPtr.p);
  initTab(tabPtr.p);
}//Dbtup::execFSREMOVECONF()