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

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

MySQL数据库

开发平台：

Visual C++

Ndb.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 */
  20. /*****************************************************************************
  21. Name:          Ndb.cpp
  22. ******************************************************************************/
  24. #include <ndb_global.h>
  27. #include "NdbApiSignal.hpp"
  28. #include "NdbImpl.hpp"
  29. #include <NdbOperation.hpp>
  30. #include <NdbConnection.hpp>
  31. #include <NdbEventOperation.hpp>
  32. #include <NdbRecAttr.hpp>
  33. #include <md5_hash.hpp>
  34. #include <NdbSleep.h>
  35. #include <NdbOut.hpp>
  36. #include <ndb_limits.h>
  37. #include "API.hpp"
  38. #include <NdbEnv.h>
  39. #include <BaseString.hpp>
  41. /****************************************************************************
  42. void connect();
  44. Connect to any node which has no connection at the moment.
  45. ****************************************************************************/
  46. NdbConnection* Ndb::doConnect(Uint32 tConNode) 
  47. {
  48.   Uint32        tNode;
  49.   Uint32        tAnyAlive = 0;
  50.   int TretCode;
  52.   if (tConNode != 0) {
  53.     TretCode = NDB_connect(tConNode);
  54.     if ((TretCode == 1) || (TretCode == 2)) {
  55. //****************************************************************************
  56. // We have connections now to the desired node. Return
  57. //****************************************************************************
  58.       return getConnectedNdbConnection(tConNode);
  59.     } else if (TretCode != 0) {
  60.       tAnyAlive = 1;
  61.     }//if
  62.   }//if
  63. //****************************************************************************
  64. // We will connect to any node. Make sure that we have connections to all
  65. // nodes.
  66. //****************************************************************************
  67.   if (theImpl->m_optimized_node_selection)
  68.   {
  69.     Ndb_cluster_connection_node_iter &node_iter= 
  70.       theImpl->m_node_iter;
  71.     theImpl->m_ndb_cluster_connection.init_get_next_node(node_iter);
  72.     while ((tNode= theImpl->m_ndb_cluster_connection.get_next_node(node_iter)))
  73.     {
  74.       TretCode= NDB_connect(tNode);
  75.       if ((TretCode == 1) ||
  76.   (TretCode == 2))
  77.       {
  78. //****************************************************************************
  79. // We have connections now to the desired node. Return
  80. //****************************************************************************
  81. return getConnectedNdbConnection(tNode);
  82.       } else if (TretCode != 0) {
  83. tAnyAlive= 1;
  84.       }//if
  85.     }
  86.   }
  87.   else // just do a regular round robin
  88.   {
  89.     Uint32 tNoOfDbNodes= theImpl->theNoOfDBnodes;
  90.     Uint32 &theCurrentConnectIndex= theImpl->theCurrentConnectIndex;
  91.     UintR Tcount = 0;
  92.     do {
  93.       theCurrentConnectIndex++;
  94.       if (theCurrentConnectIndex >= tNoOfDbNodes)
  95. theCurrentConnectIndex = 0;
  97.       Tcount++;
  98.       tNode= theImpl->theDBnodes[theCurrentConnectIndex];
  99.       TretCode= NDB_connect(tNode);
  100.       if ((TretCode == 1) ||
  101.   (TretCode == 2))
  102.       {
  103. //****************************************************************************
  104. // We have connections now to the desired node. Return
  105. //****************************************************************************
  106. return getConnectedNdbConnection(tNode);
  107.       } else if (TretCode != 0) {
  108. tAnyAlive= 1;
  109.       }//if
  110.     } while (Tcount < tNoOfDbNodes);
  111.   }
  112. //****************************************************************************
  113. // We were unable to find a free connection. If no node alive we will report
  114. // error code for cluster failure otherwise connection failure.
  115. //****************************************************************************
  116.   if (tAnyAlive == 1) {
  117. #ifdef VM_TRACE
  118.     ndbout << "TretCode = " << TretCode << endl;
  119. #endif
  120.     theError.code = 4006;
  121.   } else {
  122.     theError.code = 4009;
  123.   }//if
  124.   return NULL;
  125. }
  127. int 
  128. Ndb::NDB_connect(Uint32 tNode) 
  129. {
  130. //****************************************************************************
  131. // We will perform seize of a transaction record in DBTC in the specified node.
  132. //***************************************************************************
  133.   
  134.   int          tReturnCode;
  135.   TransporterFacade *tp = TransporterFacade::instance();
  137.   bool nodeAvail = tp->get_node_alive(tNode);
  138.   if(nodeAvail == false){
  139.     return 0;
  140.   }
  141.   
  142.   NdbConnection * tConArray = theConnectionArray[tNode];
  143.   if (tConArray != NULL) {
  144.     return 2;
  145.   }
  146.   
  147.   NdbConnection * tNdbCon = getNdbCon(); // Get free connection object.
  148.   if (tNdbCon == NULL) {
  149.     return 4;
  150.   }//if
  151.   NdbApiSignal* tSignal = getSignal(); // Get signal object
  152.   if (tSignal == NULL) {
  153.     releaseNdbCon(tNdbCon);
  154.     return 4;
  155.   }//if
  156.   if (tSignal->setSignal(GSN_TCSEIZEREQ) == -1) {
  157.     releaseNdbCon(tNdbCon);
  158.     releaseSignal(tSignal);
  159.     return 4;
  160.   }//if
  161.   tSignal->setData(tNdbCon->ptr2int(), 1);
  162. //************************************************
  163. // Set connection pointer as NdbConnection object
  164. //************************************************
  165.   tSignal->setData(theMyRef, 2); // Set my block reference
  166.   tNdbCon->Status(NdbConnection::Connecting); // Set status to connecting
  167.   Uint32 nodeSequence;
  168.   { // send and receive signal
  169.     Guard guard(tp->theMutexPtr);
  170.     nodeSequence = tp->getNodeSequence(tNode);
  171.     bool node_is_alive = tp->get_node_alive(tNode);
  172.     if (node_is_alive) { 
  173.       tReturnCode = tp->sendSignal(tSignal, tNode);  
  174.       releaseSignal(tSignal); 
  175.       if (tReturnCode != -1) {
  176.         theImpl->theWaiter.m_node = tNode;  
  177.         theImpl->theWaiter.m_state = WAIT_TC_SEIZE;  
  178.         tReturnCode = receiveResponse(); 
  179.       }//if
  180.     } else {
  181.       releaseSignal(tSignal);
  182.       tReturnCode = -1;
  183.     }//if
  184.   }
  185.   if ((tReturnCode == 0) && (tNdbCon->Status() == NdbConnection::Connected)) {
  186.     //************************************************
  187.     // Send and receive was successful
  188.     //************************************************
  189.     NdbConnection* tPrevFirst = theConnectionArray[tNode];
  190.     tNdbCon->setConnectedNodeId(tNode, nodeSequence);
  191.     
  192.     tNdbCon->setMyBlockReference(theMyRef);
  193.     theConnectionArray[tNode] = tNdbCon;
  194.     tNdbCon->theNext = tPrevFirst;
  195.     return 1;
  196.   } else {
  197.     releaseNdbCon(tNdbCon);
  198. //****************************************************************************
  199. // Unsuccessful connect is indicated by 3.
  200. //****************************************************************************
  201.     return 3;
  202.   }//if
  203. }//Ndb::NDB_connect()
  205. NdbConnection *
  206. Ndb::getConnectedNdbConnection(Uint32 nodeId){
  207.   NdbConnection* next = theConnectionArray[nodeId];
  208.   theConnectionArray[nodeId] = next->theNext;
  209.   next->theNext = NULL;
  211.   return next;
  212. }//Ndb::getConnectedNdbConnection()
  214. /*****************************************************************************
  215. disconnect();
  217. Remark:        Disconnect all connections to the database. 
  218. *****************************************************************************/
  219. void 
  220. Ndb::doDisconnect()
  221. {
  222.   DBUG_ENTER("Ndb::doDisconnect");
  223.   NdbConnection* tNdbCon;
  224.   CHECK_STATUS_MACRO_VOID;
  226.   Uint32 tNoOfDbNodes = theImpl->theNoOfDBnodes;
  227.   Uint8 *theDBnodes= theImpl->theDBnodes;
  228.   DBUG_PRINT("info", ("theNoOfDBnodes=%d", tNoOfDbNodes));
  229.   UintR i;
  230.   for (i = 0; i < tNoOfDbNodes; i++) {
  231.     Uint32 tNode = theDBnodes[i];
  232.     tNdbCon = theConnectionArray[tNode];
  233.     while (tNdbCon != NULL) {
  234.       NdbConnection* tmpNdbCon = tNdbCon;
  235.       tNdbCon = tNdbCon->theNext;
  236.       releaseConnectToNdb(tmpNdbCon);
  237.     }//while
  238.   }//for
  239.   tNdbCon = theTransactionList;
  240.   while (tNdbCon != NULL) {
  241.     NdbConnection* tmpNdbCon = tNdbCon;
  242.     tNdbCon = tNdbCon->theNext;
  243.     releaseConnectToNdb(tmpNdbCon);
  244.   }//while
  245.   DBUG_VOID_RETURN;
  246. }//Ndb::disconnect()
  248. /*****************************************************************************
  249. int waitUntilReady(int timeout);
  251. Return Value:   Returns 0 if the Ndb is ready within timeout seconds.
  252.                 Returns -1 otherwise.
  253. Remark:         Waits until a node has status != 0
  254. *****************************************************************************/ 
  255. int
  256. Ndb::waitUntilReady(int timeout)
  257. {
  258.   DBUG_ENTER("Ndb::waitUntilReady");
  259.   int secondsCounter = 0;
  260.   int milliCounter = 0;
  261.   int noChecksSinceFirstAliveFound = 0;
  262.   int id;
  264.   if (theInitState != Initialised) {
  265.     // Ndb::init is not called
  266.     theError.code = 4256;
  267.     DBUG_RETURN(-1);
  268.   }
  270.   while (theNode == 0) {
  271.     if (secondsCounter >= timeout)
  272.     {
  273.       theError.code = 4269;
  274.       DBUG_RETURN(-1);
  275.     }
  276.     NdbSleep_MilliSleep(100);
  277.     milliCounter += 100;
  278.     if (milliCounter >= 1000) {
  279.       secondsCounter++;
  280.       milliCounter = 0;
  281.     }//if
  282.   }
  284.   if (theImpl->m_ndb_cluster_connection.wait_until_ready
  285.       (timeout-secondsCounter,30) < 0)
  286.   {
  287.     theError.code = 4009;
  288.     DBUG_RETURN(-1);
  289.   }
  291.   DBUG_RETURN(0);
  292. }
  294. /*****************************************************************************
  295. NdbConnection* startTransaction();
  297. Return Value:   Returns a pointer to a connection object.
  298.                 Return NULL otherwise.
  299. Remark:         Start transaction. Synchronous.
  300. *****************************************************************************/ 
  301. NdbConnection* 
  302. Ndb::startTransaction(Uint32 aPriority, const char * keyData, Uint32 keyLen)
  303. {
  304.   DBUG_ENTER("Ndb::startTransaction");
  306.   if (theInitState == Initialised) {
  307.     theError.code = 0;
  308.     checkFailedNode();
  309.   /**
  310.    * If the user supplied key data
  311.    * We will make a qualified quess to which node is the primary for the
  312.    * the fragment and contact that node
  313.    */
  314.     Uint32 nodeId;
  315.     if(keyData != 0) {
  316.       nodeId = 0; // guess not supported
  317.       // nodeId = m_ndb_cluster_connection->guess_primary_node(keyData, keyLen);
  318.     } else {
  319.       nodeId = 0;
  320.     }//if
  321.     {
  322.       NdbConnection *trans= startTransactionLocal(aPriority, nodeId);
  323.       DBUG_PRINT("exit",("start trans: 0x%x transid: 0x%llx",
  324.  trans, trans ? trans->getTransactionId() : 0));
  325.       DBUG_RETURN(trans);
  326.     }
  327.   } else {
  328.     DBUG_RETURN(NULL);
  329.   }//if
  330. }//Ndb::startTransaction()
  332. /*****************************************************************************
  333. NdbConnection* hupp(NdbConnection* pBuddyTrans);
  335. Return Value:   Returns a pointer to a connection object.
  336.                 Connected to the same node as pBuddyTrans
  337.                 and also using the same transction id
  338. Remark:         Start transaction. Synchronous.
  339. *****************************************************************************/ 
  340. NdbConnection* 
  341. Ndb::hupp(NdbConnection* pBuddyTrans)
  342. {
  343.   DBUG_ENTER("Ndb::hupp");
  345.   DBUG_PRINT("enter", ("trans: 0x%x",pBuddyTrans));
  347.   Uint32 aPriority = 0;
  348.   if (pBuddyTrans == NULL){
  349.     DBUG_RETURN(startTransaction());
  350.   }
  352.   if (theInitState == Initialised) {
  353.     theError.code = 0;
  354.     checkFailedNode();
  356.     Uint32 nodeId = pBuddyTrans->getConnectedNodeId();
  357.     NdbConnection* pCon = startTransactionLocal(aPriority, nodeId);
  358.     if(pCon == NULL)
  359.       DBUG_RETURN(NULL);
  361.     if (pCon->getConnectedNodeId() != nodeId){
  362.       // We could not get a connection to the desired node
  363.       // release the connection and return NULL
  364.       closeTransaction(pCon);
  365.       theError.code = 4006;
  366.       DBUG_RETURN(NULL);
  367.     }
  368.     pCon->setTransactionId(pBuddyTrans->getTransactionId());
  369.     pCon->setBuddyConPtr((Uint32)pBuddyTrans->getTC_ConnectPtr());
  370.     DBUG_PRINT("exit", ("hupp trans: 0x%x transid: 0x%llx",
  371. pCon, pCon ? pCon->getTransactionId() : 0));
  372.     DBUG_RETURN(pCon);
  373.   } else {
  374.     DBUG_RETURN(NULL);
  375.   }//if
  376. }//Ndb::hupp()
  379. NdbConnection* 
  380. Ndb::startTransactionLocal(Uint32 aPriority, Uint32 nodeId)
  381. {
  382. #ifdef VM_TRACE
  383.   char buf[255];
  384.   const char* val = NdbEnv_GetEnv("NDB_TRANSACTION_NODE_ID", buf, 255);
  385.   if(val != 0){
  386.     nodeId = atoi(val);
  387.   }
  388. #endif
  390.   DBUG_ENTER("Ndb::startTransactionLocal");
  391.   DBUG_PRINT("enter", ("nodeid: %d", nodeId));
  393.   NdbConnection* tConnection;
  394.   Uint64 tFirstTransId = theFirstTransId;
  395.   tConnection = doConnect(nodeId);
  396.   if (tConnection == NULL) {
  397.     DBUG_RETURN(NULL);
  398.   }//if
  399.   NdbConnection* tConNext = theTransactionList;
  400.   tConnection->init();
  401.   theTransactionList = tConnection;        // into a transaction list.
  402.   tConnection->next(tConNext);   // Add the active connection object
  403.   tConnection->setTransactionId(tFirstTransId);
  404.   tConnection->thePriority = aPriority;
  405.   if ((tFirstTransId & 0xFFFFFFFF) == 0xFFFFFFFF) {
  406.     //---------------------------------------------------
  407. // Transaction id rolling round. We will start from
  408. // consecutive identity 0 again.
  409. //---------------------------------------------------
  410.     theFirstTransId = ((tFirstTransId >> 32) << 32);      
  411.   } else {
  412.     theFirstTransId = tFirstTransId + 1;
  413.   }//if
  414. #ifdef VM_TRACE
  415.   if (tConnection->theListState != NdbConnection::NotInList) {
  416.     printState("startTransactionLocal %x", tConnection);
  417.     abort();
  418.   }
  419. #endif
  420.   DBUG_RETURN(tConnection);
  421. }//Ndb::startTransactionLocal()
  423. /*****************************************************************************
  424. void closeTransaction(NdbConnection* aConnection);
  426. Parameters:     aConnection: the connection used in the transaction.
  427. Remark:         Close transaction by releasing the connection and all operations.
  428. *****************************************************************************/
  429. void
  430. Ndb::closeTransaction(NdbConnection* aConnection)
  431. {
  432.   DBUG_ENTER("Ndb::closeTransaction");
  433.   NdbConnection* tCon;
  434.   NdbConnection* tPreviousCon;
  436.   if (aConnection == NULL) {
  437. //-----------------------------------------------------
  438. // closeTransaction called on NULL pointer, destructive
  439. // application behaviour.
  440. //-----------------------------------------------------
  441. #ifdef VM_TRACE
  442.     printf("NULL into closeTransactionn");
  443. #endif
  444.     DBUG_VOID_RETURN;
  445.   }//if
  446.   CHECK_STATUS_MACRO_VOID;
  447.   
  448.   tCon = theTransactionList;
  449.   
  450.   DBUG_PRINT("info",("close trans: 0x%x transid: 0x%llx",
  451.      aConnection, aConnection->getTransactionId()));
  452.   DBUG_PRINT("info",("magic number: 0x%x TCConPtr: 0x%x theMyRef: 0x%x 0x%x",
  453.      aConnection->theMagicNumber, aConnection->theTCConPtr,
  454.      aConnection->theMyRef, getReference()));
  456.   if (aConnection == tCon) { // Remove the active connection object
  457.     theTransactionList = tCon->next(); // from the transaction list.
  458.   } else { 
  459.     while (aConnection != tCon) {
  460.       if (tCon == NULL) {
  461. //-----------------------------------------------------
  462. // closeTransaction called on non-existing transaction
  463. //-----------------------------------------------------
  465. if(aConnection->theError.code == 4008){
  466.   /**
  467.    * When a SCAN timed-out, returning the NdbConnection leads
  468.    * to reuse. And TC crashes when the API tries to reuse it to
  469.    * something else...
  470.    */
  471. #ifdef VM_TRACE
  472.   printf("Scan timeout:ed NdbConnection-> "
  473.  "not returning it-> memory leakn");
  474. #endif
  475.   DBUG_VOID_RETURN;
  476. }
  478. #ifdef VM_TRACE
  479. printf("Non-existing transaction into closeTransactionn");
  480. abort();
  481. #endif
  482. DBUG_VOID_RETURN;
  483.       }//if
  484.       tPreviousCon = tCon;
  485.       tCon = tCon->next();
  486.     }//while
  487.     tPreviousCon->next(tCon->next());
  488.   }//if
  489.   
  490.   aConnection->release();
  491.   
  492.   if(aConnection->theError.code == 4008){
  493.     /**
  494.      * Something timed-out, returning the NdbConnection leads
  495.      * to reuse. And TC crashes when the API tries to reuse it to
  496.      * something else...
  497.      */
  498. #ifdef VM_TRACE
  499.     printf("Con timeout:ed NdbConnection-> not returning it-> memory leakn");
  500. #endif
  501.     DBUG_VOID_RETURN;
  502.   }
  503.   
  504.   if (aConnection->theReleaseOnClose == false) {
  505.     /**
  506.      * Put it back in idle list for that node
  507.      */
  508.     Uint32 nodeId = aConnection->getConnectedNodeId();
  509.     aConnection->theNext = theConnectionArray[nodeId];
  510.     theConnectionArray[nodeId] = aConnection;
  511.     DBUG_VOID_RETURN;
  512.   } else {
  513.     aConnection->theReleaseOnClose = false;
  514.     releaseNdbCon(aConnection);
  515.   }//if
  516.   DBUG_VOID_RETURN;
  517. }//Ndb::closeTransaction()
  519. /*****************************************************************************
  520. int* NdbTamper(int aAction, int aNode);
  522. Parameters: aAction     Specifies what action to be taken
  523.             1: Lock global checkpointing    Can only be sent to master DIH, Parameter aNode ignored.
  524.             2: UnLock global checkpointing    Can only be sent to master DIH, Parameter aNode ignored.
  525.     3: Crash node
  527.            aNode        Specifies which node the action will be taken
  528.         -1: Master DIH 
  529.         0-16: Nodnumber
  531. Return Value: -1 Error  .
  532.                 
  533. Remark:         Sends a signal to DIH.
  534. *****************************************************************************/ 
  535. int 
  536. Ndb::NdbTamper(TamperType aAction, int aNode)
  537. {
  538.   NdbConnection* tNdbConn;
  539.   NdbApiSignal tSignal(theMyRef);
  540.   int tNode;
  541.   int                   tAction;
  542.   int ret_code;
  544. #ifdef CUSTOMER_RELEASE
  545.   return -1;
  546. #else
  547.   CHECK_STATUS_MACRO;
  548.   checkFailedNode();
  550.   theRestartGCI = 0;
  551.   switch (aAction) {
  552. // Translate enum to integer. This is done because the SCI layer
  553. // expects integers. 
  554.      case LockGlbChp:
  555.         tAction = 1;
  556.         break;
  557.      case UnlockGlbChp:
  558.         tAction = 2;
  559. break;
  560.      case CrashNode:
  561.         tAction = 3;
  562.         break;
  563.      case ReadRestartGCI:
  564. tAction = 4;
  565. break;
  566.      default:
  567.         theError.code = 4102;
  568.         return -1;
  569.   }
  571.   tNdbConn = getNdbCon(); // Get free connection object
  572.   if (tNdbConn == NULL) {
  573.     theError.code = 4000;
  574.     return -1;
  575.   }
  576.   tSignal.setSignal(GSN_DIHNDBTAMPER);
  577.   tSignal.setData (tAction, 1);
  578.   tSignal.setData(tNdbConn->ptr2int(),2);
  579.   tSignal.setData(theMyRef,3); // Set return block reference
  580.   tNdbConn->Status(NdbConnection::Connecting); // Set status to connecting
  581.   TransporterFacade *tp = TransporterFacade::instance();
  582.   if (tAction == 3) {
  583.     tp->lock_mutex();
  584.     tp->sendSignal(&tSignal, aNode);
  585.     tp->unlock_mutex();
  586.     releaseNdbCon(tNdbConn);
  587.   } else if ( (tAction == 2) || (tAction == 1) ) {
  588.     tp->lock_mutex();
  589.     tNode = tp->get_an_alive_node();
  590.     if (tNode == 0) {
  591.       theError.code = 4002;
  592.       releaseNdbCon(tNdbConn);
  593.       return -1;
  594.     }//if
  595.     ret_code = tp->sendSignal(&tSignal,aNode);
  596.     tp->unlock_mutex();
  597.     releaseNdbCon(tNdbConn);
  598.     return ret_code;
  599.   } else {
  600.     do {
  601.       tp->lock_mutex();
  602.       // Start protected area
  603.       tNode = tp->get_an_alive_node();
  604.       tp->unlock_mutex();
  605.       // End protected area
  606.       if (tNode == 0) {
  607.         theError.code = 4009;
  608.         releaseNdbCon(tNdbConn);
  609.         return -1;
  610.       }//if
  611.       ret_code = sendRecSignal(tNode, WAIT_NDB_TAMPER, &tSignal, 0);
  612.       if (ret_code == 0) {  
  613.         if (tNdbConn->Status() != NdbConnection::Connected) {
  614.           theRestartGCI = 0;
  615.         }//if
  616.         releaseNdbCon(tNdbConn);
  617.         return theRestartGCI;
  618.       } else if ((ret_code == -5) || (ret_code == -2)) {
  619.         TRACE_DEBUG("Continue DIHNDBTAMPER when node failed/stopping");
  620.       } else {
  621.         return -1;
  622.       }//if
  623.     } while (1);
  624.   }
  625.   return 0;
  626. #endif
  627. }
  628. #if 0
  629. /****************************************************************************
  630. NdbSchemaCon* startSchemaTransaction();
  632. Return Value:   Returns a pointer to a schema connection object.
  633.                 Return NULL otherwise.
  634. Remark:         Start schema transaction. Synchronous.
  635. ****************************************************************************/ 
  636. NdbSchemaCon* 
  637. Ndb::startSchemaTransaction()
  638. {
  639.   NdbSchemaCon* tSchemaCon;
  640.   if (theSchemaConToNdbList != NULL) {
  641.     theError.code = 4321;
  642.     return NULL;
  643.   }//if
  644.   tSchemaCon = new NdbSchemaCon(this);
  645.   if (tSchemaCon == NULL) {
  646.     theError.code = 4000;
  647.     return NULL;
  648.   }//if 
  649.   theSchemaConToNdbList = tSchemaCon;
  650.   return tSchemaCon;  
  651. }
  652. /*****************************************************************************
  653. void closeSchemaTransaction(NdbSchemaCon* aSchemaCon);
  655. Parameters:     aSchemaCon: the schemacon used in the transaction.
  656. Remark:         Close transaction by releasing the schemacon and all schemaop.
  657. *****************************************************************************/
  658. void
  659. Ndb::closeSchemaTransaction(NdbSchemaCon* aSchemaCon)
  660. {
  661.   if (theSchemaConToNdbList != aSchemaCon) {
  662.     abort();
  663.     return;
  664.   }//if
  665.   aSchemaCon->release();
  666.   delete aSchemaCon;
  667.   theSchemaConToNdbList = NULL;
  668.   return;
  669. }//Ndb::closeSchemaTransaction()
  670. #endif
  672. /*****************************************************************************
  673. void RestartGCI(int aRestartGCI);
  675. Remark: Set theRestartGCI on the NDB object
  676. *****************************************************************************/
  677. void
  678. Ndb::RestartGCI(int aRestartGCI)
  679. {
  680.   theRestartGCI = aRestartGCI;
  681. }
  683. /****************************************************************************
  684. int getBlockNumber(void);
  686. Remark:
  687. ****************************************************************************/
  688. int
  689. Ndb::getBlockNumber()
  690. {
  691.   return theNdbBlockNumber;
  692. }
  694. NdbDictionary::Dictionary *
  695. Ndb::getDictionary() const {
  696.   return theDictionary;
  697. }
  699. /****************************************************************************
  700. int getNodeId();
  702. Remark:
  703. ****************************************************************************/
  704. int
  705. Ndb::getNodeId()
  706. {
  707.   return theNode;
  708. }
  710. /****************************************************************************
  711. Uint64 getTupleIdFromNdb( Uint32 aTableId, Uint32 cacheSize );
  713. Parameters:     aTableId : The TableId.
  714.                 cacheSize: Prefetch this many values
  715. Remark: Returns a new TupleId to the application.
  716.                 The TupleId comes from SYSTAB_0 where SYSKEY_0 = TableId.
  717.                 It is initialized to (TableId << 48) + 1 in NdbcntrMain.cpp.
  718. ****************************************************************************/
  719. #define DEBUG_TRACE(msg) 
  720. //  ndbout << __FILE__ << " line: " << __LINE__ << " msg: " << msg << endl
  722. Uint64
  723. Ndb::getAutoIncrementValue(const char* aTableName, Uint32 cacheSize)
  724. {
  725.   DBUG_ENTER("getAutoIncrementValue");
  726.   const char * internalTableName = internalizeTableName(aTableName);
  727.   Ndb_local_table_info *info=
  728.     theDictionary->get_local_table_info(internalTableName, false);
  729.   if (info == 0)
  730.     DBUG_RETURN(~(Uint64)0);
  731.   const NdbTableImpl *table= info->m_table_impl;
  732.   Uint64 tupleId = getTupleIdFromNdb(table->m_tableId, cacheSize);
  733.   DBUG_PRINT("info", ("value %ul", (ulong) tupleId));
  734.   DBUG_RETURN(tupleId);
  735. }
  737. Uint64
  738. Ndb::getAutoIncrementValue(const NdbDictionary::Table * aTable, Uint32 cacheSize)
  739. {
  740.   DBUG_ENTER("getAutoIncrementValue");
  741.   if (aTable == 0)
  742.     DBUG_RETURN(~(Uint64)0);
  743.   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
  744.   Uint64 tupleId = getTupleIdFromNdb(table->m_tableId, cacheSize);
  745.   DBUG_PRINT("info", ("value %ul", (ulong) tupleId));
  746.   DBUG_RETURN(tupleId);
  747. }
  749. Uint64 
  750. Ndb::getTupleIdFromNdb(const char* aTableName, Uint32 cacheSize)
  751. {
  752.   const NdbTableImpl* table = theDictionary->getTable(aTableName);
  753.   if (table == 0)
  754.     return ~(Uint64)0;
  755.   return getTupleIdFromNdb(table->m_tableId, cacheSize);
  756. }
  758. Uint64
  759. Ndb::getTupleIdFromNdb(Uint32 aTableId, Uint32 cacheSize)
  760. {
  761.   DBUG_ENTER("getTupleIdFromNdb");
  762.   if ( theFirstTupleId[aTableId] != theLastTupleId[aTableId] )
  763.   {
  764.     theFirstTupleId[aTableId]++;
  765.     DBUG_PRINT("info", ("next cached value %ul", 
  766.                         (ulong) theFirstTupleId[aTableId]));
  767.     DBUG_RETURN(theFirstTupleId[aTableId]);
  768.   }
  769.   else // theFirstTupleId == theLastTupleId
  770.   {
  771.     DBUG_PRINT("info",("reading %u values from database", 
  772.                        (cacheSize == 0) ? 1 : cacheSize));
  773.     DBUG_RETURN(opTupleIdOnNdb(aTableId, (cacheSize == 0) ? 1 : cacheSize, 0));
  774.   }
  775. }
  777. Uint64
  778. Ndb::readAutoIncrementValue(const char* aTableName)
  779. {
  780.   DBUG_ENTER("readtAutoIncrementValue");
  781.   const NdbTableImpl* table = theDictionary->getTable(aTableName);
  782.   if (table == 0) {
  783.     theError= theDictionary->getNdbError();
  784.     DBUG_RETURN(~(Uint64)0);
  785.   }
  786.   Uint64 tupleId = readTupleIdFromNdb(table->m_tableId);
  787.   DBUG_PRINT("info", ("value %ul", (ulong) tupleId));
  788.   DBUG_RETURN(tupleId);
  789. }
  791. Uint64
  792. Ndb::readAutoIncrementValue(const NdbDictionary::Table * aTable)
  793. {
  794.   DBUG_ENTER("readtAutoIncrementValue");
  795.   if (aTable == 0)
  796.     DBUG_RETURN(~(Uint64)0);
  797.   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
  798.   Uint64 tupleId = readTupleIdFromNdb(table->m_tableId);
  799.   DBUG_PRINT("info", ("value %ul", (ulong) tupleId));
  800.   DBUG_RETURN(tupleId);
  801. }
  803. Uint64
  804. Ndb::readTupleIdFromNdb(Uint32 aTableId)
  805. {
  806.   if ( theFirstTupleId[aTableId] == theLastTupleId[aTableId] )
  807.     // Cache is empty, check next in database
  808.     return opTupleIdOnNdb(aTableId, 0, 3);
  810.   return theFirstTupleId[aTableId] + 1;
  811. }
  813. bool
  814. Ndb::setAutoIncrementValue(const char* aTableName, Uint64 val, bool increase)
  815. {
  816.   DEBUG_TRACE("setAutoIncrementValue " << val);
  817.   const char * internalTableName= internalizeTableName(aTableName);
  818.   Ndb_local_table_info *info=
  819.     theDictionary->get_local_table_info(internalTableName, false);
  820.   if (info == 0) {
  821.     theError= theDictionary->getNdbError();
  822.     return false;
  823.   }
  824.   const NdbTableImpl* table= info->m_table_impl;
  825.   return setTupleIdInNdb(table->m_tableId, val, increase);
  826. }
  828. bool
  829. Ndb::setAutoIncrementValue(const NdbDictionary::Table * aTable, Uint64 val, bool increase)
  830. {
  831.   DEBUG_TRACE("setAutoIncrementValue " << val);
  832.   if (aTable == 0)
  833.     return ~(Uint64)0;
  834.   const NdbTableImpl* table = & NdbTableImpl::getImpl(*aTable);
  835.   return setTupleIdInNdb(table->m_tableId, val, increase);
  836. }
  838. bool 
  839. Ndb::setTupleIdInNdb(const char* aTableName, Uint64 val, bool increase )
  840. {
  841.   DEBUG_TRACE("setTupleIdInNdb");
  842.   const NdbTableImpl* table = theDictionary->getTable(aTableName);
  843.   if (table == 0) {
  844.     theError= theDictionary->getNdbError();
  845.     return false;
  846.   }
  847.   return setTupleIdInNdb(table->m_tableId, val, increase);
  848. }
  850. bool
  851. Ndb::setTupleIdInNdb(Uint32 aTableId, Uint64 val, bool increase )
  852. {
  853.   DEBUG_TRACE("setTupleIdInNdb");
  854.   if (increase)
  855.   {
  856.     if (theFirstTupleId[aTableId] != theLastTupleId[aTableId])
  857.     {
  858.       // We have a cache sequence
  859.       if (val <= theFirstTupleId[aTableId]+1)
  860. return false;
  861.       if (val <= theLastTupleId[aTableId])
  862.       {
  863. theFirstTupleId[aTableId] = val - 1;
  864. return true;
  865.       }
  866.       // else continue;
  867.     }    
  868.     return (opTupleIdOnNdb(aTableId, val, 2) == val);
  869.   }
  870.   else
  871.     return (opTupleIdOnNdb(aTableId, val, 1) == val);
  872. }
  874. Uint64
  875. Ndb::opTupleIdOnNdb(Uint32 aTableId, Uint64 opValue, Uint32 op)
  876. {
  877.   DEBUG_TRACE("opTupleIdOnNdb");
  879.   NdbConnection*     tConnection;
  880.   NdbOperation*      tOperation;
  881.   Uint64             tValue;
  882.   NdbRecAttr*        tRecAttrResult;
  883.   int                result;
  884.   Uint64 ret;
  886.   CHECK_STATUS_MACRO_ZERO;
  888.   BaseString currentDb(getDatabaseName());
  889.   BaseString currentSchema(getDatabaseSchemaName());
  891.   setDatabaseName("sys");
  892.   setDatabaseSchemaName("def");
  893.   tConnection = this->startTransaction();
  894.   if (tConnection == NULL)
  895.     goto error_return;
  897.   if (usingFullyQualifiedNames())
  898.     tOperation = tConnection->getNdbOperation("SYSTAB_0");
  899.   else
  900.     tOperation = tConnection->getNdbOperation("sys/def/SYSTAB_0");
  901.   if (tOperation == NULL)
  902.     goto error_handler;
  904.   switch (op)
  905.     {
  906.     case 0:
  907.       tOperation->interpretedUpdateTuple();
  908.       tOperation->equal("SYSKEY_0", aTableId );
  909.       tOperation->incValue("NEXTID", opValue);
  910.       tRecAttrResult = tOperation->getValue("NEXTID");
  912.       if (tConnection->execute( Commit ) == -1 )
  913.         goto error_handler;
  915.       tValue = tRecAttrResult->u_64_value();
  917.       theFirstTupleId[aTableId] = tValue - opValue;
  918.       theLastTupleId[aTableId]  = tValue - 1;
  919.       ret = theFirstTupleId[aTableId];
  920.       break;
  921.     case 1:
  922.       tOperation->updateTuple();
  923.       tOperation->equal("SYSKEY_0", aTableId );
  924.       tOperation->setValue("NEXTID", opValue);
  926.       if (tConnection->execute( Commit ) == -1 )
  927.         goto error_handler;
  929.       theFirstTupleId[aTableId] = ~(Uint64)0;
  930.       theLastTupleId[aTableId]  = ~(Uint64)0;
  931.       ret = opValue;
  932.       break;
  933.     case 2:
  934.       tOperation->interpretedUpdateTuple();
  935.       tOperation->equal("SYSKEY_0", aTableId );
  936.       tOperation->load_const_u64(1, opValue);
  937.       tOperation->read_attr("NEXTID", 2);
  938.       tOperation->branch_le(2, 1, 0);
  939.       tOperation->write_attr("NEXTID", 1);
  940.       tOperation->interpret_exit_ok();
  941.       tOperation->def_label(0);
  942.       tOperation->interpret_exit_nok(9999);
  943.       
  944.       if ( (result = tConnection->execute( Commit )) == -1 )
  945.         goto error_handler;
  946.       
  947.       if (result == 9999)
  948.         ret = ~(Uint64)0;
  949.       else
  950.       {
  951.         theFirstTupleId[aTableId] = theLastTupleId[aTableId] = opValue - 1;
  952. ret = opValue;
  953.       }
  954.       break;
  955.     case 3:
  956.       tOperation->readTuple();
  957.       tOperation->equal("SYSKEY_0", aTableId );
  958.       tRecAttrResult = tOperation->getValue("NEXTID");
  959.       if (tConnection->execute( Commit ) == -1 )
  960.         goto error_handler;
  961.       ret = tRecAttrResult->u_64_value();
  962.       break;
  963.     default:
  964.       goto error_handler;
  965.     }
  967.   this->closeTransaction(tConnection);
  969.   // Restore current name space
  970.   setDatabaseName(currentDb.c_str());
  971.   setDatabaseSchemaName(currentSchema.c_str());
  973.   return ret;
  975.   error_handler:
  976.     theError.code = tConnection->theError.code;
  977.     this->closeTransaction(tConnection);
  978.   error_return:
  979.     // Restore current name space
  980.     setDatabaseName(currentDb.c_str());
  981.     setDatabaseSchemaName(currentSchema.c_str());
  983.   return ~(Uint64)0;
  984. }
  986. Uint32
  987. convertEndian(Uint32 Data)
  988. {
  989. #ifdef WORDS_BIGENDIAN
  990.   Uint32 t1, t2, t3, t4;
  991.   t4 = (Data >> 24) & 255;
  992.   t3 = (Data >> 16) & 255;
  993.   t4 = t4 + (t3 << 8);
  994.   t2 = (Data >> 8) & 255;
  995.   t4 = t4 + (t2 << 16);
  996.   t1 = Data & 255;
  997.   t4 = t4 + (t1 << 24);
  998.   return t4;
  999. #else
  1000.   return Data;
  1001. #endif
  1002. }
  1003. const char * Ndb::getCatalogName() const
  1004. {
  1005.   return theDataBase;
  1006. }
  1007.  
  1008. void Ndb::setCatalogName(const char * a_catalog_name)
  1009. {
  1010.   if (a_catalog_name) {
  1011.     BaseString::snprintf(theDataBase, sizeof(theDataBase), "%s",
  1012.              a_catalog_name ? a_catalog_name : "");
  1013.     
  1014.     int len = BaseString::snprintf(prefixName, sizeof(prefixName), "%s%c%s%c",
  1015.                        theDataBase, table_name_separator,
  1016.                        theDataBaseSchema, table_name_separator);
  1017.     prefixEnd = prefixName + (len < (int) sizeof(prefixName) ? len : 
  1018.                               sizeof(prefixName) - 1);
  1019.   }
  1020. }
  1021.  
  1022. const char * Ndb::getSchemaName() const
  1023. {
  1024.   return theDataBaseSchema;
  1025. }
  1026.  
  1027. void Ndb::setSchemaName(const char * a_schema_name)
  1028. {
  1029.   if (a_schema_name) {
  1030.     BaseString::snprintf(theDataBaseSchema, sizeof(theDataBase), "%s",
  1031.              a_schema_name ? a_schema_name : "");
  1033.     int len = BaseString::snprintf(prefixName, sizeof(prefixName), "%s%c%s%c",
  1034.                        theDataBase, table_name_separator,
  1035.                        theDataBaseSchema, table_name_separator);
  1036.     prefixEnd = prefixName + (len < (int) sizeof(prefixName) ? len : 
  1037.                               sizeof(prefixName) - 1);
  1038.   }
  1039. }
  1040.  
  1041. /*
  1042. Deprecated functions
  1043. */
  1044. const char * Ndb::getDatabaseName() const
  1045. {
  1046.   return getCatalogName();
  1047. }
  1048.  
  1049. void Ndb::setDatabaseName(const char * a_catalog_name)
  1050. {
  1051.   setCatalogName(a_catalog_name);
  1052. }
  1053.  
  1054. const char * Ndb::getDatabaseSchemaName() const
  1055. {
  1056.   return getSchemaName();
  1057. }
  1058.  
  1059. void Ndb::setDatabaseSchemaName(const char * a_schema_name)
  1060. {
  1061.   setSchemaName(a_schema_name);
  1062. }
  1063.  
  1064. bool Ndb::usingFullyQualifiedNames()
  1065. {
  1066.   return fullyQualifiedNames;
  1067. }
  1068.  
  1069. const char *
  1070. Ndb::externalizeTableName(const char * internalTableName, bool fullyQualifiedNames)
  1071. {
  1072.   if (fullyQualifiedNames) {
  1073.     register const char *ptr = internalTableName;
  1074.    
  1075.     // Skip database name
  1076.     while (*ptr && *ptr++ != table_name_separator);
  1077.     // Skip schema name
  1078.     while (*ptr && *ptr++ != table_name_separator);
  1079.     return ptr;
  1080.   }
  1081.   else
  1082.     return internalTableName;
  1083. }
  1085. const char *
  1086. Ndb::externalizeTableName(const char * internalTableName)
  1087. {
  1088.   return externalizeTableName(internalTableName, usingFullyQualifiedNames());
  1089. }
  1091. const char *
  1092. Ndb::externalizeIndexName(const char * internalIndexName, bool fullyQualifiedNames)
  1093. {
  1094.   if (fullyQualifiedNames) {
  1095.     register const char *ptr = internalIndexName;
  1096.    
  1097.     // Scan name from the end
  1098.     while (*ptr++); ptr--; // strend
  1099.     while (ptr >= internalIndexName && *ptr != table_name_separator)
  1100.       ptr--;
  1101.      
  1102.     return ptr + 1;
  1103.   }
  1104.   else
  1105.     return internalIndexName;
  1106. }
  1108. const char *
  1109. Ndb::externalizeIndexName(const char * internalIndexName)
  1110. {
  1111.   return externalizeIndexName(internalIndexName, usingFullyQualifiedNames());
  1112. }
  1114. const char *
  1115. Ndb::internalizeTableName(const char * externalTableName)
  1116. {
  1117.   if (fullyQualifiedNames) {
  1118.     strncpy(prefixEnd, externalTableName, NDB_MAX_TAB_NAME_SIZE);
  1119.     return prefixName;
  1120.   }
  1121.   else
  1122.     return externalTableName;
  1123. }
  1124.  
  1125. const char *
  1126. Ndb::internalizeIndexName(const NdbTableImpl * table,
  1127.                           const char * externalIndexName)
  1128. {
  1129.   if (fullyQualifiedNames) {
  1130.     char tableId[10];
  1131.     sprintf(tableId, "%d", table->m_tableId);
  1132.     Uint32 tabIdLen = strlen(tableId);
  1133.     strncpy(prefixEnd, tableId, tabIdLen);
  1134.     prefixEnd[tabIdLen] = table_name_separator;
  1135.     strncpy(prefixEnd + tabIdLen + 1, 
  1136.     externalIndexName, NDB_MAX_TAB_NAME_SIZE);
  1137.     return prefixName;
  1138.   }
  1139.   else
  1140.     return externalIndexName;
  1141. }
  1143. const BaseString
  1144. Ndb::getDatabaseFromInternalName(const char * internalName)
  1145. {
  1146.   char * databaseName = new char[strlen(internalName) + 1];
  1147.   strcpy(databaseName, internalName);
  1148.   register char *ptr = databaseName;
  1149.    
  1150.   /* Scan name for the first table_name_separator */
  1151.   while (*ptr && *ptr != table_name_separator)
  1152.     ptr++;
  1153.   *ptr = '';
  1154.   BaseString ret = BaseString(databaseName);
  1155.   delete [] databaseName;
  1156.   return ret;
  1157. }
  1158.  
  1159. const BaseString
  1160. Ndb::getSchemaFromInternalName(const char * internalName)
  1161. {
  1162.   char * schemaName = new char[strlen(internalName)];
  1163.   register const char *ptr1 = internalName;
  1164.    
  1165.   /* Scan name for the second table_name_separator */
  1166.   while (*ptr1 && *ptr1 != table_name_separator)
  1167.     ptr1++;
  1168.   strcpy(schemaName, ptr1 + 1);
  1169.   register char *ptr = schemaName;
  1170.   while (*ptr && *ptr != table_name_separator)
  1171.     ptr++;
  1172.   *ptr = '';
  1173.   BaseString ret = BaseString(schemaName);
  1174.   delete [] schemaName;
  1175.   return ret;
  1176. }
  1178. NdbEventOperation* Ndb::createEventOperation(const char* eventName,
  1179.      const int bufferLength)
  1180. {
  1181.   NdbEventOperation* tOp;
  1183.   tOp = new NdbEventOperation(this, eventName, bufferLength);
  1185.   if (tOp->getState() != NdbEventOperation::CREATED) {
  1186.     delete tOp;
  1187.     tOp = NULL;
  1188.   }
  1190.   //now we have to look up this event in dict
  1192.   return tOp;
  1193. }
  1195. int Ndb::dropEventOperation(NdbEventOperation* op) {
  1196.   delete op;
  1197.   return 0;
  1198. }
  1200. NdbGlobalEventBufferHandle* Ndb::getGlobalEventBufferHandle()
  1201. {
  1202.   return theGlobalEventBufferHandle;
  1203. }
  1205. //void Ndb::monitorEvent(NdbEventOperation *op, NdbEventCallback cb, void* rs)
  1206. //{
  1207. //}
  1209. int
  1210. Ndb::pollEvents(int aMillisecondNumber)
  1211. {
  1212.   return NdbEventOperation::wait(theGlobalEventBufferHandle,
  1213.  aMillisecondNumber);
  1214. }
  1216. #ifdef VM_TRACE
  1217. #include <NdbMutex.h>
  1218. extern NdbMutex *ndb_print_state_mutex;
  1220. static bool
  1221. checkdups(NdbConnection** list, unsigned no)
  1222. {
  1223.   for (unsigned i = 0; i < no; i++)
  1224.     for (unsigned j = i + 1; j < no; j++)
  1225.       if (list[i] == list[j])
  1226.         return true;
  1227.   return false;
  1228. }
  1229. void
  1230. Ndb::printState(const char* fmt, ...)
  1231. {
  1232.   char buf[200];
  1233.   va_list ap;
  1234.   va_start(ap, fmt);
  1235.   vsprintf(buf, fmt, ap);
  1236.   va_end(ap);
  1237.   NdbMutex_Lock(ndb_print_state_mutex);
  1238.   bool dups = false;
  1239.   unsigned i;
  1240.   ndbout << buf << " ndb=" << hex << this << dec;
  1241. #ifndef NDB_WIN32
  1242.   ndbout << " thread=" << (int)pthread_self();
  1243. #endif
  1244.   ndbout << endl;
  1245.   for (unsigned n = 0; n < MAX_NDB_NODES; n++) {
  1246.     NdbConnection* con = theConnectionArray[n];
  1247.     if (con != 0) {
  1248.       ndbout << "conn " << n << ":" << endl;
  1249.       while (con != 0) {
  1250.         con->printState();
  1251.         con = con->theNext;
  1252.       }
  1253.     }
  1254.   }
  1255.   ndbout << "prepared: " << theNoOfPreparedTransactions<< endl;
  1256.   if (checkdups(thePreparedTransactionsArray, theNoOfPreparedTransactions)) {
  1257.     ndbout << "!! DUPS !!" << endl;
  1258.     dups = true;
  1259.   }
  1260.   for (i = 0; i < theNoOfPreparedTransactions; i++)
  1261.     thePreparedTransactionsArray[i]->printState();
  1262.   ndbout << "sent: " << theNoOfSentTransactions<< endl;
  1263.   if (checkdups(theSentTransactionsArray, theNoOfSentTransactions)) {
  1264.     ndbout << "!! DUPS !!" << endl;
  1265.     dups = true;
  1266.   }
  1267.   for (i = 0; i < theNoOfSentTransactions; i++)
  1268.     theSentTransactionsArray[i]->printState();
  1269.   ndbout << "completed: " << theNoOfCompletedTransactions<< endl;
  1270.   if (checkdups(theCompletedTransactionsArray, theNoOfCompletedTransactions)) {
  1271.     ndbout << "!! DUPS !!" << endl;
  1272.     dups = true;
  1273.   }
  1274.   for (i = 0; i < theNoOfCompletedTransactions; i++)
  1275.     theCompletedTransactionsArray[i]->printState();
  1276.   NdbMutex_Unlock(ndb_print_state_mutex);
  1277. }
  1278. #endif