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

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

MySQL数据库

开发平台：

Visual C++

NdbOperationInt.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. #include <ndb_global.h>
  19. #include <NdbOperation.hpp>
  20. #include "NdbApiSignal.hpp"
  21. #include <NdbConnection.hpp>
  22. #include <Ndb.hpp>
  23. #include "NdbRecAttr.hpp"
  24. #include "NdbUtil.hpp"
  25. #include "Interpreter.hpp"
  26. #include <NdbIndexScanOperation.hpp>
  28. #ifdef VM_TRACE
  29. #include <NdbEnv.h>
  30. #define INT_DEBUG(x) 
  31.   { const char* tmp = NdbEnv_GetEnv("INT_DEBUG", (char*)0, 0); 
  32.   if (tmp != 0 && strlen(tmp) != 0) { ndbout << "INT:"; ndbout_c x; } }
  33. #else
  34. #define INT_DEBUG(x)
  35. #endif
  37. void
  38. NdbOperation::initInterpreter(){
  39.   theFirstLabel = NULL;
  40.   theLastLabel = NULL;
  41.   theFirstBranch = NULL;
  42.   theLastBranch = NULL;
  43.   
  44.   theFirstCall = NULL;
  45.   theLastCall = NULL;
  46.   theFirstSubroutine = NULL;
  47.   theLastSubroutine = NULL;
  48.   
  49.   theNoOfLabels = 0;
  50.   theNoOfSubroutines = 0;
  51.   
  52.   theSubroutineSize = 0;
  53.   theInitialReadSize = 0;
  54.   theInterpretedSize = 0;
  55.   theFinalUpdateSize = 0;
  56.   theFinalReadSize = 0;
  57.   theInterpretIndicator = 1;
  59.   theTotalCurrAI_Len = 5;
  60. }
  62. int
  63. NdbOperation::incCheck(const NdbColumnImpl* tNdbColumnImpl)
  64. {
  65.   if ((theInterpretIndicator == 1)) {
  66.     if ((tNdbColumnImpl == NULL) ||
  67.         (theOperationType == OpenScanRequest ||
  68.          theOperationType == OpenRangeScanRequest))
  69.       goto inc_check_error1;
  70.     if ((tNdbColumnImpl->getInterpretableType() != true) ||
  71.         (tNdbColumnImpl->m_pk != false) ||
  72.         (tNdbColumnImpl->m_nullable))
  73.       goto inc_check_error2;
  74.     if (theStatus == ExecInterpretedValue) {
  75.       ; // Simply continue with interpretation
  76.     } else if (theStatus == GetValue) {
  77.       theInitialReadSize = theTotalCurrAI_Len - 5;
  78.       theStatus = ExecInterpretedValue;
  79.     } else if (theStatus == SubroutineExec) {
  80.       ; // Simply continue with interpretation
  81.     } else {
  82.       setErrorCodeAbort(4231);
  83.       return -1;
  84.     }
  85.     return tNdbColumnImpl->m_attrId;
  86.   } else {
  87.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  88.       setErrorCodeAbort(4200);
  89.   }
  90.   return -1;
  91.   
  92.  inc_check_error1:
  93.   if (theOperationType == OpenScanRequest ||
  94.       theOperationType == OpenRangeScanRequest) {
  95.     setErrorCodeAbort(4228);
  96.     return -1;
  97.   }
  98.   setErrorCodeAbort(4004);
  99.   return -1;
  100.   
  101.  inc_check_error2:
  102.   if (tNdbColumnImpl->m_pk){
  103.     setErrorCodeAbort(4202);
  104.     return -1;
  105.   }//if
  106.   if (!tNdbColumnImpl->getInterpretableType()){
  107.     setErrorCodeAbort(4217);
  108.     return -1;
  109.   }//if
  110.   if (tNdbColumnImpl->m_nullable){
  111.     setErrorCodeAbort(4218);
  112.     return -1;
  113.   }//if
  114.   setErrorCodeAbort(4219);
  115.   return -1;
  116. }
  118. int
  119. NdbOperation::write_attrCheck(const NdbColumnImpl* tNdbColumnImpl)
  120. {
  121.   if ((theInterpretIndicator == 1)) {
  122.     if ((tNdbColumnImpl == NULL) ||
  123.         (theOperationType == OpenScanRequest ||
  124.          theOperationType == OpenRangeScanRequest))
  125.       goto write_attr_check_error1;
  126.     if ((tNdbColumnImpl->getInterpretableType() == false) ||
  127.         (tNdbColumnImpl->m_pk))
  128.       goto write_attr_check_error2;
  129.     if (theStatus == ExecInterpretedValue) {
  130.       ; // Simply continue with interpretation
  131.     } else if (theStatus == SubroutineExec) {
  132.       ; // Simply continue with interpretation
  133.     } else {
  134.       setErrorCodeAbort(4231);
  135.       return -1;
  136.     }
  137.     return tNdbColumnImpl->m_attrId;
  138.   } else {
  139.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  140.       setErrorCodeAbort(4200);
  141.   }
  142.   return -1;
  144. write_attr_check_error1:
  145.   if (theOperationType == OpenScanRequest ||
  146.       theOperationType == OpenRangeScanRequest) {
  147.     setErrorCodeAbort(4228);
  148.     return -1;
  149.   }
  150.   setErrorCodeAbort(4004);
  151.   return -1;
  153. write_attr_check_error2:
  154.   if (tNdbColumnImpl->m_pk) {
  155.     setErrorCodeAbort(4202);
  156.     return -1;
  157.   }//if
  158.   if (tNdbColumnImpl->getInterpretableType() == false){
  159.     setErrorCodeAbort(4217);
  160.     return -1;
  161.   }//if
  162.   setErrorCodeAbort(4219);
  163.   return -1;
  164. }
  166. int
  167. NdbOperation::read_attrCheck(const NdbColumnImpl* tNdbColumnImpl)
  168. {
  169.   if ((theInterpretIndicator == 1)) {
  170.     if (tNdbColumnImpl == NULL)
  171.       goto read_attr_check_error1;
  172.     if (tNdbColumnImpl->getInterpretableType() == false)
  173.       goto read_attr_check_error2;
  174.     if (theStatus == ExecInterpretedValue) {
  175.       ; // Simply continue with interpretation
  176.     } else if (theStatus == GetValue) {
  177.       theInitialReadSize = theTotalCurrAI_Len - 5;
  178.       theStatus = ExecInterpretedValue;
  179.     } else if (theStatus == SubroutineExec) {
  180.       ; // Simply continue with interpretation
  181.     } else {
  182.       setErrorCodeAbort(4231);
  183.       return -1;
  184.     }
  185.     return tNdbColumnImpl->m_attrId;
  186.   } else {
  187.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  188.       setErrorCodeAbort(4200);
  189.   }
  190.   return -1;
  191.   
  192.  read_attr_check_error1:
  193.   setErrorCodeAbort(4004);
  194.   return -1;
  195.   
  196.  read_attr_check_error2:
  197.   if (tNdbColumnImpl->getInterpretableType() == false)
  198.     setErrorCodeAbort(4217);
  199.   else
  200.     setErrorCodeAbort(4219);
  201.   return -1;
  203. }
  205. int
  206. NdbOperation::initial_interpreterCheck()
  207. {
  208.   if ((theInterpretIndicator == 1)) {
  209.     if (theStatus == ExecInterpretedValue) {
  210.        return 0; // Simply continue with interpretation
  211.     } else if (theStatus == GetValue) {
  212.       theInitialReadSize = theTotalCurrAI_Len - 5;
  213.       theStatus = ExecInterpretedValue;
  214.       return 0;
  215.     } else if (theStatus == SubroutineExec) {
  216.        return 0; // Simply continue with interpretation
  217.     } else {
  218.       setErrorCodeAbort(4231);
  219.       return -1;
  220.     }
  221.     return 0;
  222.   } else {
  223.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  224.       setErrorCodeAbort(4200);
  225.   }
  226.   return -1;
  227. }
  229. int
  230. NdbOperation::labelCheck()
  231. {
  232.   if ((theInterpretIndicator == 1)) {
  233.     if (theStatus == ExecInterpretedValue) {
  234.        return 0; // Simply continue with interpretation
  235.     } else if (theStatus == GetValue) {
  236.       theInitialReadSize = theTotalCurrAI_Len - 5;
  237.       theStatus = ExecInterpretedValue;
  238.       return 0;
  239.     } else if (theStatus == SubroutineExec) {
  240.        return 0; // Simply continue with interpretation
  241.     } else if (theStatus == SubroutineEnd) {
  242.        theStatus = SubroutineExec;
  243.     } else {
  244.       setErrorCodeAbort(4231);
  245.       return -1;
  246.     }
  247.     return 0;
  248.   } else {
  249.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  250.       setErrorCodeAbort(4200);
  251.   }
  252.   return -1;
  253. }
  255. int
  256. NdbOperation::intermediate_interpreterCheck()
  257. {
  258.   if ((theInterpretIndicator == 1)) {
  259.     if (theStatus == ExecInterpretedValue) {
  260.        return 0; // Simply continue with interpretation
  261.     } else if (theStatus == SubroutineExec) {
  262.        return 0; // Simply continue with interpretation
  263.     } else {
  264.       setErrorCodeAbort(4231);
  265.       return -1;
  266.     }
  267.     return 0;
  268.   } else {
  269.     if (theNdbCon->theCommitStatus == NdbConnection::Started)
  270.       setErrorCodeAbort(4200);
  271.   }
  272.   return -1;
  273. }
  275. /*****************************************************************************
  276.  * int incValue(const char* anAttrName, char* aValue, Uint32 aValue)
  277.  *
  278.  * Return Value:  Return 0 : incValue was succesful.
  279.  *                Return -1: In all other case.   
  280.  * Parameters:    anAttrName : Attribute name where the attribute value 
  281.  *                             will be save.
  282.  *                aValue : The constant to increment the attribute value with. 
  283.  *****************************************************************************/
  284. int
  285. NdbOperation::incValue(const NdbColumnImpl* tNdbColumnImpl, Uint32 aValue)
  286. {
  287.   INT_DEBUG(("incValue32 %d %u", tNdbColumnImpl->m_attrId, aValue));
  288.   int tAttrId;
  290.   tAttrId = incCheck(tNdbColumnImpl);
  291.   if (tAttrId == -1)
  292.     goto incValue_error1;
  294. // Load Attribute into register 6
  296.   if (insertATTRINFO( Interpreter::Read(tAttrId, 6)) == -1)
  297.     goto incValue_error1;
  298. // Load aValue into register 7
  299.   if (aValue < 65536)
  300.   {
  301.     if (insertATTRINFO(Interpreter::LoadConst16(7, aValue)) == -1)
  302.       goto incValue_error1;
  303.   } else {
  304.     if (insertATTRINFO(Interpreter::LoadConst32(7)) == -1)
  305.       goto incValue_error1;
  306.     if (insertATTRINFO(aValue) == -1)
  307.       goto incValue_error1;
  308.   }
  309.   // Add register 6 and 7 and put result in register 7
  311.   if (insertATTRINFO( Interpreter::Add(7, 6, 7)) == -1)
  312.     goto incValue_error1;
  313.   if (insertATTRINFO( Interpreter::Write(tAttrId, 7)) == -1)
  314.     goto incValue_error1;
  315.   
  316.   theErrorLine++;
  317.   return 0;
  319. incValue_error1:
  320.   return -1;
  321. }
  323. /*****************************************************************************
  324.  * int subValue(const char* anAttrName, char* aValue, Uint32 aValue)
  325.  *
  326.  * Return Value:   Return 0 : incValue was succesful.
  327.  *                 Return -1: In all other case.   
  328.  * Parameters:     anAttrName : Attribute name where the attribute value 
  329.  *                              will be save.
  330.  *                aValue : The constant to increment the attribute value with. 
  331. ******************************************************************************/
  332. int
  333. NdbOperation::subValue(const NdbColumnImpl* tNdbColumnImpl, Uint32 aValue)
  334. {
  335.   INT_DEBUG(("subValue32 %d %u", tNdbColumnImpl->m_attrId, aValue));
  336.   int tAttrId;
  338.   tAttrId = incCheck(tNdbColumnImpl);
  339.   if (tAttrId == -1)
  340.     goto subValue_error1;
  342. // Load Attribute into register 6
  344.   if (insertATTRINFO( Interpreter::Read(tAttrId, 6)) == -1)
  345.     goto subValue_error1;
  346. // Load aValue into register 7
  347.   if (aValue < 65536)
  348.   {
  349.     if (insertATTRINFO( Interpreter::LoadConst16(7, aValue)) == -1)
  350.       goto subValue_error1;
  351.   } else {
  352.     if (insertATTRINFO( Interpreter::LoadConst32(7)) == -1)
  353.       goto subValue_error1;
  354.     if (insertATTRINFO(aValue) == -1)
  355.       goto subValue_error1;
  356.   }
  357.   // Subtract register 6 and 7 and put result in register 7
  358.   
  359.   if (insertATTRINFO( Interpreter::Sub(7, 6, 7)) == -1)
  360.     goto subValue_error1;
  361.   if (insertATTRINFO( Interpreter::Write(tAttrId, 7)) == -1)
  362.     goto subValue_error1;
  363.   
  364.   theErrorLine++;
  365.   return 0;
  366.   
  367.  subValue_error1:
  368.   return -1;
  369. }
  371. /******************************************************************************
  372.  * int incValue(const char* anAttrName, char* aValue, Uint64 aValue)
  373.  *
  374.  * Return Value:   Return 0 : incValue was succesful.
  375.  *                 Return -1: In all other case.   
  376.  * Parameters:     anAttrName : Attribute name where the attribute value will 
  377.  *                             be save.
  378.  *                aValue : The constant to increment the attribute value with. 
  379.  *****************************************************************************/
  380. int
  381. NdbOperation::incValue(const NdbColumnImpl* tNdbColumnImpl, Uint64 aValue)
  382. {
  383.   INT_DEBUG(("incValue64 %d %llu", tNdbColumnImpl->m_attrId, aValue));
  384.   int tAttrId;
  386.   tAttrId = incCheck(tNdbColumnImpl);
  387.   if (tAttrId == -1)
  388.     goto incValue_error1;
  390. // Load Attribute into register 6
  392.   if (insertATTRINFO( Interpreter::Read(tAttrId, 6)) == -1)
  393.     goto incValue_error1;
  394. // Load aValue into register 7
  395.   if (insertATTRINFO( Interpreter::LoadConst64(7)) == -1)
  396.     goto incValue_error1;
  397.   if (insertATTRINFOloop((Uint32*)&aValue, 2) == -1)
  398.     goto incValue_error1;
  399.   // Add register 6 and 7 and put result in register 7
  400.   if (insertATTRINFO( Interpreter::Add(7, 6, 7)) == -1)
  401.     goto incValue_error1;
  402.   if (insertATTRINFO( Interpreter::Write(tAttrId, 7)) == -1)
  403.     goto incValue_error1;
  404.   
  405.   theErrorLine++;
  406.   return 0;  
  408. incValue_error1:
  409.   return -1;
  410. }
  412. /*****************************************************************************
  413.  * int subValue(const char* anAttrName, char* aValue, Uint64 aValue)
  414.  *
  415.  * Return Value:   Return 0 : incValue was succesful.
  416.  *                Return -1: In all other case.   
  417.  * Parameters:     anAttrName : Attribute name where the attribute value will 
  418.  *                              be save.
  419.  *                aValue : The constant to increment the attribute value with. 
  420. ******************************************************************************/
  421. int
  422. NdbOperation::subValue(const NdbColumnImpl* tNdbColumnImpl, Uint64 aValue)
  423. {
  424.   INT_DEBUG(("subValue64 %d %llu", tNdbColumnImpl->m_attrId, aValue));
  425.   int tAttrId;
  427.   tAttrId = incCheck(tNdbColumnImpl);
  428.   if (tAttrId == -1)
  429.     goto subValue_error1;
  431. // Load Attribute into register 6
  433.   if (insertATTRINFO( Interpreter::Read(6, tAttrId)) == -1)
  434.     goto subValue_error1;
  435. // Load aValue into register 7
  436.   if (insertATTRINFO( Interpreter::LoadConst64(7)) == -1)
  437.     goto subValue_error1;
  438.   if (insertATTRINFOloop((Uint32*)&aValue, 2) == -1)
  439.     goto subValue_error1;
  440. // Subtract register 6 and 7 and put result in register 7
  441.   if (insertATTRINFO( Interpreter::Sub(7, 6, 7)) == -1)
  442.     goto subValue_error1;
  443.   if (insertATTRINFO( Interpreter::Write(tAttrId, 7)) == -1)
  444.     goto subValue_error1;
  446.   theErrorLine++;
  447.   return 0;  
  449. subValue_error1:
  450.   return -1;
  451. }
  453. /*****************************************************************************
  454.  * int NdbOperation::def_label()
  455.  *****************************************************************************/
  456. int
  457. NdbOperation::def_label(int tLabelNo)
  458. {
  459.   INT_DEBUG(("def_label %d", tLabelNo));
  460.   Uint32 tLabelIndex;
  461.   if (labelCheck() == -1)
  462.     return -1;
  464.   tLabelIndex = theNoOfLabels - ((theNoOfLabels >> 4) << 4);
  465.   if (tLabelIndex == 0)
  466.   {
  467.     NdbLabel* tNdbLabel = theNdb->getNdbLabel();
  468.     if (tNdbLabel == NULL)
  469.     {
  470.       setErrorCodeAbort(4000);
  471.       return -1;
  472.     }
  473.     if (theFirstLabel == NULL)
  474.       theFirstLabel = tNdbLabel;
  475.     else
  476.       theLastLabel->theNext = tNdbLabel;
  478.     theLastLabel = tNdbLabel;
  479.     tNdbLabel->theNext = NULL;
  480.   }
  482.   /**
  483.    * Here we set the address that the label should point to (jump address), 
  484.    * the first 5 words are excluded since they are length specifications and 
  485.    * not part of the data. 
  486.    * We need to add 1 to the current ATTRINFO length since the last inserted 
  487.    * item is not where we want to jump to. 
  488.    * Later on we will update the branch items with this address, this is done in
  489.    * the NdbOperation::prepareSendInterpreted method.
  490.    */
  492.   theLastLabel->theLabelNo[tLabelIndex] = tLabelNo;
  493.   theLastLabel->theLabelAddress[tLabelIndex] = (theTotalCurrAI_Len + 1) - (theInitialReadSize + 5);
  494.   theLastLabel->theSubroutine[tLabelIndex] = theNoOfSubroutines;
  495.   theNoOfLabels++;
  496.   theErrorLine++;
  497.   return (theNoOfLabels - 1);
  498. }
  500. /************************************************************************************************
  501. int NdbOperation::def_subroutine()
  503. ************************************************************************************************/
  504. int
  505. NdbOperation::def_subroutine(int tSubNo)
  506. {
  507.   INT_DEBUG(("def_subroutine %d", tSubNo));
  508.   Uint32 tSubroutineIndex;
  510.   if (theInterpretIndicator != 1)
  511.   {
  512.     setErrorCodeAbort(4200);
  513.     return -1;
  514.   }
  516.   if (int(theNoOfSubroutines) != tSubNo)
  517.   {
  518.     setErrorCodeAbort(4227);
  519.     return -1;
  520.   }
  521.   if (theStatus == FinalGetValue)
  522.   {
  523.     theFinalReadSize = theTotalCurrAI_Len -
  524.        (theInitialReadSize + theInterpretedSize + 
  525.         theFinalUpdateSize + 5);
  527.   } else if (theStatus == SubroutineEnd)
  528.   {
  529.      ; // Correct Status, last call was ret_sub()
  530.   } else if (theStatus == ExecInterpretedValue)
  531.   {
  532.     if (insertATTRINFO(Interpreter::EXIT_OK) == -1)
  533.       return -1;
  534.     theInterpretedSize = theTotalCurrAI_Len - (theInitialReadSize + 5);
  535.   } else if (theStatus == SetValueInterpreted)
  536.   {
  537.     theFinalUpdateSize = theTotalCurrAI_Len -
  538.        (theInitialReadSize + theInterpretedSize + 5);
  540.   } else if (theStatus == GetValue)
  541.   {
  543.     theInitialReadSize = theTotalCurrAI_Len - 5;
  545.   } else
  546.   {
  547.     setErrorCodeAbort(4200);
  548.     return -1;
  549.   }
  550.   theStatus = SubroutineExec;
  551.   tSubroutineIndex = theNoOfSubroutines - ((theNoOfSubroutines >> 4) << 4);
  552.   if (tSubroutineIndex == 0)
  553.   {
  554.     NdbSubroutine* tNdbSubroutine = theNdb->getNdbSubroutine();
  555.     if (tNdbSubroutine == NULL)
  556.     {
  557.       setErrorCodeAbort(4000);
  558.       return -1;
  559.     }
  560.     if (theFirstSubroutine == NULL)
  561.       theFirstSubroutine = tNdbSubroutine;
  562.     else
  563.       theLastSubroutine->theNext = tNdbSubroutine;
  565.     theLastSubroutine = tNdbSubroutine;
  566.     tNdbSubroutine->theNext = NULL;
  567.   }
  568.   theLastSubroutine->theSubroutineAddress[tSubroutineIndex] = theTotalCurrAI_Len - 
  569.     (theInitialReadSize + theInterpretedSize + 
  570.      theFinalUpdateSize + theFinalReadSize);
  571.   theNoOfSubroutines++;
  572.   theErrorLine++;
  573.   return (theNoOfSubroutines - 1);
  574. }
  576. /************************************************************************************************
  577. int NdbOperation::add_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest)
  579. ************************************************************************************************/
  580. int
  581. NdbOperation::add_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest)
  582. {
  583.   INT_DEBUG(("add_reg %u %u %u", RegSource1, RegSource2, RegDest));
  584.   if (intermediate_interpreterCheck() == -1)
  585.     return -1;
  587.   if (RegSource1 >= 8)
  588.   {
  589.     setErrorCodeAbort(4229);
  590.     return -1;
  591.   }
  592.   if (RegSource2 >= 8)
  593.   {
  594.     setErrorCodeAbort(4229);
  595.     return -1;
  596.   }
  597.   if (RegDest >= 8)
  598.   {
  599.     setErrorCodeAbort(4229);
  600.     return -1;
  601.   }
  602.   if (insertATTRINFO( Interpreter::Add(RegDest, RegSource1, RegSource2)) == -1)
  603.     return -1;
  604.   theErrorLine++;
  605.   return 0;
  606. }
  608. /************************************************************************************************
  609. int NdbOperation::sub_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest)
  611. ************************************************************************************************/
  612. int
  613. NdbOperation::sub_reg(Uint32 RegSource1, Uint32 RegSource2, Uint32 RegDest)
  614. {
  615.   INT_DEBUG(("sub_reg %u %u %u", RegSource1, RegSource2, RegDest));
  616.   if (intermediate_interpreterCheck() == -1)
  617.     return -1;
  619.   if (RegSource1 >= 8)
  620.   {
  621.     setErrorCodeAbort(4229);
  622.     return -1;
  623.   }
  624.   if (RegSource2 >= 8)
  625.   {
  626.     setErrorCodeAbort(4229);
  627.     return -1;
  628.   }
  629.   if (RegDest >= 8)
  630.   {
  631.     setErrorCodeAbort(4229);
  632.     return -1;
  633.   }
  634.   if (insertATTRINFO( Interpreter::Sub(RegDest, RegSource1, RegSource2)) == -1)
  635.     return -1;
  636.   theErrorLine++;
  637.   return 0;
  638. }
  640. /************************************************************************************************
  641. int NdbOperation::load_const_u32(Uint32 RegDest, Uint32 Constant)
  643. ************************************************************************************************/
  644. int
  645. NdbOperation::load_const_u32(Uint32 RegDest, Uint32 Constant)
  646. {
  647.   INT_DEBUG(("load_const_u32 %u %u", RegDest, Constant));
  648.   if (initial_interpreterCheck() == -1)
  649.     goto l_u32_error1;
  650.   if (RegDest >= 8)
  651.     goto l_u32_error2;
  652.   if (insertATTRINFO( Interpreter::LoadConst32(RegDest)) == -1)
  653.     goto l_u32_error1;
  654.   if (insertATTRINFO(Constant) == -1)
  655.     goto l_u32_error1;
  656.   theErrorLine++;
  657.   return 0;
  659.  l_u32_error1:
  660.   return -1;
  661.   
  662.  l_u32_error2:
  663.   setErrorCodeAbort(4229);
  664.   return -1;
  665. }
  667. /************************************************************************************************
  668. int NdbOperation::load_const_u64(Uint32 RegDest, Uint64 Constant)
  670. ************************************************************************************************/
  671. int
  672. NdbOperation::load_const_u64(Uint32 RegDest, Uint64 Constant)
  673. {
  674.   INT_DEBUG(("load_const_u64 %u %llu", RegDest, Constant));
  675.   if (initial_interpreterCheck() == -1)
  676.     return -1;
  677.   if (RegDest >= 8)
  678.   {
  679.     setErrorCodeAbort(4229);
  680.     return -1;
  681.   }
  682.   
  683.   // 64 bit value
  684.   if (insertATTRINFO( Interpreter::LoadConst64(RegDest)) == -1)
  685.     return -1;
  686.   if (insertATTRINFOloop((Uint32*)&Constant, 2) == -1)
  687.     return -1;
  688.   theErrorLine++;
  689.   return 0;
  690. }
  692. /************************************************************************************************
  693. int NdbOperation::load_const_null(Uint32 RegDest)
  695. ************************************************************************************************/
  696. int
  697. NdbOperation::load_const_null(Uint32 RegDest)
  698. {
  699.   INT_DEBUG(("load_const_null %u", RegDest));
  700.   if (initial_interpreterCheck() == -1)
  701.     return -1;
  702.   if (RegDest >= 8)
  703.   {
  704.     setErrorCodeAbort(4229);
  705.     return -1;
  706.   }
  707.   if (insertATTRINFO( Interpreter::LOAD_CONST_NULL) == -1)
  708.     return -1;
  709.   theErrorLine++;
  710.   return 0;
  711. }
  713. /************************************************************************************************
  714. int NdbOperation::read_attr(const char* anAttrName, Uint32 RegDest)
  716. ************************************************************************************************/
  717. int
  718. NdbOperation::read_attr(const NdbColumnImpl* anAttrObject, Uint32 RegDest)
  719. {
  720.   INT_DEBUG(("read_attr %d %u", anAttrObject->m_attrId, RegDest));
  721.   if (initial_interpreterCheck() == -1)
  722.     return -1;
  724.   int tAttrId = read_attrCheck(anAttrObject);
  725.   if (tAttrId == -1)
  726.     goto read_attr_error1;
  727.   if (RegDest >= 8)
  728.     goto read_attr_error2;
  729.   if (insertATTRINFO( Interpreter::Read(tAttrId, RegDest)) != -1) {
  730.     return 0;
  731.     theErrorLine++;
  732.   }//if
  733.   return -1;
  735. read_attr_error1:
  736.   return -1;
  738. read_attr_error2:
  739.   setErrorCodeAbort(4229);
  740.   return -1;
  741. }
  743. /************************************************************************************************
  744. int NdbOperation::write_attr(const char* anAttrName, Uint32 RegSource)
  746. ************************************************************************************************/
  747. int
  748. NdbOperation::write_attr(const NdbColumnImpl* anAttrObject, Uint32 RegSource)
  749. {
  750.   INT_DEBUG(("write_attr %d %u", anAttrObject->m_attrId, RegSource));
  751.   int tAttrId = write_attrCheck(anAttrObject);
  752.   if (tAttrId == -1)
  753.     return -1;
  754.   if (insertATTRINFO( Interpreter::Write(tAttrId, RegSource)) == -1)
  755.     return -1;
  756.   theErrorLine++;
  757.   return 0;
  758. }
  760. int
  761. NdbOperation::branch_reg_reg(Uint32 type,
  762.      Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  763. {
  764.   if (intermediate_interpreterCheck() == -1)
  765.     return -1;
  766.   if (insertATTRINFO(Interpreter::Branch(type, RegLvalue, RegRvalue)) == -1)
  767.     return -1;
  768.   if (insertBranch(Label) == -1)
  769.     return -1;
  770.   theErrorLine++;
  771.   return 0;
  772. }
  774. int
  775. NdbOperation::branch_ge(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  776. {
  777.   INT_DEBUG(("branch_ge %u %u %u", RegLvalue, RegRvalue, Label));
  778.   return branch_reg_reg(Interpreter::BRANCH_GE_REG_REG,
  779. RegLvalue, RegRvalue, Label);
  780. }
  782. int
  783. NdbOperation::branch_gt(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  784. {
  785.   INT_DEBUG(("branch_gt %u %u %u", RegLvalue, RegRvalue, Label));
  786.   return branch_reg_reg(Interpreter::BRANCH_GT_REG_REG,
  787. RegLvalue, RegRvalue, Label);
  788. }
  790. int
  791. NdbOperation::branch_le(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  792. {
  793.   INT_DEBUG(("branch_le %u %u %u", RegLvalue, RegRvalue, Label));
  794.   return branch_reg_reg(Interpreter::BRANCH_LE_REG_REG,
  795. RegLvalue, RegRvalue, Label);
  796. }
  798. int
  799. NdbOperation::branch_lt(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  800. {
  801.   INT_DEBUG(("branch_lt %u %u %u", RegLvalue, RegRvalue, Label));
  802.   return branch_reg_reg(Interpreter::BRANCH_LT_REG_REG,
  803. RegLvalue, RegRvalue, Label);
  804. }
  806. int
  807. NdbOperation::branch_eq(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  808. {
  809.   INT_DEBUG(("branch_eq %u %u %u", RegLvalue, RegRvalue, Label));
  810.   return branch_reg_reg(Interpreter::BRANCH_EQ_REG_REG,
  811. RegLvalue, RegRvalue, Label);
  812. }
  814. int
  815. NdbOperation::branch_ne(Uint32 RegLvalue, Uint32 RegRvalue, Uint32 Label)
  816. {
  817.   INT_DEBUG(("branch_ne %u %u %u", RegLvalue, RegRvalue, Label));
  818.   return branch_reg_reg(Interpreter::BRANCH_NE_REG_REG,
  819. RegLvalue, RegRvalue, Label);
  820. }
  822. int
  823. NdbOperation::branch_ne_null(Uint32 RegLvalue, Uint32 Label)
  824. {
  825.   INT_DEBUG(("branch_ne_null %u %u", RegLvalue, Label));
  826.   if (intermediate_interpreterCheck() == -1)
  827.     return -1;
  828.   if (insertATTRINFO((RegLvalue << 6) + Interpreter::BRANCH_REG_NE_NULL) == -1)
  829.     return -1;
  830.   if (insertBranch(Label) == -1)
  831.     return -1;
  832.   theErrorLine++;
  833.   return 0;
  834. }
  836. int
  837. NdbOperation::branch_eq_null(Uint32 RegLvalue, Uint32 Label)
  838. {
  839.   INT_DEBUG(("branch_eq_null %u %u", RegLvalue, Label));
  840.   if (intermediate_interpreterCheck() == -1)
  841.     return -1;
  842.   if (insertATTRINFO((RegLvalue << 6) + Interpreter::BRANCH_REG_EQ_NULL) == -1)
  843.     return -1;
  844.   if (insertBranch(Label) == -1)
  845.     return -1;
  846.   theErrorLine++;
  847.   return 0;
  848. }
  850. int
  851. NdbOperation::branch_label(Uint32 Label)
  852. {
  853.   INT_DEBUG(("branch_label %u", Label));
  854.   if (initial_interpreterCheck() == -1)
  855.     return -1;
  856.   if (insertATTRINFO(Interpreter::BRANCH) == -1)
  857.     return -1;
  858.   if (insertBranch(Label) == -1)
  859.     return -1;
  860.   theErrorLine++;
  861.   return 0;
  862. }
  864. /************************************************************************************************
  865. int NdbOperation::interpret_exit_ok()
  867. ************************************************************************************************/
  868. int
  869. NdbOperation::interpret_exit_ok()
  870. {
  871.   INT_DEBUG(("interpret_exit_ok"));
  872.   if (initial_interpreterCheck() == -1)
  873.     return -1;
  874.   if (insertATTRINFO(Interpreter::EXIT_OK) == -1)
  875.     return -1;
  876.   theErrorLine++;
  877.   return 0;
  878. }
  880. int
  881. NdbOperation::interpret_exit_last_row()
  882. {
  883.   INT_DEBUG(("interpret_exit_last_row"));
  884.   if (initial_interpreterCheck() == -1)
  885.     return -1;
  886.   if (insertATTRINFO(Interpreter::EXIT_OK_LAST) == -1)
  887.     return -1;
  888.   theErrorLine++;
  889.   return 0;
  890. }
  892. /************************************************************************************************
  893. int NdbOperation::interpret_exit_nok(Uint32 ErrorCode)
  895. ************************************************************************************************/
  896. int
  897. NdbOperation::interpret_exit_nok(Uint32 ErrorCode)
  898. {
  899.   INT_DEBUG(("interpret_exit_nok %u", ErrorCode));
  900.   if (initial_interpreterCheck() == -1)
  901.     return -1;
  902.   if (insertATTRINFO( (ErrorCode << 16) + Interpreter::EXIT_REFUSE) == -1)
  903.     return -1;
  904.   theErrorLine++;
  905.   return 0;
  906. }
  908. int
  909. NdbOperation::interpret_exit_nok()
  910. {
  911.   INT_DEBUG(("interpret_exit_nok"));
  912.   Uint32 ErrorCode = 899;
  914.   if (initial_interpreterCheck() == -1)
  915.     return -1;
  916.   if (insertATTRINFO( (ErrorCode << 16) + Interpreter::EXIT_REFUSE) == -1)
  917.     return -1;
  918.   theErrorLine++;
  919.   return 0;
  920. }
  922. int
  923. NdbOperation::call_sub(Uint32 Subroutine)
  924. {
  925.   INT_DEBUG(("call_sub %u", Subroutine));
  926.   if (initial_interpreterCheck() == -1)
  927.     return -1;
  928.   if (insertATTRINFO( (Subroutine << 16) + Interpreter::CALL) == -1)
  929.     return -1;
  930.   if (insertCall(Subroutine) == -1)
  931.     return -1;
  932.   theErrorLine++;
  933.   return 0;
  934. }
  936. int
  937. NdbOperation::ret_sub()
  938. {
  939.   INT_DEBUG(("ret_sub"));
  940.   if (theInterpretIndicator != 1)
  941.   {
  942.     setErrorCodeAbort(4200);
  943.     return -1;
  944.   }
  945.   if (theStatus == SubroutineExec)
  946.   {
  947.      ; // Simply continue with interpretation
  948.   } else
  949.   {
  950.     setErrorCodeAbort(4200);
  951.     return -1;
  952.   }
  953.   if (insertATTRINFO(Interpreter::RETURN) == -1)
  954.     return -1;
  955.   theStatus = SubroutineEnd;
  956.   theErrorLine++;
  957.   return 0;
  958. }
  960. int
  961. NdbOperation::insertBranch(Uint32 aLabel)
  962. {
  963.   Uint32 tAddress;
  964.   NdbBranch* tBranch = theNdb->getNdbBranch();
  965.   if (tBranch == NULL)
  966.     goto insertBranch_error1;
  967.   if (theFirstBranch == NULL)
  968.     theFirstBranch = tBranch;
  969.   else
  970.     theLastBranch->theNext = tBranch;
  971.   theLastBranch = tBranch;
  972.   if (theNoOfSubroutines == 0)
  973.     tAddress = theTotalCurrAI_Len - 
  974.        (theInitialReadSize + 5);
  975.   else
  976.     tAddress = theTotalCurrAI_Len - 
  977.       (theInitialReadSize + theInterpretedSize +
  978.        theFinalUpdateSize + theFinalReadSize + 5);
  980.   tBranch->theBranchAddress = tAddress;
  981.   tBranch->theSignal = theCurrentATTRINFO;
  982.   tBranch->theSignalAddress = theAI_LenInCurrAI; // + 1;  theAI_LenInCurrAI has already been updated in
  983.   tBranch->theSubroutine = theNoOfSubroutines;   //       insertATTRINFO which was done before insertBranch!!
  984.   tBranch->theBranchLabel = aLabel;
  985.   return 0;
  987. insertBranch_error1:
  988.   setErrorCodeAbort(4000);
  989.   return -1;
  990. }
  992. int
  993. NdbOperation::insertCall(Uint32 aCall)
  994. {
  995.   NdbCall* tCall = theNdb->getNdbCall();
  996.   if (tCall == NULL)
  997.   {
  998.     setErrorCodeAbort(4000);
  999.     return -1;
  1000.   }
  1001.   if (theFirstCall == NULL)
  1002.     theFirstCall = tCall;
  1003.   else
  1004.     theLastCall->theNext = tCall;
  1005.   theLastCall = tCall;
  1007.   tCall->theSignal = theCurrentATTRINFO;
  1008.   tCall->theSignalAddress = theAI_LenInCurrAI;
  1009.   tCall->theSubroutine = aCall;
  1010.   return 0;
  1011. }
  1013. int
  1014. NdbOperation::branch_col(Uint32 type, 
  1015.  Uint32 ColId, const char * val, Uint32 len, 
  1016.  bool nopad, Uint32 Label){
  1018.   if (initial_interpreterCheck() == -1)
  1019.     return -1;
  1021.   Interpreter::BinaryCondition c = (Interpreter::BinaryCondition)type;
  1023.   const NdbDictionary::Column * col = 
  1024.     m_currentTable->getColumn(ColId);
  1025.   
  1026.   if(col == 0){
  1027.     abort();
  1028.   }
  1030.   Uint32 vc = col->getType() == NdbDictionary::Column::Varchar;
  1031.   Uint32 colLen = col->getLength() + 2 * vc;
  1032.   Uint32 al = (4 - (colLen & 3)) & 0x3;
  1033.   
  1034.   if (insertATTRINFO(Interpreter::BranchCol(c, al, vc, nopad)) == -1)
  1035.     return -1;
  1036.   
  1037.   if (insertBranch(Label) == -1)
  1038.     return -1;
  1039.   
  1040.   if (insertATTRINFO(Interpreter::BranchCol_2(ColId, len)))
  1041.     return -1;
  1042.   
  1043.   Uint32 len2 = Interpreter::mod4(len);
  1044.   if(len2 == len){
  1045.     insertATTRINFOloop((Uint32*)val, len2 >> 2);
  1046.   } else {
  1047.     len2 -= 4;
  1048.     insertATTRINFOloop((Uint32*)val, len2 >> 2);
  1049.     Uint32 tmp = 0;
  1050.     for (Uint32 i = 0; i < len-len2; i++) {
  1051.       char* p = (char*)&tmp;
  1052.       p[i] = val[len2+i];
  1053.     }
  1054.     insertATTRINFO(tmp);
  1055.   }
  1056.   
  1057.   theErrorLine++;
  1058.   return 0;
  1059. }
  1061. int 
  1062. NdbOperation::branch_col_eq(Uint32 ColId, const char * val, Uint32 len, 
  1063.     bool nopad, Uint32 Label){
  1064.   INT_DEBUG(("branch_col_eq %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1065.   return branch_col(Interpreter::EQ, ColId, val, len, nopad, Label);
  1066. }
  1068. int
  1069. NdbOperation::branch_col_ne(Uint32 ColId, const char * val, Uint32 len, 
  1070.     bool nopad, Uint32 Label){
  1071.   INT_DEBUG(("branch_col_ne %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1072.   return branch_col(Interpreter::NE, ColId, val, len, nopad, Label);
  1073. }
  1074. int
  1075. NdbOperation::branch_col_lt(Uint32 ColId, const char * val, Uint32 len, 
  1076.     bool nopad, Uint32 Label){
  1077.   INT_DEBUG(("branch_col_lt %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1078.   return branch_col(Interpreter::LT, ColId, val, len, nopad, Label);
  1079. }
  1080. int
  1081. NdbOperation::branch_col_le(Uint32 ColId, const char * val, Uint32 len, 
  1082.     bool nopad, Uint32 Label){
  1083.   INT_DEBUG(("branch_col_le %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1084.   return branch_col(Interpreter::LE, ColId, val, len, nopad, Label);
  1085. }
  1086. int
  1087. NdbOperation::branch_col_gt(Uint32 ColId, const char * val, Uint32 len, 
  1088.     bool nopad, Uint32 Label){
  1089.   INT_DEBUG(("branch_col_gt %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1090.   return branch_col(Interpreter::GT, ColId, val, len, nopad, Label);
  1091. }
  1093. int
  1094. NdbOperation::branch_col_ge(Uint32 ColId, const char * val, Uint32 len, 
  1095.     bool nopad, Uint32 Label){
  1096.   INT_DEBUG(("branch_col_ge %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1097.   return branch_col(Interpreter::GE, ColId, val, len, nopad, Label);
  1098. }
  1100. int
  1101. NdbOperation::branch_col_like(Uint32 ColId, const char * val, Uint32 len, 
  1102.       bool nopad, Uint32 Label){
  1103.   INT_DEBUG(("branch_col_like %u %.*s(%u,%d) -> %u", ColId, len, val, len, nopad, Label));
  1104.   return branch_col(Interpreter::LIKE, ColId, val, len, nopad, Label);
  1105. }
  1107. int
  1108. NdbOperation::branch_col_notlike(Uint32 ColId, const char * val, Uint32 len, 
  1109.       bool nopad, Uint32 Label){
  1110.   INT_DEBUG(("branch_col_notlike %u %.*s(%u,%d) -> %u", ColId,len,val,len,nopad,Label));
  1111.   return branch_col(Interpreter::NOT_LIKE, ColId, val, len, nopad, Label);
  1112. }
  1114. int
  1115. NdbOperation::branch_col_null(Uint32 type, Uint32 ColId, Uint32 Label){
  1116.   
  1117.   if (initial_interpreterCheck() == -1)
  1118.     return -1;
  1119.   
  1120.   if (insertATTRINFO(type) == -1)
  1121.     return -1;
  1122.   
  1123.   if (insertBranch(Label) == -1)
  1124.     return -1;
  1125.   
  1126.   if (insertATTRINFO(Interpreter::BranchCol_2(ColId)))
  1127.     return -1;
  1128.   
  1129.   theErrorLine++;
  1130.   return 0;
  1131. }
  1133. int
  1134. NdbOperation::branch_col_eq_null(Uint32 ColId, Uint32 Label){
  1135.   
  1136.   INT_DEBUG(("branch_col_eq_null %u -> %u", ColId, Label));
  1137.   return branch_col_null(Interpreter::BRANCH_ATTR_EQ_NULL, ColId, Label);
  1138. }
  1140. int
  1141. NdbOperation::branch_col_ne_null(Uint32 ColId, Uint32 Label){
  1142.   
  1143.   INT_DEBUG(("branch_col_ne_null %u -> %u", ColId, Label));
  1144.   return branch_col_null(Interpreter::BRANCH_ATTR_NE_NULL, ColId, Label);
  1145. }