dbtupmeta.cpp

mysql-5.0.22.tar.gz源码包

/* Copyright (C) 2003 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


#define DBTUP_C
#include "Dbtup.hpp"
#include <RefConvert.hpp>
#include <ndb_limits.h>
#include <pc.hpp>
#include <signaldata/TupFrag.hpp>
#include <signaldata/FsConf.hpp>
#include <signaldata/FsRemoveReq.hpp>
#include <signaldata/DropTab.hpp>
#include <signaldata/AlterTab.hpp>
#include <AttributeDescriptor.hpp>
#include "AttributeOffset.hpp"
#include <my_sys.h>

#define ljam() { jamLine(20000 + __LINE__); }
#define ljamEntry() { jamEntryLine(20000 + __LINE__); }

/* ---------------------------------------------------------------- */
/* ---------------------------------------------------------------- */
/* --------------- ADD/DROP FRAGMENT TABLE MODULE ----------------- */
/* ---------------------------------------------------------------- */
/* ---------------------------------------------------------------- */
void Dbtup::execTUPFRAGREQ(Signal* signal)
{
  ljamEntry();

  if (signal->theData[0] == (Uint32)-1) {
    ljam();
    abortAddFragOp(signal);
    return;
  }

  FragoperrecPtr fragOperPtr;
  FragrecordPtr regFragPtr;
  TablerecPtr regTabPtr;

  Uint32 userptr = signal->theData[0];
  Uint32 userblockref = signal->theData[1];
  Uint32 reqinfo = signal->theData[2];
  regTabPtr.i = signal->theData[3];
  Uint32 noOfAttributes = signal->theData[4];
  Uint32 fragId = signal->theData[5];
  Uint32 noOfNullAttr = signal->theData[7];
  /*  Uint32 schemaVersion = signal->theData[8];*/
  Uint32 noOfKeyAttr = signal->theData[9];

  Uint32 noOfNewAttr = (signal->theData[10] & 0xFFFF);
  /* DICT sends number of character sets in upper half */
  Uint32 noOfCharsets = (signal->theData[10] >> 16);

  Uint32 checksumIndicator = signal->theData[11];
  Uint32 noOfAttributeGroups = signal->theData[12];
  Uint32 globalCheckpointIdIndicator = signal->theData[13];

#ifndef VM_TRACE
  // config mismatch - do not crash if release compiled
  if (regTabPtr.i >= cnoOfTablerec) {
    ljam();
    signal->theData[0] = userptr;
    signal->theData[1] = 800;
    sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
    return;
  }
#endif

  ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  if (cfirstfreeFragopr == RNIL) {
    ljam();
    signal->theData[0] = userptr;
    signal->theData[1] = ZNOFREE_FRAGOP_ERROR;
    sendSignal(userblockref, GSN_TUPFRAGREF, signal, 2, JBB);
    return;
  }//if
  seizeFragoperrec(fragOperPtr);

  fragOperPtr.p->nextFragoprec = RNIL;
  fragOperPtr.p->lqhBlockrefFrag = userblockref;
  fragOperPtr.p->lqhPtrFrag = userptr;
  fragOperPtr.p->fragidFrag = fragId;
  fragOperPtr.p->tableidFrag = regTabPtr.i;
  fragOperPtr.p->attributeCount = noOfAttributes;
  fragOperPtr.p->noOfNullBits = noOfNullAttr;
  fragOperPtr.p->noOfNewAttrCount = noOfNewAttr;
  fragOperPtr.p->charsetIndex = 0;
  fragOperPtr.p->currNullBit = 0;

  ndbrequire(reqinfo == ZADDFRAG);

  getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  if (regFragPtr.i != RNIL) {
    ljam();
    terrorCode = ZEXIST_FRAG_ERROR;	/* THE FRAGMENT ALREADY EXIST */
    fragrefuse1Lab(signal, fragOperPtr);
    return;
  }//if
  if (cfirstfreefrag != RNIL) {
    ljam();
    seizeFragrecord(regFragPtr);
  } else {
    ljam();
    terrorCode = ZFULL_FRAGRECORD_ERROR;
    fragrefuse1Lab(signal, fragOperPtr);
    return;
  }//if
  initFragRange(regFragPtr.p);
  if (!addfragtotab(regTabPtr.p, fragId, regFragPtr.i)) {
    ljam();
    terrorCode = ZNO_FREE_TAB_ENTRY_ERROR;
    fragrefuse2Lab(signal, fragOperPtr, regFragPtr);
    return;
  }//if
  if (cfirstfreerange == RNIL) {
    ljam();
    terrorCode = ZNO_FREE_PAGE_RANGE_ERROR;
    fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
    return;
  }//if

  regFragPtr.p->emptyPrimPage = RNIL;
  regFragPtr.p->thFreeFirst = RNIL;
  regFragPtr.p->thFreeCopyFirst = RNIL;
  regFragPtr.p->noCopyPagesAlloc = 0;
  regFragPtr.p->fragTableId = regTabPtr.i;
  regFragPtr.p->fragmentId = fragId;
  regFragPtr.p->checkpointVersion = RNIL;

  Uint32 noAllocatedPages = 2;
  noAllocatedPages = allocFragPages(regFragPtr.p, noAllocatedPages);

  if (noAllocatedPages == 0) {
    ljam();
    terrorCode = ZNO_PAGES_ALLOCATED_ERROR;
    fragrefuse3Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
    return;
  }//if

  if (ERROR_INSERTED(4007) && regTabPtr.p->fragid[0] == fragId ||
      ERROR_INSERTED(4008) && regTabPtr.p->fragid[1] == fragId) {
    ljam();
    terrorCode = 1;
    fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
    CLEAR_ERROR_INSERT_VALUE;
    return;
  }

  if (regTabPtr.p->tableStatus == NOT_DEFINED) {
    ljam();
//-------------------------------------------------------------------------------------
// We are setting up references to the header of the tuple.
// Active operation  This word contains a reference to the operation active on the tuple
//                   at the moment. RNIL means no one active at all.  Not optional.
// Tuple version     Uses only low 16 bits.  Not optional.
// Checksum          The third header word is optional and contains a checksum of the
//                   tuple header.
// Null-bits         A number of words to contain null bits for all non-dynamic attributes.
//                   Each word contains upto 32 null bits. Each time a new word is needed
//                   we allocate the complete word. Zero nullable attributes means that
//                   there is no word at all
// Global Checkpoint id
//                   This word is optional. When used it is stored as a 32-bit unsigned
//                   attribute with attribute identity 0. Thus the kernel assumes that
//                   this is the first word after the header.
//-------------------------------------------------------------------------------------
    fragOperPtr.p->definingFragment = true;
    regTabPtr.p->tableStatus = DEFINING;
    regTabPtr.p->checksumIndicator = (checksumIndicator != 0 ? true : false);
    regTabPtr.p->GCPIndicator = (globalCheckpointIdIndicator != 0 ? true : false);

    regTabPtr.p->tupChecksumIndex = 2;
    regTabPtr.p->tupNullIndex = 2 + (checksumIndicator != 0 ? 1 : 0);
    regTabPtr.p->tupNullWords = (noOfNullAttr + 31) >> 5;
    regTabPtr.p->tupGCPIndex = regTabPtr.p->tupNullIndex + regTabPtr.p->tupNullWords;
    regTabPtr.p->tupheadsize = regTabPtr.p->tupGCPIndex;

    regTabPtr.p->noOfKeyAttr = noOfKeyAttr;
    regTabPtr.p->noOfCharsets = noOfCharsets;
    regTabPtr.p->noOfAttr = noOfAttributes;
    regTabPtr.p->noOfNewAttr = noOfNewAttr;
    regTabPtr.p->noOfNullAttr = noOfNullAttr;
    regTabPtr.p->noOfAttributeGroups = noOfAttributeGroups;

    regTabPtr.p->notNullAttributeMask.clear();

    Uint32 offset[10];
    Uint32 tableDescriptorRef = allocTabDescr(regTabPtr.p, offset);
    if (tableDescriptorRef == RNIL) {
      ljam();
      fragrefuse4Lab(signal, fragOperPtr, regFragPtr, regTabPtr.p, fragId);
      return;
    }//if
    setUpDescriptorReferences(tableDescriptorRef, regTabPtr.p, offset);
  } else {
    ljam();
    fragOperPtr.p->definingFragment = false;
  }//if
  signal->theData[0] = fragOperPtr.p->lqhPtrFrag;
  signal->theData[1] = fragOperPtr.i;
  signal->theData[2] = regFragPtr.i;
  signal->theData[3] = fragId;
  sendSignal(fragOperPtr.p->lqhBlockrefFrag, GSN_TUPFRAGCONF, signal, 4, JBB);
  return;
}//Dbtup::execTUPFRAGREQ()

/* -------------------------------------------------------------------- */
/* ------------------------- ADDFRAGTOTAB ----------------------------- */
/* PUTS A FRAGMENT POINTER AND FID IN THE TABLE ARRAY OF THE TID RECORD */
/* -------------------------------------------------------------------- */
bool Dbtup::addfragtotab(Tablerec* const regTabPtr, Uint32 fragId, Uint32 fragIndex) 
{
  for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
    ljam();
    if (regTabPtr->fragid[i] == RNIL) {
      ljam();
      regTabPtr->fragid[i] = fragId;
      regTabPtr->fragrec[i] = fragIndex;
      return true;
    }//if
  }//for
  return false;
}//Dbtup::addfragtotab()

void Dbtup::getFragmentrec(FragrecordPtr& regFragPtr, Uint32 fragId, Tablerec* const regTabPtr) 
{
  for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
    ljam();
    if (regTabPtr->fragid[i] == fragId) {
      ljam();
/* ---------------------------------------------------------------- */
/* A FRAGMENT  RECORD HAVE BEEN FOUND FOR THIS OPERATION.           */
/* ---------------------------------------------------------------- */
      regFragPtr.i = regTabPtr->fragrec[i];
      ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
      return;
    }//if
  }//for
  regFragPtr.i = RNIL;
  ptrNull(regFragPtr);
}//Dbtup::getFragmentrec()

void Dbtup::seizeFragrecord(FragrecordPtr& regFragPtr) 
{
  regFragPtr.i = cfirstfreefrag;
  ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  cfirstfreefrag = regFragPtr.p->nextfreefrag;
  regFragPtr.p->nextfreefrag = RNIL;
}//Dbtup::seizeFragrecord()

/* ---------------------------------------------------------------- */
/* SEIZE A FRAGMENT OPERATION RECORD                                */
/* ---------------------------------------------------------------- */
void Dbtup::seizeFragoperrec(FragoperrecPtr& fragOperPtr) 
{
  fragOperPtr.i = cfirstfreeFragopr;
  ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  cfirstfreeFragopr = fragOperPtr.p->nextFragoprec;
  fragOperPtr.p->nextFragoprec = RNIL;
  fragOperPtr.p->inUse = true;
}//Dbtup::seizeFragoperrec()

/* **************************************************************** */
/* **************          TUP_ADD_ATTRREQ       ****************** */
/* **************************************************************** */
void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
{
  FragrecordPtr regFragPtr;
  FragoperrecPtr fragOperPtr;
  TablerecPtr regTabPtr;

  ljamEntry();
  fragOperPtr.i = signal->theData[0];
  ptrCheckGuard(fragOperPtr, cnoOfFragoprec, fragoperrec);
  Uint32 attrId = signal->theData[2];
  Uint32 attrDescriptor = signal->theData[3];
  // DICT sends charset number in upper half
  Uint32 csNumber = (signal->theData[4] >> 16);

  regTabPtr.i = fragOperPtr.p->tableidFrag;
  ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);

  Uint32 fragId = fragOperPtr.p->fragidFrag;

  getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  ndbrequire(regFragPtr.i != RNIL);

  ndbrequire(fragOperPtr.p->attributeCount > 0);
  fragOperPtr.p->attributeCount--;
  const bool lastAttr = (fragOperPtr.p->attributeCount == 0);

  if ((regTabPtr.p->tableStatus == DEFINING) &&
      (fragOperPtr.p->definingFragment)) {
    ljam();
    Uint32 firstTabDesIndex = regTabPtr.p->tabDescriptor + (attrId * ZAD_SIZE);
    setTabDescrWord(firstTabDesIndex, attrDescriptor);
    Uint32 attrLen = AttributeDescriptor::getSize(attrDescriptor);
    Uint32 nullBitPos = fragOperPtr.p->currNullBit;
    Uint32 bitCount = 0;

    if (AttributeDescriptor::getNullable(attrDescriptor)) {
      if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
        ljam();                                      /* NULL ATTR */
        fragOperPtr.p->currNullBit++;
      }//if
    } else {
      ljam();
      regTabPtr.p->notNullAttributeMask.set(attrId);
    }//if

    Uint32 attrDes2 = 0;
    if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
      ljam();
      Uint32 attributePos = regTabPtr.p->tupheadsize;
      switch (AttributeDescriptor::getArrayType(attrDescriptor)) {
      case 1:
      case 2:
      {
        ljam();
	if(attrLen != 0)
	{
	  ljam();
	  Uint32 bitsUsed = 
	    AttributeDescriptor::getArraySize(attrDescriptor) * (1 << attrLen);
	  regTabPtr.p->tupheadsize += ((bitsUsed + 31) >> 5);
	  break;
	}
	else
	{
	  ljam();
	  bitCount = AttributeDescriptor::getArraySize(attrDescriptor);
	  fragOperPtr.p->currNullBit += bitCount;
	  break;
	}
      }
      default:
        ndbrequire(false);
        break;
      }//switch