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

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

MySQL数据库

开发平台：

Visual C++

DbtupRoutines.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 <AttributeDescriptor.hpp>
  24. #include "AttributeOffset.hpp"
  25. #include <AttributeHeader.hpp>
  27. #define ljam() { jamLine(3000 + __LINE__); }
  28. #define ljamEntry() { jamEntryLine(3000 + __LINE__); }
  30. void
  31. Dbtup::setUpQueryRoutines(Tablerec* const regTabPtr)
  32. {
  33.   Uint32 startDescriptor = regTabPtr->tabDescriptor;
  34.   ndbrequire((startDescriptor + (regTabPtr->noOfAttr << ZAD_LOG_SIZE)) <= cnoOfTabDescrRec);
  35.   for (Uint32 i = 0; i < regTabPtr->noOfAttr; i++) {
  36.     Uint32 attrDescriptorStart = startDescriptor + (i << ZAD_LOG_SIZE);
  37.     Uint32 attrDescriptor = tableDescriptor[attrDescriptorStart].tabDescr;
  38.     Uint32 attrOffset = tableDescriptor[attrDescriptorStart + 1].tabDescr;
  39.     if (!AttributeDescriptor::getDynamic(attrDescriptor)) {
  40.       if ((AttributeDescriptor::getArrayType(attrDescriptor) == ZNON_ARRAY) ||
  41.           (AttributeDescriptor::getArrayType(attrDescriptor) == ZFIXED_ARRAY)) {
  42.         if (!AttributeDescriptor::getNullable(attrDescriptor)) {
  43.           if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 1) {
  44.             ljam();
  45.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNotNULL;
  46.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHOneWordNotNULL;
  47.           } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 2) {
  48.             ljam();
  49.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHTwoWordNotNULL;
  50.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHTwoWordNotNULL;
  51.           } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) > 2) {
  52.             ljam();
  53.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNotNULL;
  54.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNotNULL;
  55.           } else {
  56.             ndbrequire(false);
  57.           }//if
  58.           // replace read function of char attribute
  59.           if (AttributeOffset::getCharsetFlag(attrOffset)) {
  60.             ljam();
  61.             regTabPtr->readFunctionArray[i] = &Dbtup::readCharNotNULL;
  62.           }
  63.         } else {
  64.           if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 1) {
  65.             ljam();
  66.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHOneWordNULLable;
  67.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
  68.           } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) == 2) {
  69.             ljam();
  70.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHTwoWordNULLable;
  71.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
  72.           } else if (AttributeDescriptor::getSizeInWords(attrDescriptor) > 2) {
  73.             ljam();
  74.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHManyWordNULLable;
  75.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
  76.           } else {
  77.             ljam();
  78.             regTabPtr->readFunctionArray[i] = &Dbtup::readFixedSizeTHZeroWordNULLable;
  79.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateFixedSizeTHManyWordNULLable;
  80.           }//if
  81.           // replace read function of char attribute
  82.           if (AttributeOffset::getCharsetFlag(attrOffset)) {
  83.             ljam();
  84.             regTabPtr->readFunctionArray[i] = &Dbtup::readCharNULLable;
  85.           }
  86.         }//if
  87.       } else if (AttributeDescriptor::getArrayType(attrDescriptor) == ZVAR_ARRAY) {
  88.         if (!AttributeDescriptor::getNullable(attrDescriptor)) {
  89.           if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) {
  90.             ljam();
  91.             regTabPtr->readFunctionArray[i] = &Dbtup::readVarSizeUnlimitedNotNULL;
  92.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateVarSizeUnlimitedNotNULL;
  93.           } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) {
  94.             ljam();
  95.             regTabPtr->readFunctionArray[i] = &Dbtup::readBigVarSizeNotNULL;
  96.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBigVarSizeNotNULL;
  97.           } else {
  98.             ljam();
  99.             regTabPtr->readFunctionArray[i] = &Dbtup::readSmallVarSizeNotNULL;
  100.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateSmallVarSizeNotNULL;
  101.           }//if
  102.         } else {
  103.           if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) {
  104.             ljam();
  105.             regTabPtr->readFunctionArray[i] = &Dbtup::readVarSizeUnlimitedNULLable;
  106.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateVarSizeUnlimitedNULLable;
  107.           } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) {
  108.             ljam();
  109.             regTabPtr->readFunctionArray[i] = &Dbtup::readBigVarSizeNULLable;
  110.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateBigVarSizeNULLable;
  111.           } else {
  112.             ljam();
  113.             regTabPtr->readFunctionArray[i] = &Dbtup::readSmallVarSizeNULLable;
  114.             regTabPtr->updateFunctionArray[i] = &Dbtup::updateSmallVarSizeNULLable;
  115.           }//if
  116.         }//if
  117.       } else {
  118.         ndbrequire(false);
  119.       }//if
  120.     } else {
  121.       if ((AttributeDescriptor::getArrayType(attrDescriptor) == ZNON_ARRAY) ||
  122.           (AttributeDescriptor::getArrayType(attrDescriptor) == ZFIXED_ARRAY)) {
  123.         ljam();
  124.         regTabPtr->readFunctionArray[i] = &Dbtup::readDynFixedSize;
  125.         regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynFixedSize;
  126.       } else if (AttributeDescriptor::getType(attrDescriptor) == ZVAR_ARRAY) {
  127.         if (AttributeDescriptor::getArraySize(attrDescriptor) == 0) {
  128.           ljam();
  129.           regTabPtr->readFunctionArray[i] = &Dbtup::readDynVarSizeUnlimited;
  130.           regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynVarSizeUnlimited;
  131.         } else if (AttributeDescriptor::getArraySize(attrDescriptor) > ZMAX_SMALL_VAR_ARRAY) {
  132.           ljam();
  133.           regTabPtr->readFunctionArray[i] = &Dbtup::readDynBigVarSize;
  134.           regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynBigVarSize;
  135.         } else {
  136.           ljam();
  137.           regTabPtr->readFunctionArray[i] = &Dbtup::readDynSmallVarSize;
  138.           regTabPtr->updateFunctionArray[i] = &Dbtup::updateDynSmallVarSize;
  139.         }//if
  140.       } else {
  141.         ndbrequire(false);
  142.       }//if
  143.     }//if
  144.   }//for
  145. }//Dbtup::setUpQueryRoutines()
  147. /* ---------------------------------------------------------------- */
  148. /*       THIS ROUTINE IS USED TO READ A NUMBER OF ATTRIBUTES IN THE */
  149. /*       DATABASE AND PLACE THE RESULT IN ATTRINFO RECORDS.         */
  150. //
  151. // In addition to the parameters used in the call it also relies on the
  152. // following variables set-up properly.
  153. //
  154. // operPtr.p      Operation record pointer
  155. // fragptr.p      Fragment record pointer
  156. // tabptr.p       Table record pointer
  157. /* ---------------------------------------------------------------- */
  158. int Dbtup::readAttributes(Page* const pagePtr,
  159.   Uint32  tupHeadOffset,
  160.   const Uint32* inBuffer,
  161.   Uint32  inBufLen,
  162.   Uint32* outBuffer,
  163.   Uint32  maxRead,
  164.   bool    xfrmFlag)
  165. {
  166.   Tablerec* const regTabPtr =  tabptr.p;
  167.   Uint32 numAttributes = regTabPtr->noOfAttr;
  168.   Uint32 attrDescriptorStart = regTabPtr->tabDescriptor;
  169.   Uint32 inBufIndex = 0;
  171.   ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec);
  173.   tOutBufIndex = 0;
  174.   tCheckOffset = regTabPtr->tupheadsize;
  175.   tMaxRead = maxRead;
  176.   tTupleHeader = &pagePtr->pageWord[tupHeadOffset];
  177.   tXfrmFlag = xfrmFlag;
  179.   ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE);
  180.   while (inBufIndex < inBufLen) {
  181.     Uint32 tmpAttrBufIndex = tOutBufIndex;
  182.     AttributeHeader ahIn(inBuffer[inBufIndex]);
  183.     inBufIndex++;
  184.     Uint32 attributeId = ahIn.getAttributeId();
  185.     Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE);
  186.     ljam();
  188.     AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, 0);
  189.     AttributeHeader* ahOut = (AttributeHeader*)&outBuffer[tmpAttrBufIndex];
  190.     tOutBufIndex = tmpAttrBufIndex + 1;
  191.     if (attributeId < numAttributes) {
  192.       Uint32 attributeDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr;
  193.       Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr;
  194.       ReadFunction f = regTabPtr->readFunctionArray[attributeId];
  195.       if ((this->*f)(outBuffer,
  196.                      ahOut,
  197.                      attributeDescriptor,
  198.                      attributeOffset)) {
  199.         continue;
  200.       } else {
  201.         return -1;
  202.       }//if
  203.     } else if(attributeId & AttributeHeader::PSUEDO){
  204.       Uint32 sz = read_psuedo(attributeId, 
  205.       outBuffer+tmpAttrBufIndex+1);
  206.       AttributeHeader::init(&outBuffer[tmpAttrBufIndex], attributeId, sz);
  207.       tOutBufIndex = tmpAttrBufIndex + 1 + sz;
  208.     } else {
  209.       terrorCode = ZATTRIBUTE_ID_ERROR;
  210.       return -1;
  211.     }//if
  212.   }//while
  213.   return tOutBufIndex;
  214. }//Dbtup::readAttributes()
  216. #if 0
  217. int Dbtup::readAttributesWithoutHeader(Page* const pagePtr,
  218.                                        Uint32  tupHeadOffset,
  219.                                        Uint32* inBuffer,
  220.                                        Uint32  inBufLen,
  221.                                        Uint32* outBuffer,
  222.                                        Uint32* attrBuffer,
  223.                                        Uint32  maxRead)
  224. {
  225.   Tablerec* const regTabPtr =  tabptr.p;
  226.   Uint32 numAttributes = regTabPtr->noOfAttr;
  227.   Uint32 attrDescriptorStart = regTabPtr->tabDescriptor;
  228.   Uint32 inBufIndex = 0;
  229.   Uint32 attrBufIndex = 0;
  231.   ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec);
  233.   tOutBufIndex = 0;
  234.   tCheckOffset = regTabPtr->tupheadsize;
  235.   tMaxRead = maxRead;
  236.   tTupleHeader = &pagePtr->pageWord[tupHeadOffset];
  238.   ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE);
  239.   while (inBufIndex < inBufLen) {
  240.     AttributeHeader ahIn(inBuffer[inBufIndex]);
  241.     inBufIndex++;
  242.     Uint32 attributeId = ahIn.getAttributeId();
  243.     Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE);
  244.     ljam();
  246.     AttributeHeader::init(&attrBuffer[attrBufIndex], attributeId, 0);
  247.     AttributeHeader* ahOut = (AttributeHeader*)&attrBuffer[attrBufIndex];
  248.     attrBufIndex++;
  249.     if (attributeId < numAttributes) {
  250.       Uint32 attributeDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr;
  251.       Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr;
  252.       ReadFunction f = regTabPtr->readFunctionArray[attributeId];
  253.       if ((this->*f)(outBuffer,
  254.                      ahOut,
  255.                      attributeDescriptor,
  256.                      attributeOffset)) {
  257.         continue;
  258.       } else {
  259.         return -1;
  260.       }//if
  261.     } else {
  262.       terrorCode = ZATTRIBUTE_ID_ERROR;
  263.       return -1;
  264.     }//if
  265.   }//while
  266.   ndbrequire(attrBufIndex == inBufLen);
  267.   return tOutBufIndex;
  268. }//Dbtup::readAttributes()
  269. #endif
  271. bool
  272. Dbtup::readFixedSizeTHOneWordNotNULL(Uint32* outBuffer,
  273.                                      AttributeHeader* ahOut,
  274.                                      Uint32  attrDescriptor,
  275.                                      Uint32  attrDes2)
  276. {
  277.   Uint32 indexBuf = tOutBufIndex;
  278.   Uint32 readOffset = AttributeOffset::getOffset(attrDes2);
  279.   Uint32 const wordRead = tTupleHeader[readOffset];
  280.   Uint32 newIndexBuf = indexBuf + 1;
  281.   Uint32 maxRead = tMaxRead;
  283.   ndbrequire(readOffset < tCheckOffset);
  284.   if (newIndexBuf <= maxRead) {
  285.     ljam();
  286.     outBuffer[indexBuf] = wordRead;
  287.     ahOut->setDataSize(1);
  288.     tOutBufIndex = newIndexBuf;
  289.     return true;
  290.   } else {
  291.     ljam();
  292.     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
  293.     return false;
  294.   }//if
  295. }//Dbtup::readFixedSizeTHOneWordNotNULL()
  297. bool
  298. Dbtup::readFixedSizeTHTwoWordNotNULL(Uint32* outBuffer,
  299.                                      AttributeHeader* ahOut,
  300.                                      Uint32  attrDescriptor,
  301.                                      Uint32  attrDes2)
  302. {
  303.   Uint32 indexBuf = tOutBufIndex;
  304.   Uint32 readOffset = AttributeOffset::getOffset(attrDes2);
  305.   Uint32 const wordReadFirst = tTupleHeader[readOffset];
  306.   Uint32 const wordReadSecond = tTupleHeader[readOffset + 1];
  307.   Uint32 newIndexBuf = indexBuf + 2;
  308.   Uint32 maxRead = tMaxRead;
  310.   ndbrequire(readOffset + 1 < tCheckOffset);
  311.   if (newIndexBuf <= maxRead) {
  312.     ljam();
  313.     ahOut->setDataSize(2);
  314.     outBuffer[indexBuf] = wordReadFirst;
  315.     outBuffer[indexBuf + 1] = wordReadSecond;
  316.     tOutBufIndex = newIndexBuf;
  317.     return true;
  318.   } else {
  319.     ljam();
  320.     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
  321.     return false;
  322.   }//if
  323. }//Dbtup::readFixedSizeTHTwoWordNotNULL()
  325. bool
  326. Dbtup::readFixedSizeTHManyWordNotNULL(Uint32* outBuffer,
  327.                                       AttributeHeader* ahOut,
  328.                                       Uint32  attrDescriptor,
  329.                                       Uint32  attrDes2)
  330. {
  331.   Uint32 indexBuf = tOutBufIndex;
  332.   Uint32 readOffset = AttributeOffset::getOffset(attrDes2);
  333.   Uint32 attrNoOfWords = AttributeDescriptor::getSizeInWords(attrDescriptor);
  334.   Uint32 newIndexBuf = indexBuf + attrNoOfWords;
  335.   Uint32 maxRead = tMaxRead;
  337.   ndbrequire((readOffset + attrNoOfWords - 1) < tCheckOffset);
  338.   if (newIndexBuf <= maxRead) {
  339.     ljam();
  340.     ahOut->setDataSize(attrNoOfWords);
  341.     MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
  342.                      &tTupleHeader[readOffset],
  343.                      attrNoOfWords);
  344.     tOutBufIndex = newIndexBuf;
  345.     return true;
  346.   } else {
  347.     ljam();
  348.     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
  349.     return false;
  350.   }//if
  351. }//Dbtup::readFixedSizeTHManyWordNotNULL()
  353. bool
  354. Dbtup::readFixedSizeTHOneWordNULLable(Uint32* outBuffer,
  355.                                       AttributeHeader* ahOut,
  356.                                       Uint32  attrDescriptor,
  357.                                       Uint32  attrDes2)
  358. {
  359.   if (!nullFlagCheck(attrDes2)) {
  360.     ljam();
  361.     return readFixedSizeTHOneWordNotNULL(outBuffer,
  362.                                          ahOut,
  363.                                          attrDescriptor,
  364.                                          attrDes2);
  365.   } else {
  366.     ljam();
  367.     ahOut->setNULL();
  368.     return true;
  369.   }//if
  370. }//Dbtup::readFixedSizeTHOneWordNULLable()
  372. bool
  373. Dbtup::readFixedSizeTHTwoWordNULLable(Uint32* outBuffer,
  374.                                       AttributeHeader* ahOut,
  375.                                       Uint32  attrDescriptor,
  376.                                       Uint32  attrDes2)
  377. {
  378.   if (!nullFlagCheck(attrDes2)) {
  379.     ljam();
  380.     return readFixedSizeTHTwoWordNotNULL(outBuffer,
  381.                                          ahOut,
  382.                                          attrDescriptor,
  383.                                          attrDes2);
  384.   } else {
  385.     ljam();
  386.     ahOut->setNULL();
  387.     return true;
  388.   }//if
  389. }//Dbtup::readFixedSizeTHTwoWordNULLable()
  391. bool
  392. Dbtup::readFixedSizeTHManyWordNULLable(Uint32* outBuffer,
  393.                                        AttributeHeader* ahOut,
  394.                                        Uint32  attrDescriptor,
  395.                                        Uint32  attrDes2)
  396. {
  397. ljam();
  398.   if (!nullFlagCheck(attrDes2)) {
  399.     ljam();
  400.     return readFixedSizeTHManyWordNotNULL(outBuffer,
  401.                                           ahOut,
  402.                                           attrDescriptor,
  403.                                           attrDes2);
  404.   } else {
  405.     ljam();
  406.     ahOut->setNULL();
  407.     return true;
  408.   }//if
  409. }//Dbtup::readFixedSizeTHManyWordNULLable()
  411. bool
  412. Dbtup::readFixedSizeTHZeroWordNULLable(Uint32* outBuffer,
  413.                                        AttributeHeader* ahOut,
  414.                                        Uint32  attrDescriptor,
  415.                                        Uint32  attrDes2)
  416. {
  417.   ljam();
  418.   if (nullFlagCheck(attrDes2)) {
  419.     ljam();
  420.     ahOut->setNULL();
  421.   }//if
  422.   return true;
  423. }//Dbtup::readFixedSizeTHZeroWordNULLable()
  425. bool
  426. Dbtup::nullFlagCheck(Uint32  attrDes2)
  427. {
  428.   Tablerec* const regTabPtr = tabptr.p;
  429.   Uint32 nullFlagOffsetInTuple = AttributeOffset::getNullFlagOffset(attrDes2);
  430.   ndbrequire(nullFlagOffsetInTuple < regTabPtr->tupNullWords);
  431.   nullFlagOffsetInTuple += regTabPtr->tupNullIndex;
  432.   ndbrequire(nullFlagOffsetInTuple < tCheckOffset);
  434.   return (AttributeOffset::isNULL(tTupleHeader[nullFlagOffsetInTuple], attrDes2));
  435. }//Dbtup::nullFlagCheck()
  437. bool
  438. Dbtup::readVariableSizedAttr(Uint32* outBuffer,
  439.                              AttributeHeader* ahOut,
  440.                              Uint32  attrDescriptor,
  441.                              Uint32  attrDes2)
  442. {
  443.   ljam();
  444.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  445.   return false;
  446. }//Dbtup::readVariableSizedAttr()
  448. bool
  449. Dbtup::readVarSizeUnlimitedNotNULL(Uint32* outBuffer,
  450.                                    AttributeHeader* ahOut,
  451.                                    Uint32  attrDescriptor,
  452.                                    Uint32  attrDes2)
  453. {
  454.   ljam();
  455.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  456.   return false;
  457. }//Dbtup::readVarSizeUnlimitedNotNULL()
  459. bool
  460. Dbtup::readVarSizeUnlimitedNULLable(Uint32* outBuffer,
  461.                                     AttributeHeader* ahOut,
  462.                                     Uint32  attrDescriptor,
  463.                                     Uint32  attrDes2)
  464. {
  465.   ljam();
  466.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  467.   return false;
  468. }//Dbtup::readVarSizeUnlimitedNULLable()
  470. bool
  471. Dbtup::readBigVarSizeNotNULL(Uint32* outBuffer,
  472.                              AttributeHeader* ahOut,
  473.                              Uint32  attrDescriptor,
  474.                              Uint32  attrDes2)
  475. {
  476.   ljam();
  477.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  478.   return false;
  479. }//Dbtup::readBigVarSizeNotNULL()
  481. bool
  482. Dbtup::readBigVarSizeNULLable(Uint32* outBuffer,
  483.                              AttributeHeader* ahOut,
  484.                              Uint32  attrDescriptor,
  485.                              Uint32  attrDes2)
  486. {
  487.   ljam();
  488.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  489.   return false;
  490. }//Dbtup::readBigVarSizeNULLable()
  492. bool
  493. Dbtup::readSmallVarSizeNotNULL(Uint32* outBuffer,
  494.                                AttributeHeader* ahOut,
  495.                                Uint32  attrDescriptor,
  496.                                Uint32  attrDes2)
  497. {
  498.   ljam();
  499.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  500.   return false;
  501. }//Dbtup::readSmallVarSizeNotNULL()
  503. bool
  504. Dbtup::readSmallVarSizeNULLable(Uint32* outBuffer,
  505.                                 AttributeHeader* ahOut,
  506.                                 Uint32  attrDescriptor,
  507.                                 Uint32  attrDes2)
  508. {
  509.   ljam();
  510.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  511.   return false;
  512. }//Dbtup::readSmallVarSizeNULLable()
  514. bool
  515. Dbtup::readDynFixedSize(Uint32* outBuffer,
  516.                         AttributeHeader* ahOut,
  517.                         Uint32  attrDescriptor,
  518.                         Uint32  attrDes2)
  519. {
  520.   ljam();
  521.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  522.   return false;
  523. }//Dbtup::readDynFixedSize()
  525. bool
  526. Dbtup::readDynVarSizeUnlimited(Uint32* outBuffer,
  527.                                AttributeHeader* ahOut,
  528.                                Uint32  attrDescriptor,
  529.                                Uint32  attrDes2)
  530. {
  531.   ljam();
  532.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  533.   return false;
  534. }//Dbtup::readDynVarSizeUnlimited()
  536. bool
  537. Dbtup::readDynBigVarSize(Uint32* outBuffer,
  538.                          AttributeHeader* ahOut,
  539.                          Uint32  attrDescriptor,
  540.                          Uint32  attrDes2)
  541. {
  542.   ljam();
  543.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  544.   return false;
  545. }//Dbtup::readDynBigVarSize()
  547. bool
  548. Dbtup::readDynSmallVarSize(Uint32* outBuffer,
  549.                            AttributeHeader* ahOut,
  550.                            Uint32  attrDescriptor,
  551.                            Uint32  attrDes2)
  552. {
  553.   ljam();
  554.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  555.   return false;
  556. }//Dbtup::readDynSmallVarSize()
  559. bool
  560. Dbtup::readCharNotNULL(Uint32* outBuffer,
  561.                        AttributeHeader* ahOut,
  562.                        Uint32  attrDescriptor,
  563.                        Uint32  attrDes2)
  564. {
  565.   Uint32 indexBuf = tOutBufIndex;
  566.   Uint32 readOffset = AttributeOffset::getOffset(attrDes2);
  567.   Uint32 attrNoOfWords = AttributeDescriptor::getSizeInWords(attrDescriptor);
  568.   Uint32 newIndexBuf = indexBuf + attrNoOfWords;
  569.   Uint32 maxRead = tMaxRead;
  571.   ndbrequire((readOffset + attrNoOfWords - 1) < tCheckOffset);
  572.   if (newIndexBuf <= maxRead) {
  573.     ljam();
  574.     ahOut->setDataSize(attrNoOfWords);
  575.     if (! tXfrmFlag) {
  576.       MEMCOPY_NO_WORDS(&outBuffer[indexBuf],
  577.                        &tTupleHeader[readOffset],
  578.                        attrNoOfWords);
  579.     } else {
  580.       ljam();
  581.       Tablerec* regTabPtr = tabptr.p;
  582.       Uint32 i = AttributeOffset::getCharsetPos(attrDes2);
  583.       ndbrequire(i < tabptr.p->noOfCharsets);
  584.       // not const in MySQL
  585.       CHARSET_INFO* cs = tabptr.p->charsetArray[i];
  586.       // XXX should strip Uint32 null padding
  587.       const unsigned nBytes = attrNoOfWords << 2;
  588.       unsigned n =
  589.       (*cs->coll->strnxfrm)(cs,
  590.                             (uchar*)&outBuffer[indexBuf],
  591.                             nBytes,
  592.                             (const uchar*)&tTupleHeader[readOffset],
  593.                             nBytes);
  594.       // pad with ascii spaces
  595.       while (n < nBytes)
  596.         ((uchar*)&outBuffer[indexBuf])[n++] = 0x20;
  597.     }
  598.     tOutBufIndex = newIndexBuf;
  599.     return true;
  600.   } else {
  601.     ljam();
  602.     terrorCode = ZTRY_TO_READ_TOO_MUCH_ERROR;
  603.     return false;
  604.   }
  605. }
  607. bool
  608. Dbtup::readCharNULLable(Uint32* outBuffer,
  609.                        AttributeHeader* ahOut,
  610.                        Uint32  attrDescriptor,
  611.                        Uint32  attrDes2)
  612. {
  613.   if (!nullFlagCheck(attrDes2)) {
  614.     ljam();
  615.     return readCharNotNULL(outBuffer,
  616.                            ahOut,
  617.                            attrDescriptor,
  618.                            attrDes2);
  619.   } else {
  620.     ljam();
  621.     ahOut->setNULL();
  622.     return true;
  623.   }
  624. }
  626. /* ---------------------------------------------------------------------- */
  627. /*       THIS ROUTINE IS USED TO UPDATE A NUMBER OF ATTRIBUTES. IT IS     */
  628. /*       USED BY THE INSERT ROUTINE, THE UPDATE ROUTINE AND IT CAN BE     */
  629. /*       CALLED SEVERAL TIMES FROM THE INTERPRETER.                       */
  630. // In addition to the parameters used in the call it also relies on the
  631. // following variables set-up properly.
  632. //
  633. // pagep.p        Page record pointer
  634. // fragptr.p      Fragment record pointer
  635. // operPtr.p      Operation record pointer
  636. // tabptr.p       Table record pointer
  637. /* ---------------------------------------------------------------------- */
  638. int Dbtup::updateAttributes(Page* const pagePtr,
  639.                             Uint32 tupHeadOffset,
  640.                             Uint32* inBuffer,
  641.                             Uint32 inBufLen)
  642. {
  643.   Tablerec* const regTabPtr =  tabptr.p;
  644.   Operationrec* const regOperPtr = operPtr.p;
  645.   Uint32 numAttributes = regTabPtr->noOfAttr;
  646.   Uint32 attrDescriptorStart = regTabPtr->tabDescriptor;
  647.   ndbrequire(attrDescriptorStart + (numAttributes << ZAD_LOG_SIZE) <= cnoOfTabDescrRec);
  649.   tCheckOffset = regTabPtr->tupheadsize;
  650.   tTupleHeader = &pagePtr->pageWord[tupHeadOffset];
  651.   Uint32 inBufIndex = 0;
  652.   tInBufIndex = 0;
  653.   tInBufLen = inBufLen;
  655.   ndbrequire(tupHeadOffset + tCheckOffset <= ZWORDS_ON_PAGE);
  656.   while (inBufIndex < inBufLen) {
  657.     AttributeHeader ahIn(inBuffer[inBufIndex]);
  658.     Uint32 attributeId = ahIn.getAttributeId();
  659.     Uint32 attrDescriptorIndex = attrDescriptorStart + (attributeId << ZAD_LOG_SIZE);
  660.     if (attributeId < numAttributes) {
  661.       Uint32 attrDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr;
  662.       Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr;
  663.       if ((AttributeDescriptor::getPrimaryKey(attrDescriptor)) &&
  664.           (regOperPtr->optype != ZINSERT)) {
  665.         if (checkUpdateOfPrimaryKey(&inBuffer[inBufIndex], regTabPtr)) {
  666.           ljam();
  667.           terrorCode = ZTRY_UPDATE_PRIMARY_KEY;
  668.           return -1;
  669.         }//if
  670.       }//if
  671.       UpdateFunction f = regTabPtr->updateFunctionArray[attributeId];
  672.       ljam();
  673.       regOperPtr->changeMask.set(attributeId);
  674.       if ((this->*f)(inBuffer,
  675.                      attrDescriptor,
  676.                      attributeOffset)) {
  677.         inBufIndex = tInBufIndex;
  678.         continue;
  679.       } else {
  680.         ljam();
  681.         return -1;
  682.       }//if
  683.     } else {
  684.       ljam();
  685.       terrorCode = ZATTRIBUTE_ID_ERROR;
  686.       return -1;
  687.     }//if
  688.   }//while
  689.   return 0;
  690. }//Dbtup::updateAttributes()
  692. bool
  693. Dbtup::checkUpdateOfPrimaryKey(Uint32* updateBuffer, Tablerec* const regTabPtr)
  694. {
  695.   Uint32 keyReadBuffer[MAX_KEY_SIZE_IN_WORDS];
  696.   Uint32 attributeHeader;
  697.   AttributeHeader* ahOut = (AttributeHeader*)&attributeHeader;
  698.   AttributeHeader ahIn(*updateBuffer);
  699.   Uint32 attributeId = ahIn.getAttributeId();
  700.   Uint32 attrDescriptorIndex = regTabPtr->tabDescriptor + (attributeId << ZAD_LOG_SIZE);
  701.   Uint32 attrDescriptor = tableDescriptor[attrDescriptorIndex].tabDescr;
  702.   Uint32 attributeOffset = tableDescriptor[attrDescriptorIndex + 1].tabDescr;
  704.   Uint32 xfrmBuffer[1 + MAX_KEY_SIZE_IN_WORDS * 1]; // strxfrm_multiply == 1
  705.   Uint32 charsetFlag = AttributeOffset::getCharsetFlag(attributeOffset);
  706.   if (charsetFlag) {
  707.     Uint32 csPos = AttributeOffset::getCharsetPos(attributeOffset);
  708.     CHARSET_INFO* cs = regTabPtr->charsetArray[csPos];
  709.     Uint32 sizeInBytes = AttributeDescriptor::getSizeInBytes(attrDescriptor);
  710.     Uint32 sizeInWords = AttributeDescriptor::getSizeInWords(attrDescriptor);
  711.     const uchar* srcPtr = (uchar*)&updateBuffer[1];
  712.     uchar* dstPtr = (uchar*)&xfrmBuffer[1];
  713.     Uint32 n =
  714.       (*cs->coll->strnxfrm)(cs, dstPtr, sizeInBytes, srcPtr, sizeInBytes);
  715.     // pad with blanks (unlikely) and zeroes to match NDB API behaviour
  716.     while (n < sizeInBytes)
  717.       dstPtr[n++] = 0x20;
  718.     while (n < 4 * sizeInWords)
  719.       dstPtr[n++] = 0;
  720.     xfrmBuffer[0] = ahIn.m_value;
  721.     updateBuffer = xfrmBuffer;
  722.   }
  724.   ReadFunction f = regTabPtr->readFunctionArray[attributeId];
  726.   AttributeHeader::init(&attributeHeader, attributeId, 0);
  727.   tOutBufIndex = 0;
  728.   tMaxRead = MAX_KEY_SIZE_IN_WORDS;
  730.   bool tmp = tXfrmFlag;
  731.   tXfrmFlag = true;
  732.   ndbrequire((this->*f)(&keyReadBuffer[0], ahOut, attrDescriptor, attributeOffset));
  733.   tXfrmFlag = tmp;
  734.   ndbrequire(tOutBufIndex == ahOut->getDataSize());
  735.   if (ahIn.getDataSize() != ahOut->getDataSize()) {
  736.     ljam();
  737.     return true;
  738.   }//if
  739.   if (memcmp(&keyReadBuffer[0], &updateBuffer[1], tOutBufIndex << 2) != 0) {
  740.     ljam();
  741.     return true;
  742.   }//if
  743.   return false;
  744. }//Dbtup::checkUpdateOfPrimaryKey()
  746. #if 0
  747. void Dbtup::checkPages(Fragrecord* const regFragPtr)
  748. {
  749.   Uint32 noPages = getNoOfPages(regFragPtr);
  750.   for (Uint32 i = 0; i < noPages ; i++) {
  751.     PagePtr pagePtr;
  752.     pagePtr.i = getRealpid(regFragPtr, i);
  753.     ptrCheckGuard(pagePtr, cnoOfPage, page);
  754.     ndbrequire(pagePtr.p->pageWord[1] != (RNIL - 1));
  755.   }
  756. }
  757. #endif
  759. bool
  760. Dbtup::updateFixedSizeTHOneWordNotNULL(Uint32* inBuffer,
  761.                                        Uint32  attrDescriptor,
  762.                                        Uint32  attrDes2)
  763. {
  764.   Uint32 indexBuf = tInBufIndex;
  765.   Uint32 inBufLen = tInBufLen;
  766.   Uint32 updateOffset = AttributeOffset::getOffset(attrDes2);
  767.   AttributeHeader ahIn(inBuffer[indexBuf]);
  768.   Uint32 nullIndicator = ahIn.isNULL();
  769.   Uint32 newIndex = indexBuf + 2;
  770.   ndbrequire(updateOffset < tCheckOffset);
  772.   if (newIndex <= inBufLen) {
  773.     Uint32 updateWord = inBuffer[indexBuf + 1];
  774.     if (!nullIndicator) {
  775.       ljam();
  776.       tInBufIndex = newIndex;
  777.       tTupleHeader[updateOffset] = updateWord;
  778.       return true;
  779.     } else {
  780.       ljam();
  781.       terrorCode = ZNOT_NULL_ATTR;
  782.       return false;
  783.     }//if
  784.   } else {
  785.     ljam();
  786.     terrorCode = ZAI_INCONSISTENCY_ERROR;
  787.     return false;
  788.   }//if
  789.   return true;
  790. }//Dbtup::updateFixedSizeTHOneWordNotNULL()
  792. bool
  793. Dbtup::updateFixedSizeTHTwoWordNotNULL(Uint32* inBuffer,
  794.                                        Uint32  attrDescriptor,
  795.                                        Uint32  attrDes2)
  796. {
  797.   Uint32 indexBuf = tInBufIndex;
  798.   Uint32 inBufLen = tInBufLen;
  799.   Uint32 updateOffset = AttributeOffset::getOffset(attrDes2);
  800.   AttributeHeader ahIn(inBuffer[indexBuf]);
  801.   Uint32 nullIndicator = ahIn.isNULL();
  802.   Uint32 newIndex = indexBuf + 3;
  803.   ndbrequire((updateOffset + 1) < tCheckOffset);
  805.   if (newIndex <= inBufLen) {
  806.     Uint32 updateWord1 = inBuffer[indexBuf + 1];
  807.     Uint32 updateWord2 = inBuffer[indexBuf + 2];
  808.     if (!nullIndicator) {
  809.       ljam();
  810.       tInBufIndex = newIndex;
  811.       tTupleHeader[updateOffset] = updateWord1;
  812.       tTupleHeader[updateOffset + 1] = updateWord2;
  813.       return true;
  814.     } else {
  815.       ljam();
  816.       terrorCode = ZNOT_NULL_ATTR;
  817.       return false;
  818.     }//if
  819.   } else {
  820.     ljam();
  821.     terrorCode = ZAI_INCONSISTENCY_ERROR;
  822.     return false;
  823.   }//if
  824. }//Dbtup::updateFixedSizeTHTwoWordNotNULL()
  826. bool
  827. Dbtup::updateFixedSizeTHManyWordNotNULL(Uint32* inBuffer,
  828.                                         Uint32  attrDescriptor,
  829.                                         Uint32  attrDes2)
  830. {
  831.   Uint32 indexBuf = tInBufIndex;
  832.   Uint32 inBufLen = tInBufLen;
  833.   Uint32 updateOffset = AttributeOffset::getOffset(attrDes2);
  834.   AttributeHeader ahIn(inBuffer[indexBuf]);
  835.   Uint32 nullIndicator = ahIn.isNULL();
  836.   Uint32 noOfWords = AttributeDescriptor::getSizeInWords(attrDescriptor);
  837.   Uint32 newIndex = indexBuf + noOfWords + 1;
  838.   ndbrequire((updateOffset + noOfWords - 1) < tCheckOffset);
  840.   if (newIndex <= inBufLen) {
  841.     if (!nullIndicator) {
  842.       ljam();
  843.       tInBufIndex = newIndex;
  844.       MEMCOPY_NO_WORDS(&tTupleHeader[updateOffset],
  845.                        &inBuffer[indexBuf + 1],
  846.                        noOfWords);
  847.       return true;
  848.     } else {
  849.       ljam();
  850.       terrorCode = ZNOT_NULL_ATTR;
  851.       return false;
  852.     }//if
  853.   } else {
  854.     ljam();
  855.     terrorCode = ZAI_INCONSISTENCY_ERROR;
  856.     return false;
  857.   }//if
  858. }//Dbtup::updateFixedSizeTHManyWordNotNULL()
  860. bool
  861. Dbtup::updateFixedSizeTHManyWordNULLable(Uint32* inBuffer,
  862.                                          Uint32  attrDescriptor,
  863.                                          Uint32  attrDes2)
  864. {
  865.   Tablerec* const regTabPtr =  tabptr.p;
  866.   AttributeHeader ahIn(inBuffer[tInBufIndex]);
  867.   Uint32 nullIndicator = ahIn.isNULL();
  868.   Uint32 nullFlagOffset = AttributeOffset::getNullFlagOffset(attrDes2);
  869.   Uint32 nullFlagBitOffset = AttributeOffset::getNullFlagBitOffset(attrDes2);
  870.   Uint32 nullWordOffset = nullFlagOffset + regTabPtr->tupNullIndex;
  871.   ndbrequire((nullFlagOffset < regTabPtr->tupNullWords) &&
  872.              (nullWordOffset < tCheckOffset));
  873.   Uint32 nullBits = tTupleHeader[nullWordOffset];
  875.   if (!nullIndicator) {
  876.     nullBits &= (~(1 << nullFlagBitOffset));
  877.     ljam();
  878.     tTupleHeader[nullWordOffset] = nullBits;
  879.     return updateFixedSizeTHManyWordNotNULL(inBuffer,
  880.                                             attrDescriptor,
  881.                                             attrDes2);
  882.   } else {
  883.     Uint32 newIndex = tInBufIndex + 1;
  884.     if (newIndex <= tInBufLen) {
  885.       nullBits |= (1 << nullFlagBitOffset);
  886.       ljam();
  887.       tTupleHeader[nullWordOffset] = nullBits;
  888.       tInBufIndex = newIndex;
  889.       return true;
  890.     } else {
  891.       ljam();
  892.       terrorCode = ZAI_INCONSISTENCY_ERROR;
  893.       return false;
  894.     }//if
  895.   }//if
  896. }//Dbtup::updateFixedSizeTHManyWordNULLable()
  898. bool
  899. Dbtup::updateVariableSizedAttr(Uint32* inBuffer,
  900.                                Uint32  attrDescriptor,
  901.                                Uint32  attrDes2)
  902. {
  903.   ljam();
  904.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  905.   return false;
  906. }//Dbtup::updateVariableSizedAttr()
  908. bool
  909. Dbtup::updateVarSizeUnlimitedNotNULL(Uint32* inBuffer,
  910.                                      Uint32  attrDescriptor,
  911.                                      Uint32  attrDes2)
  912. {
  913.   ljam();
  914.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  915.   return false;
  916. }//Dbtup::updateVarSizeUnlimitedNotNULL()
  918. bool
  919. Dbtup::updateVarSizeUnlimitedNULLable(Uint32* inBuffer,
  920.                                       Uint32  attrDescriptor,
  921.                                       Uint32  attrDes2)
  922. {
  923.   ljam();
  924.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  925.   return false;
  926. }//Dbtup::updateVarSizeUnlimitedNULLable()
  928. bool
  929. Dbtup::updateBigVarSizeNotNULL(Uint32* inBuffer,
  930.                                Uint32  attrDescriptor,
  931.                                Uint32  attrDes2)
  932. {
  933.   ljam();
  934.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  935.   return false;
  936. }//Dbtup::updateBigVarSizeNotNULL()
  938. bool
  939. Dbtup::updateBigVarSizeNULLable(Uint32* inBuffer,
  940.                                 Uint32  attrDescriptor,
  941.                                 Uint32  attrDes2)
  942. {
  943.   ljam();
  944.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  945.   return false;
  946. }//Dbtup::updateBigVarSizeNULLable()
  948. bool
  949. Dbtup::updateSmallVarSizeNotNULL(Uint32* inBuffer,
  950.                                  Uint32  attrDescriptor,
  951.                                  Uint32  attrDes2)
  952. {
  953.   ljam();
  954.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  955.   return false;
  956. }//Dbtup::updateSmallVarSizeNotNULL()
  958. bool
  959. Dbtup::updateSmallVarSizeNULLable(Uint32* inBuffer,
  960.                                   Uint32  attrDescriptor,
  961.                                   Uint32  attrDes2)
  962. {
  963.   ljam();
  964.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  965.   return false;
  966. }//Dbtup::updateSmallVarSizeNULLable()
  968. bool
  969. Dbtup::updateDynFixedSize(Uint32* inBuffer,
  970.                           Uint32  attrDescriptor,
  971.                           Uint32  attrDes2)
  972. {
  973.   ljam();
  974.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  975.   return false;
  976. }//Dbtup::updateDynFixedSize()
  978. bool
  979. Dbtup::updateDynVarSizeUnlimited(Uint32* inBuffer,
  980.                                  Uint32  attrDescriptor,
  981.                                  Uint32  attrDes2)
  982. {
  983.   ljam();
  984.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  985.   return false;
  986. }//Dbtup::updateDynVarSizeUnlimited()
  988. bool
  989. Dbtup::updateDynBigVarSize(Uint32* inBuffer,
  990.                            Uint32  attrDescriptor,
  991.                            Uint32  attrDes2)
  992. {
  993.   ljam();
  994.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  995.   return false;
  996. }//Dbtup::updateDynBigVarSize()
  998. bool
  999. Dbtup::updateDynSmallVarSize(Uint32* inBuffer,
  1000.                              Uint32  attrDescriptor,
  1001.                              Uint32  attrDes2)
  1002. {
  1003.   ljam();
  1004.   terrorCode = ZVAR_SIZED_NOT_SUPPORTED;
  1005.   return false;
  1006. }//Dbtup::updateDynSmallVarSize()
  1008. Uint32 
  1009. Dbtup::read_psuedo(Uint32 attrId, Uint32* outBuffer){
  1010.   Uint32 tmp[sizeof(SignalHeader)+25];
  1011.   Signal * signal = (Signal*)&tmp;
  1012.   switch(attrId){
  1013.   case AttributeHeader::FRAGMENT:
  1014.     * outBuffer = operPtr.p->fragId;
  1015.     return 1;
  1016.   case AttributeHeader::ROW_COUNT:
  1017.   case AttributeHeader::COMMIT_COUNT:
  1018.     signal->theData[0] = operPtr.p->userpointer;
  1019.     signal->theData[1] = attrId;
  1021.     EXECUTE_DIRECT(DBLQH, GSN_READ_PSUEDO_REQ, signal, 2);
  1022.     outBuffer[0] = signal->theData[0];
  1023.     outBuffer[1] = signal->theData[1];
  1024.     return 2;
  1025.   default:
  1026.     return 0;
  1027.   }
  1028. }