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

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

MySQL数据库

开发平台：

Visual C++

NdbOperationDefine.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. /*****************************************************************************
  19.  * Name:          NdbOperationDefine.C
  20.  * Include:
  21.  * Link:
  22.  * Author:        UABMNST Mona Natterkvist UAB/B/SD                         
  23.  * Date:          970829
  24.  * Version:       0.1
  25.  * Description:   Interface between TIS and NDB
  26.  * Documentation:
  27.  * Adjust:  971022  UABMNST   First version.
  28.  *****************************************************************************/
  29. #include "NdbOperation.hpp"
  30. #include "NdbApiSignal.hpp"
  31. #include "NdbConnection.hpp"
  32. #include "Ndb.hpp"
  33. #include "NdbRecAttr.hpp"
  34. #include "NdbUtil.hpp"
  35. #include "NdbOut.hpp"
  36. #include "NdbImpl.hpp"
  37. #include <NdbIndexScanOperation.hpp>
  38. #include "NdbBlob.hpp"
  40. #include <Interpreter.hpp>
  42. #include <AttributeHeader.hpp>
  43. #include <signaldata/TcKeyReq.hpp>
  45. /*****************************************************************************
  46.  * int insertTuple();
  47.  *****************************************************************************/
  48. int
  49. NdbOperation::insertTuple()
  50. {
  51.   NdbConnection* tNdbCon = theNdbCon;
  52.   int tErrorLine = theErrorLine;
  53.   if (theStatus == Init) {
  54.     theStatus = OperationDefined;
  55.     theOperationType = InsertRequest;
  56.     tNdbCon->theSimpleState = 0;
  57.     theErrorLine = tErrorLine++;
  58.     theLockMode = LM_Exclusive;
  59.     return 0; 
  60.   } else {
  61.     setErrorCode(4200);
  62.     return -1;
  63.   }//if
  64. }//NdbOperation::insertTuple()
  65. /******************************************************************************
  66.  * int updateTuple();
  67.  *****************************************************************************/
  68. int
  69. NdbOperation::updateTuple()
  70. {  
  71.   NdbConnection* tNdbCon = theNdbCon;
  72.   int tErrorLine = theErrorLine;
  73.   if (theStatus == Init) {
  74.     theStatus = OperationDefined;
  75.     tNdbCon->theSimpleState = 0;
  76.     theOperationType = UpdateRequest;  
  77.     theErrorLine = tErrorLine++;
  78.     theLockMode = LM_Exclusive;
  79.     return 0; 
  80.   } else {
  81.     setErrorCode(4200);
  82.     return -1;
  83.   }//if
  84. }//NdbOperation::updateTuple()
  85. /*****************************************************************************
  86.  * int writeTuple();
  87.  *****************************************************************************/
  88. int
  89. NdbOperation::writeTuple()
  90. {  
  91.   NdbConnection* tNdbCon = theNdbCon;
  92.   int tErrorLine = theErrorLine;
  93.   if (theStatus == Init) {
  94.     theStatus = OperationDefined;
  95.     tNdbCon->theSimpleState = 0;
  96.     theOperationType = WriteRequest;  
  97.     theErrorLine = tErrorLine++;
  98.     theLockMode = LM_Exclusive;
  99.     return 0; 
  100.   } else {
  101.     setErrorCode(4200);
  102.     return -1;
  103.   }//if
  104. }//NdbOperation::writeTuple()
  105. /******************************************************************************
  106.  * int readTuple();
  107.  *****************************************************************************/
  108. int
  109. NdbOperation::readTuple(NdbOperation::LockMode lm)
  110. { 
  111.   switch(lm) {
  112.   case LM_Read:
  113.     return readTuple();
  114.     break;
  115.   case LM_Exclusive:
  116.     return readTupleExclusive();
  117.     break;
  118.   case LM_CommittedRead:
  119.     return committedRead();
  120.     break;
  121.   default:
  122.     return -1;
  123.   };
  124. }
  125. /******************************************************************************
  126.  * int readTuple();
  127.  *****************************************************************************/
  128. int
  129. NdbOperation::readTuple()
  130. { 
  131.   NdbConnection* tNdbCon = theNdbCon;
  132.   int tErrorLine = theErrorLine;
  133.   if (theStatus == Init) {
  134.     theStatus = OperationDefined;
  135.     tNdbCon->theSimpleState = 0;
  136.     theOperationType = ReadRequest;
  137.     theErrorLine = tErrorLine++;
  138.     theLockMode = LM_Read;
  139.     return 0;
  140.   } else {
  141.     setErrorCode(4200);
  142.     return -1;
  143.   }//if
  144. }//NdbOperation::readTuple()
  146. /*****************************************************************************
  147.  * int deleteTuple();
  148.  *****************************************************************************/
  149. int
  150. NdbOperation::deleteTuple()
  151. {
  152.   NdbConnection* tNdbCon = theNdbCon;
  153.   int tErrorLine = theErrorLine;
  154.   if (theStatus == Init) {
  155.     theStatus = OperationDefined;  
  156.     tNdbCon->theSimpleState = 0;
  157.     theOperationType = DeleteRequest;
  158.     theErrorLine = tErrorLine++;
  159.     theLockMode = LM_Exclusive;
  160.     return 0;
  161.   } else {
  162.     setErrorCode(4200);
  163.     return -1;
  164.   }//if
  165. }//NdbOperation::deleteTuple()
  167. /******************************************************************************
  168.  * int readTupleExclusive();
  169.  *****************************************************************************/
  170. int
  171. NdbOperation::readTupleExclusive()
  172. { 
  173.   NdbConnection* tNdbCon = theNdbCon;
  174.   int tErrorLine = theErrorLine;
  175.   if (theStatus == Init) {
  176.     theStatus = OperationDefined;
  177.     tNdbCon->theSimpleState = 0;
  178.     theOperationType = ReadExclusive;
  179.     theErrorLine = tErrorLine++;
  180.     theLockMode = LM_Exclusive;
  181.     return 0;
  182.   } else {
  183.     setErrorCode(4200);
  184.     return -1;
  185.   }//if
  186. }//NdbOperation::readTupleExclusive()
  188. /*****************************************************************************
  189.  * int simpleRead();
  190.  *****************************************************************************/
  191. int
  192. NdbOperation::simpleRead()
  193. {
  194.   /**
  195.    * Currently/still disabled
  196.    */
  197.   return readTuple();
  198. #if 0
  199.   int tErrorLine = theErrorLine;
  200.   if (theStatus == Init) {
  201.     theStatus = OperationDefined;
  202.     theOperationType = ReadRequest;
  203.     theSimpleIndicator = 1;
  204.     theErrorLine = tErrorLine++;
  205.     theLockMode = LM_Read;
  206.     return 0;
  207.   } else {
  208.     setErrorCode(4200);
  209.     return -1;
  210.   }//if
  211. #endif
  212. }//NdbOperation::simpleRead()
  214. /*****************************************************************************
  215.  * int dirtyRead();
  216.  *****************************************************************************/
  217. int
  218. NdbOperation::dirtyRead()
  219. {
  220.   return committedRead();
  221. }//NdbOperation::dirtyRead()
  223. /*****************************************************************************
  224.  * int committedRead();
  225.  *****************************************************************************/
  226. int
  227. NdbOperation::committedRead()
  228. {
  229.   int tErrorLine = theErrorLine;
  230.   if (theStatus == Init) {
  231.     theStatus = OperationDefined;
  232.     theOperationType = ReadRequest;
  233.     theSimpleIndicator = 1;
  234.     theDirtyIndicator = 1;
  235.     theErrorLine = tErrorLine++;
  236.     theLockMode = LM_CommittedRead;
  237.     return 0;
  238.   } else {
  239.     setErrorCode(4200);
  240.     return -1;
  241.   }//if
  242. }//NdbOperation::committedRead()
  244. /*****************************************************************************
  245.  * int dirtyUpdate();
  246.  ****************************************************************************/
  247. int
  248. NdbOperation::dirtyUpdate()
  249. {
  250.   NdbConnection* tNdbCon = theNdbCon;
  251.   int tErrorLine = theErrorLine;
  252.   if (theStatus == Init) {
  253.     theStatus = OperationDefined;
  254.     theOperationType = UpdateRequest;
  255.     tNdbCon->theSimpleState = 0;
  256.     theSimpleIndicator = 1;
  257.     theDirtyIndicator = 1;
  258.     theErrorLine = tErrorLine++;
  259.     theLockMode = LM_CommittedRead;
  260.     return 0;
  261.   } else {
  262.     setErrorCode(4200);
  263.     return -1;
  264.   }//if
  265. }//NdbOperation::dirtyUpdate()
  267. /******************************************************************************
  268.  * int dirtyWrite();
  269.  *****************************************************************************/
  270. int
  271. NdbOperation::dirtyWrite()
  272. {
  273.   NdbConnection* tNdbCon = theNdbCon;
  274.   int tErrorLine = theErrorLine;
  275.   if (theStatus == Init) {
  276.     theStatus = OperationDefined;
  277.     theOperationType = WriteRequest;
  278.     tNdbCon->theSimpleState = 0;
  279.     theSimpleIndicator = 1;
  280.     theDirtyIndicator = 1;
  281.     theErrorLine = tErrorLine++;
  282.     theLockMode = LM_CommittedRead;
  283.     return 0;
  284.   } else {
  285.     setErrorCode(4200);
  286.     return -1;
  287.   }//if
  288. }//NdbOperation::dirtyWrite()
  290. /******************************************************************************
  291.  * int interpretedUpdateTuple();
  292.  ****************************************************************************/
  293. int
  294. NdbOperation::interpretedUpdateTuple()
  295. {
  296.   NdbConnection* tNdbCon = theNdbCon;
  297.   int tErrorLine = theErrorLine;
  298.   if (theStatus == Init) {
  299.     theStatus = OperationDefined;
  300.     tNdbCon->theSimpleState = 0;
  301.     theOperationType = UpdateRequest;
  302.     theAI_LenInCurrAI = 25;
  303.     theLockMode = LM_Exclusive;
  304.     theErrorLine = tErrorLine++;
  305.     initInterpreter();
  306.     return 0;
  307.   } else {
  308.     setErrorCode(4200);
  309.     return -1;
  310.   }//if
  311. }//NdbOperation::interpretedUpdateTuple()
  313. /*****************************************************************************
  314.  * int interpretedDeleteTuple();
  315.  *****************************************************************************/
  316. int
  317. NdbOperation::interpretedDeleteTuple()
  318. {
  319.   NdbConnection* tNdbCon = theNdbCon;
  320.   int tErrorLine = theErrorLine;
  321.   if (theStatus == Init) {
  322.     theStatus = OperationDefined;
  323.     tNdbCon->theSimpleState = 0;
  324.     theOperationType = DeleteRequest;
  326.     theErrorLine = tErrorLine++;
  327.     theAI_LenInCurrAI = 25;
  328.     theLockMode = LM_Exclusive;
  329.     initInterpreter();
  330.     return 0;
  331.   } else {
  332.     setErrorCode(4200);
  333.     return -1;
  334.   }//if
  335. }//NdbOperation::interpretedDeleteTuple()
  339. /******************************************************************************
  340.  * int getValue(AttrInfo* tAttrInfo, char* aRef )
  341.  *
  342.  * Return Value   Return 0 : GetValue was successful.
  343.  *                Return -1: In all other case. 
  344.  * Parameters:    tAttrInfo : Attribute object of the retrieved attribute 
  345.  *                            value.
  346.  * Remark:        Define an attribute to retrieve in query.
  347.  *****************************************************************************/
  348. NdbRecAttr*
  349. NdbOperation::getValue_impl(const NdbColumnImpl* tAttrInfo, char* aValue)
  350. {
  351.   NdbRecAttr* tRecAttr;
  352.   if ((tAttrInfo != NULL) &&
  353.       (!tAttrInfo->m_indexOnly) && 
  354.       (theStatus != Init)){
  355.     if (theStatus != GetValue) {
  356.       if (theInterpretIndicator == 1) {
  357. if (theStatus == FinalGetValue) {
  358.   ; // Simply continue with getValue
  359. } else if (theStatus == ExecInterpretedValue) {
  360.   if (insertATTRINFO(Interpreter::EXIT_OK) == -1)
  361.     return NULL;
  362.   theInterpretedSize = theTotalCurrAI_Len -
  363.     (theInitialReadSize + 5);
  364. } else if (theStatus == SetValueInterpreted) {
  365.   theFinalUpdateSize = theTotalCurrAI_Len - 
  366.     (theInitialReadSize + theInterpretedSize + 5);
  367. } else {
  368.   setErrorCodeAbort(4230);
  369.   return NULL;
  370. }//if
  371. // MASV - How would execution come here?
  372. theStatus = FinalGetValue;
  373.       } else {
  374. setErrorCodeAbort(4230);
  375. return NULL;
  376.       }//if
  377.     }//if
  378.     Uint32 ah;
  379.     AttributeHeader::init(&ah, tAttrInfo->m_attrId, 0);
  380.     if (insertATTRINFO(ah) != -1) {
  381.       // Insert Attribute Id into ATTRINFO part. 
  382.       
  383.       /************************************************************************
  384.        * Get a Receive Attribute object and link it into the operation object.
  385.        ***********************************************************************/
  386.       if((tRecAttr = theReceiver.getValue(tAttrInfo, aValue)) != 0){
  387. theErrorLine++;
  388. return tRecAttr;
  389.       } else {  
  390. setErrorCodeAbort(4000);
  391. return NULL;
  392.       }
  393.     } else {
  394.       return NULL;
  395.     }//if insertATTRINFO failure
  396.   } else {
  397.     if (tAttrInfo == NULL) {
  398.       setErrorCodeAbort(4004);      
  399.       return NULL;
  400.     }//if
  401.     if (tAttrInfo->m_indexOnly){
  402.       setErrorCodeAbort(4208);
  403.       return NULL;
  404.     }//if
  405.   }//if
  406.   setErrorCodeAbort(4200);
  407.   return NULL;
  408. }
  410. /*****************************************************************************
  411.  * int setValue(AttrInfo* tAttrInfo, char* aValue, Uint32 len)
  412.  *
  413.  * Return Value:  Return 0 : SetValue was succesful.
  414.  *                Return -1: In all other case.   
  415.  * Parameters:    tAttrInfo : Attribute object where the attribute 
  416.  *                            info exists.
  417.  *                aValue : Reference to the variable with the new value.
  418.  *   len    : Length of the value
  419.  * Remark:        Define a attribute to set in a query.
  420. ******************************************************************************/
  421. int
  422. NdbOperation::setValue( const NdbColumnImpl* tAttrInfo, 
  423. const char* aValuePassed, Uint32 len)
  424. {
  425.   int tReturnCode;
  426.   Uint32 tAttrId;
  427.   Uint32 tData;
  428.   Uint32 tempData[2000];
  429.   OperationType tOpType = theOperationType;
  430.   OperationStatus tStatus = theStatus;
  432.   
  433.   if ((tOpType == UpdateRequest) ||
  434.       (tOpType == WriteRequest)) {
  435.     if (theInterpretIndicator == 0) {
  436.       if (tStatus == SetValue) {
  437.         ;
  438.       } else {
  439.         setErrorCodeAbort(4234);
  440.         return -1;
  441.       }//if
  442.     } else {
  443.       if (tStatus == GetValue) {
  444.         theInitialReadSize = theTotalCurrAI_Len - 5;
  445.       } else if (tStatus == ExecInterpretedValue) {
  446. //--------------------------------------------------------------------
  447. // We insert an exit from interpretation since we are now starting 
  448. // to set values in the tuple by setValue.
  449. //--------------------------------------------------------------------
  450.         if (insertATTRINFO(Interpreter::EXIT_OK) == -1){
  451.           return -1;
  452. }
  453.         theInterpretedSize = theTotalCurrAI_Len - 
  454.           (theInitialReadSize + 5);
  455.       } else if (tStatus == SetValueInterpreted) {
  456.         ; // Simply continue adding new setValue
  457.       } else {
  458. //--------------------------------------------------------------------
  459. // setValue used in the wrong context. Application coding error.
  460. //-------------------------------------------------------------------
  461.         setErrorCodeAbort(4234); //Wrong error code
  462.         return -1;
  463.       }//if
  464.       theStatus = SetValueInterpreted;
  465.     }//if
  466.   } else if (tOpType == InsertRequest) {
  467.     if ((theStatus != SetValue) && (theStatus != OperationDefined)) {
  468.       setErrorCodeAbort(4234);
  469.       return -1;
  470.     }//if
  471.   } else if (tOpType == ReadRequest || tOpType == ReadExclusive) {
  472.     setErrorCodeAbort(4504);
  473.     return -1;
  474.   } else if (tOpType == DeleteRequest) {
  475.     setErrorCodeAbort(4504);
  476.     return -1;
  477.   } else if (tOpType == OpenScanRequest || tOpType == OpenRangeScanRequest) {
  478.     setErrorCodeAbort(4228);
  479.     return -1;
  480.   } else {
  481.     //---------------------------------------------------------------------
  482.     // setValue with undefined operation type. 
  483.     // Probably application coding error.
  484.     //---------------------------------------------------------------------
  485.     setErrorCodeAbort(4108);
  486.     return -1;
  487.   }//if
  488.   if (tAttrInfo == NULL) {
  489.     setErrorCodeAbort(4004);      
  490.     return -1;
  491.   }//if
  492.   if (tAttrInfo->m_pk) {
  493.     if (theOperationType == InsertRequest) {
  494.       return equal_impl(tAttrInfo, aValuePassed, len);
  495.     } else {
  496.       setErrorCodeAbort(4202);      
  497.       return -1;
  498.     }//if
  499.   }//if
  500.   if (len > 8000) {
  501.     setErrorCodeAbort(4216);
  502.     return -1;
  503.   }//if
  504.   
  505.   tAttrId = tAttrInfo->m_attrId;
  506.   const char *aValue = aValuePassed; 
  507.   Uint32 ahValue;
  508.   if (aValue == NULL) {
  509.     if (tAttrInfo->m_nullable) {
  510.       AttributeHeader& ah = AttributeHeader::init(&ahValue, tAttrId, 0);
  511.       ah.setNULL();
  512.       insertATTRINFO(ahValue);
  513.       // Insert Attribute Id with the value
  514.       // NULL into ATTRINFO part. 
  515.       return 0;
  516.     } else {
  517.       /***********************************************************************
  518.        * Setting a NULL value on a NOT NULL attribute is not allowed.
  519.        **********************************************************************/
  520.       setErrorCodeAbort(4203);      
  521.       return -1;
  522.     }//if
  523.   }//if
  524.   
  525.   // Insert Attribute Id into ATTRINFO part. 
  526.   const Uint32 sizeInBytes = tAttrInfo->m_attrSize * tAttrInfo->m_arraySize;
  528.   CHARSET_INFO* cs = tAttrInfo->m_cs;
  529.   int dummy_error;
  530.   // invalid data can crash kernel
  531.   if (cs != NULL &&
  532.       // fast fix bug#7340
  533.       tAttrInfo->m_type != NdbDictionary::Column::Text &&
  534.      (*cs->cset->well_formed_len)(cs,
  535.                                    aValue,
  536.                                    aValue + sizeInBytes,
  537.                                    sizeInBytes,
  538.                                    &dummy_error) != sizeInBytes) {
  539.     setErrorCodeAbort(744);
  540.     return -1;
  541.   }
  542. #if 0
  543.   tAttrSize = tAttrInfo->theAttrSize;
  544.   tArraySize = tAttrInfo->theArraySize;
  545.   if (tArraySize == 0) {
  546.     setErrorCodeAbort(4201);      
  547.     return -1;
  548.   }//if
  549.   tAttrSizeInBits = tAttrSize*tArraySize;
  550.   tAttrSizeInWords = tAttrSizeInBits >> 5;
  551. #endif
  552.   const Uint32 bitsInLastWord = 8 * (sizeInBytes & 3) ;
  553.   if (len != sizeInBytes && (len != 0)) {
  554.     setErrorCodeAbort(4209);
  555.     return -1;
  556.   }//if
  557.   const Uint32 totalSizeInWords = (sizeInBytes + 3)/4; // Including bits in last word
  558.   const Uint32 sizeInWords = sizeInBytes / 4;          // Excluding bits in last word
  559.   AttributeHeader& ah = AttributeHeader::init(&ahValue, tAttrId, 
  560.       totalSizeInWords);
  561.   insertATTRINFO( ahValue );
  563.   /***********************************************************************
  564.    * Check if the pointer of the value passed is aligned on a 4 byte boundary.
  565.    * If so only assign the pointer to the internal variable aValue. 
  566.    * If it is not aligned then we start by copying the value to tempData and 
  567.    * use this as aValue instead.
  568.    *************************************************************************/
  569.   const int attributeSize = sizeInBytes;
  570.   const int slack = sizeInBytes & 3;
  571.   
  572.   if (((UintPtr)aValue & 3) != 0 || (slack != 0)){
  573.     memcpy(&tempData[0], aValue, attributeSize);
  574.     aValue = (char*)&tempData[0];
  575.     if(slack != 0) {
  576.       char * tmp = (char*)&tempData[0];
  577.       memset(&tmp[attributeSize], 0, (4 - slack));
  578.     }//if
  579.   }//if
  580.   
  581.   tReturnCode = insertATTRINFOloop((Uint32*)aValue, sizeInWords);
  582.   if (tReturnCode == -1) {
  583.     return tReturnCode;
  584.   }//if
  585.   if (bitsInLastWord != 0) {
  586.     tData = *(Uint32*)(aValue + sizeInWords*4);
  587.     tData = convertEndian(tData);
  588.     tData = tData & ((1 << bitsInLastWord) - 1);
  589.     tData = convertEndian(tData);
  590.     tReturnCode = insertATTRINFO(tData);
  591.     if (tReturnCode == -1) {
  592.       return tReturnCode;
  593.     }//if
  594.   }//if
  595.   theErrorLine++;  
  596.   return 0;
  597. }//NdbOperation::setValue()
  599. NdbBlob*
  600. NdbOperation::getBlobHandle(NdbConnection* aCon, const NdbColumnImpl* tAttrInfo)
  601. {
  602.   NdbBlob* tBlob = theBlobList;
  603.   NdbBlob* tLastBlob = NULL;
  604.   while (tBlob != NULL) {
  605.     if (tBlob->theColumn == tAttrInfo)
  606.       return tBlob;
  607.     tLastBlob = tBlob;
  608.     tBlob = tBlob->theNext;
  609.   }
  610.   tBlob = theNdb->getNdbBlob();
  611.   if (tBlob == NULL)
  612.     return NULL;
  613.   if (tBlob->atPrepare(aCon, this, tAttrInfo) == -1) {
  614.     theNdb->releaseNdbBlob(tBlob);
  615.     return NULL;
  616.   }
  617.   if (tLastBlob == NULL)
  618.     theBlobList = tBlob;
  619.   else
  620.     tLastBlob->theNext = tBlob;
  621.   tBlob->theNext = NULL;
  622.   theNdbCon->theBlobFlag = true;
  623.   return tBlob;
  624. }
  626. /****************************************************************************
  627.  * int insertATTRINFO( Uint32 aData );
  628.  *
  629.  * Return Value:   Return 0 : insertATTRINFO was succesful.
  630.  *                 Return -1: In all other case.   
  631.  * Parameters:     aData: the data to insert into ATTRINFO.
  632.  * Remark:         Puts the the data into either TCKEYREQ signal or 
  633.  *                 ATTRINFO signal.
  634.  *****************************************************************************/
  635. int
  636. NdbOperation::insertATTRINFO( Uint32 aData )
  637. {
  638.   NdbApiSignal* tSignal;
  639.   register Uint32 tAI_LenInCurrAI = theAI_LenInCurrAI;
  640.   register Uint32* tAttrPtr = theATTRINFOptr;
  641.   register Uint32 tTotCurrAILen = theTotalCurrAI_Len;
  643.   if (tAI_LenInCurrAI >= 25) {
  644.     Ndb* tNdb = theNdb;
  645.     NdbApiSignal* tFirstAttrinfo = theFirstATTRINFO;
  646.     tAI_LenInCurrAI = 3;
  647.     tSignal = tNdb->getSignal();
  648.     if (tSignal != NULL) {
  649.       tSignal->setSignal(m_attrInfoGSN);
  650.       tAttrPtr = &tSignal->getDataPtrSend()[3];
  651.       if (tFirstAttrinfo == NULL) {
  652.         tSignal->next(NULL);
  653.         theFirstATTRINFO = tSignal;
  654.         theCurrentATTRINFO = tSignal;
  655.       } else {
  656.         NdbApiSignal* tCurrentAttrinfoBeforeUpdate = theCurrentATTRINFO;
  657.         tSignal->next(NULL);
  658.         theCurrentATTRINFO = tSignal;
  659.         tCurrentAttrinfoBeforeUpdate->next(tSignal);
  660.       }//if
  661.     } else {
  662.       goto insertATTRINFO_error1;
  663.     }//if
  664.   }//if
  665.   *tAttrPtr = aData;
  666.   tAttrPtr++;
  667.   tTotCurrAILen++;
  668.   tAI_LenInCurrAI++;
  669.   theTotalCurrAI_Len = tTotCurrAILen;
  670.   theAI_LenInCurrAI = tAI_LenInCurrAI;
  671.   theATTRINFOptr = tAttrPtr;
  672.   return 0;
  674. insertATTRINFO_error1:
  675.   setErrorCodeAbort(4000);
  676.   return -1;
  678. }//NdbOperation::insertATTRINFO()
  680. /*****************************************************************************
  681.  * int insertATTRINFOloop(Uint32* aDataPtr, Uint32 aLength );
  682.  *
  683.  * Return Value:  Return 0 : insertATTRINFO was succesful.
  684.  *                Return -1: In all other case.   
  685.  * Parameters:    aDataPtr: Pointer to the data to insert into ATTRINFO.
  686.  *                aLength: Length of data to be copied
  687.  * Remark:        Puts the the data into either TCKEYREQ signal or 
  688.  *                ATTRINFO signal.
  689.  *****************************************************************************/
  690. int
  691. NdbOperation::insertATTRINFOloop(register const Uint32* aDataPtr, 
  692.  register Uint32 aLength)
  693. {
  694.   NdbApiSignal* tSignal;
  695.   register Uint32 tAI_LenInCurrAI = theAI_LenInCurrAI;
  696.   register Uint32 tTotCurrAILen = theTotalCurrAI_Len;
  697.   register Uint32* tAttrPtr = theATTRINFOptr;  
  698.   Ndb* tNdb = theNdb;
  700.   while (aLength > 0) {
  701.     if (tAI_LenInCurrAI >= 25) {
  702.       NdbApiSignal* tFirstAttrinfo = theFirstATTRINFO;
  703.       tAI_LenInCurrAI = 3;
  704.       tSignal = tNdb->getSignal();
  705.       if (tSignal != NULL) {
  706.         tSignal->setSignal(m_attrInfoGSN);
  707.         tAttrPtr = &tSignal->getDataPtrSend()[3];
  708.         if (tFirstAttrinfo == NULL) {
  709.           tSignal->next(NULL);
  710.           theFirstATTRINFO = tSignal;
  711.           theCurrentATTRINFO = tSignal;
  712.         } else {
  713.           NdbApiSignal* tCurrentAttrinfoBeforeUpdate = theCurrentATTRINFO;
  714.           tSignal->next(NULL);
  715.           theCurrentATTRINFO = tSignal;
  716.           tCurrentAttrinfoBeforeUpdate->next(tSignal);
  717.         }//if
  718.       } else {
  719.         goto insertATTRINFO_error1;
  720.       }//if
  721.     }//if
  722.     {
  723.       register Uint32 tData = *aDataPtr;
  724.       aDataPtr++;
  725.       aLength--;
  726.       tAI_LenInCurrAI++;
  727.       *tAttrPtr = tData;
  728.       tAttrPtr++;
  729.       tTotCurrAILen++;
  730.     }
  731.   }//while
  732.   theATTRINFOptr = tAttrPtr;
  733.   theTotalCurrAI_Len = tTotCurrAILen;
  734.   theAI_LenInCurrAI = tAI_LenInCurrAI;
  735.   return 0;
  737. insertATTRINFO_error1:
  738.   setErrorCodeAbort(4000);
  739.   return -1;
  741. }//NdbOperation::insertATTRINFOloop()