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

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

MySQL数据库

开发平台：

Visual C++

ndb_user_transaction3.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. extern "C" {
  20. #include "user_transaction.h"
  21. };
  23. #include "macros.h"
  24. #include "ndb_schema.hpp"
  25. #include "ndb_error.hpp"
  27. #include <time.h>
  28. #include <NdbApi.hpp>
  30. /**
  31.  * Transaction 1 - T1 
  32.  *
  33.  * Update location and changed by/time on a subscriber
  34.  *
  35.  * Input: 
  36.  *   SubscriberNumber,
  37.  *   Location,
  38.  *   ChangedBy,
  39.  *   ChangedTime
  40.  *
  41.  * Output:
  42.  */
  43. int
  44. T1(void * obj,
  45.    const SubscriberNumber number, 
  46.    const Location new_location, 
  47.    const ChangedBy changed_by, 
  48.    const ChangedTime changed_time,
  49.    BenchmarkTime * transaction_time){
  51.   Ndb * pNDB = (Ndb *) obj;
  53.   BenchmarkTime start;
  54.   get_time(&start);
  56.   int check;
  57.   NdbRecAttr * check2;
  59.   NdbConnection * MyTransaction = pNDB->startTransaction();
  60.   if (MyTransaction == NULL)   
  61.     error_handler("T1: startTranscation", pNDB->getNdbErrorString(), 0);
  62.   
  63.   NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  64.   CHECK_NULL(MyOperation, "T1: getNdbOperation", MyTransaction);
  65.   
  66.   check = MyOperation->updateTuple();
  67.   CHECK_MINUS_ONE(check, "T1: updateTuple", 
  68.   MyTransaction);
  69.   
  70.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  71.      number);
  72.   CHECK_MINUS_ONE(check, "T1: equal subscriber",
  73.   MyTransaction);
  75.   check = MyOperation->setValue(IND_SUBSCRIBER_LOCATION, 
  76. (char *)&new_location);
  77.   CHECK_MINUS_ONE(check, "T1: setValue location", 
  78.   MyTransaction);
  80.   check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY, 
  81. changed_by);
  82.   CHECK_MINUS_ONE(check, "T1: setValue changed_by", 
  83.   MyTransaction);
  85.   check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME, 
  86. changed_time);
  87.   CHECK_MINUS_ONE(check, "T1: setValue changed_time", 
  88.   MyTransaction);
  90.   check = MyTransaction->execute( Commit ); 
  91.   CHECK_MINUS_ONE(check, "T1: Commit", 
  92.   MyTransaction);
  93.   
  94.   pNDB->closeTransaction(MyTransaction);
  95.   
  96.   get_time(transaction_time);
  97.   time_diff(transaction_time, &start);
  98.   return 0;
  99. }
  101. /**
  102.  * Transaction 2 - T2
  103.  *
  104.  * Read from Subscriber:
  105.  *
  106.  * Input: 
  107.  *   SubscriberNumber
  108.  *
  109.  * Output:
  110.  *   Location
  111.  *   Changed by
  112.  *   Changed Timestamp
  113.  *   Name
  114.  */
  115. int
  116. T2(void * obj,
  117.    const SubscriberNumber number, 
  118.    Location * readLocation, 
  119.    ChangedBy changed_by, 
  120.    ChangedTime changed_time,
  121.    SubscriberName subscriberName,
  122.    BenchmarkTime * transaction_time){
  124.   Ndb * pNDB = (Ndb *) obj;
  126.   BenchmarkTime start;
  127.   get_time(&start);
  129.   int check;
  130.   NdbRecAttr * check2;
  132.   NdbConnection * MyTransaction = pNDB->startTransaction();
  133.   if (MyTransaction == NULL)   
  134.     error_handler("T2: startTranscation", pNDB->getNdbErrorString(), 0);
  135.   
  136.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  137.   CHECK_NULL(MyOperation, "T2: getNdbOperation", 
  138.      MyTransaction);
  139.   
  140.   
  141.   check = MyOperation->readTuple();
  142.   CHECK_MINUS_ONE(check, "T2: readTuple", 
  143.   MyTransaction);
  144.   
  145.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  146.      number);
  147.   CHECK_MINUS_ONE(check, "T2: equal subscriber",
  148.   MyTransaction);
  150.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  151. (char *)readLocation);
  152.   CHECK_NULL(check2, "T2: getValue location", 
  153.      MyTransaction);
  155.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  156.  changed_by);
  157.   CHECK_NULL(check2, "T2: getValue changed_by", 
  158.      MyTransaction);
  160.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  161.                                  changed_time);
  162.   CHECK_NULL(check2, "T2: getValue changed_time",
  163.      MyTransaction);
  165.   check2 = MyOperation->getValue(IND_SUBSCRIBER_NAME, 
  166. subscriberName);
  167.   CHECK_NULL(check2, "T2: getValue name", 
  168.      MyTransaction);
  170.   check = MyTransaction->execute( Commit ); 
  171.   CHECK_MINUS_ONE(check, "T2: Commit", 
  172.   MyTransaction);
  173.   
  174.   pNDB->closeTransaction(MyTransaction);
  175.   
  176.   get_time(transaction_time);
  177.   time_diff(transaction_time, &start);
  178.   return 0;
  179. }
  181. /**
  182.  * Transaction 3 - T3
  183.  *
  184.  * Read session details
  185.  *
  186.  * Input:
  187.  *   SubscriberNumber
  188.  *   ServerId
  189.  *   ServerBit
  190.  *
  191.  * Output:
  192.  *   BranchExecuted
  193.  *   SessionDetails
  194.  *   ChangedBy
  195.  *   ChangedTime
  196.  *   Location
  197.  */
  198. int
  199. T3(void * obj,
  200.    const SubscriberNumber   inNumber,
  201.    const SubscriberSuffix   inSuffix,
  202.    const ServerId           inServerId,
  203.    const ServerBit          inServerBit,
  204.    SessionDetails     outSessionDetails,
  205.    ChangedBy          outChangedBy,
  206.    ChangedTime        outChangedTime,
  207.    Location         * outLocation,
  208.    BranchExecuted   * outBranchExecuted,
  209.    BenchmarkTime    * outTransactionTime){
  210.   
  211.   Ndb * pNDB = (Ndb *) obj;
  213.   GroupId        groupId;
  214.   ActiveSessions sessions;
  215.   Permission     permission;
  217.   BenchmarkTime start;
  218.   get_time(&start);
  220.   int check;
  221.   NdbRecAttr * check2;
  223.   NdbConnection * MyTransaction = pNDB->startTransaction();
  224.   if (MyTransaction == NULL)   
  225.     error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), 0);
  226.   
  227.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  228.   CHECK_NULL(MyOperation, "T3-1: getNdbOperation", 
  229.      MyTransaction);
  230.   
  231.   
  232.   check = MyOperation->readTuple();
  233.   CHECK_MINUS_ONE(check, "T3-1: readTuple", 
  234.   MyTransaction);
  235.   
  236.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  237.      inNumber);
  238.   CHECK_MINUS_ONE(check, "T3-1: equal subscriber",
  239.   MyTransaction);
  241.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  242.  (char *)outLocation);
  243.   CHECK_NULL(check2, "T3-1: getValue location", 
  244.      MyTransaction);
  246.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  247.  outChangedBy);
  248.   CHECK_NULL(check2, "T3-1: getValue changed_by", 
  249.      MyTransaction);
  251.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  252.                                  outChangedTime);
  253.   CHECK_NULL(check2, "T3-1: getValue changed_time",
  254.      MyTransaction);
  256.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  257.  (char *)&groupId);
  258.   CHECK_NULL(check2, "T3-1: getValue group", 
  259.      MyTransaction);
  261.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  262.  (char *)&sessions);
  263.   CHECK_NULL(check2, "T3-1: getValue sessions", 
  264.      MyTransaction);
  265.   
  266.   check = MyTransaction->execute( NoCommit ); 
  267.   CHECK_MINUS_ONE(check, "T3-1: NoCommit", 
  268.   MyTransaction);
  269.   
  270.     /* Operation 2 */
  272.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  273.   CHECK_NULL(MyOperation, "T3-2: getNdbOperation", 
  274.      MyTransaction);
  275.   
  276.   
  277.   check = MyOperation->readTuple();
  278.   CHECK_MINUS_ONE(check, "T3-2: readTuple", 
  279.   MyTransaction);
  280.   
  281.   check = MyOperation->equal(IND_GROUP_ID,
  282.      (char*)&groupId);
  283.   CHECK_MINUS_ONE(check, "T3-2: equal group",
  284.   MyTransaction);
  285.   
  286.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_READ, 
  287.  (char *)&permission);
  288.   CHECK_NULL(check2, "T3-2: getValue allow_read", 
  289.      MyTransaction);
  291.   check = MyTransaction->execute( NoCommit ); 
  292.   CHECK_MINUS_ONE(check, "T3-2: NoCommit", 
  293.   MyTransaction);
  294.   
  295.   DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  297.   if(((permission & inServerBit) == inServerBit) &&
  298.      ((sessions   & inServerBit) == inServerBit)){
  299.     
  300.     DEBUG("reading - ");
  302.     /* Operation 3 */
  304.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  305.     CHECK_NULL(MyOperation, "T3-3: getNdbOperation", 
  306.        MyTransaction);
  307.     
  308.     check = MyOperation->readTuple();
  309.     CHECK_MINUS_ONE(check, "T3-3: readTuple", 
  310.     MyTransaction);
  311.     
  312.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  313.        (char*)inNumber);
  314.     CHECK_MINUS_ONE(check, "T3-3: equal number",
  315.     MyTransaction);
  317.     check = MyOperation->equal(IND_SESSION_SERVER,
  318.        (char*)&inServerId);
  319.     CHECK_MINUS_ONE(check, "T3-3: equal server id",
  320.     MyTransaction);
  321.     
  322.     check2 = MyOperation->getValue(IND_SESSION_DATA, 
  323.    (char *)outSessionDetails);
  324.     CHECK_NULL(check2, "T3-3: getValue session details", 
  325.        MyTransaction);
  326.     
  327.     /* Operation 4 */
  329.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  330.     CHECK_NULL(MyOperation, "T3-4: getNdbOperation", 
  331.        MyTransaction);
  332.     
  333.     check = MyOperation->interpretedUpdateTuple();
  334.     CHECK_MINUS_ONE(check, "T3-4: interpretedUpdateTuple", 
  335.     MyTransaction);
  336.     
  337.     check = MyOperation->equal(IND_SERVER_ID,
  338.        (char*)&inServerId);
  339.     CHECK_MINUS_ONE(check, "T3-4: equal serverId",
  340.     MyTransaction);
  342.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  343.        (char*)inSuffix);
  344.     CHECK_MINUS_ONE(check, "T3-4: equal suffix",
  345.     MyTransaction);
  347.     check = MyOperation->incValue(IND_SERVER_READS, (uint32)1);
  348.     CHECK_MINUS_ONE(check, "T3-4: inc value",
  349.     MyTransaction);
  350.     
  351.     (* outBranchExecuted) = 1;
  352.   } else {
  353.     (* outBranchExecuted) = 0;
  354.   }
  355.   DEBUG("commitn");
  356.   check = MyTransaction->execute( Commit ); 
  357.   CHECK_MINUS_ONE(check, "T3: Commit", 
  358.   MyTransaction);
  359.   
  360.   pNDB->closeTransaction(MyTransaction);
  361.   
  362.   get_time(outTransactionTime);
  363.   time_diff(outTransactionTime, &start);
  364.   return 0;
  365. }
  368. /**
  369.  * Transaction 4 - T4
  370.  * 
  371.  * Create session
  372.  *
  373.  * Input:
  374.  *   SubscriberNumber
  375.  *   ServerId
  376.  *   ServerBit
  377.  *   SessionDetails,
  378.  *   DoRollback
  379.  * Output:
  380.  *   ChangedBy
  381.  *   ChangedTime
  382.  *   Location
  383.  *   BranchExecuted
  384.  */
  385. int
  386. T4(void * obj,
  387.    const SubscriberNumber   inNumber,
  388.    const SubscriberSuffix   inSuffix,
  389.    const ServerId           inServerId,
  390.    const ServerBit          inServerBit,
  391.    const SessionDetails     inSessionDetails,
  392.    ChangedBy          outChangedBy,
  393.    ChangedTime        outChangedTime,
  394.    Location         * outLocation,
  395.    DoRollback         inDoRollback,
  396.    BranchExecuted   * outBranchExecuted,
  397.    BenchmarkTime    * outTransactionTime){
  399.   Ndb * pNDB = (Ndb *) obj;  
  401.   GroupId        groupId;
  402.   ActiveSessions sessions;
  403.   Permission     permission;
  405.   BenchmarkTime start;
  406.   get_time(&start);
  408.   int check;
  409.   NdbRecAttr * check2;
  411.   NdbConnection * MyTransaction = pNDB->startTransaction();
  412.   if (MyTransaction == NULL)   
  413.     error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), 0);
  415.   DEBUG3("T4(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  417.   NdbOperation * MyOperation = 0;
  419.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  420.   CHECK_NULL(MyOperation, "T4-1: getNdbOperation", 
  421.      MyTransaction);
  422.   
  423.   check = MyOperation->readTupleExclusive();
  424.   CHECK_MINUS_ONE(check, "T4-1: readTuple", 
  425.   MyTransaction);
  426.   
  427.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  428.      inNumber);
  429.   CHECK_MINUS_ONE(check, "T4-1: equal subscriber",
  430.   MyTransaction);
  432.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  433.  (char *)outLocation);
  434.   CHECK_NULL(check2, "T4-1: getValue location", 
  435.      MyTransaction);
  437.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  438.  outChangedBy);
  439.   CHECK_NULL(check2, "T4-1: getValue changed_by", 
  440.      MyTransaction);
  442.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  443.                                  outChangedTime);
  444.   CHECK_NULL(check2, "T4-1: getValue changed_time",
  445.      MyTransaction);
  447.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  448.  (char *)&groupId);
  449.   CHECK_NULL(check2, "T4-1: getValue group", 
  450.      MyTransaction);
  452.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  453.  (char *)&sessions);
  454.   CHECK_NULL(check2, "T4-1: getValue sessions", 
  455.      MyTransaction);
  456.   
  457.   check = MyTransaction->execute( NoCommit ); 
  458.   CHECK_MINUS_ONE(check, "T4-1: NoCommit", 
  459.   MyTransaction);
  461.     /* Operation 2 */
  462.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  463.   CHECK_NULL(MyOperation, "T4-2: getNdbOperation", 
  464.      MyTransaction);
  465.   
  466.   check = MyOperation->readTuple();
  467.   CHECK_MINUS_ONE(check, "T4-2: readTuple", 
  468.   MyTransaction);
  469.   
  470.   check = MyOperation->equal(IND_GROUP_ID,
  471.      (char*)&groupId);
  472.   CHECK_MINUS_ONE(check, "T4-2: equal group",
  473.   MyTransaction);
  474.   
  475.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_INSERT, 
  476.  (char *)&permission);
  477.   CHECK_NULL(check2, "T4-2: getValue allow_insert", 
  478.      MyTransaction);
  480.   check = MyTransaction->execute( NoCommit ); 
  481.   CHECK_MINUS_ONE(check, "T4-2: NoCommit", 
  482.   MyTransaction);
  483.   
  484.   if(((permission & inServerBit) == inServerBit) &&
  485.      ((sessions   & inServerBit) == 0)){
  487.     DEBUG("inserting - ");
  488.   
  489.     /* Operation 3 */
  490.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  491.     CHECK_NULL(MyOperation, "T4-3: getNdbOperation", 
  492.        MyTransaction);
  493.     
  494.     check = MyOperation->insertTuple();
  495.     CHECK_MINUS_ONE(check, "T4-3: insertTuple", 
  496.     MyTransaction);
  497.     
  498.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  499.        (char*)inNumber);
  500.     CHECK_MINUS_ONE(check, "T4-3: equal number",
  501.     MyTransaction);
  503.     check = MyOperation->equal(IND_SESSION_SERVER,
  504.        (char*)&inServerId);
  505.     CHECK_MINUS_ONE(check, "T4-3: equal server id",
  506.     MyTransaction);
  507.     
  508.     check = MyOperation->setValue(SESSION_DATA, 
  509.    (char *)inSessionDetails);
  510.     CHECK_MINUS_ONE(check, "T4-3: setValue session details", 
  511.        MyTransaction);
  513.     /* Operation 4 */
  514.     MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  515.     CHECK_NULL(MyOperation, "T4-4: getNdbOperation", 
  516.        MyTransaction);
  517.     
  518.     check = MyOperation->interpretedUpdateTuple();
  519.     CHECK_MINUS_ONE(check, "T4-4: interpretedUpdateTuple", 
  520.     MyTransaction);
  521.     
  522.     check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
  523.        (char*)inNumber);
  524.     CHECK_MINUS_ONE(check, "T4-4: equal number",
  525.     MyTransaction);
  527.     check = MyOperation->incValue(IND_SUBSCRIBER_SESSIONS, 
  528.   (uint32)inServerBit);
  529.     CHECK_MINUS_ONE(check, "T4-4: inc value",
  530.     MyTransaction);
  532.     /* Operation 5 */
  533.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  534.     CHECK_NULL(MyOperation, "T4-5: getNdbOperation", 
  535.        MyTransaction);
  536.     
  537.     check = MyOperation->interpretedUpdateTuple();
  538.     CHECK_MINUS_ONE(check, "T4-5: interpretedUpdateTuple", 
  539.     MyTransaction);
  540.     
  541.     check = MyOperation->equal(IND_SERVER_ID,
  542.        (char*)&inServerId);
  543.     CHECK_MINUS_ONE(check, "T4-5: equal serverId",
  544.     MyTransaction);
  546.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  547.        (char*)inSuffix);
  548.     CHECK_MINUS_ONE(check, "T4-5: equal suffix",
  549.     MyTransaction);
  551.     check = MyOperation->incValue(IND_SERVER_INSERTS, (uint32)1);
  552.     CHECK_MINUS_ONE(check, "T4-5: inc value",
  553.     MyTransaction);
  554.         
  555.     (* outBranchExecuted) = 1;
  556.   } else {
  557.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  558.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  559.     (* outBranchExecuted) = 0;
  560.   }
  562.   if(!inDoRollback){
  563.     DEBUG("commitn");
  564.     check = MyTransaction->execute( Commit ); 
  565.     CHECK_MINUS_ONE(check, "T4: Commit", 
  566.     MyTransaction);
  567.   } else {
  568.     DEBUG("rollbackn");
  569.     check = MyTransaction->execute(Rollback);
  570.     CHECK_MINUS_ONE(check, "T4:Rollback", 
  571.     MyTransaction);
  572.     
  573.   }
  574.   
  575.   pNDB->closeTransaction(MyTransaction);
  576.   
  577.   get_time(outTransactionTime);
  578.   time_diff(outTransactionTime, &start);
  579.   return 0;
  580. }
  583. /**
  584.  * Transaction 5 - T5
  585.  * 
  586.  * Delete session
  587.  *
  588.  * Input:
  589.  *   SubscriberNumber
  590.  *   ServerId
  591.  *   ServerBit
  592.  *   DoRollback
  593.  * Output:
  594.  *   ChangedBy
  595.  *   ChangedTime
  596.  *   Location
  597.  *   BranchExecuted
  598.  */
  599. int
  600. T5(void * obj,
  601.    const SubscriberNumber   inNumber,
  602.    const SubscriberSuffix   inSuffix,
  603.    const ServerId           inServerId,
  604.    const ServerBit          inServerBit,
  605.    ChangedBy          outChangedBy,
  606.    ChangedTime        outChangedTime,
  607.    Location         * outLocation,
  608.    DoRollback         inDoRollback,
  609.    BranchExecuted   * outBranchExecuted,
  610.    BenchmarkTime    * outTransactionTime){
  611.   
  612.   Ndb           * pNDB = (Ndb *) obj;  
  613.   NdbConnection * MyTransaction = 0;
  614.   NdbOperation  * MyOperation = 0;
  616.   GroupId        groupId;
  617.   ActiveSessions sessions;
  618.   Permission     permission;
  620.   BenchmarkTime start;
  621.   get_time(&start);
  623.   int check;
  624.   NdbRecAttr * check2;
  626.   MyTransaction = pNDB->startTransaction();
  627.   if (MyTransaction == NULL)   
  628.     error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), 0);
  630.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  631.   CHECK_NULL(MyOperation, "T5-1: getNdbOperation", 
  632.      MyTransaction);
  633.   
  634.   
  635.   check = MyOperation->readTupleExclusive();
  636.   CHECK_MINUS_ONE(check, "T5-1: readTuple", 
  637.   MyTransaction);
  638.   
  639.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  640.      inNumber);
  641.   CHECK_MINUS_ONE(check, "T5-1: equal subscriber",
  642.   MyTransaction);
  644.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  645.  (char *)outLocation);
  646.   CHECK_NULL(check2, "T5-1: getValue location", 
  647.      MyTransaction);
  649.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  650.  outChangedBy);
  651.   CHECK_NULL(check2, "T5-1: getValue changed_by", 
  652.      MyTransaction);
  654.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  655.                                  outChangedTime);
  656.   CHECK_NULL(check2, "T5-1: getValue changed_time",
  657.      MyTransaction);
  659.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  660.  (char *)&groupId);
  661.   CHECK_NULL(check2, "T5-1: getValue group", 
  662.      MyTransaction);
  664.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  665.  (char *)&sessions);
  666.   CHECK_NULL(check2, "T5-1: getValue sessions", 
  667.      MyTransaction);
  668.   
  669.   check = MyTransaction->execute( NoCommit ); 
  670.   CHECK_MINUS_ONE(check, "T5-1: NoCommit", 
  671.   MyTransaction);
  672.   
  673.     /* Operation 2 */
  675.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  676.   CHECK_NULL(MyOperation, "T5-2: getNdbOperation", 
  677.      MyTransaction);
  678.   
  679.   
  680.   check = MyOperation->readTuple();
  681.   CHECK_MINUS_ONE(check, "T5-2: readTuple", 
  682.   MyTransaction);
  683.   
  684.   check = MyOperation->equal(IND_GROUP_ID,
  685.      (char*)&groupId);
  686.   CHECK_MINUS_ONE(check, "T5-2: equal group",
  687.   MyTransaction);
  688.   
  689.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_DELETE, 
  690.  (char *)&permission);
  691.   CHECK_NULL(check2, "T5-2: getValue allow_delete", 
  692.      MyTransaction);
  693.   
  694.   check = MyTransaction->execute( NoCommit ); 
  695.   CHECK_MINUS_ONE(check, "T5-2: NoCommit", 
  696.   MyTransaction);
  697.   
  698.   DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  700.   if(((permission & inServerBit) == inServerBit) &&
  701.      ((sessions   & inServerBit) == inServerBit)){
  702.   
  703.     DEBUG("deleting - ");
  704.   
  705.     /* Operation 3 */
  706.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  707.     CHECK_NULL(MyOperation, "T5-3: getNdbOperation", 
  708.        MyTransaction);
  709.     
  710.     check = MyOperation->deleteTuple();
  711.     CHECK_MINUS_ONE(check, "T5-3: deleteTuple", 
  712.     MyTransaction);
  713.     
  714.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  715.        (char*)inNumber);
  716.     CHECK_MINUS_ONE(check, "T5-3: equal number",
  717.     MyTransaction);
  719.     check = MyOperation->equal(IND_SESSION_SERVER,
  720.        (char*)&inServerId);
  721.     CHECK_MINUS_ONE(check, "T5-3: equal server id",
  722.     MyTransaction);
  723.     
  724.     /* Operation 4 */
  725.     MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  726.     CHECK_NULL(MyOperation, "T5-4: getNdbOperation", 
  727.        MyTransaction);
  728.     
  729.     check = MyOperation->interpretedUpdateTuple();
  730.     CHECK_MINUS_ONE(check, "T5-4: interpretedUpdateTuple", 
  731.     MyTransaction);
  732.     
  733.     check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
  734.        (char*)inNumber);
  735.     CHECK_MINUS_ONE(check, "T5-4: equal number",
  736.     MyTransaction);
  738.     check = MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, 
  739.   (uint32)inServerBit);
  740.     CHECK_MINUS_ONE(check, "T5-4: dec value",
  741.     MyTransaction);
  742.         
  743.     /* Operation 5 */
  744.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  745.     CHECK_NULL(MyOperation, "T5-5: getNdbOperation", 
  746.        MyTransaction);
  747.     
  748.     
  749.     check = MyOperation->interpretedUpdateTuple();
  750.     CHECK_MINUS_ONE(check, "T5-5: interpretedUpdateTuple", 
  751.     MyTransaction);
  752.     
  753.     check = MyOperation->equal(IND_SERVER_ID,
  754.        (char*)&inServerId);
  755.     CHECK_MINUS_ONE(check, "T5-5: equal serverId",
  756.     MyTransaction);
  758.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  759.        (char*)inSuffix);
  760.     CHECK_MINUS_ONE(check, "T5-5: equal suffix",
  761.     MyTransaction);
  763.     check = MyOperation->incValue(IND_SERVER_DELETES, (uint32)1);
  764.     CHECK_MINUS_ONE(check, "T5-5: inc value",
  765.     MyTransaction);
  767.     (* outBranchExecuted) = 1;
  768.   } else {
  769.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  770.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  771.     (* outBranchExecuted) = 0;
  772.   }
  774.   if(!inDoRollback){
  775.     DEBUG("commitn");
  776.     check = MyTransaction->execute( Commit ); 
  777.     CHECK_MINUS_ONE(check, "T5: Commit", 
  778.     MyTransaction);
  779.   } else {
  780.     DEBUG("rollbackn");
  781.     check = MyTransaction->execute(Rollback);
  782.     CHECK_MINUS_ONE(check, "T5:Rollback", 
  783.     MyTransaction);
  784.     
  785.   }
  786.   
  787.   pNDB->closeTransaction(MyTransaction);
  788.   
  789.   get_time(outTransactionTime);
  790.   time_diff(outTransactionTime, &start);
  791.   return 0;
  792. }