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

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

MySQL数据库

开发平台：

Visual C++

ndb_user_transaction6.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. //#define DEBUG_ON
  19. #include <string.h>
  20. #include "userHandle.h"
  21. #include "userInterface.h"
  23. #include "macros.h"
  24. #include "ndb_schema.hpp"
  25. #include "ndb_error.hpp"
  27. #include <NdbApi.hpp>
  30. void
  31. userCheckpoint(UserHandle *uh){
  32. }
  34. inline
  35. NdbConnection *
  36. startTransaction(Ndb * pNDB, ServerId inServerId, const SubscriberNumber inNumber){
  37.   
  38.   const int keyDataLenBytes    = sizeof(ServerId)+SUBSCRIBER_NUMBER_LENGTH;
  39.   const int keyDataLen_64Words = keyDataLenBytes >> 3;
  41.   Uint64 keyDataBuf[keyDataLen_64Words+1]; // The "+1" is for rounding...
  42.   
  43.   char     * keyDataBuf_charP = (char *)&keyDataBuf[0];
  44.   Uint32  * keyDataBuf_wo32P = (Uint32 *)&keyDataBuf[0];
  45.   
  46.   // Server Id comes first
  47.   keyDataBuf_wo32P[0] = inServerId;
  48.   // Then subscriber number
  49.   memcpy(&keyDataBuf_charP[sizeof(ServerId)], inNumber, SUBSCRIBER_NUMBER_LENGTH);
  51.   return pNDB->startTransaction(0, keyDataBuf_charP, keyDataLenBytes);
  52. }
  54. /**
  55.  * Transaction 1 - T1 
  56.  *
  57.  * Update location and changed by/time on a subscriber
  58.  *
  59.  * Input: 
  60.  *   SubscriberNumber,
  61.  *   Location,
  62.  *   ChangedBy,
  63.  *   ChangedTime
  64.  *
  65.  * Output:
  66.  */
  67. void
  68. userTransaction_T1(UserHandle * uh,
  69.    SubscriberNumber number, 
  70.    Location new_location, 
  71.    ChangedBy changed_by, 
  72.    ChangedTime changed_time){
  73.   Ndb * pNDB = uh->pNDB;
  75.   DEBUG2("T1(%.*s):n", SUBSCRIBER_NUMBER_LENGTH, number);
  77.   int check;
  78.   NdbRecAttr * check2;
  80.   NdbConnection * MyTransaction = pNDB->startTransaction();
  81.   if (MyTransaction != NULL) {
  82.     NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  83.     if (MyOperation != NULL) {  
  84.       MyOperation->updateTuple();  
  85.       MyOperation->equal(IND_SUBSCRIBER_NUMBER,
  86.                          number);
  87.       MyOperation->setValue(IND_SUBSCRIBER_LOCATION, 
  88.             (char *)&new_location);
  89.       MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY, 
  90.     changed_by);
  91.       MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME, 
  92.     changed_time);
  93.       check = MyTransaction->execute( Commit );
  94.       if (check != -1) {
  95.         pNDB->closeTransaction(MyTransaction);
  96.         return;
  97.       } else {
  98.         CHECK_MINUS_ONE(check, "T1: Commit", 
  99.         MyTransaction);
  100.       }//if
  101.     } else {
  102.       CHECK_NULL(MyOperation, "T1: getNdbOperation", MyTransaction);
  103.     }//if
  104.   } else {
  105.     error_handler("T1-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError());
  106.   }//if
  107. }
  109. /**
  110.  * Transaction 2 - T2
  111.  *
  112.  * Read from Subscriber:
  113.  *
  114.  * Input: 
  115.  *   SubscriberNumber
  116.  *
  117.  * Output:
  118.  *   Location
  119.  *   Changed by
  120.  *   Changed Timestamp
  121.  *   Name
  122.  */
  123. void
  124. userTransaction_T2(UserHandle * uh,
  125.    SubscriberNumber number, 
  126.    Location * readLocation, 
  127.    ChangedBy changed_by, 
  128.    ChangedTime changed_time,
  129.    SubscriberName subscriberName){
  130.   Ndb * pNDB = uh->pNDB;
  132.   DEBUG2("T2(%.*s):n", SUBSCRIBER_NUMBER_LENGTH, number);
  134.   int check;
  135.   NdbRecAttr * check2;
  137.   NdbConnection * MyTransaction = pNDB->startTransaction();
  138.   if (MyTransaction == NULL)   
  139.     error_handler("T2-1: startTransaction", pNDB->getNdbErrorString(), pNDB->getNdbError());
  141.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  142.   CHECK_NULL(MyOperation, "T2: getNdbOperation", 
  143.      MyTransaction);
  144.   
  145.   MyOperation->readTuple();
  146.   MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  147.      number);
  148.   MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  149. (char *)readLocation);
  150.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  151. changed_by);
  152.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  153.                         changed_time);
  154.   MyOperation->getValue(IND_SUBSCRIBER_NAME, 
  155. subscriberName);
  156.   check = MyTransaction->execute( Commit ); 
  157.   CHECK_MINUS_ONE(check, "T2: Commit", 
  158.   MyTransaction);  
  159.   pNDB->closeTransaction(MyTransaction);
  160. }
  162. /**
  163.  * Transaction 3 - T3
  164.  *
  165.  * Read session details
  166.  *
  167.  * Input:
  168.  *   SubscriberNumber
  169.  *   ServerId
  170.  *   ServerBit
  171.  *
  172.  * Output:
  173.  *   BranchExecuted
  174.  *   SessionDetails
  175.  *   ChangedBy
  176.  *   ChangedTime
  177.  *   Location
  178.  */
  179. void
  180. userTransaction_T3(UserHandle * uh,
  181.    SubscriberNumber   inNumber,
  182.    ServerId           inServerId,
  183.    ServerBit          inServerBit,
  184.    SessionDetails     outSessionDetails,
  185.    BranchExecuted   * outBranchExecuted){
  186.   Ndb * pNDB = uh->pNDB;
  188.   char               outChangedBy   [sizeof(ChangedBy)  +(4-(sizeof(ChangedBy)   & 3))];
  189.   char               outChangedTime [sizeof(ChangedTime)+(4-(sizeof(ChangedTime) & 3))];
  190.   Location           outLocation;
  191.   GroupId            groupId;
  192.   ActiveSessions     sessions;
  193.   Permission         permission;
  194.   SubscriberSuffix   inSuffix;
  196.   DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  198.   int check;
  199.   NdbRecAttr * check2;
  201.   NdbConnection * MyTransaction = startTransaction(pNDB, inServerId, inNumber);
  202.   if (MyTransaction == NULL)   
  203.     error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError());
  205.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  206.   CHECK_NULL(MyOperation, "T3-1: getNdbOperation", 
  207.      MyTransaction);
  208.     
  209.   MyOperation->readTuple();
  210.   MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  211.      inNumber);
  212.   MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  213. (char *)&outLocation);
  214.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  215. outChangedBy);
  216.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  217.                         outChangedTime);
  218.   MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  219. (char *)&groupId);
  220.   MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  221. (char *)&sessions);
  222.   check = MyTransaction->execute( NoCommit ); 
  223.   CHECK_MINUS_ONE(check, "T3-1: NoCommit", 
  224.   MyTransaction);
  225.   
  226.     /* Operation 2 */
  228.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  229.   CHECK_NULL(MyOperation, "T3-2: getNdbOperation", 
  230.      MyTransaction);
  231.   
  232.   
  233.   MyOperation->readTuple();
  234.   MyOperation->equal(IND_GROUP_ID,
  235.      (char*)&groupId);
  236.   MyOperation->getValue(IND_GROUP_ALLOW_READ, 
  237. (char *)&permission);
  238.   check = MyTransaction->execute( NoCommit ); 
  239.   CHECK_MINUS_ONE(check, "T3-2: NoCommit", 
  240.   MyTransaction);
  241.   
  242.   if(((permission & inServerBit) == inServerBit) &&
  243.      ((sessions   & inServerBit) == inServerBit)){
  245.     memcpy(inSuffix,
  246.    &inNumber[SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  247.     DEBUG2("reading(%.*s) - ", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, inSuffix);
  248.     
  249.     /* Operation 3 */
  250.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  251.     CHECK_NULL(MyOperation, "T3-3: getNdbOperation", 
  252.        MyTransaction);
  253.     
  254.     MyOperation->simpleRead();
  255.   
  256.     MyOperation->equal(IND_SESSION_SUBSCRIBER,
  257.        (char*)inNumber);
  258.     MyOperation->equal(IND_SESSION_SERVER,
  259.        (char*)&inServerId);
  260.     MyOperation->getValue(IND_SESSION_DATA, 
  261.   (char *)outSessionDetails);
  262.     /* Operation 4 */
  263.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  264.     CHECK_NULL(MyOperation, "T3-4: getNdbOperation", 
  265.        MyTransaction);
  266.     
  267.     MyOperation->interpretedUpdateTuple();
  268.     MyOperation->equal(IND_SERVER_ID,
  269.        (char*)&inServerId);
  270.     MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  271.         (char*)inSuffix);
  272.     MyOperation->incValue(IND_SERVER_READS, (uint32)1);
  273.     (* outBranchExecuted) = 1;
  274.   } else {
  275.     (* outBranchExecuted) = 0;
  276.   }
  277.   DEBUG("commit...");
  278.   check = MyTransaction->execute( Commit ); 
  279.   CHECK_MINUS_ONE(check, "T3: Commit", 
  280.   MyTransaction);
  281.   
  282.   pNDB->closeTransaction(MyTransaction);
  283.   
  284.   DEBUG("donen");
  285. }
  288. /**
  289.  * Transaction 4 - T4
  290.  * 
  291.  * Create session
  292.  *
  293.  * Input:
  294.  *   SubscriberNumber
  295.  *   ServerId
  296.  *   ServerBit
  297.  *   SessionDetails,
  298.  *   DoRollback
  299.  * Output:
  300.  *   ChangedBy
  301.  *   ChangedTime
  302.  *   Location
  303.  *   BranchExecuted
  304.  */
  305. void
  306. userTransaction_T4(UserHandle * uh,
  307.    SubscriberNumber   inNumber,
  308.    ServerId           inServerId,
  309.    ServerBit          inServerBit,
  310.    SessionDetails     inSessionDetails,
  311.    DoRollback         inDoRollback,
  312.    BranchExecuted   * outBranchExecuted){
  313.   
  314.   Ndb * pNDB = uh->pNDB;
  315.   
  316.   char               outChangedBy   [sizeof(ChangedBy)  +(4-(sizeof(ChangedBy)   & 3))];
  317.   char               outChangedTime [sizeof(ChangedTime)+(4-(sizeof(ChangedTime) & 3))];
  318.   Location         outLocation;
  319.   GroupId          groupId;
  320.   ActiveSessions   sessions;
  321.   Permission       permission;
  322.   SubscriberSuffix inSuffix;
  324.   DEBUG3("T4(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  326.   int check;
  327.   NdbRecAttr * check2;
  329.   NdbConnection * MyTransaction = startTransaction(pNDB, inServerId, inNumber);
  330.   if (MyTransaction == NULL)   
  331.     error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError());
  333.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  334.   CHECK_NULL(MyOperation, "T4-1: getNdbOperation", 
  335.      MyTransaction);
  336.   
  337.   MyOperation->interpretedUpdateTuple();
  338.   MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  339.      inNumber);
  340.   MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  341. (char *)&outLocation);
  342.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  343.         outChangedBy);
  344.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  345.                         outChangedTime);
  346.   MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  347. (char *)&groupId);
  348.   MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  349. (char *)&sessions); 
  350.   MyOperation->incValue(IND_SUBSCRIBER_SESSIONS, 
  351. (uint32)inServerBit);
  352.   check = MyTransaction->execute( NoCommit ); 
  354.     /* Operation 2 */
  356.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  357.   CHECK_NULL(MyOperation, "T4-2: getNdbOperation", 
  358.      MyTransaction);
  359.   
  360.   MyOperation->readTuple();
  361.   MyOperation->equal(IND_GROUP_ID,
  362.      (char*)&groupId);
  363.   MyOperation->getValue(IND_GROUP_ALLOW_INSERT, 
  364. (char *)&permission);
  365.   check = MyTransaction->execute( NoCommit ); 
  366.   CHECK_MINUS_ONE(check, "T4-2: NoCommit", 
  367.   MyTransaction);
  368.   
  369.   if(((permission & inServerBit) == inServerBit) &&
  370.      ((sessions   & inServerBit) == 0)){
  371.   
  372.     memcpy(inSuffix,
  373.    &inNumber[SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  375.     DEBUG2("inserting(%.*s) - ", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, inSuffix);
  376.   
  377.     /* Operation 3 */
  378.     
  379.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  380.     CHECK_NULL(MyOperation, "T4-3: getNdbOperation", 
  381.        MyTransaction);
  382.     
  383.     MyOperation->insertTuple();
  384.     MyOperation->equal(IND_SESSION_SUBSCRIBER,
  385.       (char*)inNumber);
  386.     MyOperation->equal(IND_SESSION_SERVER,
  387.        (char*)&inServerId);
  388.     MyOperation->setValue(SESSION_DATA, 
  389.   (char *)inSessionDetails);
  390.     /* Operation 4 */
  392.     /* Operation 5 */
  393.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  394.     CHECK_NULL(MyOperation, "T4-5: getNdbOperation", 
  395.        MyTransaction);
  396.     
  397.     MyOperation->interpretedUpdateTuple();
  398.     MyOperation->equal(IND_SERVER_ID,
  399.        (char*)&inServerId);
  400.     MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  401.        (char*)inSuffix);
  402.     MyOperation->incValue(IND_SERVER_INSERTS, (uint32)1);
  403.     (* outBranchExecuted) = 1;
  404.   } else {
  405.     (* outBranchExecuted) = 0;
  406.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  407.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  408.   }
  410.   if(!inDoRollback && (* outBranchExecuted)){
  411.     DEBUG("commitn");
  412.     check = MyTransaction->execute( Commit ); 
  413.     CHECK_MINUS_ONE(check, "T4: Commit", 
  414.     MyTransaction);
  415.   } else {
  416.     DEBUG("rollbackn");
  417.     check = MyTransaction->execute(Rollback);
  418.     CHECK_MINUS_ONE(check, "T4:Rollback", 
  419.     MyTransaction);
  420.     
  421.   }
  422.   
  423.   pNDB->closeTransaction(MyTransaction);
  424. }
  427. /**
  428.  * Transaction 5 - T5
  429.  * 
  430.  * Delete session
  431.  *
  432.  * Input:
  433.  *   SubscriberNumber
  434.  *   ServerId
  435.  *   ServerBit
  436.  *   DoRollback
  437.  * Output:
  438.  *   ChangedBy
  439.  *   ChangedTime
  440.  *   Location
  441.  *   BranchExecuted
  442.  */
  443. void
  444. userTransaction_T5(UserHandle * uh,
  445.    SubscriberNumber   inNumber,
  446.    ServerId           inServerId,
  447.    ServerBit          inServerBit,
  448.    DoRollback         inDoRollback,
  449.    BranchExecuted   * outBranchExecuted){
  450.   Ndb * pNDB = uh->pNDB;
  452.   DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  454.   NdbConnection * MyTransaction = 0;
  455.   NdbOperation  * MyOperation = 0;
  457.   char             outChangedBy   [sizeof(ChangedBy)  +(4-(sizeof(ChangedBy)   & 3))];
  458.   char             outChangedTime [sizeof(ChangedTime)+(4-(sizeof(ChangedTime) & 3))];
  459.   Location         outLocation;
  460.   GroupId          groupId;
  461.   ActiveSessions   sessions;
  462.   Permission       permission;
  463.   SubscriberSuffix inSuffix;
  465.   int check;
  466.   NdbRecAttr * check2;
  468.   MyTransaction = pNDB->startTransaction();
  469.   if (MyTransaction == NULL)   
  470.     error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), pNDB->getNdbError());
  471.   
  472.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  473.   CHECK_NULL(MyOperation, "T5-1: getNdbOperation", 
  474.      MyTransaction);
  475.   
  476.   MyOperation->interpretedUpdateTuple();
  477.   MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  478.      inNumber);
  479.   MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  480.         (char *)&outLocation);
  481.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  482. &outChangedBy[0]);
  483.   MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  484.                         &outChangedTime[0]);
  485.   MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  486.         (char *)&groupId);
  487.   MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  488.         (char *)&sessions);
  489.   MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, 
  490.         (uint32)inServerBit);
  491.   MyTransaction->execute( NoCommit ); 
  492.     /* Operation 2 */
  494.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  495.   CHECK_NULL(MyOperation, "T5-2: getNdbOperation", 
  496.      MyTransaction);
  497.     
  498.   MyOperation->readTuple();
  499.   MyOperation->equal(IND_GROUP_ID,
  500.      (char*)&groupId);
  501.   MyOperation->getValue(IND_GROUP_ALLOW_DELETE, 
  502. (char *)&permission);
  503.   check = MyTransaction->execute( NoCommit ); 
  504.   CHECK_MINUS_ONE(check, "T5-2: NoCommit", 
  505.   MyTransaction);
  506.   
  507.   if(((permission & inServerBit) == inServerBit) &&
  508.      ((sessions   & inServerBit) == inServerBit)){
  509.   
  510.     memcpy(inSuffix,
  511.    &inNumber[SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  512.     
  513.     DEBUG2("deleting(%.*s) - ", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, inSuffix);
  515.     /* Operation 3 */
  516.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  517.     CHECK_NULL(MyOperation, "T5-3: getNdbOperation", 
  518.        MyTransaction);
  519.     
  520.     MyOperation->deleteTuple();
  521.     MyOperation->equal(IND_SESSION_SUBSCRIBER,
  522.        (char*)inNumber);
  523.     MyOperation->equal(IND_SESSION_SERVER,
  524.        (char*)&inServerId);
  525.     /* Operation 4 */
  526.         
  527.     /* Operation 5 */
  528.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  529.     CHECK_NULL(MyOperation, "T5-5: getNdbOperation", 
  530.        MyTransaction);
  531.     
  532.     
  533.     MyOperation->interpretedUpdateTuple();
  534.     MyOperation->equal(IND_SERVER_ID,
  535.        (char*)&inServerId);
  536.     MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  537.        (char*)inSuffix);
  538.     MyOperation->incValue(IND_SERVER_DELETES, (uint32)1);
  539.     (* outBranchExecuted) = 1;
  540.   } else {
  541.     (* outBranchExecuted) = 0;
  542.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  543.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  544.   }
  546.   if(!inDoRollback && (* outBranchExecuted)){
  547.     DEBUG("commitn");
  548.     check = MyTransaction->execute( Commit ); 
  549.     CHECK_MINUS_ONE(check, "T5: Commit", 
  550.     MyTransaction);
  551.   } else {
  552.     DEBUG("rollbackn");
  553.     check = MyTransaction->execute(Rollback);
  554.     CHECK_MINUS_ONE(check, "T5:Rollback", 
  555.     MyTransaction);
  556.     
  557.   }
  558.   
  559.   pNDB->closeTransaction(MyTransaction);
  560. }