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

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

MySQL数据库

开发平台：

Visual C++

ndb_user_transaction5.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.   DEBUG2("T1(%.*s):n", SUBSCRIBER_NUMBER_LENGTH, number);
  55.   BenchmarkTime start;
  56.   get_time(&start);
  58.   int check;
  59.   NdbRecAttr * check2;
  61.   NdbConnection * MyTransaction = pNDB->startTransaction();
  62.   if (MyTransaction == NULL)   
  63.     error_handler("T1-1: startTranscation", pNDB->getNdbErrorString(), 0);
  65.   NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  66.   CHECK_NULL(MyOperation, "T1: getNdbOperation", MyTransaction);
  67.   
  68.   check = MyOperation->updateTuple();
  69.   CHECK_MINUS_ONE(check, "T1: updateTuple", 
  70.   MyTransaction);
  71.   
  72.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  73.      number);
  74.   CHECK_MINUS_ONE(check, "T1: equal subscriber",
  75.   MyTransaction);
  77.   check = MyOperation->setValue(IND_SUBSCRIBER_LOCATION, 
  78. (char *)&new_location);
  79.   CHECK_MINUS_ONE(check, "T1: setValue location", 
  80.   MyTransaction);
  82.   check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY, 
  83. changed_by);
  84.   CHECK_MINUS_ONE(check, "T1: setValue changed_by", 
  85.   MyTransaction);
  87.   check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME, 
  88. changed_time);
  89.   CHECK_MINUS_ONE(check, "T1: setValue changed_time", 
  90.   MyTransaction);
  92.   check = MyTransaction->execute( Commit ); 
  93.   CHECK_MINUS_ONE(check, "T1: Commit", 
  94.   MyTransaction);
  95.   
  96.   pNDB->closeTransaction(MyTransaction);
  97.   
  98.   get_time(transaction_time);
  99.   time_diff(transaction_time, &start);
  100.   return 0;
  101. }
  103. /**
  104.  * Transaction 2 - T2
  105.  *
  106.  * Read from Subscriber:
  107.  *
  108.  * Input: 
  109.  *   SubscriberNumber
  110.  *
  111.  * Output:
  112.  *   Location
  113.  *   Changed by
  114.  *   Changed Timestamp
  115.  *   Name
  116.  */
  117. int
  118. T2(void * obj,
  119.    const SubscriberNumber number, 
  120.    Location * readLocation, 
  121.    ChangedBy changed_by, 
  122.    ChangedTime changed_time,
  123.    SubscriberName subscriberName,
  124.    BenchmarkTime * transaction_time){
  126.   Ndb * pNDB = (Ndb *) obj;
  128.   DEBUG2("T2(%.*s):n", SUBSCRIBER_NUMBER_LENGTH, number);
  130.   BenchmarkTime start;
  131.   get_time(&start);
  133.   int check;
  134.   NdbRecAttr * check2;
  136.   NdbConnection * MyTransaction = pNDB->startTransaction();
  137.   if (MyTransaction == NULL)   
  138.     error_handler("T2-1: startTranscation", pNDB->getNdbErrorString(), 0);
  140.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  141.   CHECK_NULL(MyOperation, "T2: getNdbOperation", 
  142.      MyTransaction);
  143.   
  144.   
  145.   check = MyOperation->readTuple();
  146.   CHECK_MINUS_ONE(check, "T2: readTuple", 
  147.   MyTransaction);
  148.   
  149.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  150.      number);
  151.   CHECK_MINUS_ONE(check, "T2: equal subscriber",
  152.   MyTransaction);
  154.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  155. (char *)readLocation);
  156.   CHECK_NULL(check2, "T2: getValue location", 
  157.      MyTransaction);
  159.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  160.  changed_by);
  161.   CHECK_NULL(check2, "T2: getValue changed_by", 
  162.      MyTransaction);
  164.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  165.                                  changed_time);
  166.   CHECK_NULL(check2, "T2: getValue changed_time",
  167.      MyTransaction);
  169.   check2 = MyOperation->getValue(IND_SUBSCRIBER_NAME, 
  170. subscriberName);
  171.   CHECK_NULL(check2, "T2: getValue name", 
  172.      MyTransaction);
  174.   check = MyTransaction->execute( Commit ); 
  175.   CHECK_MINUS_ONE(check, "T2: Commit", 
  176.   MyTransaction);
  177.   
  178.   pNDB->closeTransaction(MyTransaction);
  179.   
  180.   get_time(transaction_time);
  181.   time_diff(transaction_time, &start);
  182.   return 0;
  183. }
  185. /**
  186.  * Transaction 3 - T3
  187.  *
  188.  * Read session details
  189.  *
  190.  * Input:
  191.  *   SubscriberNumber
  192.  *   ServerId
  193.  *   ServerBit
  194.  *
  195.  * Output:
  196.  *   BranchExecuted
  197.  *   SessionDetails
  198.  *   ChangedBy
  199.  *   ChangedTime
  200.  *   Location
  201.  */
  202. int
  203. T3(void * obj,
  204.    const SubscriberNumber   inNumber,
  205.    const SubscriberSuffix   inSuffix,
  206.    const ServerId           inServerId,
  207.    const ServerBit          inServerBit,
  208.    SessionDetails     outSessionDetails,
  209.    ChangedBy          outChangedBy,
  210.    ChangedTime        outChangedTime,
  211.    Location         * outLocation,
  212.    BranchExecuted   * outBranchExecuted,
  213.    BenchmarkTime    * outTransactionTime){
  214.   
  215.   Ndb * pNDB = (Ndb *) obj;
  217.   GroupId        groupId;
  218.   ActiveSessions sessions;
  219.   Permission     permission;
  221.   BenchmarkTime start;
  222.   get_time(&start);
  224.   int check;
  225.   NdbRecAttr * check2;
  227.   NdbConnection * MyTransaction = pNDB->startTransaction();
  228.   if (MyTransaction == NULL)   
  229.     error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), 0);
  231.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  232.   CHECK_NULL(MyOperation, "T3-1: getNdbOperation", 
  233.      MyTransaction);
  234.     
  235.   check = MyOperation->readTuple();
  236.   CHECK_MINUS_ONE(check, "T3-1: readTuple", 
  237.   MyTransaction);
  238.   
  239.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  240.      inNumber);
  241.   CHECK_MINUS_ONE(check, "T3-1: equal subscriber",
  242.   MyTransaction);
  244.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  245.  (char *)outLocation);
  246.   CHECK_NULL(check2, "T3-1: getValue location", 
  247.      MyTransaction);
  249.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  250.  outChangedBy);
  251.   CHECK_NULL(check2, "T3-1: getValue changed_by", 
  252.      MyTransaction);
  254.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  255.                                  outChangedTime);
  256.   CHECK_NULL(check2, "T3-1: getValue changed_time",
  257.      MyTransaction);
  259.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  260.  (char *)&groupId);
  261.   CHECK_NULL(check2, "T3-1: getValue group", 
  262.      MyTransaction);
  264.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  265.  (char *)&sessions);
  266.   CHECK_NULL(check2, "T3-1: getValue sessions", 
  267.      MyTransaction);
  268.   
  269.   check = MyTransaction->execute( NoCommit ); 
  270.   CHECK_MINUS_ONE(check, "T3-1: NoCommit", 
  271.   MyTransaction);
  272.   
  273.     /* Operation 2 */
  275.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  276.   CHECK_NULL(MyOperation, "T3-2: getNdbOperation", 
  277.      MyTransaction);
  278.   
  279.   
  280.   check = MyOperation->readTuple();
  281.   CHECK_MINUS_ONE(check, "T3-2: readTuple", 
  282.   MyTransaction);
  283.   
  284.   check = MyOperation->equal(IND_GROUP_ID,
  285.      (char*)&groupId);
  286.   CHECK_MINUS_ONE(check, "T3-2: equal group",
  287.   MyTransaction);
  288.   
  289.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_READ, 
  290.  (char *)&permission);
  291.   CHECK_NULL(check2, "T3-2: getValue allow_read", 
  292.      MyTransaction);
  294.   check = MyTransaction->execute( NoCommit ); 
  295.   CHECK_MINUS_ONE(check, "T3-2: NoCommit", 
  296.   MyTransaction);
  297.   
  298.   DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  300.   if(((permission & inServerBit) == inServerBit) &&
  301.      ((sessions   & inServerBit) == inServerBit)){
  302.     
  303.     DEBUG("reading - ");
  305.     /* Operation 3 */
  306.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  307.     CHECK_NULL(MyOperation, "T3-3: getNdbOperation", 
  308.        MyTransaction);
  309.     
  310.     check = MyOperation->simpleRead();
  311.     CHECK_MINUS_ONE(check, "T3-3: readTuple", 
  312.     MyTransaction);
  313.     
  314.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  315.        (char*)inNumber);
  316.     CHECK_MINUS_ONE(check, "T3-3: equal number",
  317.     MyTransaction);
  319.     check = MyOperation->equal(IND_SESSION_SERVER,
  320.        (char*)&inServerId);
  321.     CHECK_MINUS_ONE(check, "T3-3: equal server id",
  322.     MyTransaction);
  323.     
  324.     check2 = MyOperation->getValue(IND_SESSION_DATA, 
  325.    (char *)outSessionDetails);
  326.     CHECK_NULL(check2, "T3-3: getValue session details", 
  327.        MyTransaction);
  328.     
  329.     /* Operation 4 */
  330.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  331.     CHECK_NULL(MyOperation, "T3-4: getNdbOperation", 
  332.        MyTransaction);
  333.     
  334.     check = MyOperation->interpretedUpdateTuple();
  335.     CHECK_MINUS_ONE(check, "T3-4: interpretedUpdateTuple", 
  336.     MyTransaction);
  337.     
  338.     check = MyOperation->equal(IND_SERVER_ID,
  339.        (char*)&inServerId);
  340.     CHECK_MINUS_ONE(check, "T3-4: equal serverId",
  341.     MyTransaction);
  343.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  344.        (char*)inSuffix);
  345.     CHECK_MINUS_ONE(check, "T3-4: equal suffix",
  346.     MyTransaction);
  348.     check = MyOperation->incValue(IND_SERVER_READS, (uint32)1);
  349.     CHECK_MINUS_ONE(check, "T3-4: inc value",
  350.     MyTransaction);
  351.     (* outBranchExecuted) = 1;
  352.   } else {
  353.     (* outBranchExecuted) = 0;
  354.   }
  355.   DEBUG("commit...");
  356.   check = MyTransaction->execute( Commit ); 
  357.   CHECK_MINUS_ONE(check, "T3: Commit", 
  358.   MyTransaction);
  359.   
  360.   pNDB->closeTransaction(MyTransaction);
  361.   
  362.   DEBUG("donen");
  363.   get_time(outTransactionTime);
  364.   time_diff(outTransactionTime, &start);
  365.   return 0;
  366. }
  369. /**
  370.  * Transaction 4 - T4
  371.  * 
  372.  * Create session
  373.  *
  374.  * Input:
  375.  *   SubscriberNumber
  376.  *   ServerId
  377.  *   ServerBit
  378.  *   SessionDetails,
  379.  *   DoRollback
  380.  * Output:
  381.  *   ChangedBy
  382.  *   ChangedTime
  383.  *   Location
  384.  *   BranchExecuted
  385.  */
  386. int
  387. T4(void * obj,
  388.    const SubscriberNumber   inNumber,
  389.    const SubscriberSuffix   inSuffix,
  390.    const ServerId           inServerId,
  391.    const ServerBit          inServerBit,
  392.    const SessionDetails     inSessionDetails,
  393.    ChangedBy          outChangedBy,
  394.    ChangedTime        outChangedTime,
  395.    Location         * outLocation,
  396.    DoRollback         inDoRollback,
  397.    BranchExecuted   * outBranchExecuted,
  398.    BenchmarkTime    * outTransactionTime){
  400.   Ndb * pNDB = (Ndb *) obj;  
  402.   GroupId        groupId;
  403.   ActiveSessions sessions;
  404.   Permission     permission;
  406.   BenchmarkTime start;
  407.   get_time(&start);
  409.   int check;
  410.   NdbRecAttr * check2;
  412.   NdbConnection * MyTransaction = pNDB->startTransaction();
  413.   if (MyTransaction == NULL)   
  414.     error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), 0);
  416.   NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  417.   CHECK_NULL(MyOperation, "T4-1: getNdbOperation", 
  418.      MyTransaction);
  419.   
  420.   check = MyOperation->interpretedUpdateTuple();
  421.   CHECK_MINUS_ONE(check, "T4-1: readTuple", 
  422.   MyTransaction);
  423.   
  424.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  425.      inNumber);
  426.   CHECK_MINUS_ONE(check, "T4-1: equal subscriber",
  427.   MyTransaction);
  429.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  430.  (char *)outLocation);
  431.   CHECK_NULL(check2, "T4-1: getValue location", 
  432.      MyTransaction);
  434.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  435.  outChangedBy);
  436.   CHECK_NULL(check2, "T4-1: getValue changed_by", 
  437.      MyTransaction);
  439.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  440.                                  outChangedTime);
  441.   CHECK_NULL(check2, "T4-1: getValue changed_time",
  442.      MyTransaction);
  444.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  445.  (char *)&groupId);
  446.   CHECK_NULL(check2, "T4-1: getValue group", 
  447.      MyTransaction);
  449.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  450.  (char *)&sessions);
  451.   CHECK_NULL(check2, "T4-1: getValue sessions", 
  452.      MyTransaction);
  453.   
  454.   check = MyOperation->incValue(IND_SUBSCRIBER_SESSIONS, 
  455. (uint32)inServerBit);
  456.   CHECK_MINUS_ONE(check, "T4-4: inc value",
  457.   MyTransaction);
  458.   
  459.   check = MyTransaction->execute( NoCommit ); 
  460.   CHECK_MINUS_ONE(check, "T4-1: NoCommit", 
  461.   MyTransaction);
  463.     /* Operation 2 */
  465.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  466.   CHECK_NULL(MyOperation, "T4-2: getNdbOperation", 
  467.      MyTransaction);
  468.   
  469.   check = MyOperation->readTuple();
  470.   CHECK_MINUS_ONE(check, "T4-2: readTuple", 
  471.   MyTransaction);
  472.   
  473.   check = MyOperation->equal(IND_GROUP_ID,
  474.      (char*)&groupId);
  475.   CHECK_MINUS_ONE(check, "T4-2: equal group",
  476.   MyTransaction);
  477.   
  478.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_INSERT, 
  479.  (char *)&permission);
  480.   CHECK_NULL(check2, "T4-2: getValue allow_insert", 
  481.      MyTransaction);
  483.   check = MyTransaction->execute( NoCommit ); 
  484.   CHECK_MINUS_ONE(check, "T4-2: NoCommit", 
  485.   MyTransaction);
  486.   
  487.   DEBUG3("T4(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  489.   if(((permission & inServerBit) == inServerBit) &&
  490.      ((sessions   & inServerBit) == 0)){
  491.   
  492.     DEBUG("inserting - ");
  493.   
  494.     /* Operation 3 */
  495.     
  496.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  497.     CHECK_NULL(MyOperation, "T4-3: getNdbOperation", 
  498.        MyTransaction);
  499.     
  500.     check = MyOperation->insertTuple();
  501.     CHECK_MINUS_ONE(check, "T4-3: insertTuple", 
  502.     MyTransaction);
  503.     
  504.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  505.        (char*)inNumber);
  506.     CHECK_MINUS_ONE(check, "T4-3: equal number",
  507.     MyTransaction);
  509.     check = MyOperation->equal(IND_SESSION_SERVER,
  510.        (char*)&inServerId);
  511.     CHECK_MINUS_ONE(check, "T4-3: equal server id",
  512.     MyTransaction);
  513.     
  514.     check = MyOperation->setValue(SESSION_DATA, 
  515.    (char *)inSessionDetails);
  516.     CHECK_MINUS_ONE(check, "T4-3: setValue session details", 
  517.        MyTransaction);
  518.     
  519.     /* Operation 4 */
  521.     /* Operation 5 */
  522.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  523.     CHECK_NULL(MyOperation, "T4-5: getNdbOperation", 
  524.        MyTransaction);
  525.     
  526.     check = MyOperation->interpretedUpdateTuple();
  527.     CHECK_MINUS_ONE(check, "T4-5: interpretedUpdateTuple", 
  528.     MyTransaction);
  529.     
  530.     check = MyOperation->equal(IND_SERVER_ID,
  531.        (char*)&inServerId);
  532.     CHECK_MINUS_ONE(check, "T4-5: equal serverId",
  533.     MyTransaction);
  535.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  536.        (char*)inSuffix);
  537.     CHECK_MINUS_ONE(check, "T4-5: equal suffix",
  538.     MyTransaction);
  540.     check = MyOperation->incValue(IND_SERVER_INSERTS, (uint32)1);
  541.     CHECK_MINUS_ONE(check, "T4-5: inc value",
  542.     MyTransaction);
  543.         
  544.     (* outBranchExecuted) = 1;
  545.   } else {
  546.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  547.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  548.     (* outBranchExecuted) = 0;
  549.   }
  551.   if(!inDoRollback && (* outBranchExecuted)){
  552.     DEBUG("commitn");
  553.     check = MyTransaction->execute( Commit ); 
  554.     CHECK_MINUS_ONE(check, "T4: Commit", 
  555.     MyTransaction);
  556.   } else {
  557.     DEBUG("rollbackn");
  558.     check = MyTransaction->execute(Rollback);
  559.     CHECK_MINUS_ONE(check, "T4:Rollback", 
  560.     MyTransaction);
  561.     
  562.   }
  563.   
  564.   pNDB->closeTransaction(MyTransaction);
  565.   
  566.   get_time(outTransactionTime);
  567.   time_diff(outTransactionTime, &start);
  568.   return 0;
  569. }
  572. /**
  573.  * Transaction 5 - T5
  574.  * 
  575.  * Delete session
  576.  *
  577.  * Input:
  578.  *   SubscriberNumber
  579.  *   ServerId
  580.  *   ServerBit
  581.  *   DoRollback
  582.  * Output:
  583.  *   ChangedBy
  584.  *   ChangedTime
  585.  *   Location
  586.  *   BranchExecuted
  587.  */
  588. int
  589. T5(void * obj,
  590.    const SubscriberNumber   inNumber,
  591.    const SubscriberSuffix   inSuffix,
  592.    const ServerId           inServerId,
  593.    const ServerBit          inServerBit,
  594.    ChangedBy          outChangedBy,
  595.    ChangedTime        outChangedTime,
  596.    Location         * outLocation,
  597.    DoRollback         inDoRollback,
  598.    BranchExecuted   * outBranchExecuted,
  599.    BenchmarkTime    * outTransactionTime){
  600.   
  601.   Ndb           * pNDB = (Ndb *) obj;  
  602.   NdbConnection * MyTransaction = 0;
  603.   NdbOperation  * MyOperation = 0;
  605.   GroupId        groupId;
  606.   ActiveSessions sessions;
  607.   Permission     permission;
  609.   BenchmarkTime start;
  610.   get_time(&start);
  612.   int check;
  613.   NdbRecAttr * check2;
  615.   MyTransaction = pNDB->startTransaction();
  616.   if (MyTransaction == NULL)   
  617.     error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), 0);
  618.   
  619.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  620.   CHECK_NULL(MyOperation, "T5-1: getNdbOperation", 
  621.      MyTransaction);
  622.   
  623.   check = MyOperation->interpretedUpdateTuple();
  624.   CHECK_MINUS_ONE(check, "T5-1: readTuple", 
  625.   MyTransaction);
  626.   
  627.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  628.      inNumber);
  629.   CHECK_MINUS_ONE(check, "T5-1: equal subscriber",
  630.   MyTransaction);
  632.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  633.  (char *)outLocation);
  634.   CHECK_NULL(check2, "T5-1: getValue location", 
  635.      MyTransaction);
  637.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  638.  outChangedBy);
  639.   CHECK_NULL(check2, "T5-1: getValue changed_by", 
  640.      MyTransaction);
  642.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  643.                                  outChangedTime);
  644.   CHECK_NULL(check2, "T5-1: getValue changed_time",
  645.      MyTransaction);
  647.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  648.  (char *)&groupId);
  649.   CHECK_NULL(check2, "T5-1: getValue group", 
  650.      MyTransaction);
  652.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  653.  (char *)&sessions);
  654.   CHECK_NULL(check2, "T5-1: getValue sessions", 
  655.      MyTransaction);
  656.   
  657.   check = MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, 
  658. (uint32)inServerBit);
  659.   CHECK_MINUS_ONE(check, "T5-4: dec value",
  660.   MyTransaction);
  662.   check = MyTransaction->execute( NoCommit ); 
  663.   CHECK_MINUS_ONE(check, "T5-1: NoCommit", 
  664.   MyTransaction);
  665.   
  666.     /* Operation 2 */
  668.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  669.   CHECK_NULL(MyOperation, "T5-2: getNdbOperation", 
  670.      MyTransaction);
  671.   
  672.   
  673.   check = MyOperation->readTuple();
  674.   CHECK_MINUS_ONE(check, "T5-2: readTuple", 
  675.   MyTransaction);
  676.   
  677.   check = MyOperation->equal(IND_GROUP_ID,
  678.      (char*)&groupId);
  679.   CHECK_MINUS_ONE(check, "T5-2: equal group",
  680.   MyTransaction);
  681.   
  682.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_DELETE, 
  683.  (char *)&permission);
  684.   CHECK_NULL(check2, "T5-2: getValue allow_delete", 
  685.      MyTransaction);
  686.   
  687.   check = MyTransaction->execute( NoCommit ); 
  688.   CHECK_MINUS_ONE(check, "T5-2: NoCommit", 
  689.   MyTransaction);
  690.   
  691.   DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  693.   if(((permission & inServerBit) == inServerBit) &&
  694.      ((sessions   & inServerBit) == inServerBit)){
  695.   
  696.     DEBUG("deleting - ");
  697.   
  698.     /* Operation 3 */
  699.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  700.     CHECK_NULL(MyOperation, "T5-3: getNdbOperation", 
  701.        MyTransaction);
  702.     
  703.     check = MyOperation->deleteTuple();
  704.     CHECK_MINUS_ONE(check, "T5-3: deleteTuple", 
  705.     MyTransaction);
  706.     
  707.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  708.        (char*)inNumber);
  709.     CHECK_MINUS_ONE(check, "T5-3: equal number",
  710.     MyTransaction);
  712.     check = MyOperation->equal(IND_SESSION_SERVER,
  713.        (char*)&inServerId);
  714.     CHECK_MINUS_ONE(check, "T5-3: equal server id",
  715.     MyTransaction);
  716.     
  717.     /* Operation 4 */
  718.         
  719.     /* Operation 5 */
  720.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  721.     CHECK_NULL(MyOperation, "T5-5: getNdbOperation", 
  722.        MyTransaction);
  723.     
  724.     
  725.     check = MyOperation->interpretedUpdateTuple();
  726.     CHECK_MINUS_ONE(check, "T5-5: interpretedUpdateTuple", 
  727.     MyTransaction);
  728.     
  729.     check = MyOperation->equal(IND_SERVER_ID,
  730.        (char*)&inServerId);
  731.     CHECK_MINUS_ONE(check, "T5-5: equal serverId",
  732.     MyTransaction);
  734.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  735.        (char*)inSuffix);
  736.     CHECK_MINUS_ONE(check, "T5-5: equal suffix",
  737.     MyTransaction);
  739.     check = MyOperation->incValue(IND_SERVER_DELETES, (uint32)1);
  740.     CHECK_MINUS_ONE(check, "T5-5: inc value",
  741.     MyTransaction);
  743.     (* outBranchExecuted) = 1;
  744.   } else {
  745.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  746.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  747.     (* outBranchExecuted) = 0;
  748.   }
  750.   if(!inDoRollback && (* outBranchExecuted)){
  751.     DEBUG("commitn");
  752.     check = MyTransaction->execute( Commit ); 
  753.     CHECK_MINUS_ONE(check, "T5: Commit", 
  754.     MyTransaction);
  755.   } else {
  756.     DEBUG("rollbackn");
  757.     check = MyTransaction->execute(Rollback);
  758.     CHECK_MINUS_ONE(check, "T5:Rollback", 
  759.     MyTransaction);
  760.     
  761.   }
  762.   
  763.   pNDB->closeTransaction(MyTransaction);
  764.   
  765.   get_time(outTransactionTime);
  766.   time_diff(outTransactionTime, &start);
  767.   return 0;
  768. }