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

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

MySQL数据库

开发平台：

Visual C++

DbUtil.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 */
  17. #include <ndb_global.h>
  19. #include "DbUtil.hpp"
  21. #include <ndb_version.h>
  23. #include <signaldata/WaitGCP.hpp>
  24. #include <signaldata/KeyInfo.hpp>
  25. #include <signaldata/AttrInfo.hpp>
  26. #include <signaldata/TcKeyConf.hpp>
  27. #include <signaldata/TcKeyFailConf.hpp>
  28. #include <signaldata/GetTabInfo.hpp>
  29. #include <signaldata/DictTabInfo.hpp>
  31. #include <signaldata/UtilSequence.hpp>
  32. #include <signaldata/UtilPrepare.hpp>
  33. #include <signaldata/UtilRelease.hpp>
  34. #include <signaldata/UtilExecute.hpp>
  35. #include <signaldata/UtilLock.hpp>
  37. #include <SectionReader.hpp>
  38. #include <Interpreter.hpp>
  39. #include <AttributeHeader.hpp>
  41. #include <NdbTick.h>
  44. /**************************************************************************
  45.  * ------------------------------------------------------------------------
  46.  *  MODULE:       Startup
  47.  * ------------------------------------------------------------------------
  48.  * 
  49.  *  Constructors, startup, initializations
  50.  **************************************************************************/
  52. DbUtil::DbUtil(const Configuration & conf) :
  53.   SimulatedBlock(DBUTIL, conf),
  54.   c_runningPrepares(c_preparePool),
  55.   c_runningPreparedOperations(c_preparedOperationPool),
  56.   c_seizingTransactions(c_transactionPool),
  57.   c_runningTransactions(c_transactionPool),
  58.   c_lockQueues(c_lockQueuePool)
  59. {
  60.   BLOCK_CONSTRUCTOR(DbUtil);
  61.   
  62.   // Add received signals
  63.   addRecSignal(GSN_STTOR, &DbUtil::execSTTOR);
  64.   addRecSignal(GSN_NDB_STTOR, &DbUtil::execNDB_STTOR);
  65.   addRecSignal(GSN_DUMP_STATE_ORD, &DbUtil::execDUMP_STATE_ORD);
  66.   addRecSignal(GSN_CONTINUEB, &DbUtil::execCONTINUEB);
  67.   
  68.   //addRecSignal(GSN_TCSEIZEREF, &DbUtil::execTCSEIZEREF);
  69.   addRecSignal(GSN_TCSEIZECONF, &DbUtil::execTCSEIZECONF);
  70.   addRecSignal(GSN_TCKEYCONF, &DbUtil::execTCKEYCONF);
  71.   addRecSignal(GSN_TCKEYREF, &DbUtil::execTCKEYREF);
  72.   addRecSignal(GSN_TCROLLBACKREP, &DbUtil::execTCROLLBACKREP);
  74.   //addRecSignal(GSN_TCKEY_FAILCONF, &DbUtil::execTCKEY_FAILCONF);
  75.   //addRecSignal(GSN_TCKEY_FAILREF, &DbUtil::execTCKEY_FAILREF);
  76.   addRecSignal(GSN_TRANSID_AI, &DbUtil::execTRANSID_AI);
  78.   /**
  79.    *  Sequence Service
  80.    */
  81.   addRecSignal(GSN_UTIL_SEQUENCE_REQ, &DbUtil::execUTIL_SEQUENCE_REQ);
  82.   // Debug
  83.   addRecSignal(GSN_UTIL_SEQUENCE_REF, &DbUtil::execUTIL_SEQUENCE_REF);
  84.   addRecSignal(GSN_UTIL_SEQUENCE_CONF, &DbUtil::execUTIL_SEQUENCE_CONF);
  86.   /**
  87.    * Locking
  88.    */
  89.   addRecSignal(GSN_UTIL_CREATE_LOCK_REQ,  &DbUtil::execUTIL_CREATE_LOCK_REQ);
  90.   addRecSignal(GSN_UTIL_DESTROY_LOCK_REQ, &DbUtil::execUTIL_DESTORY_LOCK_REQ);
  91.   addRecSignal(GSN_UTIL_LOCK_REQ,  &DbUtil::execUTIL_LOCK_REQ);
  92.   addRecSignal(GSN_UTIL_UNLOCK_REQ, &DbUtil::execUTIL_UNLOCK_REQ);
  94.   /**
  95.    *  Backend towards Dict
  96.    */
  97.   addRecSignal(GSN_GET_TABINFOREF, &DbUtil::execGET_TABINFOREF);
  98.   addRecSignal(GSN_GET_TABINFO_CONF, &DbUtil::execGET_TABINFO_CONF);
  100.   /**
  101.    *  Prepare / Execute / Release Services
  102.    */
  103.   addRecSignal(GSN_UTIL_PREPARE_REQ,  &DbUtil::execUTIL_PREPARE_REQ);
  104.   addRecSignal(GSN_UTIL_PREPARE_CONF, &DbUtil::execUTIL_PREPARE_CONF);
  105.   addRecSignal(GSN_UTIL_PREPARE_REF,  &DbUtil::execUTIL_PREPARE_REF);
  107.   addRecSignal(GSN_UTIL_EXECUTE_REQ,  &DbUtil::execUTIL_EXECUTE_REQ);
  108.   addRecSignal(GSN_UTIL_EXECUTE_CONF, &DbUtil::execUTIL_EXECUTE_CONF);
  109.   addRecSignal(GSN_UTIL_EXECUTE_REF,  &DbUtil::execUTIL_EXECUTE_REF);
  111.   addRecSignal(GSN_UTIL_RELEASE_REQ,  &DbUtil::execUTIL_RELEASE_REQ);
  112.   addRecSignal(GSN_UTIL_RELEASE_CONF, &DbUtil::execUTIL_RELEASE_CONF);
  113.   addRecSignal(GSN_UTIL_RELEASE_REF,  &DbUtil::execUTIL_RELEASE_REF);
  115.   c_pagePool.setSize(10);
  116.   c_preparePool.setSize(1);            // one parallel prepare at a time
  117.   c_preparedOperationPool.setSize(5);  // three hardcoded, two for test
  118.   c_operationPool.setSize(64);         // 64 parallel operations
  119.   c_transactionPool.setSize(32);       // 16 parallel transactions
  120.   c_attrMappingPool.setSize(100);
  121.   c_dataBufPool.setSize(6000);        // 6000*11*4 = 264K > 8k+8k*16 = 256k
  122.   {
  123.     SLList<Prepare> tmp(c_preparePool);
  124.     PreparePtr ptr;
  125.     while(tmp.seize(ptr))
  126.       new (ptr.p) Prepare(c_pagePool);
  127.     tmp.release();
  128.   }
  129.   {
  130.     SLList<Operation> tmp(c_operationPool);
  131.     OperationPtr ptr;
  132.     while(tmp.seize(ptr))
  133.       new (ptr.p) Operation(c_dataBufPool, c_dataBufPool, c_dataBufPool);
  134.     tmp.release();
  135.   }
  136.   {
  137.     SLList<PreparedOperation> tmp(c_preparedOperationPool);
  138.     PreparedOperationPtr ptr;
  139.     while(tmp.seize(ptr))
  140.       new (ptr.p) PreparedOperation(c_attrMappingPool, 
  141.     c_dataBufPool, c_dataBufPool);
  142.     tmp.release();
  143.   }
  144.   {
  145.     SLList<Transaction> tmp(c_transactionPool);
  146.     TransactionPtr ptr;
  147.     while(tmp.seize(ptr))
  148.       new (ptr.p) Transaction(c_pagePool, c_operationPool);
  149.     tmp.release();
  150.   }
  152.   c_lockQueuePool.setSize(5);
  153.   c_lockElementPool.setSize(5);
  154.   c_lockQueues.setSize(8);
  155. }
  157. DbUtil::~DbUtil()
  158. {
  159. }
  161. BLOCK_FUNCTIONS(DbUtil)
  163. void 
  164. DbUtil::releasePrepare(PreparePtr prepPtr) {
  165.   prepPtr.p->preparePages.release();
  166.   c_runningPrepares.release(prepPtr);  // Automatic release in pool
  167. }
  169. void 
  170. DbUtil::releasePreparedOperation(PreparedOperationPtr prepOpPtr) {
  171.   prepOpPtr.p->attrMapping.release();
  172.   prepOpPtr.p->attrInfo.release();
  173.   prepOpPtr.p->rsInfo.release();
  174.   prepOpPtr.p->pkBitmask.clear();
  175.   c_preparedOperationPool.release(prepOpPtr);  // No list holding these structs
  176. }
  178. void
  179. DbUtil::releaseTransaction(TransactionPtr transPtr){
  180.   transPtr.p->executePages.release();
  181.   OperationPtr opPtr;
  182.   for(transPtr.p->operations.first(opPtr); opPtr.i != RNIL; 
  183.       transPtr.p->operations.next(opPtr)){
  184.     opPtr.p->attrInfo.release();
  185.     opPtr.p->keyInfo.release();
  186.     opPtr.p->rs.release();
  187.     if (opPtr.p->prepOp != 0 && opPtr.p->prepOp_i != RNIL) {
  188.       if (opPtr.p->prepOp->releaseFlag) {
  189. PreparedOperationPtr prepOpPtr;
  190. prepOpPtr.i = opPtr.p->prepOp_i;
  191. prepOpPtr.p = opPtr.p->prepOp;
  192. releasePreparedOperation(prepOpPtr);
  193.       }
  194.     }
  195.   }
  196.   transPtr.p->operations.release();
  197.   c_runningTransactions.release(transPtr);
  198. }
  200. void
  201. DbUtil::execSTTOR(Signal* signal) 
  202. {
  203.   jamEntry();                            
  205.   const Uint32 startphase = signal->theData[1];
  206.   
  207.   if(startphase == 1){
  208.     c_transId[0] = (number() << 20) + (getOwnNodeId() << 8);
  209.     c_transId[1] = 0;
  210.   }
  211.   
  212.   if(startphase == 6){
  213.     hardcodedPrepare();
  214.     connectTc(signal);
  215.   }
  216.   
  217.   signal->theData[0] = 0;
  218.   signal->theData[3] = 1;
  219.   signal->theData[4] = 6;
  220.   signal->theData[5] = 255;
  221.   sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 6, JBB);
  223.   return;
  224. }
  226. void
  227. DbUtil::execNDB_STTOR(Signal* signal) 
  228. {
  229.   (void)signal;  // Don't want compiler warning
  231.   jamEntry();                            
  232. }
  235. /***************************
  236.  *  Seize a number of TC records 
  237.  *  to use for Util transactions
  238.  */
  240. void
  241. DbUtil::connectTc(Signal* signal){
  242.   
  243.   TransactionPtr ptr;
  244.   while(c_seizingTransactions.seize(ptr)){
  245.     signal->theData[0] = ptr.i << 1; // See TcCommitConf
  246.     signal->theData[1] = reference();
  247.     sendSignal(DBTC_REF, GSN_TCSEIZEREQ, signal, 2, JBB);
  248.   }  
  249. }
  251. void
  252. DbUtil::execTCSEIZECONF(Signal* signal){
  253.   jamEntry();
  254.   
  255.   TransactionPtr ptr;
  256.   ptr.i = signal->theData[0] >> 1;
  257.   c_seizingTransactions.getPtr(ptr, signal->theData[0] >> 1);
  258.   ptr.p->connectPtr = signal->theData[1];
  259.   
  260.   c_seizingTransactions.release(ptr);
  261. }
  264. /**************************************************************************
  265.  * ------------------------------------------------------------------------
  266.  *  MODULE:       Misc
  267.  * ------------------------------------------------------------------------
  268.  *
  269.  *  ContinueB, Dump
  270.  **************************************************************************/
  272. void
  273. DbUtil::execCONTINUEB(Signal* signal){
  274.   jamEntry();
  275.   const Uint32 Tdata0 = signal->theData[0];
  276.   
  277.   switch(Tdata0){
  278.   default:
  279.     ndbrequire(0);
  280.   }
  281. }
  283. void
  284. DbUtil::execDUMP_STATE_ORD(Signal* signal){
  285.   jamEntry();
  287.   /****************************************************************************
  288.    *  SEQUENCE SERVICE
  289.    * 
  290.    *  200 : Simple test of Public Sequence Interface
  291.    *  ----------------------------------------------
  292.    *  - Sends a SEQUENCE_REQ signal to Util (itself)
  293.    */
  294.   const Uint32 tCase = signal->theData[0];
  295.   if(tCase == 200){
  296.     jam()
  297.     ndbout << "--------------------------------------------------" << endl;
  298.     UtilSequenceReq * req = (UtilSequenceReq*)signal->getDataPtrSend();
  299.     Uint32 seqId = 1;
  300.     Uint32 reqTy = UtilSequenceReq::CurrVal;
  302.     if(signal->length() > 1) seqId = signal->theData[1];
  303.     if(signal->length() > 2) reqTy = signal->theData[2];
  304.     
  305.     req->senderData = 12;
  306.     req->sequenceId = seqId;
  307.     req->requestType = reqTy;
  309.     sendSignal(DBUTIL_REF, GSN_UTIL_SEQUENCE_REQ, 
  310.        signal, UtilSequenceReq::SignalLength, JBB);
  311.   }
  313.   /****************************************************************************/
  314.   /* // Obsolete tests, should be rewritten for long signals!!
  315.   if(tCase == 210){
  316.     jam();
  317.     ndbout << "--------------------------------------------------" << endl;
  318.     const Uint32 pageSizeInWords = 128;
  319.     Uint32 propPage[pageSizeInWords];
  320.     LinearWriter w(&propPage[0], 128);
  321.     w.first();
  322.     w.add(UtilPrepareReq::NoOfOperations, 1);
  323.     w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Delete);
  324.     w.add(UtilPrepareReq::TableName,      "sys/def/SYSTAB_0");
  325.     w.add(UtilPrepareReq::AttributeName,  "SYSKEY_0"); // AttrNo = 0
  326.     Uint32 length = w.getWordsUsed();
  327.     ndbassert(length <= pageSizeInWords);
  329.     sendUtilPrepareReqSignals(signal, propPage, length);
  330.   }
  331.   if(tCase == 211){
  332.     jam();
  333.     ndbout << "--------------------------------------------------" << endl;
  334.     const Uint32 pageSizeInWords = 128;
  335.     Uint32 propPage[pageSizeInWords];
  336.     LinearWriter w(&propPage[0],128);
  337.     w.first();
  338.     w.add(UtilPrepareReq::NoOfOperations, 1);
  339.     w.add(UtilPrepareReq::OperationType,  UtilPrepareReq::Insert);
  340.     w.add(UtilPrepareReq::TableName,      "sys/def/SYSTAB_0");
  341.     w.add(UtilPrepareReq::AttributeName,  "SYSKEY_0");  // AttrNo = 0
  342.     w.add(UtilPrepareReq::AttributeName,  "NEXTID");    // AttrNo = 1
  343.     Uint32 length = w.getWordsUsed();
  344.     ndbassert(length <= pageSizeInWords);
  346.     sendUtilPrepareReqSignals(signal, propPage, length);
  347.   }
  348.   if(tCase == 212){
  349.     jam();
  350.     ndbout << "--------------------------------------------------" << endl;
  351.     const Uint32 pageSizeInWords = 128;
  352.     Uint32 propPage[pageSizeInWords];
  353.     LinearWriter w(&propPage[0],128);
  354.     w.first();
  355.     w.add(UtilPrepareReq::NoOfOperations, 1);
  356.     w.add(UtilPrepareReq::OperationType,  UtilPrepareReq::Update);
  357.     w.add(UtilPrepareReq::TableName,      "sys/def/SYSTAB_0");
  358.     w.add(UtilPrepareReq::AttributeName,  "SYSKEY_0");  // AttrNo = 0
  359.     w.add(UtilPrepareReq::AttributeName,  "NEXTID");    // AttrNo = 1
  360.     Uint32 length = w.getWordsUsed();
  361.     ndbassert(length <= pageSizeInWords);
  363.     sendUtilPrepareReqSignals(signal, propPage, length);
  364.   }
  365.   if(tCase == 213){
  366.     jam();
  367.     ndbout << "--------------------------------------------------" << endl;
  368.     const Uint32 pageSizeInWords = 128;
  369.     Uint32 propPage[pageSizeInWords];
  370.     LinearWriter w(&propPage[0],128);
  371.     w.first();
  372.     w.add(UtilPrepareReq::NoOfOperations, 1);
  373.     w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Read);
  374.     w.add(UtilPrepareReq::TableName,      "sys/def/SYSTAB_0");
  375.     w.add(UtilPrepareReq::AttributeName,  "SYSKEY_0"); // AttrNo = 0
  376.     Uint32 length = w.getWordsUsed();
  377.     ndbassert(length <= pageSizeInWords);
  379.     sendUtilPrepareReqSignals(signal, propPage, length);
  380.   }
  381.   if(tCase == 214){
  382.     jam();
  383.     ndbout << "--------------------------------------------------" << endl;
  384.     const Uint32 pageSizeInWords = 128;
  385.     Uint32 propPage[pageSizeInWords];
  386.     LinearWriter w(&propPage[0], 128);
  387.     w.first();
  388.     w.add(UtilPrepareReq::NoOfOperations, 1);
  389.     w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Delete);
  390.     w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0
  391.     w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0
  392.     Uint32 length = w.getWordsUsed();
  393.     ndbassert(length <= pageSizeInWords);
  395.     sendUtilPrepareReqSignals(signal, propPage, length);
  396.   }
  397.   if(tCase == 215){
  398.     jam();
  399.     ndbout << "--------------------------------------------------" << endl;
  400.     const Uint32 pageSizeInWords = 128;
  401.     Uint32 propPage[pageSizeInWords];
  402.     LinearWriter w(&propPage[0],128);
  403.     w.first();
  404.     w.add(UtilPrepareReq::NoOfOperations, 1);
  405.     w.add(UtilPrepareReq::OperationType,  UtilPrepareReq::Insert);
  406.     w.add(UtilPrepareReq::TableId, (unsigned int)0);  // SYSTAB_0
  407.     w.add(UtilPrepareReq::AttributeId, (unsigned int)0); // SYSKEY_0
  408.     w.add(UtilPrepareReq::AttributeId, 1);  // NEXTID
  409.     Uint32 length = w.getWordsUsed();
  410.     ndbassert(length <= pageSizeInWords);
  412.     sendUtilPrepareReqSignals(signal, propPage, length);
  413.   }
  414.   if(tCase == 216){
  415.     jam();
  416.     ndbout << "--------------------------------------------------" << endl;
  417.     const Uint32 pageSizeInWords = 128;
  418.     Uint32 propPage[pageSizeInWords];
  419.     LinearWriter w(&propPage[0],128);
  420.     w.first();
  421.     w.add(UtilPrepareReq::NoOfOperations, 1);
  422.     w.add(UtilPrepareReq::OperationType,  UtilPrepareReq::Update);
  423.     w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0
  424.     w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0
  425.     w.add(UtilPrepareReq::AttributeId, 1); // NEXTID
  426.     Uint32 length = w.getWordsUsed();
  427.     ndbassert(length <= pageSizeInWords);
  429.     sendUtilPrepareReqSignals(signal, propPage, length);
  430.   }
  431.   if(tCase == 217){
  432.     jam();
  433.     ndbout << "--------------------------------------------------" << endl;
  434.     const Uint32 pageSizeInWords = 128;
  435.     Uint32 propPage[pageSizeInWords];
  436.     LinearWriter w(&propPage[0],128);
  437.     w.first();
  438.     w.add(UtilPrepareReq::NoOfOperations, 1);
  439.     w.add(UtilPrepareReq::OperationType, UtilPrepareReq::Read);
  440.     w.add(UtilPrepareReq::TableId, (unsigned int)0); // SYSTAB_0
  441.     w.add(UtilPrepareReq::AttributeId, (unsigned int)0);// SYSKEY_0
  442.     Uint32 length = w.getWordsUsed();
  443.     ndbassert(length <= pageSizeInWords);
  445.     sendUtilPrepareReqSignals(signal, propPage, length);
  446.   }
  447.   */
  448.   /****************************************************************************/
  449.   /* // Obsolete tests, should be rewritten for long signals!!
  450.   if(tCase == 220){
  451.     jam();
  452.     ndbout << "--------------------------------------------------" << endl;    
  453.     Uint32 prepI = signal->theData[1];
  454.     Uint32 length = signal->theData[2];
  455.     Uint32 attributeValue0 = signal->theData[3];
  456.     Uint32 attributeValue1a = signal->theData[4];
  457.     Uint32 attributeValue1b = signal->theData[5];
  458.     ndbrequire(prepI != 0);
  460.     UtilExecuteReq * req = (UtilExecuteReq *)signal->getDataPtrSend();
  462.     req->senderData   = 221;
  463.     req->prepareId    = prepI;
  464.     req->totalDataLen = length;  // Including headers
  465.     req->offset       = 0;
  467.     AttributeHeader::init(&req->attrData[0], 0, 1);  // AttrNo 0, DataSize
  468.     req->attrData[1] = attributeValue0;              // AttrValue 
  469.     AttributeHeader::init(&req->attrData[2], 1, 2);  // AttrNo 1, DataSize
  470.     req->attrData[3] = attributeValue1a;             // AttrValue 
  471.     req->attrData[4] = attributeValue1b;             // AttrValue 
  473.     printUTIL_EXECUTE_REQ(stdout, signal->getDataPtrSend(), 3 + 5,0);
  474.     sendSignal(DBUTIL_REF, GSN_UTIL_EXECUTE_REQ, signal, 3 + 5, JBB);
  475.   }
  476. */
  477.   /****************************************************************************
  478.    *  230 : PRINT STATE
  479.    */
  480. #ifdef ARRAY_GUARD
  481.   if(tCase == 230){
  482.     jam();
  484.     ndbout << "--------------------------------------------------" << endl;
  485.     if (signal->length() <= 1) {
  486.       ndbout << "Usage: DUMP 230 <recordType> <recordNo>" << endl 
  487.      << "[1] Print Prepare (running) records" << endl
  488.      << "[2] Print PreparedOperation records" << endl
  489.      << "[3] Print Transaction records" << endl
  490.      << "[4] Print Operation records" << endl
  491.      << "Ex. "dump 230 1 2" prints Prepare record no 2." << endl
  492.      << endl
  493.      << "210 : PREPARE_REQ DELETE SYSTAB_0 SYSKEY_0" << endl
  494.      << "211 : PREPARE_REQ INSERT SYSTAB_0 SYSKEY_0 NEXTID" << endl
  495.      << "212 : PREPARE_REQ UPDATE SYSTAB_0 SYSKEY_0 NEXTID" << endl
  496.      << "213 : PREPARE_REQ READ   SYSTAB_0 SYSKEY_0" << endl
  497.      << "214 : PREPARE_REQ DELETE SYSTAB_0 SYSKEY_0 using id" << endl
  498.      << "215 : PREPARE_REQ INSERT SYSTAB_0 SYSKEY_0 NEXTID using id" << endl
  499.      << "216 : PREPARE_REQ UPDATE SYSTAB_0 SYSKEY_0 NEXTID using id" << endl
  500.      << "217 : PREPARE_REQ READ   SYSTAB_0 SYSKEY_0 using id" << endl
  501.      << "220 : EXECUTE_REQ <PrepId> <Len> <Val1> <Val2a> <Val2b>" <<endl
  502.      << "299 : Crash system (using ndbrequire(0))" 
  503.      << endl
  504.      << "Ex. "dump 220 3 5 1 0 17 " prints Prepare record no 2." 
  505.      << endl;
  506.       return;
  507.     }
  509.     switch (signal->theData[1]) {
  510.     case 1:
  511.       // ** Print a specific record **
  512.       if (signal->length() >= 3) {
  513. PreparePtr prepPtr;
  514. if (!c_preparePool.isSeized(signal->theData[2])) {
  515.   ndbout << "Prepare Id: " << signal->theData[2] 
  516.  << " (Not seized!)" << endl;
  517. } else {
  518.   c_preparePool.getPtr(prepPtr, signal->theData[2]);
  519.   prepPtr.p->print();
  520. }
  521. return;
  522.       }
  524.       // ** Print all records **
  525.       PreparePtr prepPtr;
  526.       if (!c_runningPrepares.first(prepPtr)) {
  527. ndbout << "No Prepare records exist" << endl;
  528. return;
  529.       }
  530.       
  531.       while (!prepPtr.isNull()) {
  532. prepPtr.p->print();
  533. c_runningPrepares.next(prepPtr);
  534.       }
  535.       return;
  537.     case 2:
  538.       // ** Print a specific record **
  539.       if (signal->length() >= 3) {
  540. if (!c_preparedOperationPool.isSeized(signal->theData[2])) {
  541.   ndbout << "PreparedOperation Id: " << signal->theData[2] 
  542.  << " (Not seized!)" << endl;
  543.   return;
  544. }
  545. ndbout << "PreparedOperation Id: " << signal->theData[2] << endl;
  546. PreparedOperationPtr prepOpPtr;
  547. c_runningPreparedOperations.getPtr(prepOpPtr, signal->theData[2]);
  548. prepOpPtr.p->print();
  549. return;
  550.       }
  552.       // ** Print all records **
  553.       PreparedOperationPtr prepOpPtr;
  554.       if (!c_runningPreparedOperations.first(prepOpPtr)) {
  555. ndbout << "No PreparedOperations exist" << endl;
  556. return;
  557.       }
  558.       while (!prepOpPtr.isNull()) {
  559. ndbout << "[-PreparedOperation no " << prepOpPtr.i << ":"; 
  560. prepOpPtr.p->print();
  561. ndbout << "]";
  562. c_runningPreparedOperations.next(prepOpPtr);
  563.       }
  564.       return;
  566.     case 3:
  567.       // ** Print a specific record **
  568.       if (signal->length() >= 3) {
  569. ndbout << "Print specific record not implemented." << endl;
  570. return;
  571.       }
  573.       // ** Print all records **
  574.       ndbout << "Print all records not implemented, specify an Id." << endl;
  575.       return;
  577.     case 4:
  578.       ndbout << "Not implemented" << endl;
  579.       return;
  581.     default:
  582.       ndbout << "Unknown input (try without any data)" << endl;
  583.       return;
  584.     }      
  585.   }
  586. #endif
  587.   if(tCase == 240 && signal->getLength() == 2){
  588.     MutexManager::ActiveMutexPtr ptr;
  589.     ndbrequire(c_mutexMgr.seize(ptr));
  590.     ptr.p->m_mutexId = signal->theData[1];
  591.     Callback c = { safe_cast(&DbUtil::mutex_created), ptr.i };
  592.     ptr.p->m_callback = c;
  593.     c_mutexMgr.create(signal, ptr);
  594.     ndbout_c("c_mutexMgr.create ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId);
  595.   }
  597.   if(tCase == 241 && signal->getLength() == 2){
  598.     MutexManager::ActiveMutexPtr ptr;
  599.     ndbrequire(c_mutexMgr.seize(ptr));
  600.     ptr.p->m_mutexId = signal->theData[1];
  601.     Callback c = { safe_cast(&DbUtil::mutex_locked), ptr.i };
  602.     ptr.p->m_callback = c;
  603.     c_mutexMgr.lock(signal, ptr);
  604.     ndbout_c("c_mutexMgr.lock ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId);
  605.   }
  607.   if(tCase == 242 && signal->getLength() == 2){
  608.     MutexManager::ActiveMutexPtr ptr;
  609.     ptr.i = signal->theData[1];
  610.     c_mutexMgr.getPtr(ptr);
  611.     Callback c = { safe_cast(&DbUtil::mutex_unlocked), ptr.i };
  612.     ptr.p->m_callback = c;
  613.     c_mutexMgr.unlock(signal, ptr);
  614.     ndbout_c("c_mutexMgr.unlock ptrI=%d mutexId=%d", ptr.i, ptr.p->m_mutexId);
  615.   }
  616.   
  617.   if(tCase == 243 && signal->getLength() == 3){
  618.     MutexManager::ActiveMutexPtr ptr;
  619.     ndbrequire(c_mutexMgr.seize(ptr));
  620.     ptr.p->m_mutexId = signal->theData[1];
  621.     ptr.p->m_mutexKey = signal->theData[2];
  622.     Callback c = { safe_cast(&DbUtil::mutex_destroyed), ptr.i };
  623.     ptr.p->m_callback = c;
  624.     c_mutexMgr.destroy(signal, ptr);
  625.     ndbout_c("c_mutexMgr.destroy ptrI=%d mutexId=%d key=%d", 
  626.      ptr.i, ptr.p->m_mutexId, ptr.p->m_mutexKey);
  627.   }
  628. }
  630. void
  631. DbUtil::mutex_created(Signal* signal, Uint32 ptrI, Uint32 retVal){
  632.   MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI;
  633.   c_mutexMgr.getPtr(ptr);
  634.   ndbout_c("mutex_created - mutexId=%d, retVal=%d", 
  635.    ptr.p->m_mutexId, retVal);
  636.   c_mutexMgr.release(ptrI);
  637. }
  639. void
  640. DbUtil::mutex_destroyed(Signal* signal, Uint32 ptrI, Uint32 retVal){
  641.   MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI;
  642.   c_mutexMgr.getPtr(ptr);
  643.   ndbout_c("mutex_destroyed - mutexId=%d, retVal=%d", 
  644.    ptr.p->m_mutexId, retVal); 
  645.   c_mutexMgr.release(ptrI);
  646. }
  648. void
  649. DbUtil::mutex_locked(Signal* signal, Uint32 ptrI, Uint32 retVal){
  650.   MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI;
  651.   c_mutexMgr.getPtr(ptr);
  652.   ndbout_c("mutex_locked - mutexId=%d, retVal=%d key=%d ptrI=%d", 
  653.    ptr.p->m_mutexId, retVal, ptr.p->m_mutexKey, ptrI);
  654.   if(retVal)
  655.     c_mutexMgr.release(ptrI);
  656. }
  658. void
  659. DbUtil::mutex_unlocked(Signal* signal, Uint32 ptrI, Uint32 retVal){
  660.   MutexManager::ActiveMutexPtr ptr; ptr.i = ptrI;
  661.   c_mutexMgr.getPtr(ptr);
  662.   ndbout_c("mutex_unlocked - mutexId=%d, retVal=%d", 
  663.    ptr.p->m_mutexId, retVal); 
  664.   if(!retVal)
  665.     c_mutexMgr.release(ptrI);
  666. }
  667.    
  668. void
  669. DbUtil::execUTIL_SEQUENCE_REF(Signal* signal){
  670.   jamEntry();
  671.   ndbout << "UTIL_SEQUENCE_REF" << endl;
  672.   printUTIL_SEQUENCE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0);
  673. }
  675. void
  676. DbUtil::execUTIL_SEQUENCE_CONF(Signal* signal){
  677.   jamEntry();
  678.   ndbout << "UTIL_SEQUENCE_CONF" << endl;
  679.   printUTIL_SEQUENCE_CONF(stdout, signal->getDataPtrSend(), signal->length(),0);
  680. }
  682. void
  683. DbUtil::execUTIL_PREPARE_CONF(Signal* signal){
  684.   jamEntry();
  685.   ndbout << "UTIL_PREPARE_CONF" << endl;
  686.   printUTIL_PREPARE_CONF(stdout, signal->getDataPtrSend(), signal->length(), 0);
  687. }
  689. void
  690. DbUtil::execUTIL_PREPARE_REF(Signal* signal){
  691.   jamEntry();
  692.   ndbout << "UTIL_PREPARE_REF" << endl;
  693.   printUTIL_PREPARE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0);
  694. }
  696. void 
  697. DbUtil::execUTIL_EXECUTE_CONF(Signal* signal) {
  698.   jamEntry();
  699.   ndbout << "UTIL_EXECUTE_CONF" << endl;
  700.   printUTIL_EXECUTE_CONF(stdout, signal->getDataPtrSend(), signal->length(), 0);
  701. }
  703. void 
  704. DbUtil::execUTIL_EXECUTE_REF(Signal* signal) {
  705.   jamEntry();
  707.   ndbout << "UTIL_EXECUTE_REF" << endl;
  708.   printUTIL_EXECUTE_REF(stdout, signal->getDataPtrSend(), signal->length(), 0);
  709. }
  711. void 
  712. DbUtil::execUTIL_RELEASE_CONF(Signal* signal) {
  713.   jamEntry();
  714.   ndbout << "UTIL_RELEASE_CONF" << endl;
  715. }
  717. void 
  718. DbUtil::execUTIL_RELEASE_REF(Signal* signal) {
  719.   jamEntry();
  721.   ndbout << "UTIL_RELEASE_REF" << endl;
  722. }
  724. void
  725. DbUtil::sendUtilPrepareRef(Signal* signal, UtilPrepareRef::ErrorCode error, 
  726.    Uint32 recipient, Uint32 senderData){
  727.   UtilPrepareRef * ref = (UtilPrepareRef *)signal->getDataPtrSend();
  728.   ref->errorCode = error;
  729.   ref->senderData = senderData;
  731.   sendSignal(recipient, GSN_UTIL_PREPARE_REF, signal, 
  732.      UtilPrepareRef::SignalLength, JBB);
  733. }
  735. void
  736. DbUtil::sendUtilExecuteRef(Signal* signal, UtilExecuteRef::ErrorCode error, 
  737.    Uint32 TCerror, Uint32 recipient, Uint32 senderData){
  738.   
  739.   UtilExecuteRef * ref = (UtilExecuteRef *)signal->getDataPtrSend();
  740.   ref->senderData  = senderData;
  741.   ref->errorCode   = error;
  742.   ref->TCErrorCode = TCerror;
  744.   sendSignal(recipient, GSN_UTIL_EXECUTE_REF, signal, 
  745.      UtilPrepareRef::SignalLength, JBB);
  746. }
  749. /**************************************************************************
  750.  * ------------------------------------------------------------------------
  751.  *  MODULE:       Prepare service
  752.  * ------------------------------------------------------------------------
  753.  *
  754.  *  Prepares a transaction by storing info in some structs
  755.  **************************************************************************/
  757. void 
  758. DbUtil::execUTIL_PREPARE_REQ(Signal* signal)
  759. {
  760.   jamEntry();  
  761.   
  762.   /****************
  763.    * Decode Signal
  764.    ****************/
  765.   UtilPrepareReq * req = (UtilPrepareReq *)signal->getDataPtr();
  766.   const Uint32 senderRef    = req->senderRef;
  767.   const Uint32 senderData   = req->senderData;
  769.   if(signal->getNoOfSections() == 0) {
  770.     // Missing prepare data
  771.     jam();
  772.     releaseSections(signal);
  773.     sendUtilPrepareRef(signal, UtilPrepareRef::MISSING_PROPERTIES_SECTION,
  774.        senderRef, senderData);
  775.     return;
  776.   }
  778.   PreparePtr prepPtr;
  779.   SegmentedSectionPtr ptr;
  780.   
  781.   jam();
  782.   if(!c_runningPrepares.seize(prepPtr)) {
  783.     jam();
  784.     releaseSections(signal);
  785.     sendUtilPrepareRef(signal, UtilPrepareRef::PREPARE_SEIZE_ERROR,
  786.        senderRef, senderData);
  787.     return;
  788.   };
  789.   signal->getSection(ptr, UtilPrepareReq::PROPERTIES_SECTION);
  790.   const Uint32 noPages  = (ptr.sz + sizeof(Page32)) / sizeof(Page32);
  791.   ndbassert(noPages > 0);
  792.   if (!prepPtr.p->preparePages.seize(noPages)) {
  793.     jam();
  794.     releaseSections(signal);
  795.     sendUtilPrepareRef(signal, UtilPrepareRef::PREPARE_PAGES_SEIZE_ERROR,
  796.        senderRef, senderData);
  797.     c_preparePool.release(prepPtr);
  798.     return;
  799.   }
  800.   // Save SimpleProperties
  801.   Uint32* target = &prepPtr.p->preparePages.getPtr(0)->data[0];
  802.   copy(target, ptr);
  803.   prepPtr.p->prepDataLen = ptr.sz;
  804.   // Release long signal sections
  805.   releaseSections(signal);
  806.   // Check table properties with DICT
  807.   SimplePropertiesSectionReader reader(ptr, getSectionSegmentPool());
  808.   prepPtr.p->clientRef = senderRef;
  809.   prepPtr.p->clientData = senderData;
  810.   // Release long signal sections
  811.   releaseSections(signal);
  812.   readPrepareProps(signal, &reader, prepPtr.i);
  813. }
  815. void DbUtil::readPrepareProps(Signal* signal,
  816.       SimpleProperties::Reader* reader, 
  817.       Uint32 senderData)
  818. {
  819.   jam();
  820. #if 0
  821.   printf("DbUtil::readPrepareProps: Received SimpleProperties:n");
  822.   reader->printAll(ndbout);
  823. #endif
  824.   ndbrequire(reader->first());
  825.   ndbrequire(reader->getKey() == UtilPrepareReq::NoOfOperations);
  826.   ndbrequire(reader->getUint32() == 1);      // Only one op/trans implemented
  827.   
  828.   ndbrequire(reader->next());
  829.   ndbrequire(reader->getKey() == UtilPrepareReq::OperationType);
  830.   
  831.   ndbrequire(reader->next());
  832.   UtilPrepareReq::KeyValue tableKey = 
  833.     (UtilPrepareReq::KeyValue) reader->getKey();
  834.   ndbrequire((tableKey == UtilPrepareReq::TableName) ||
  835.      (tableKey == UtilPrepareReq::TableId));
  837.   /************************
  838.    * Ask Dict for metadata
  839.    ************************/
  840.   {
  841.     GetTabInfoReq * req = (GetTabInfoReq *)signal->getDataPtrSend();
  842.     req->senderRef = reference();
  843.     req->senderData = senderData;           
  844.     if (tableKey == UtilPrepareReq::TableName) {
  845.       jam();
  846.       char tableName[MAX_TAB_NAME_SIZE];
  847.       req->requestType = GetTabInfoReq::RequestByName |
  848. GetTabInfoReq::LongSignalConf;
  850.       req->tableNameLen = reader->getValueLen();    // Including trailing 
  851.       
  852.       /********************************************
  853.        * Code signal data and send signals to DICT
  854.        ********************************************/
  856.       ndbrequire(req->tableNameLen < MAX_TAB_NAME_SIZE); 
  857.       reader->getString((char*)tableName);
  858.       LinearSectionPtr ptr[1];
  859.       ptr[0].p = (Uint32*)tableName; 
  860.       ptr[0].sz = req->tableNameLen; 
  861.       sendSignal(DBDICT_REF, GSN_GET_TABINFOREQ, signal, 
  862.  GetTabInfoReq::SignalLength, JBB, ptr,1);
  864.     }
  865.     else { // (tableKey == UtilPrepareReq::TableId)
  866.       jam();
  867.       req->requestType = GetTabInfoReq::RequestById |
  868. GetTabInfoReq::LongSignalConf;
  869.       req->tableId = reader->getUint32();
  870.       sendSignal(DBDICT_REF, GSN_GET_TABINFOREQ, signal, 
  871.  GetTabInfoReq::SignalLength, JBB);
  872.     }
  874.   }
  875. }
  877. /**
  878.  *  @note  We assume that this signal comes due to a request related
  879.  *         to a Prepare struct.  DictTabInfo:s 'senderData' denotes
  880.  *         the Prepare struct related to the request.
  881.  */
  882. void
  883. DbUtil::execGET_TABINFO_CONF(Signal* signal){
  884.   jamEntry();
  886.   if(!assembleFragments(signal)){
  887.     jam();
  888.     return;
  889.   }
  891.   /****************
  892.    * Decode signal 
  893.    ****************/
  894.   GetTabInfoConf * const conf = (GetTabInfoConf*)signal->getDataPtr();
  895.   const Uint32  prepI    = conf->senderData;
  896.   const Uint32  totalLen = conf->totalLen;
  897.   
  898.   SegmentedSectionPtr dictTabInfoPtr;
  899.   signal->getSection(dictTabInfoPtr, GetTabInfoConf::DICT_TAB_INFO);
  900.   ndbrequire(dictTabInfoPtr.sz == totalLen);
  901.   
  902.   PreparePtr prepPtr;
  903.   c_runningPrepares.getPtr(prepPtr, prepI);
  904.   prepareOperation(signal, prepPtr);
  905. }
  907. void
  908. DbUtil::execGET_TABINFOREF(Signal* signal){
  909.   jamEntry();
  911.   GetTabInfoRef * ref = (GetTabInfoRef *)signal->getDataPtr();
  912.   Uint32 prepI = ref->senderData;
  913. #define EVENT_DEBUG
  914. #if 0 //def EVENT_DEBUG
  915.   ndbout << "Signal GET_TABINFOREF received." << endl;
  916.   ndbout << "Error Code: " << ref->errorCode << endl;
  918.   switch (ref->errorCode) {
  919.   case GetTabInfoRef::InvalidTableId:
  920.     ndbout << "      Msg:  Invalid table id" << endl;
  921.     break;
  922.   case GetTabInfoRef::TableNotDefined:
  923.     ndbout << "      Msg:  Table not defined" << endl;
  924.     break;
  925.   case GetTabInfoRef::TableNameToLong:
  926.     ndbout << "      Msg:  Table node too long" << endl;
  927.     break;
  928.   default:
  929.     ndbout << "      Msg:  Unknown error returned from Dict" << endl;
  930.     break;
  931.   }  
  932. #endif
  934.   PreparePtr prepPtr;
  935.   c_runningPrepares.getPtr(prepPtr, prepI);
  937.   sendUtilPrepareRef(signal, UtilPrepareRef::DICT_TAB_INFO_ERROR,
  938.      prepPtr.p->clientRef, prepPtr.p->clientData);
  940.   releasePrepare(prepPtr);
  941. }
  944. /******************************************************************************
  945.  * Prepare Operation
  946.  * 
  947.  * Using a prepare record, prepare an operation (i.e. create PreparedOperation).
  948.  * Info from both Pepare request (PreparePages) and DictTabInfo is used.
  949.  * 
  950.  * Algorithm:
  951.  * -# Seize AttrbuteMapping
  952.  *    - Lookup in preparePages how many attributes should be prepared
  953.  *    - Seize AttributeMapping
  954.  * -# For each attributes in preparePages 
  955.  *    - Lookup id and isPK in dictInfoPages
  956.  *    - Store "no -> (AttributeId, Position)" in AttributeMapping
  957.  * -# For each map in AttributeMapping
  958.  *    - if (isPK) then assign offset
  959.  ******************************************************************************/
  960. void
  961. DbUtil::prepareOperation(Signal* signal, PreparePtr prepPtr) 
  962. {
  963.   jam();
  964.   
  965.   /*******************************************
  966.    * Seize and store PreparedOperation struct
  967.    *******************************************/
  968.   PreparedOperationPtr prepOpPtr;  
  969.   if(!c_runningPreparedOperations.seize(prepOpPtr)) {
  970.     jam();
  971.     releaseSections(signal);
  972.     sendUtilPrepareRef(signal, UtilPrepareRef::PREPARED_OPERATION_SEIZE_ERROR,
  973.        prepPtr.p->clientRef, prepPtr.p->clientData);
  974.     releasePrepare(prepPtr);
  975.     return;
  976.   }
  977.   prepPtr.p->prepOpPtr = prepOpPtr;
  979.   /********************
  980.    * Read request info
  981.    ********************/
  982.   SimplePropertiesLinearReader prepPagesReader(&prepPtr.p->preparePages.getPtr(0)->data[0], 
  983.        prepPtr.p->prepDataLen);
  984.   
  985.   ndbrequire(prepPagesReader.first());
  986.   ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::NoOfOperations);
  987.   const Uint32 noOfOperations = prepPagesReader.getUint32();
  988.   ndbrequire(noOfOperations == 1);
  990.   ndbrequire(prepPagesReader.next());
  991.   ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::OperationType);
  992.   const Uint32 operationType = prepPagesReader.getUint32();
  993.   
  994.   ndbrequire(prepPagesReader.next());
  995.   
  996.   char tableName[MAX_TAB_NAME_SIZE];
  997.   Uint32 tableId;
  998.   UtilPrepareReq::KeyValue tableKey = 
  999.     (UtilPrepareReq::KeyValue) prepPagesReader.getKey();
  1000.   if (tableKey == UtilPrepareReq::TableId) {
  1001.     jam();
  1002.     tableId = prepPagesReader.getUint32();
  1003.   }
  1004.   else {
  1005.     jam();
  1006.     ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::TableName);
  1007.     ndbrequire(prepPagesReader.getValueLen() <= MAX_TAB_NAME_SIZE);
  1008.     prepPagesReader.getString(tableName);
  1009.   }
  1010.   /******************************************************************
  1011.    * Seize AttributeMapping (by counting no of attribs in prepPages)
  1012.    ******************************************************************/
  1013.   Uint32 noOfAttributes = 0;   // No of attributes in PreparePages (used later)
  1014.   while(prepPagesReader.next()) {
  1015.     if (tableKey == UtilPrepareReq::TableName) {
  1016.       jam();
  1017.       ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::AttributeName);
  1018.     } else {
  1019.       jam();
  1020.       ndbrequire(prepPagesReader.getKey() == UtilPrepareReq::AttributeId);
  1021.     }
  1022.     noOfAttributes++;
  1023.   }
  1024.   ndbrequire(prepPtr.p->prepOpPtr.p->attrMapping.seize(noOfAttributes));
  1025.   if (operationType == UtilPrepareReq::Read) {
  1026.     ndbrequire(prepPtr.p->prepOpPtr.p->rsInfo.seize(noOfAttributes));
  1027.   }
  1028.   /***************************************
  1029.    * For each attribute name, lookup info 
  1030.    ***************************************/
  1031.   // Goto start of attribute names 
  1032.   ndbrequire(prepPagesReader.first() && prepPagesReader.next() && 
  1033.      prepPagesReader.next());
  1034.   
  1035.   DictTabInfo::Table tableDesc; tableDesc.init();
  1036.   AttrMappingBuffer::DataBufferIterator attrMappingIt;
  1037.   ndbrequire(prepPtr.p->prepOpPtr.p->attrMapping.first(attrMappingIt));
  1039.   ResultSetBuffer::DataBufferIterator rsInfoIt;
  1040.   if (operationType == UtilPrepareReq::Read) {
  1041.     ndbrequire(prepPtr.p->prepOpPtr.p->rsInfo.first(rsInfoIt));
  1042.   }
  1044.   Uint32 noOfPKAttribsStored = 0;
  1045.   Uint32 noOfNonPKAttribsStored = 0;
  1046.   Uint32 attrLength = 0;
  1047.   Uint32 pkAttrLength = 0;
  1048.   char attrNameRequested[MAX_ATTR_NAME_SIZE];
  1049.   Uint32 attrIdRequested;
  1051.   while(prepPagesReader.next()) {
  1052.     UtilPrepareReq::KeyValue attributeKey = 
  1053.       (UtilPrepareReq::KeyValue) prepPagesReader.getKey();    
  1054.     
  1055.     ndbrequire((attributeKey == UtilPrepareReq::AttributeName) ||
  1056.        (attributeKey == UtilPrepareReq::AttributeId));
  1057.     if (attributeKey == UtilPrepareReq::AttributeName) {
  1058.       jam();
  1059.       ndbrequire(prepPagesReader.getValueLen() <= MAX_ATTR_NAME_SIZE);
  1060.       
  1061.       prepPagesReader.getString(attrNameRequested);
  1062.       attrIdRequested= ~0u;
  1063.     } else {
  1064.       jam();
  1065.       attrIdRequested = prepPagesReader.getUint32();
  1066.     }
  1067.     /*****************************************
  1068.      * Copy DictTabInfo into tableDesc struct
  1069.      *****************************************/
  1070.       
  1071.     SegmentedSectionPtr ptr;
  1072.     signal->getSection(ptr, GetTabInfoConf::DICT_TAB_INFO);
  1073.     SimplePropertiesSectionReader dictInfoReader(ptr, getSectionSegmentPool());
  1075.     SimpleProperties::UnpackStatus unpackStatus;
  1076.     unpackStatus = SimpleProperties::unpack(dictInfoReader, &tableDesc, 
  1077.     DictTabInfo::TableMapping, 
  1078.     DictTabInfo::TableMappingSize, 
  1079.     true, true);
  1080.     ndbrequire(unpackStatus == SimpleProperties::Break);
  1081.     
  1082.     /************************
  1083.      * Lookup in DictTabInfo
  1084.      ************************/
  1085.     DictTabInfo::Attribute attrDesc; attrDesc.init();
  1086.     char attrName[MAX_ATTR_NAME_SIZE];
  1087.     Uint32 attrId= ~(Uint32)0;
  1088.     bool attributeFound = false;
  1089.     Uint32 noOfKeysFound = 0;     // # PK attrs found before attr in DICTdata
  1090.     Uint32 noOfNonKeysFound = 0;  // # nonPK attrs found before attr in DICTdata
  1091.     for (Uint32 i=0; i<tableDesc.NoOfAttributes; i++) {
  1092.       if (tableKey == UtilPrepareReq::TableName) {
  1093. jam();
  1094. ndbrequire(dictInfoReader.getKey() == DictTabInfo::AttributeName);
  1095. ndbrequire(dictInfoReader.getValueLen() <= MAX_ATTR_NAME_SIZE);
  1096. dictInfoReader.getString(attrName);
  1097. attrId= ~(Uint32)0; // attrId not used
  1098.       } else { // (tableKey == UtilPrepareReq::TableId)
  1099. jam();
  1100. dictInfoReader.next(); // Skip name
  1101. ndbrequire(dictInfoReader.getKey() == DictTabInfo::AttributeId);
  1102. attrId = dictInfoReader.getUint32();
  1103. attrName[0]= ''; // attrName not used
  1104.       }
  1105.       unpackStatus = SimpleProperties::unpack(dictInfoReader, &attrDesc, 
  1106.       DictTabInfo::AttributeMapping, 
  1107.       DictTabInfo::AttributeMappingSize,
  1108.       true, true);
  1109.       ndbrequire(unpackStatus == SimpleProperties::Break);
  1110.       //attrDesc.print(stdout);
  1111.       
  1112.       if (attrDesc.AttributeKeyFlag) { jam(); noOfKeysFound++; } 
  1113.       else                           { jam(); noOfNonKeysFound++; }
  1114.       if (attributeKey == UtilPrepareReq::AttributeName) {
  1115. if (strcmp(attrName, attrNameRequested) == 0) {
  1116.   attributeFound = true;
  1117.   break;  
  1118. }
  1119.       }
  1120.       else // (attributeKey == UtilPrepareReq::AttributeId)
  1121. if (attrId == attrIdRequested) {
  1122.   attributeFound = true;
  1123.   break;  
  1124. }
  1125.       
  1126.       // Move to next attribute
  1127.       ndbassert(dictInfoReader.getKey() == DictTabInfo::AttributeEnd);
  1128.       dictInfoReader.next();
  1129.     }
  1130.     
  1131.     /**********************
  1132.      * Attribute not found
  1133.      **********************/
  1134.     if (!attributeFound) {
  1135.       jam(); 
  1136.       releaseSections(signal);
  1137.       sendUtilPrepareRef(signal, 
  1138.  UtilPrepareRef::DICT_TAB_INFO_ERROR,
  1139.  prepPtr.p->clientRef, prepPtr.p->clientData);
  1140.       infoEvent("UTIL: Unknown attribute requested: %s in table: %s",
  1141. attrNameRequested, tableName);
  1142.       releasePreparedOperation(prepOpPtr);
  1143.       releasePrepare(prepPtr);
  1144.       return;
  1145.     }
  1146.     
  1147.     /**************************************************************
  1148.      * Attribute found - store in mapping  (AttributeId, Position)
  1149.      **************************************************************/
  1150.     AttributeHeader & attrMap = 
  1151.       AttributeHeader::init(attrMappingIt.data, 
  1152.     attrDesc.AttributeId,    // 1. Store AttrId
  1153.     0);
  1154.     
  1155.     if (attrDesc.AttributeKeyFlag) {
  1156.       // ** Attribute belongs to PK **
  1157.       prepOpPtr.p->pkBitmask.set(attrDesc.AttributeId);
  1158.       attrMap.setDataSize(noOfKeysFound - 1);        // 2. Store Position
  1159.       noOfPKAttribsStored++;
  1160.     } else {
  1161.       attrMap.setDataSize(0x3fff);                   // 2. Store Position (fake)
  1162.       noOfNonPKAttribsStored++;
  1164.       /***********************************************************
  1165.        * Error: Read nonPK Attr before all PK attr have been read
  1166.        ***********************************************************/
  1167.       if (noOfPKAttribsStored != tableDesc.NoOfKeyAttr) {
  1168. jam(); 
  1169. releaseSections(signal);
  1170. sendUtilPrepareRef(signal, 
  1171.    UtilPrepareRef::DICT_TAB_INFO_ERROR,
  1172.    prepPtr.p->clientRef, prepPtr.p->clientData);
  1173. infoEvent("UTIL: Non-PK attr not allowed before "
  1174.   "all PK attrs have been defined, table: %s",
  1175.   tableName);
  1176. releasePreparedOperation(prepOpPtr);
  1177. releasePrepare(prepPtr);
  1178. return;
  1179.       }
  1180.     }
  1181. #if 0
  1182.     ndbout << "BEFORE: attrLength: " << attrLength << endl;
  1183. #endif
  1184.     {
  1185.       int len = 0;
  1186.       switch (attrDesc.AttributeSize) {
  1187.       case DictTabInfo::an8Bit:
  1188. len = (attrDesc.AttributeArraySize + 3)/ 4;
  1189. break;
  1190.       case DictTabInfo::a16Bit:
  1191. len = (attrDesc.AttributeArraySize + 1) / 2;
  1192. break;
  1193.       case DictTabInfo::a32Bit:
  1194. len = attrDesc.AttributeArraySize;
  1195. break;
  1196.       case DictTabInfo::a64Bit:
  1197. len = attrDesc.AttributeArraySize * 2;
  1198.       break;
  1199.       case DictTabInfo::a128Bit:
  1200. len = attrDesc.AttributeArraySize * 4;
  1201. break;
  1202.       }
  1203.       attrLength += len;
  1204.       if (attrDesc.AttributeKeyFlag)
  1205. pkAttrLength += len;
  1207.       if (operationType == UtilPrepareReq::Read) {
  1208. AttributeHeader::init(rsInfoIt.data, 
  1209.       attrDesc.AttributeId,    // 1. Store AttrId
  1210.       len);
  1211. prepOpPtr.p->rsInfo.next(rsInfoIt, 1);
  1212.       }
  1213.     }
  1214. #if 0
  1215.     ndbout << ": AttributeSize: " << attrDesc.AttributeSize << endl;
  1216.     ndbout << ": AttributeArraySize: " << attrDesc.AttributeArraySize << endl;
  1217.     ndbout << "AFTER: attrLength: " << attrLength << endl;
  1218. #endif    
  1219.     //attrMappingIt.print(stdout);
  1220.     //prepPtr.p->prepOpPtr.p->attrMapping.print(stdout);
  1221.     prepPtr.p->prepOpPtr.p->attrMapping.next(attrMappingIt, 1);
  1222.   }   
  1224.   /***************************
  1225.    * Error: Not all PKs found 
  1226.    ***************************/
  1227.   if (noOfPKAttribsStored != tableDesc.NoOfKeyAttr) {
  1228.     jam(); 
  1229.     releaseSections(signal);
  1230.     sendUtilPrepareRef(signal, 
  1231.        UtilPrepareRef::DICT_TAB_INFO_ERROR,
  1232.        prepPtr.p->clientRef, prepPtr.p->clientData);
  1233.     infoEvent("UTIL: Not all primary key attributes requested for table: %s",
  1234.       tableName);
  1235.     releasePreparedOperation(prepOpPtr);
  1236.     releasePrepare(prepPtr);
  1237.     return;
  1238.   }
  1240. #if 0
  1241.   AttrMappingBuffer::ConstDataBufferIterator tmpIt;
  1242.   for (prepPtr.p->prepOpPtr.p->attrMapping.first(tmpIt); tmpIt.curr.i != RNIL;
  1243.        prepPtr.p->prepOpPtr.p->attrMapping.next(tmpIt)) {
  1244.     AttributeHeader* ah = (AttributeHeader *) tmpIt.data;
  1245.     ah->print(stdout);
  1246.   }
  1247. #endif
  1248.   
  1249.   /**********************************************
  1250.    * Preparing of PreparedOperation signal train 
  1251.    **********************************************/
  1252.   Uint32 static_len = TcKeyReq::StaticLength;
  1253.   prepOpPtr.p->tckey.tableId = tableDesc.TableId;
  1254.   prepOpPtr.p->tckey.tableSchemaVersion = tableDesc.TableVersion;
  1255.   prepOpPtr.p->noOfKeyAttr = tableDesc.NoOfKeyAttr;
  1256.   prepOpPtr.p->keyLen = tableDesc.KeyLength; // Total no of words in PK
  1257.   if (prepOpPtr.p->keyLen > TcKeyReq::MaxKeyInfo) {
  1258.     jam();
  1259.     prepOpPtr.p->tckeyLenInBytes = (static_len + TcKeyReq::MaxKeyInfo) * 4;
  1260.   } else {
  1261.     jam();
  1262.     prepOpPtr.p->tckeyLenInBytes = (static_len + prepOpPtr.p->keyLen) * 4;
  1263.   }
  1264.   prepOpPtr.p->keyDataPos = static_len;  // Start of keyInfo[] in tckeyreq
  1265.   
  1266.   Uint32 requestInfo = 0;
  1267.   TcKeyReq::setAbortOption(requestInfo, TcKeyReq::AbortOnError);
  1268.   TcKeyReq::setKeyLength(requestInfo, tableDesc.KeyLength);  
  1269.   switch(operationType) {
  1270.   case(UtilPrepareReq::Read):
  1271.     prepOpPtr.p->rsLen =
  1272.       attrLength + 
  1273.       tableDesc.NoOfKeyAttr +
  1274.       noOfNonPKAttribsStored;          // Read needs a resultset
  1275.     prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored;
  1276.     prepOpPtr.p->tckey.attrLen = prepOpPtr.p->noOfAttr;
  1277.     TcKeyReq::setOperationType(requestInfo, ZREAD);
  1278.     break;
  1279.   case(UtilPrepareReq::Update):
  1280.     prepOpPtr.p->rsLen = 0; 
  1281.     prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored;
  1282.     prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr;
  1283.     TcKeyReq::setOperationType(requestInfo, ZUPDATE);
  1284.     break;
  1285.   case(UtilPrepareReq::Insert):
  1286.     prepOpPtr.p->rsLen = 0; 
  1287.     prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored;
  1288.     prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr;
  1289.     TcKeyReq::setOperationType(requestInfo, ZINSERT);
  1290.     break;
  1291.   case(UtilPrepareReq::Delete):
  1292.     // The number of attributes should equal the size of the primary key
  1293.     ndbrequire(tableDesc.KeyLength == attrLength);
  1294.     prepOpPtr.p->rsLen = 0; 
  1295.     prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr;
  1296.     prepOpPtr.p->tckey.attrLen = 0;
  1297.     TcKeyReq::setOperationType(requestInfo, ZDELETE);
  1298.     break;
  1299.   case(UtilPrepareReq::Write):
  1300.     prepOpPtr.p->rsLen = 0; 
  1301.     prepOpPtr.p->noOfAttr = tableDesc.NoOfKeyAttr + noOfNonPKAttribsStored;
  1302.     prepOpPtr.p->tckey.attrLen = attrLength + prepOpPtr.p->noOfAttr;
  1303.     TcKeyReq::setOperationType(requestInfo, ZWRITE);
  1304.     break;
  1305.   }
  1306.   TcKeyReq::setAIInTcKeyReq(requestInfo, 0);  // Attrinfo sent separately
  1307.   prepOpPtr.p->tckey.requestInfo = requestInfo;
  1309.   /****************************
  1310.    * Confirm completed prepare
  1311.    ****************************/
  1312.   UtilPrepareConf * conf = (UtilPrepareConf *)signal->getDataPtr();
  1313.   conf->senderData = prepPtr.p->clientData;
  1314.   conf->prepareId = prepPtr.p->prepOpPtr.i;
  1316.   releaseSections(signal);
  1317.   sendSignal(prepPtr.p->clientRef, GSN_UTIL_PREPARE_CONF, signal, 
  1318.      UtilPrepareConf::SignalLength, JBB);
  1320. #if 0
  1321.   prepPtr.p->prepOpPtr.p->print();
  1322. #endif
  1323.   releasePrepare(prepPtr);
  1324. }
  1327. void 
  1328. DbUtil::execUTIL_RELEASE_REQ(Signal* signal){
  1329.   jamEntry();  
  1330.   
  1331.   UtilReleaseReq * req = (UtilReleaseReq *)signal->getDataPtr();
  1332.   const Uint32 clientRef      = signal->senderBlockRef();
  1333.   const Uint32 prepareId      = req->prepareId;
  1334.   const Uint32 senderData     = req->senderData;
  1336. #if 0
  1337.   /**
  1338.    * This only works in when ARRAY_GUARD is defined (debug-mode)
  1339.    */
  1340.   if (!c_preparedOperationPool.isSeized(prepareId)) {
  1341.     UtilReleaseRef * ref = (UtilReleaseRef *)signal->getDataPtr();
  1342.     ref->prepareId = prepareId;
  1343.     ref->errorCode = UtilReleaseRef::NO_SUCH_PREPARE_SEIZED;
  1344.     sendSignal(clientRef, GSN_UTIL_RELEASE_REF, signal, 
  1345.        UtilReleaseRef::SignalLength, JBB);
  1346.   }
  1347. #endif
  1348.   PreparedOperationPtr prepOpPtr;
  1349.   c_preparedOperationPool.getPtr(prepOpPtr, prepareId);
  1350.   
  1351.   releasePreparedOperation(prepOpPtr);
  1352.   
  1353.   UtilReleaseConf * const conf = (UtilReleaseConf*)signal->getDataPtrSend();
  1354.   conf->senderData = senderData;
  1355.   sendSignal(clientRef, GSN_UTIL_RELEASE_CONF, signal, 
  1356.      UtilReleaseConf::SignalLength, JBB);
  1357. }
  1360. /**************************************************************************
  1361.  * ------------------------------------------------------------------------
  1362.  *  MODULE:       Sequence Service
  1363.  * ------------------------------------------------------------------------
  1364.  *
  1365.  *  A service with a stored incrementable number
  1366.  **************************************************************************/
  1368. void
  1369. DbUtil::hardcodedPrepare() {
  1370.   /**
  1371.    * Prepare SequenceCurrVal (READ)
  1372.    */
  1373.   {
  1374.     PreparedOperationPtr ptr;
  1375.     ndbrequire(c_preparedOperationPool.seizeId(ptr, 0));
  1376.     ptr.p->keyLen = 1;
  1377.     ptr.p->tckey.attrLen = 1;
  1378.     ptr.p->rsLen = 3;
  1379.     ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength +
  1380.                               ptr.p->keyLen + ptr.p->tckey.attrLen) * 4;
  1381.     ptr.p->keyDataPos = TcKeyReq::StaticLength; 
  1382.     ptr.p->tckey.tableId = 0;
  1383.     Uint32 requestInfo = 0;
  1384.     TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree);
  1385.     TcKeyReq::setOperationType(requestInfo, ZREAD);
  1386.     TcKeyReq::setKeyLength(requestInfo, 1);
  1387.     TcKeyReq::setAIInTcKeyReq(requestInfo, 1);
  1388.     ptr.p->tckey.requestInfo = requestInfo;
  1389.     ptr.p->tckey.tableSchemaVersion = 1;
  1391.     // This is actually attr data
  1392.     AttributeHeader::init(&ptr.p->tckey.distrGroupHashValue, 1, 0); 
  1393.     
  1394.     ndbrequire(ptr.p->rsInfo.seize(1));
  1395.     ResultSetInfoBuffer::DataBufferIterator it; 
  1396.     ptr.p->rsInfo.first(it);
  1397.     AttributeHeader::init(it.data, 1, 2); // Attribute 1 - 2 data words
  1398.   }
  1400.   /**
  1401.    * Prepare SequenceNextVal (UPDATE)
  1402.    */
  1403.   {
  1404.     PreparedOperationPtr ptr;
  1405.     ndbrequire(c_preparedOperationPool.seizeId(ptr, 1));
  1406.     ptr.p->keyLen = 1;
  1407.     ptr.p->rsLen = 3;
  1408.     ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength + ptr.p->keyLen + 5) * 4;
  1409.     ptr.p->keyDataPos = TcKeyReq::StaticLength; 
  1410.     ptr.p->tckey.attrLen = 11;
  1411.     ptr.p->tckey.tableId = 0;
  1412.     Uint32 requestInfo = 0;
  1413.     TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree);
  1414.     TcKeyReq::setOperationType(requestInfo, ZUPDATE);
  1415.     TcKeyReq::setKeyLength(requestInfo, 1);
  1416.     TcKeyReq::setAIInTcKeyReq(requestInfo, 5);
  1417.     TcKeyReq::setInterpretedFlag(requestInfo, 1);
  1418.     ptr.p->tckey.requestInfo = requestInfo;
  1419.     ptr.p->tckey.tableSchemaVersion = 1;
  1420.     
  1421.     // Signal is packed, which is why attrInfo is at distrGroupHashValue 
  1422.     // position 
  1423.     Uint32 * attrInfo = &ptr.p->tckey.distrGroupHashValue;
  1424.     attrInfo[0] = 0; // IntialReadSize
  1425.     attrInfo[1] = 5; // InterpretedSize
  1426.     attrInfo[2] = 0; // FinalUpdateSize
  1427.     attrInfo[3] = 1; // FinalReadSize
  1428.     attrInfo[4] = 0; // SubroutineSize
  1429.     
  1430.     { // AttrInfo
  1431.       ndbrequire(ptr.p->attrInfo.seize(6));
  1432.       AttrInfoBuffer::DataBufferIterator it;
  1433.       ptr.p->attrInfo.first(it);
  1434.       * it.data = Interpreter::Read(1, 6);
  1435.       ndbrequire(ptr.p->attrInfo.next(it));
  1436.       * it.data = Interpreter::LoadConst16(7, 1);
  1437.       ndbrequire(ptr.p->attrInfo.next(it));
  1438.       * it.data = Interpreter::Add(7, 6, 7);
  1439.       ndbrequire(ptr.p->attrInfo.next(it));
  1440.       * it.data = Interpreter::Write(1, 7);
  1441.       ndbrequire(ptr.p->attrInfo.next(it));
  1442.       * it.data = Interpreter::ExitOK();
  1443.       
  1444.       ndbrequire(ptr.p->attrInfo.next(it));
  1445.       AttributeHeader::init(it.data, 1, 0);
  1446.     }
  1447.     
  1448.     { // ResultSet
  1449.       ndbrequire(ptr.p->rsInfo.seize(1));
  1450.       ResultSetInfoBuffer::DataBufferIterator it; 
  1451.       ptr.p->rsInfo.first(it);
  1452.       AttributeHeader::init(it.data, 1, 2); // Attribute 1 - 2 data words
  1453.     }
  1454.   }
  1456.   /**
  1457.    * Prepare CreateSequence (INSERT)
  1458.    */
  1459.   {
  1460.     PreparedOperationPtr ptr;
  1461.     ndbrequire(c_preparedOperationPool.seizeId(ptr, 2));
  1462.     ptr.p->keyLen = 1;
  1463.     ptr.p->tckey.attrLen = 5;
  1464.     ptr.p->rsLen = 0;
  1465.     ptr.p->tckeyLenInBytes = (TcKeyReq::StaticLength +
  1466.                               ptr.p->keyLen + ptr.p->tckey.attrLen) * 4;
  1467.     ptr.p->keyDataPos = TcKeyReq::StaticLength;
  1468.     ptr.p->tckey.tableId = 0;
  1469.     Uint32 requestInfo = 0;
  1470.     TcKeyReq::setAbortOption(requestInfo, TcKeyReq::CommitIfFailFree);
  1471.     TcKeyReq::setOperationType(requestInfo, ZINSERT);
  1472.     TcKeyReq::setKeyLength(requestInfo, 1);
  1473.     TcKeyReq::setAIInTcKeyReq(requestInfo, 0);
  1474.     ptr.p->tckey.requestInfo = requestInfo;
  1475.     ptr.p->tckey.tableSchemaVersion = 1;
  1476.   }
  1477. }
  1479. void
  1480. DbUtil::execUTIL_SEQUENCE_REQ(Signal* signal){
  1481.   jamEntry();
  1483.   UtilSequenceReq * req = (UtilSequenceReq*)signal->getDataPtr();
  1484.   
  1485.   PreparedOperation * prepOp;
  1486.   
  1487.   switch(req->requestType){
  1488.   case UtilSequenceReq::CurrVal:
  1489.     prepOp = c_preparedOperationPool.getPtr(0); //c_SequenceCurrVal
  1490.     break;
  1491.   case UtilSequenceReq::NextVal:
  1492.     prepOp = c_preparedOperationPool.getPtr(1); //c_SequenceNextVal
  1493.     break;
  1494.   case UtilSequenceReq::Create:
  1495.     prepOp = c_preparedOperationPool.getPtr(2); //c_CreateSequence
  1496.     break;
  1497.   default:
  1498.     ndbrequire(false);
  1499.     prepOp = 0; // remove warning
  1500.   }
  1501.   
  1502.   /**
  1503.    * 1 Transaction with 1 operation
  1504.    */
  1505.   TransactionPtr transPtr;
  1506.   ndbrequire(c_runningTransactions.seize(transPtr));
  1507.   
  1508.   OperationPtr opPtr;
  1509.   ndbrequire(transPtr.p->operations.seize(opPtr));
  1510.   
  1511.   ndbrequire(opPtr.p->rs.seize(prepOp->rsLen));
  1512.   ndbrequire(opPtr.p->keyInfo.seize(prepOp->keyLen));
  1514.   transPtr.p->gsn = GSN_UTIL_SEQUENCE_REQ;
  1515.   transPtr.p->clientRef = signal->senderBlockRef();
  1516.   transPtr.p->clientData = req->senderData;
  1517.   transPtr.p->sequence.sequenceId = req->sequenceId;
  1518.   transPtr.p->sequence.requestType = req->requestType;
  1519.   
  1520.   opPtr.p->prepOp   = prepOp;
  1521.   opPtr.p->prepOp_i = RNIL;
  1523.   KeyInfoBuffer::DataBufferIterator it; 
  1524.   opPtr.p->keyInfo.first(it);
  1525.   it.data[0] = transPtr.p->sequence.sequenceId;
  1527.   if(req->requestType == UtilSequenceReq::Create){
  1528.     ndbrequire(opPtr.p->attrInfo.seize(5));
  1529.     AttrInfoBuffer::DataBufferIterator it;   
  1531.     opPtr.p->attrInfo.first(it);
  1532.     AttributeHeader::init(it.data, 0, 1);
  1534.     ndbrequire(opPtr.p->attrInfo.next(it));
  1535.     * it.data = transPtr.p->sequence.sequenceId;
  1537.     ndbrequire(opPtr.p->attrInfo.next(it));
  1538.     AttributeHeader::init(it.data, 1, 2);
  1539.     
  1540.     ndbrequire(opPtr.p->attrInfo.next(it));
  1541.     * it.data = 0;
  1542.     
  1543.     ndbrequire(opPtr.p->attrInfo.next(it));
  1544.     * it.data = 0;
  1545.   }
  1546.   
  1547.   runTransaction(signal, transPtr);
  1548. }
  1550. int
  1551. DbUtil::getResultSet(Signal* signal, const Transaction * transP,
  1552.      struct LinearSectionPtr sectionsPtr[]) {
  1553.   OperationPtr opPtr;
  1554.   ndbrequire(transP->operations.first(opPtr));
  1555.   ndbrequire(transP->operations.hasNext(opPtr) == false);
  1557.   int noAttr = 0;
  1558.   int dataSz = 0;
  1559.   Uint32* tmpBuf = signal->theData + 25;
  1560.   const Uint32* headerBuffer = tmpBuf;
  1562.   const ResultSetBuffer & rs = opPtr.p->rs;
  1563.   ResultSetInfoBuffer::ConstDataBufferIterator it;
  1565.   // extract headers
  1566.   for(rs.first(it); it.curr.i != RNIL; ) {
  1567.     *tmpBuf++ = it.data[0];
  1568.     rs.next(it, ((AttributeHeader*)&it.data[0])->getDataSize() + 1);
  1569.     noAttr++;
  1570.   }
  1572.   if (noAttr == 0)
  1573.     return 0;
  1575.   const Uint32* dataBuffer = tmpBuf;
  1577.   // extract data
  1578.   for(rs.first(it); it.curr.i != RNIL; ) {
  1579.     int sz = ((AttributeHeader*)&it.data[0])->getDataSize();
  1580.     rs.next(it,1);
  1581.     for (int i = 0; i < sz; i++) {
  1582.       *tmpBuf++ = *it.data;
  1583.       rs.next(it,1);
  1584.       dataSz++;
  1585.     }
  1586.   }
  1588.   sectionsPtr[UtilExecuteReq::HEADER_SECTION].p = (Uint32 *)headerBuffer;
  1589.   sectionsPtr[UtilExecuteReq::HEADER_SECTION].sz = noAttr;
  1590.   sectionsPtr[UtilExecuteReq::DATA_SECTION].p = (Uint32 *)dataBuffer;
  1591.   sectionsPtr[UtilExecuteReq::DATA_SECTION].sz = dataSz;
  1593.   return 1;
  1594. }
  1596. void
  1597. DbUtil::reportSequence(Signal* signal, const Transaction * transP){
  1598.   OperationPtr opPtr;
  1599.   ndbrequire(transP->operations.first(opPtr));
  1600.   ndbrequire(transP->operations.hasNext(opPtr) == false);
  1601.   
  1602.   if(transP->errorCode == 0){
  1603.     jam(); // OK
  1605.     UtilSequenceConf * ret = (UtilSequenceConf *)signal->getDataPtrSend();
  1606.     ret->senderData = transP->clientData;
  1607.     ret->sequenceId = transP->sequence.sequenceId;
  1608.     ret->requestType = transP->sequence.requestType;
  1609.     
  1610.     bool ok = false;
  1611.     switch(transP->sequence.requestType){
  1612.     case UtilSequenceReq::CurrVal:
  1613.     case UtilSequenceReq::NextVal:{
  1614.       ok = true;
  1615.       ndbrequire(opPtr.p->rsRecv == 3);
  1616.       
  1617.       ResultSetBuffer::DataBufferIterator rsit;  
  1618.       ndbrequire(opPtr.p->rs.first(rsit));
  1619.       
  1620.       ret->sequenceValue[0] = rsit.data[1];
  1621.       ret->sequenceValue[1] = rsit.data[2];
  1622.       break;
  1623.     }
  1624.     case UtilSequenceReq::Create:
  1625.       ok = true;
  1626.       ret->sequenceValue[0] = 0;
  1627.       ret->sequenceValue[1] = 0;
  1628.       break;
  1629.     }
  1630.     ndbrequire(ok);
  1631.     sendSignal(transP->clientRef, GSN_UTIL_SEQUENCE_CONF, signal, 
  1632.        UtilSequenceConf::SignalLength, JBB);
  1633.     return;
  1634.   }
  1635.   
  1636.   UtilSequenceRef::ErrorCode errCode = UtilSequenceRef::TCError;
  1638.   switch(transP->sequence.requestType)
  1639.     {
  1640.     case UtilSequenceReq::CurrVal:
  1641.     case UtilSequenceReq::NextVal:{
  1642.       if (transP->errorCode == 626)
  1643. errCode = UtilSequenceRef::NoSuchSequence;
  1644.       break;
  1645.     }
  1646.     case UtilSequenceReq::Create:
  1647.       break;
  1648.     }
  1650.   UtilSequenceRef * ret = (UtilSequenceRef *)signal->getDataPtrSend();
  1651.   ret->senderData = transP->clientData;
  1652.   ret->sequenceId = transP->sequence.sequenceId;
  1653.   ret->requestType = transP->sequence.requestType;
  1654.   ret->errorCode = (Uint32)errCode;
  1655.   sendSignal(transP->clientRef, GSN_UTIL_SEQUENCE_REF, signal, 
  1656.      UtilSequenceRef::SignalLength, JBB);
  1657. }
  1658. #if 0
  1659.   Ndb ndb("ndb","def");
  1660.   NdbConnection* tConnection = ndb.startTransaction();
  1661.   NdbOperation* tOperation = tConnection->getNdbOperation("SYSTAB_0");     
  1662.   
  1663.   //#if 0 && API_CODE
  1664.   if( tOperation != NULL ) {
  1665.     tOperation->interpretedUpdateTuple();
  1666.     tOperation->equal((U_Int32)0, keyValue );
  1667.     tNextId_Result = tOperation->getValue((U_Int32)1);
  1668.     tOperation->incValue((U_Int32)1, (U_Int32)8192);
  1669.     
  1670.     if (tConnection->execute( Commit ) != -1 ) {
  1671.       U_Int64 tValue = tNextId_Result->u_64_value();   // Read result value
  1672.       theFirstTransId = tValue;
  1673.       theLastTransId  = tValue + 8191;
  1674.       closeTransaction(tConnection);
  1675.       return startTransactionLocal(aPriority, nodeId);
  1676.     }
  1677.   }
  1678.   /**
  1679.    * IntialReadSize = 0;
  1680.    * InterpretedSize = incValue(1);
  1681.    * FinalUpdateSize = 0;
  1682.    * FinalReadSize = 1; // Read value
  1683.    * SubroutineSize = 0;
  1684.    */
  1685. #endif
  1688. /**************************************************************************
  1689.  * ------------------------------------------------------------------------
  1690.  *  MODULE:       Transaction execution request
  1691.  * ------------------------------------------------------------------------
  1692.  *  
  1693.  *  Handle requests to execute a prepared transaction
  1694.  **************************************************************************/
  1696. void 
  1697. DbUtil::execUTIL_EXECUTE_REQ(Signal* signal) 
  1698. {
  1699.   jamEntry();
  1701.   UtilExecuteReq * req = (UtilExecuteReq *)signal->getDataPtr();
  1702.   const Uint32  clientRef      = req->senderRef;
  1703.   const Uint32  clientData     = req->senderData;
  1704.   const Uint32  prepareId      = req->getPrepareId();
  1705.   const bool    releaseFlag    = req->getReleaseFlag();
  1707.   if(signal->getNoOfSections() == 0) {
  1708.     // Missing prepare data
  1709.     jam();
  1710.     releaseSections(signal);
  1711.     sendUtilExecuteRef(signal, UtilExecuteRef::MissingDataSection, 
  1712.        0, clientRef, clientData);
  1713.     return;
  1714.   }
  1715.   /*******************************
  1716.    * Get PreparedOperation struct
  1717.    *******************************/
  1718.   PreparedOperationPtr prepOpPtr;
  1719.   c_runningPreparedOperations.first(prepOpPtr);
  1720.   while (!prepOpPtr.isNull() && prepOpPtr.i != prepareId) 
  1721.     c_runningPreparedOperations.next(prepOpPtr);
  1722.   
  1723.   if (prepOpPtr.i != prepareId) {
  1724.     jam();
  1725.     releaseSections(signal);
  1726.     sendUtilExecuteRef(signal, UtilExecuteRef::IllegalPrepareId,
  1727.        0, clientRef, clientData);
  1728.     return;
  1729.   }
  1731.   prepOpPtr.p->releaseFlag = releaseFlag;
  1733.   TransactionPtr  transPtr;
  1734.   OperationPtr    opPtr;
  1735.   SegmentedSectionPtr headerPtr, dataPtr;
  1737.   signal->getSection(headerPtr, UtilExecuteReq::HEADER_SECTION);
  1738.   SectionReader headerReader(headerPtr, getSectionSegmentPool());
  1739.   signal->getSection(dataPtr, UtilExecuteReq::DATA_SECTION);
  1740.   SectionReader dataReader(dataPtr, getSectionSegmentPool());
  1742. #if 0 //def EVENT_DEBUG
  1743.   // Debugging
  1744.   printf("DbUtil::execUTIL_EXECUTEL_REQ: Headers (%u): ", headerPtr.sz);
  1745.   Uint32 word;
  1746.   while(headerReader.getWord(&word))
  1747.     printf("H'%.8x ", word);
  1748.   printf("n");
  1749.   printf("DbUtil::execUTIL_EXECUTEL_REQ: Data (%u): ", dataPtr.sz);
  1750.   headerReader.reset();
  1751.   while(dataReader.getWord(&word))
  1752.     printf("H'%.8x ", word);
  1753.   printf("n");
  1754.   dataReader.reset();
  1755. #endif
  1756.   
  1757. //  Uint32 totalDataLen = headerPtr.sz + dataPtr.sz;
  1759.   /************************************************************
  1760.    * Seize Transaction record
  1761.    ************************************************************/
  1762.   ndbrequire(c_runningTransactions.seize(transPtr));
  1763.   transPtr.p->gsn        = GSN_UTIL_EXECUTE_REQ;
  1764.   transPtr.p->clientRef  = clientRef;
  1765.   transPtr.p->clientData = clientData;
  1766.   ndbrequire(transPtr.p->operations.seize(opPtr));
  1767.   opPtr.p->prepOp   = prepOpPtr.p;
  1768.   opPtr.p->prepOp_i = prepOpPtr.i;
  1769.   
  1770. #if 0 //def EVENT_DEBUG
  1771.   printf("opPtr.p->rs.seize( %u )n", prepOpPtr.p->rsLen);
  1772. #endif
  1773.   ndbrequire(opPtr.p->rs.seize(prepOpPtr.p->rsLen));
  1774.   
  1775.  /***********************************************************
  1776.    * Store signal data on linear memory in Transaction record 
  1777.    ***********************************************************/
  1778.   KeyInfoBuffer* keyInfo = &opPtr.p->keyInfo;
  1779.   AttrInfoBuffer* attrInfo = &opPtr.p->attrInfo;
  1780.   AttributeHeader header;
  1781.   Uint32* tempBuf = signal->theData + 25;
  1782.   bool dataComplete = true;
  1784.   while(headerReader.getWord((Uint32 *)&header)) {
  1785.     Uint32* bufStart = tempBuf;
  1786.     header.insertHeader(tempBuf++);
  1787.     for(unsigned int i = 0; i < header.getDataSize(); i++) {
  1788.       if (!dataReader.getWord(tempBuf++)) {
  1789. dataComplete = false;
  1790. break;
  1791.       } 
  1792.     }
  1793.     bool res = true;
  1795. #if 0 //def EVENT_DEBUG
  1796.     if (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo) ==
  1797. TcKeyReq::Read) {
  1798.       if(prepOpPtr.p->pkBitmask.get(header.getAttributeId()))
  1799. printf("PrimaryKeyn");
  1800.     }
  1801.     printf("AttrId %u Hdrsz %d Datasz %u n",
  1802.    header.getAttributeId(),
  1803.    header.getHeaderSize(),
  1804.    header.getDataSize());
  1805. #endif
  1807.     if(prepOpPtr.p->pkBitmask.get(header.getAttributeId()))
  1808.       // A primary key attribute
  1809.       res = keyInfo->append(bufStart + header.getHeaderSize(), 
  1810.     header.getDataSize());
  1812.     switch (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo)) {
  1813.     case ZREAD:
  1814.       res &= attrInfo->append(bufStart, header.getHeaderSize());
  1815.       break;
  1816.     case ZDELETE:
  1817.       // no attrinfo for Delete
  1818.       break;
  1819.     default:
  1820.       res &= attrInfo->append(bufStart,
  1821.       header.getHeaderSize() + header.getDataSize());
  1822.     }
  1824.     if (!res) {
  1825.       // Failed to allocate buffer data
  1826.       jam();
  1827.       releaseSections(signal);
  1828.       sendUtilExecuteRef(signal, UtilExecuteRef::AllocationError, 
  1829.  0, clientRef, clientData);
  1830.       releaseTransaction(transPtr);    
  1831.       return;
  1832.     }
  1833.   }
  1834.   if (!dataComplete) {
  1835.     // Missing data in data section
  1836.     jam();
  1837.     releaseSections(signal);
  1838.     sendUtilExecuteRef(signal, UtilExecuteRef::MissingData, 
  1839.        0, clientRef, clientData);
  1840.     releaseTransaction(transPtr);    
  1841.     return;
  1842.   }
  1844.   const Uint32 l1 = prepOpPtr.p->tckey.attrLen;
  1845.   const Uint32 l2 = 
  1846.     prepOpPtr.p->attrInfo.getSize() + opPtr.p->attrInfo.getSize();
  1848.   if (TcKeyReq::getOperationType(prepOpPtr.p->tckey.requestInfo) != ZREAD){
  1849.     ndbrequire(l1 == l2);
  1850.   } else {
  1851. #if 0
  1852.     ndbout_c("TcKeyReq::Read");
  1853. #endif
  1854.   }
  1856.   releaseSections(signal);
  1857.   transPtr.p->noOfRetries = 3;
  1858.   runTransaction(signal, transPtr);
  1859. }
  1861. /**************************************************************************
  1862.  * ------------------------------------------------------------------------
  1863.  *  MODULE:       General transaction machinery
  1864.  * ------------------------------------------------------------------------
  1865.  *   Executes a prepared transaction
  1866.  **************************************************************************/
  1867. void
  1868. DbUtil::runTransaction(Signal* signal, TransactionPtr transPtr){
  1870.   /* Init transaction */
  1871.   transPtr.p->sent = 0;
  1872.   transPtr.p->recv = 0;
  1873.   transPtr.p->errorCode = 0;
  1874.   getTransId(transPtr.p);
  1875.   
  1876.   OperationPtr opPtr;
  1877.   ndbrequire(transPtr.p->operations.first(opPtr));
  1878.   
  1879.   /* First operation */
  1880.   Uint32 start = 0;
  1881.   TcKeyReq::setStartFlag(start, 1);
  1882.   runOperation(signal, transPtr, opPtr, start);
  1883.   transPtr.p->sent ++;
  1884.   
  1885.   /* Rest of operations */
  1886.   start = 0;
  1887.   while(opPtr.i != RNIL){
  1888.     runOperation(signal, transPtr, opPtr, start);
  1889.     transPtr.p->sent ++;
  1890.   }
  1891.   //transPtr.p->print();
  1892. }
  1894. void
  1895. DbUtil::runOperation(Signal* signal, TransactionPtr & transPtr, 
  1896.      OperationPtr & opPtr, Uint32 start) {
  1897.   Uint32 opI = opPtr.i;
  1898.   Operation * op = opPtr.p;
  1899.   const PreparedOperation * pop = op->prepOp;
  1901.   if(!transPtr.p->operations.next(opPtr)){
  1902.     TcKeyReq::setCommitFlag(start, 1);   // Last operation
  1903.     TcKeyReq::setExecuteFlag(start, 1);
  1904.   }
  1905.   
  1906. #if 0 //def EVENT_DEBUG
  1907.   if (TcKeyReq::getOperationType(pop->tckey.requestInfo) ==
  1908.       TcKeyReq::Read) {
  1909.     printf("TcKeyReq::Read runOperationn");
  1910.   }
  1911. #endif
  1913.   /**
  1914.    * Init operation w.r.t result set
  1915.    */
  1916.   initResultSet(op->rs, pop->rsInfo);
  1917.   op->rs.first(op->rsIterator);
  1918.   op->rsRecv = 0;
  1919. #if 0 //def EVENT_DEBUG
  1920.   printf("pop->rsLen %un", pop->rsLen);
  1921. #endif
  1922.   op->rsExpect = 0;
  1923.   op->transPtrI = transPtr.i;
  1924.   
  1925.   TcKeyReq * tcKey = (TcKeyReq*)signal->getDataPtrSend();
  1926.   //ndbout << "*** 6 ***"<< endl; pop->print();
  1927.   memcpy(tcKey, &pop->tckey, pop->tckeyLenInBytes);
  1928.   //ndbout << "*** 6b ***"<< endl; 
  1929.   //printTCKEYREQ(stdout, signal->getDataPtrSend(), 
  1930.   //              pop->tckeyLenInBytes >> 2, 0);
  1931.   tcKey->apiConnectPtr = transPtr.p->connectPtr;
  1932.   tcKey->senderData = opI;
  1933.   tcKey->transId1 = transPtr.p->transId[0];
  1934.   tcKey->transId2 = transPtr.p->transId[1];
  1935.   tcKey->requestInfo |= start;
  1936.   
  1937. #if 0 //def EVENT_DEBUG
  1938.   // Debugging
  1939.   printf("DbUtil::runOperation: KEYINFOn");
  1940.   op->keyInfo.print(stdout);
  1941.   printf("DbUtil::runOperation: ATTRINFOn");
  1942.   op->attrInfo.print(stdout);
  1943. #endif
  1945.   /**
  1946.    * Key Info
  1947.    */
  1948.   //KeyInfoBuffer::DataBufferIterator kit; 
  1949.   KeyInfoIterator kit;
  1950.   op->keyInfo.first(kit);
  1951.   Uint32 *keyDst = ((Uint32*)tcKey) + pop->keyDataPos;
  1952.   for(Uint32 i = 0; i<8 && kit.curr.i != RNIL; i++, op->keyInfo.next(kit)){
  1953.     keyDst[i] = * kit.data;
  1954.   }
  1955.   //ndbout << "*** 7 ***" << endl;
  1956.   //printTCKEYREQ(stdout, signal->getDataPtrSend(), 
  1957.   // pop->tckeyLenInBytes >> 2, 0);
  1959. #if 0 //def EVENT_DEBUG
  1960.     printf("DbUtil::runOperation: sendSignal(DBTC_REF, GSN_TCKEYREQ, signal, %d , JBB)n",  pop->tckeyLenInBytes >> 2);
  1961.     printTCKEYREQ(stdout, signal->getDataPtr(), pop->tckeyLenInBytes >> 2,0);
  1962. #endif
  1963.   sendSignal(DBTC_REF, GSN_TCKEYREQ, signal, pop->tckeyLenInBytes >> 2, JBB);
  1964.   
  1965.   /**
  1966.    * More the 8 words of key info not implemented
  1967.    */
  1968.   // ndbrequire(kit.curr.i == RNIL); // Yes it is
  1970.   /**
  1971.    * KeyInfo
  1972.    */
  1973.   KeyInfo* keyInfo = (KeyInfo *)signal->getDataPtrSend();
  1974.   keyInfo->connectPtr = transPtr.p->connectPtr;
  1975.   keyInfo->transId[0] = transPtr.p->transId[0];
  1976.   keyInfo->transId[1] = transPtr.p->transId[1];
  1977.   sendKeyInfo(signal, keyInfo, op->keyInfo, kit);
  1979.   /**
  1980.    * AttrInfo
  1981.    */
  1982.   AttrInfo* attrInfo = (AttrInfo *)signal->getDataPtrSend();
  1983.   attrInfo->connectPtr = transPtr.p->connectPtr;
  1984.   attrInfo->transId[0] = transPtr.p->transId[0];
  1985.   attrInfo->transId[1] = transPtr.p->transId[1];
  1987.   AttrInfoIterator ait;
  1988.   pop->attrInfo.first(ait);
  1989.   sendAttrInfo(signal, attrInfo, pop->attrInfo, ait);
  1990.   
  1991.   op->attrInfo.first(ait);
  1992.   sendAttrInfo(signal, attrInfo, op->attrInfo, ait);
  1993. }
  1995. void
  1996. DbUtil::sendKeyInfo(Signal* signal, 
  1997.     KeyInfo* keyInfo,
  1998.     const KeyInfoBuffer & keyBuf,
  1999.     KeyInfoIterator & kit)
  2000. {
  2001.   while(kit.curr.i != RNIL) {
  2002.     Uint32 *keyDst = keyInfo->keyData;
  2003.     Uint32 keyDataLen = 0;
  2004.     for(Uint32 i = 0; i<KeyInfo::DataLength && kit.curr.i != RNIL; 
  2005. i++, keyBuf.next(kit)){
  2006.       keyDst[i] = * kit.data;
  2007.       keyDataLen++;
  2008.     }
  2009. #if 0 //def EVENT_DEBUG
  2010.     printf("DbUtil::sendKeyInfo: sendSignal(DBTC_REF, GSN_KEYINFO, signal, %d , JBB)n", KeyInfo::HeaderLength + keyDataLen);
  2011. #endif
  2012.     sendSignal(DBTC_REF, GSN_KEYINFO, signal, 
  2013.        KeyInfo::HeaderLength + keyDataLen, JBB);
  2014.   }
  2015. }
  2017. void
  2018. DbUtil::sendAttrInfo(Signal* signal, 
  2019.      AttrInfo* attrInfo, 
  2020.      const AttrInfoBuffer & attrBuf,
  2021.      AttrInfoIterator & ait)
  2022. {
  2023.   while(ait.curr.i != RNIL) {
  2024.     Uint32 *attrDst = attrInfo->attrData;
  2025.     Uint32 i = 0;
  2026.     for(i = 0; i<AttrInfo::DataLength && ait.curr.i != RNIL; 
  2027. i++, attrBuf.next(ait)){
  2028.       attrDst[i] = * ait.data;
  2029.     }
  2030. #if 0 //def EVENT_DEBUG
  2031.     printf("DbUtil::sendAttrInfo: sendSignal(DBTC_REF, GSN_ATTRINFO, signal, %d , JBB)n", AttrInfo::HeaderLength + i);
  2032. #endif
  2033.     sendSignal(DBTC_REF, GSN_ATTRINFO, signal, 
  2034.        AttrInfo::HeaderLength + i, JBB);
  2035.   }
  2036. }
  2038. void
  2039. DbUtil::initResultSet(ResultSetBuffer & rs, 
  2040.       const ResultSetInfoBuffer & rsi){
  2041.   
  2042.   ResultSetBuffer::DataBufferIterator rsit;
  2043.   rs.first(rsit);
  2044.   
  2045.   ResultSetInfoBuffer::ConstDataBufferIterator rsiit;
  2046.   for(rsi.first(rsiit); rsiit.curr.i != RNIL; rsi.next(rsiit)){
  2047.     ndbrequire(rsit.curr.i != RNIL);
  2048.     
  2049.     rsit.data[0] = rsiit.data[0];
  2050. #if 0 //def EVENT_DEBUG
  2051.     printf("Init resultset %u, sz %dn",
  2052.    rsit.curr.i,
  2053.    ((AttributeHeader*)&rsit.data[0])->getDataSize() + 1);
  2054. #endif
  2055.     rs.next(rsit, ((AttributeHeader*)&rsit.data[0])->getDataSize() + 1);
  2056.   }
  2057. }
  2059. void
  2060. DbUtil::getTransId(Transaction * transP){
  2062.   Uint32 tmp[2];
  2063.   tmp[0] = c_transId[0];
  2064.   tmp[1] = c_transId[1];
  2066.   transP->transId[0] = tmp[0];
  2067.   transP->transId[1] = tmp[1];
  2068.   
  2069.   c_transId[1] = tmp[1] + 1;
  2070. }
  2074. /**************************************************************************
  2075.  * ------------------------------------------------------------------------
  2076.  *  MODULE:       Post Execute 
  2077.  * ------------------------------------------------------------------------
  2078.  *
  2079.  *  Handles result from a sent transaction
  2080.  **************************************************************************/
  2082. /**
  2083.  * execTRANSID_AI
  2084.  *
  2085.  * Receive result from transaction
  2086.  *
  2087.  * NOTE: This codes assumes that 
  2088.  *       TransidAI::DataLength = ResultSetBuffer::getSegmentSize() * n
  2089.  */
  2090. void
  2091. DbUtil::execTRANSID_AI(Signal* signal){
  2092.   jamEntry();
  2093. #if 0 //def EVENT_DEBUG
  2094.   ndbout_c("File: %s line: %u",__FILE__,__LINE__);
  2095. #endif
  2097.   const Uint32 opI      = signal->theData[0];
  2098.   const Uint32 transId1 = signal->theData[1];
  2099.   const Uint32 transId2 = signal->theData[2];
  2100.   const Uint32 dataLen  = signal->length() - 3;
  2102.   Operation * opP = c_operationPool.getPtr(opI);
  2103.   TransactionPtr transPtr;
  2104.   c_runningTransactions.getPtr(transPtr, opP->transPtrI);
  2106.   ndbrequire(transId1 == transPtr.p->transId[0] && 
  2107.      transId2 == transPtr.p->transId[1]);
  2108.   opP->rsRecv += dataLen;
  2109.   
  2110.   /**
  2111.    * Save result
  2112.    */
  2113.   const Uint32 *src = &signal->theData[3];
  2114.   ResultSetBuffer::DataBufferIterator rs = opP->rsIterator;
  2116.   ndbrequire(opP->rs.import(rs,src,dataLen));
  2117.   opP->rs.next(rs, dataLen);
  2118.   opP->rsIterator = rs;
  2120.   if(!opP->complete()){
  2121.    jam();
  2122.    return;
  2123.   }
  2125.   transPtr.p->recv++;
  2126.   if(!transPtr.p->complete()){
  2127.     jam();
  2128.     return;
  2129.   }
  2131.   finishTransaction(signal, transPtr);
  2132. }
  2134. void
  2135. DbUtil::execTCKEYCONF(Signal* signal){
  2136.   jamEntry();
  2137. #if 0 //def EVENT_DEBUG
  2138.   ndbout_c("File: %s line: %u",__FILE__,__LINE__);
  2139. #endif
  2140.   
  2141.   TcKeyConf * keyConf = (TcKeyConf*)signal->getDataPtr();
  2143.   //const Uint32 gci      = keyConf->gci;
  2144.   const Uint32 transI   = keyConf->apiConnectPtr >> 1;
  2145.   const Uint32 confInfo = keyConf->confInfo;
  2146.   const Uint32 transId1 = keyConf->transId1;
  2147.   const Uint32 transId2 = keyConf->transId2;
  2148.   
  2149.   Uint32 recv = 0;
  2150.   const Uint32 ops = TcKeyConf::getNoOfOperations(confInfo);  
  2151.   for(Uint32 i = 0; i<ops; i++){
  2152.     OperationPtr opPtr;
  2153.     c_operationPool.getPtr(opPtr, keyConf->operations[i].apiOperationPtr);
  2154.     
  2155.     ndbrequire(opPtr.p->transPtrI == transI);
  2156.     opPtr.p->rsExpect += keyConf->operations[i].attrInfoLen;
  2157.     if(opPtr.p->complete()){
  2158.       recv++;
  2159.     }
  2160.   }
  2162.   /**
  2163.    * Check commit ack marker flag
  2164.    */
  2165.   if (TcKeyConf::getMarkerFlag(confInfo)){
  2166.     signal->theData[0] = transId1;
  2167.     signal->theData[1] = transId2;
  2168.     sendSignal(DBTC_REF, GSN_TC_COMMIT_ACK, signal, 2, JBB);    
  2169.   }//if
  2171.   TransactionPtr transPtr;
  2172.   c_runningTransactions.getPtr(transPtr, transI);
  2173.   ndbrequire(transId1 == transPtr.p->transId[0] && 
  2174.      transId2 == transPtr.p->transId[1]);
  2175.   
  2176.   transPtr.p->recv += recv;
  2177.   if(!transPtr.p->complete()){
  2178.     jam();
  2179.     return;
  2180.   }
  2181.   finishTransaction(signal, transPtr);
  2182. }
  2184. void
  2185. DbUtil::execTCKEYREF(Signal* signal){
  2186.   jamEntry();
  2187. #if 0 //def EVENT_DEBUG
  2188.   ndbout_c("File: %s line: %u",__FILE__,__LINE__);
  2189. #endif
  2191.   const Uint32 transI   = signal->theData[0] >> 1;
  2192.   const Uint32 transId1 = signal->theData[1];
  2193.   const Uint32 transId2 = signal->theData[2];
  2194.   const Uint32 errCode  = signal->theData[3];
  2196.   TransactionPtr transPtr;
  2197.   c_runningTransactions.getPtr(transPtr, transI);
  2198.   ndbrequire(transId1 == transPtr.p->transId[0] && 
  2199.      transId2 == transPtr.p->transId[1]);
  2201.   //if(getClassification(errCode) == PermanentError){
  2202.   //}
  2203.   
  2204.   //ndbout << "Transaction error (code: " << errCode << ")" << endl;
  2205.   
  2206.   transPtr.p->errorCode = errCode;
  2207.   finishTransaction(signal, transPtr);
  2208. }
  2210. void
  2211. DbUtil::execTCROLLBACKREP(Signal* signal){
  2212.   jamEntry();
  2213. #if 0 //def EVENT_DEBUG
  2214.   ndbout_c("File: %s line: %u",__FILE__,__LINE__);
  2215. #endif
  2217.   const Uint32 transI   = signal->theData[0] >> 1;
  2218.   const Uint32 transId1 = signal->theData[1];
  2219.   const Uint32 transId2 = signal->theData[2];
  2220.   const Uint32 errCode  = signal->theData[3];
  2222.   TransactionPtr transPtr;
  2223.   c_runningTransactions.getPtr(transPtr, transI);
  2224.   ndbrequire(transId1 == transPtr.p->transId[0] && 
  2225.      transId2 == transPtr.p->transId[1]);
  2227.   //if(getClassification(errCode) == PermanentError){
  2228.   //}
  2229.   
  2230. #if 0 //def EVENT_DEBUG
  2231.   ndbout << "Transaction error (code: " << errCode << ")" << endl;
  2232. #endif
  2233.  
  2234.   if(transPtr.p->noOfRetries > 0){
  2235.     transPtr.p->noOfRetries--;
  2236.     switch(errCode){
  2237.     case 266:
  2238.     case 410:
  2239.     case 1204:
  2240. #if 0
  2241.       ndbout_c("errCode: %d noOfRetries: %d -> retry", 
  2242.        errCode, transPtr.p->noOfRetries);
  2243. #endif
  2244.       runTransaction(signal, transPtr);
  2245.       return;
  2246.     }
  2247.   }
  2249.   transPtr.p->errorCode = errCode;
  2250.   finishTransaction(signal, transPtr);
  2251. }
  2253. void 
  2254. DbUtil::finishTransaction(Signal* signal, TransactionPtr transPtr){
  2255. #if 0 //def EVENT_DEBUG
  2256.   ndbout_c("Transaction %x %x completed %s",
  2257.    transPtr.p->transId[0], 
  2258.    transPtr.p->transId[1],
  2259.    transPtr.p->errorCode == 0 ? "OK" : "FAILED");
  2260. #endif
  2262.   /* 
  2263.      How to find the correct RS?  Could we have multi-RS/transaction?
  2265.   Operation * opP = c_operationPool.getPtr(opI);
  2267.   ResultSetBuffer::DataBufferIterator rsit;  
  2268.   ndbrequire(opP->rs.first(rsit));
  2269.   ndbout << "F Result: " << rsit.data << endl;
  2271.   while (opP->rs.next(rsit)) {
  2272.     ndbout << "R Result: " << rsit.data << endl;
  2273.   }
  2274.   */
  2276.   switch(transPtr.p->gsn){
  2277.   case GSN_UTIL_SEQUENCE_REQ:
  2278.     jam();
  2279.     reportSequence(signal, transPtr.p);
  2280.     break;
  2281.   case GSN_UTIL_EXECUTE_REQ:
  2282.     if (transPtr.p->errorCode) {
  2283.       UtilExecuteRef * ret = (UtilExecuteRef *)signal->getDataPtrSend();
  2284.       ret->senderData = transPtr.p->clientData;
  2285.       ret->errorCode = UtilExecuteRef::TCError;
  2286.       ret->TCErrorCode = transPtr.p->errorCode;
  2287.       sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_REF, signal, 
  2288.  UtilExecuteRef::SignalLength, JBB);
  2289.     } else {
  2290.       struct LinearSectionPtr sectionsPtr[UtilExecuteReq::NoOfSections];
  2291.       UtilExecuteConf * ret = (UtilExecuteConf *)signal->getDataPtrSend();
  2292.       ret->senderData = transPtr.p->clientData;
  2293.       if (getResultSet(signal, transPtr.p, sectionsPtr)) {
  2294. #if 0 //def EVENT_DEBUG
  2295. for (int j = 0; j < 2; j++) {
  2296.   printf("Result set %u %un", j,sectionsPtr[j].sz);
  2297.   for (int i=0; i < sectionsPtr[j].sz; i++)
  2298.     printf("H'%.8x ", sectionsPtr[j].p[i]);
  2299.   printf("n");
  2300. }
  2301. #endif
  2302. sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_CONF, signal, 
  2303.    UtilExecuteConf::SignalLength, JBB,
  2304.    sectionsPtr, UtilExecuteReq::NoOfSections);
  2305.       } else
  2306. sendSignal(transPtr.p->clientRef, GSN_UTIL_EXECUTE_CONF, signal, 
  2307.    UtilExecuteConf::SignalLength, JBB);
  2308.     } 
  2309.     break;
  2310.   default:
  2311.     ndbrequire(0);
  2312.     break;
  2313.   }
  2314.   releaseTransaction(transPtr);
  2315. }
  2317. void
  2318. DbUtil::execUTIL_LOCK_REQ(Signal * signal){
  2319.   jamEntry();
  2320.   UtilLockReq * req = (UtilLockReq*)signal->getDataPtr();
  2321.   const Uint32 lockId = req->lockId;
  2323.   LockQueuePtr lockQPtr;
  2324.   if(!c_lockQueues.find(lockQPtr, lockId)){
  2325.     jam();
  2326.     sendLOCK_REF(signal, req, UtilLockRef::NoSuchLock);
  2327.     return;
  2328.   }
  2330. //  const Uint32 requestInfo = req->requestInfo;
  2331.   const Uint32 senderNode = refToNode(req->senderRef);
  2332.   if(senderNode != getOwnNodeId() && senderNode != 0){
  2333.     jam();
  2334.     sendLOCK_REF(signal, req, UtilLockRef::DistributedLockNotSupported);    
  2335.     return;
  2336.   }
  2338.   LocalDLFifoList<LockQueueElement> queue(c_lockElementPool,
  2339.   lockQPtr.p->m_queue);
  2340.   if(req->requestInfo & UtilLockReq::TryLock && !queue.isEmpty()){
  2341.     jam();
  2342.     sendLOCK_REF(signal, req, UtilLockRef::LockAlreadyHeld);
  2343.     return;
  2344.   }
  2345.   
  2346.   LockQueueElementPtr lockEPtr;
  2347.   if(!c_lockElementPool.seize(lockEPtr)){
  2348.     jam();
  2349.     sendLOCK_REF(signal, req, UtilLockRef::OutOfLockRecords);
  2350.     return;
  2351.   }
  2352.   
  2353.   lockEPtr.p->m_senderRef = req->senderRef;
  2354.   lockEPtr.p->m_senderData = req->senderData;
  2355.   
  2356.   if(queue.isEmpty()){
  2357.     jam();
  2358.     sendLOCK_CONF(signal, lockQPtr.p, lockEPtr.p);
  2359.   }
  2360.   
  2361.   queue.add(lockEPtr);
  2362. }
  2364. void
  2365. DbUtil::execUTIL_UNLOCK_REQ(Signal* signal){
  2366.   jamEntry();
  2367.   
  2368.   UtilUnlockReq * req = (UtilUnlockReq*)signal->getDataPtr();
  2369.   const Uint32 lockId = req->lockId;
  2370.   
  2371.   LockQueuePtr lockQPtr;
  2372.   if(!c_lockQueues.find(lockQPtr, lockId)){
  2373.     jam();
  2374.     sendUNLOCK_REF(signal, req, UtilUnlockRef::NoSuchLock);
  2375.     return;
  2376.   }
  2378.   LocalDLFifoList<LockQueueElement> queue(c_lockElementPool, 
  2379.   lockQPtr.p->m_queue);
  2380.   LockQueueElementPtr lockEPtr;
  2381.   if(!queue.first(lockEPtr)){
  2382.     jam();
  2383.     sendUNLOCK_REF(signal, req, UtilUnlockRef::NotLockOwner);
  2384.     return;
  2385.   }
  2387.   if(lockQPtr.p->m_lockKey != req->lockKey){
  2388.     jam();
  2389.     sendUNLOCK_REF(signal, req, UtilUnlockRef::NotLockOwner);
  2390.     return;
  2391.   }
  2393.   sendUNLOCK_CONF(signal, lockQPtr.p, lockEPtr.p);
  2394.   queue.release(lockEPtr);
  2395.   
  2396.   if(queue.first(lockEPtr)){
  2397.     jam();
  2398.     sendLOCK_CONF(signal, lockQPtr.p, lockEPtr.p);
  2399.     return;
  2400.   }
  2401. }
  2403. void
  2404. DbUtil::sendLOCK_REF(Signal* signal, 
  2405.      const UtilLockReq * req, UtilLockRef::ErrorCode err){
  2406.   const Uint32 senderData = req->senderData;
  2407.   const Uint32 senderRef = req->senderRef;
  2408.   const Uint32 lockId = req->lockId;
  2410.   UtilLockRef * ref = (UtilLockRef*)signal->getDataPtrSend();
  2411.   ref->senderData = senderData;
  2412.   ref->senderRef = reference();
  2413.   ref->lockId = lockId;
  2414.   ref->errorCode = err;
  2415.   sendSignal(senderRef, GSN_UTIL_LOCK_REF, signal, 
  2416.      UtilLockRef::SignalLength, JBB);
  2417. }
  2419. void
  2420. DbUtil::sendLOCK_CONF(Signal* signal, 
  2421.       LockQueue * lockQP, 
  2422.       LockQueueElement * lockEP){
  2423.   const Uint32 senderData = lockEP->m_senderData;
  2424.   const Uint32 senderRef = lockEP->m_senderRef;
  2425.   const Uint32 lockId = lockQP->m_lockId;
  2426.   const Uint32 lockKey = ++lockQP->m_lockKey;
  2428.   UtilLockConf * conf = (UtilLockConf*)signal->getDataPtrSend();
  2429.   conf->senderData = senderData;
  2430.   conf->senderRef = reference();
  2431.   conf->lockId = lockId;
  2432.   conf->lockKey = lockKey;
  2433.   sendSignal(senderRef, GSN_UTIL_LOCK_CONF, signal,
  2434.      UtilLockConf::SignalLength, JBB);
  2435. }
  2437. void
  2438. DbUtil::sendUNLOCK_REF(Signal* signal, 
  2439.        const UtilUnlockReq* req, UtilUnlockRef::ErrorCode err){
  2440.   
  2441.   const Uint32 senderData = req->senderData;
  2442.   const Uint32 senderRef = req->senderRef;
  2443.   const Uint32 lockId = req->lockId;
  2444.   
  2445.   UtilUnlockRef * ref = (UtilUnlockRef*)signal->getDataPtrSend();
  2446.   ref->senderData = senderData;
  2447.   ref->senderRef = reference();
  2448.   ref->lockId = lockId;
  2449.   ref->errorCode = err;
  2450.   sendSignal(senderRef, GSN_UTIL_UNLOCK_REF, signal, 
  2451.      UtilUnlockRef::SignalLength, JBB);
  2452. }
  2454. void 
  2455. DbUtil::sendUNLOCK_CONF(Signal* signal, 
  2456. LockQueue * lockQP, 
  2457. LockQueueElement * lockEP){
  2458.   const Uint32 senderData = lockEP->m_senderData;
  2459.   const Uint32 senderRef = lockEP->m_senderRef;
  2460.   const Uint32 lockId = lockQP->m_lockId;
  2461.   ++lockQP->m_lockKey;
  2462.   
  2463.   UtilUnlockConf * conf = (UtilUnlockConf*)signal->getDataPtrSend();
  2464.   conf->senderData = senderData;
  2465.   conf->senderRef = reference();
  2466.   conf->lockId = lockId;
  2467.   sendSignal(senderRef, GSN_UTIL_UNLOCK_CONF, signal,
  2468.      UtilUnlockConf::SignalLength, JBB);
  2469. }
  2471. void
  2472. DbUtil::execUTIL_CREATE_LOCK_REQ(Signal* signal){
  2473.   jamEntry();
  2474.   UtilCreateLockReq req = * (UtilCreateLockReq*)signal->getDataPtr();
  2476.   UtilCreateLockRef::ErrorCode err = UtilCreateLockRef::OK;
  2478.   do {
  2479.     LockQueuePtr lockQPtr;
  2480.     if(c_lockQueues.find(lockQPtr, req.lockId)){
  2481.       jam();
  2482.       err = UtilCreateLockRef::LockIdAlreadyUsed;
  2483.       break;
  2484.     }
  2486.     if(req.lockType != UtilCreateLockReq::Mutex){
  2487.       jam();
  2488.       err = UtilCreateLockRef::UnsupportedLockType;
  2489.       break;
  2490.     }
  2491.     
  2492.     if(!c_lockQueues.seize(lockQPtr)){
  2493.       jam();
  2494.       err = UtilCreateLockRef::OutOfLockQueueRecords;
  2495.       break;
  2496.     }      
  2498.     new (lockQPtr.p) LockQueue(req.lockId);
  2499.     c_lockQueues.add(lockQPtr);
  2501.     UtilCreateLockConf * conf = (UtilCreateLockConf*)signal->getDataPtrSend();
  2502.     conf->senderData = req.senderData;
  2503.     conf->senderRef = reference();
  2504.     conf->lockId = req.lockId;
  2505.     
  2506.     sendSignal(req.senderRef, GSN_UTIL_CREATE_LOCK_CONF, signal, 
  2507.        UtilCreateLockConf::SignalLength, JBB);
  2508.     return;
  2509.   } while(false);
  2511.   UtilCreateLockRef * ref = (UtilCreateLockRef*)signal->getDataPtrSend();
  2512.   ref->senderData = req.senderData;
  2513.   ref->senderRef = reference();
  2514.   ref->lockId = req.lockId;
  2515.   ref->errorCode = err;
  2517.   sendSignal(req.senderRef, GSN_UTIL_CREATE_LOCK_REF, signal, 
  2518.      UtilCreateLockRef::SignalLength, JBB);
  2519. }
  2521. void
  2522. DbUtil::execUTIL_DESTORY_LOCK_REQ(Signal* signal){
  2523.   jamEntry();
  2524.   
  2525.   UtilDestroyLockReq req = * (UtilDestroyLockReq*)signal->getDataPtr();
  2526.   UtilDestroyLockRef::ErrorCode err = UtilDestroyLockRef::OK;
  2527.   do {
  2528.     LockQueuePtr lockQPtr;
  2529.     if(!c_lockQueues.find(lockQPtr, req.lockId)){
  2530.       jam();
  2531.       err = UtilDestroyLockRef::NoSuchLock;
  2532.       break;
  2533.     }
  2534.     
  2535.     LocalDLFifoList<LockQueueElement> queue(c_lockElementPool, 
  2536.     lockQPtr.p->m_queue);
  2537.     LockQueueElementPtr lockEPtr;
  2538.     if(!queue.first(lockEPtr)){
  2539.       jam();
  2540.       err = UtilDestroyLockRef::NotLockOwner;
  2541.       break;
  2542.     }
  2543.     
  2544.     if(lockQPtr.p->m_lockKey != req.lockKey){
  2545.       jam();
  2546.       err = UtilDestroyLockRef::NotLockOwner;
  2547.       break;
  2548.     }
  2549.     
  2550.     /**
  2551.      * OK
  2552.      */
  2553.     
  2554.     // Inform all in lock queue that queue has been destroyed
  2555.     UtilLockRef * ref = (UtilLockRef*)signal->getDataPtrSend();
  2556.     ref->lockId = req.lockId;
  2557.     ref->errorCode = UtilLockRef::NoSuchLock;
  2558.     ref->senderRef = reference();
  2559.     LockQueueElementPtr loopPtr = lockEPtr;      
  2560.     for(queue.next(loopPtr); !loopPtr.isNull(); queue.next(loopPtr)){
  2561.       jam();
  2562.       ref->senderData = loopPtr.p->m_senderData;
  2563.       const Uint32 senderRef = loopPtr.p->m_senderRef;
  2564.       sendSignal(senderRef, GSN_UTIL_LOCK_REF, signal, 
  2565.  UtilLockRef::SignalLength, JBB);
  2566.     }
  2567.     queue.release();
  2568.     c_lockQueues.release(lockQPtr);
  2569.     
  2570.     // Send Destroy conf
  2571.     UtilDestroyLockConf* conf=(UtilDestroyLockConf*)signal->getDataPtrSend();
  2572.     conf->senderData = req.senderData;
  2573.     conf->senderRef = reference();
  2574.     conf->lockId = req.lockId;
  2575.     sendSignal(req.senderRef, GSN_UTIL_DESTROY_LOCK_CONF, signal,
  2576.        UtilDestroyLockConf::SignalLength, JBB);
  2577.     return;
  2578.   } while(false);
  2580.   UtilDestroyLockRef * ref = (UtilDestroyLockRef*)signal->getDataPtrSend();
  2581.   ref->senderData = req.senderData;
  2582.   ref->senderRef = reference();
  2583.   ref->lockId = req.lockId;
  2584.   ref->errorCode = err;
  2585.   sendSignal(req.senderRef, GSN_UTIL_DESTROY_LOCK_REF, signal,
  2586.      UtilDestroyLockRef::SignalLength, JBB);
  2587. }
  2589. template class ArrayPool<DbUtil::Page32>;