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

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

MySQL数据库

开发平台：

Visual C++

ndb_user_transaction2.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.     check = MyTransaction->execute( NoCommit ); 
  328.     CHECK_MINUS_ONE(check, "T3-3: NoCommit", 
  329.     MyTransaction);
  331.     /* Operation 4 */
  333.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  334.     CHECK_NULL(MyOperation, "T3-4: getNdbOperation", 
  335.        MyTransaction);
  336.     
  337.     check = MyOperation->interpretedUpdateTuple();
  338.     CHECK_MINUS_ONE(check, "T3-4: interpretedUpdateTuple", 
  339.     MyTransaction);
  340.     
  341.     check = MyOperation->equal(IND_SERVER_ID,
  342.        (char*)&inServerId);
  343.     CHECK_MINUS_ONE(check, "T3-4: equal serverId",
  344.     MyTransaction);
  346.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  347.        (char*)inSuffix);
  348.     CHECK_MINUS_ONE(check, "T3-4: equal suffix",
  349.     MyTransaction);
  351.     check = MyOperation->incValue(IND_SERVER_READS, (uint32)1);
  352.     CHECK_MINUS_ONE(check, "T3-4: inc value",
  353.     MyTransaction);
  354.     
  355.     check = MyTransaction->execute( NoCommit ); 
  356.     CHECK_MINUS_ONE(check, "T3-4: NoCommit", 
  357.     MyTransaction);
  359.     (* outBranchExecuted) = 1;
  360.   } else {
  361.     (* outBranchExecuted) = 0;
  362.   }
  363.   DEBUG("commitn");
  364.   check = MyTransaction->execute( Commit ); 
  365.   CHECK_MINUS_ONE(check, "T3: Commit", 
  366.   MyTransaction);
  367.   
  368.   pNDB->closeTransaction(MyTransaction);
  369.   
  370.   get_time(outTransactionTime);
  371.   time_diff(outTransactionTime, &start);
  372.   return 0;
  373. }
  376. /**
  377.  * Transaction 4 - T4
  378.  * 
  379.  * Create session
  380.  *
  381.  * Input:
  382.  *   SubscriberNumber
  383.  *   ServerId
  384.  *   ServerBit
  385.  *   SessionDetails,
  386.  *   DoRollback
  387.  * Output:
  388.  *   ChangedBy
  389.  *   ChangedTime
  390.  *   Location
  391.  *   BranchExecuted
  392.  */
  393. int
  394. T4(void * obj,
  395.    const SubscriberNumber   inNumber,
  396.    const SubscriberSuffix   inSuffix,
  397.    const ServerId           inServerId,
  398.    const ServerBit          inServerBit,
  399.    const SessionDetails     inSessionDetails,
  400.    ChangedBy          outChangedBy,
  401.    ChangedTime        outChangedTime,
  402.    Location         * outLocation,
  403.    DoRollback         inDoRollback,
  404.    BranchExecuted   * outBranchExecuted,
  405.    BenchmarkTime    * outTransactionTime){
  407.   Ndb * pNDB = (Ndb *) obj;  
  409.   GroupId        groupId;
  410.   ActiveSessions sessions;
  411.   Permission     permission;
  413.   BenchmarkTime start;
  414.   get_time(&start);
  416.   int check;
  417.   NdbRecAttr * check2;
  419.   NdbConnection * MyTransaction = pNDB->startTransaction();
  420.   if (MyTransaction == NULL)   
  421.     error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), 0);
  423.   DEBUG3("T4(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  425.   NdbOperation * MyOperation = 0;
  427.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  428.   CHECK_NULL(MyOperation, "T4-1: getNdbOperation", 
  429.      MyTransaction);
  430.   
  431.   check = MyOperation->readTupleExclusive();
  432.   CHECK_MINUS_ONE(check, "T4-1: readTuple", 
  433.   MyTransaction);
  434.   
  435.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  436.      inNumber);
  437.   CHECK_MINUS_ONE(check, "T4-1: equal subscriber",
  438.   MyTransaction);
  440.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  441.  (char *)outLocation);
  442.   CHECK_NULL(check2, "T4-1: getValue location", 
  443.      MyTransaction);
  445.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  446.  outChangedBy);
  447.   CHECK_NULL(check2, "T4-1: getValue changed_by", 
  448.      MyTransaction);
  450.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  451.                                  outChangedTime);
  452.   CHECK_NULL(check2, "T4-1: getValue changed_time",
  453.      MyTransaction);
  455.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  456.  (char *)&groupId);
  457.   CHECK_NULL(check2, "T4-1: getValue group", 
  458.      MyTransaction);
  460.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  461.  (char *)&sessions);
  462.   CHECK_NULL(check2, "T4-1: getValue sessions", 
  463.      MyTransaction);
  464.   
  465.   check = MyTransaction->execute( NoCommit ); 
  466.   CHECK_MINUS_ONE(check, "T4-1: NoCommit", 
  467.   MyTransaction);
  469.     /* Operation 2 */
  470.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  471.   CHECK_NULL(MyOperation, "T4-2: getNdbOperation", 
  472.      MyTransaction);
  473.   
  474.   check = MyOperation->readTuple();
  475.   CHECK_MINUS_ONE(check, "T4-2: readTuple", 
  476.   MyTransaction);
  477.   
  478.   check = MyOperation->equal(IND_GROUP_ID,
  479.      (char*)&groupId);
  480.   CHECK_MINUS_ONE(check, "T4-2: equal group",
  481.   MyTransaction);
  482.   
  483.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_INSERT, 
  484.  (char *)&permission);
  485.   CHECK_NULL(check2, "T4-2: getValue allow_insert", 
  486.      MyTransaction);
  488.   check = MyTransaction->execute( NoCommit ); 
  489.   CHECK_MINUS_ONE(check, "T4-2: NoCommit", 
  490.   MyTransaction);
  491.   
  492.   if(((permission & inServerBit) == inServerBit) &&
  493.      ((sessions   & inServerBit) == 0)){
  495.     DEBUG("inserting - ");
  496.   
  497.     /* Operation 3 */
  498.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  499.     CHECK_NULL(MyOperation, "T4-3: getNdbOperation", 
  500.        MyTransaction);
  501.     
  502.     check = MyOperation->insertTuple();
  503.     CHECK_MINUS_ONE(check, "T4-3: insertTuple", 
  504.     MyTransaction);
  505.     
  506.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  507.        (char*)inNumber);
  508.     CHECK_MINUS_ONE(check, "T4-3: equal number",
  509.     MyTransaction);
  511.     check = MyOperation->equal(IND_SESSION_SERVER,
  512.        (char*)&inServerId);
  513.     CHECK_MINUS_ONE(check, "T4-3: equal server id",
  514.     MyTransaction);
  515.     
  516.     check = MyOperation->setValue(SESSION_DATA, 
  517.    (char *)inSessionDetails);
  518.     CHECK_MINUS_ONE(check, "T4-3: setValue session details", 
  519.        MyTransaction);
  521.     check = MyTransaction->execute( NoCommit ); 
  522.     CHECK_MINUS_ONE(check, "T4-3: NoCommit", 
  523.     MyTransaction);
  525.     /* Operation 4 */
  526.     MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  527.     CHECK_NULL(MyOperation, "T4-4: getNdbOperation", 
  528.        MyTransaction);
  529.     
  530.     check = MyOperation->interpretedUpdateTuple();
  531.     CHECK_MINUS_ONE(check, "T4-4: interpretedUpdateTuple", 
  532.     MyTransaction);
  533.     
  534.     check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
  535.        (char*)inNumber);
  536.     CHECK_MINUS_ONE(check, "T4-4: equal number",
  537.     MyTransaction);
  539.     check = MyOperation->incValue(IND_SUBSCRIBER_SESSIONS, 
  540.   (uint32)inServerBit);
  541.     CHECK_MINUS_ONE(check, "T4-4: inc value",
  542.     MyTransaction);
  544.     check = MyTransaction->execute( NoCommit ); 
  545.     CHECK_MINUS_ONE(check, "T4-4: NoCommit", 
  546.     MyTransaction);
  548.     /* Operation 5 */
  549.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  550.     CHECK_NULL(MyOperation, "T4-5: getNdbOperation", 
  551.        MyTransaction);
  552.     
  553.     check = MyOperation->interpretedUpdateTuple();
  554.     CHECK_MINUS_ONE(check, "T4-5: interpretedUpdateTuple", 
  555.     MyTransaction);
  556.     
  557.     check = MyOperation->equal(IND_SERVER_ID,
  558.        (char*)&inServerId);
  559.     CHECK_MINUS_ONE(check, "T4-5: equal serverId",
  560.     MyTransaction);
  562.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  563.        (char*)inSuffix);
  564.     CHECK_MINUS_ONE(check, "T4-5: equal suffix",
  565.     MyTransaction);
  567.     check = MyOperation->incValue(IND_SERVER_INSERTS, (uint32)1);
  568.     CHECK_MINUS_ONE(check, "T4-5: inc value",
  569.     MyTransaction);
  570.         
  571.     check = MyTransaction->execute( NoCommit ); 
  572.     CHECK_MINUS_ONE(check, "T4-5: NoCommit", 
  573.     MyTransaction);
  575.     (* outBranchExecuted) = 1;
  576.   } else {
  577.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  578.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  579.     (* outBranchExecuted) = 0;
  580.   }
  582.   if(!inDoRollback){
  583.     DEBUG("commitn");
  584.     check = MyTransaction->execute( Commit ); 
  585.     CHECK_MINUS_ONE(check, "T4: Commit", 
  586.     MyTransaction);
  587.   } else {
  588.     DEBUG("rollbackn");
  589.     check = MyTransaction->execute(Rollback);
  590.     CHECK_MINUS_ONE(check, "T4:Rollback", 
  591.     MyTransaction);
  592.     
  593.   }
  594.   
  595.   pNDB->closeTransaction(MyTransaction);
  596.   
  597.   get_time(outTransactionTime);
  598.   time_diff(outTransactionTime, &start);
  599.   return 0;
  600. }
  603. /**
  604.  * Transaction 5 - T5
  605.  * 
  606.  * Delete session
  607.  *
  608.  * Input:
  609.  *   SubscriberNumber
  610.  *   ServerId
  611.  *   ServerBit
  612.  *   DoRollback
  613.  * Output:
  614.  *   ChangedBy
  615.  *   ChangedTime
  616.  *   Location
  617.  *   BranchExecuted
  618.  */
  619. int
  620. T5(void * obj,
  621.    const SubscriberNumber   inNumber,
  622.    const SubscriberSuffix   inSuffix,
  623.    const ServerId           inServerId,
  624.    const ServerBit          inServerBit,
  625.    ChangedBy          outChangedBy,
  626.    ChangedTime        outChangedTime,
  627.    Location         * outLocation,
  628.    DoRollback         inDoRollback,
  629.    BranchExecuted   * outBranchExecuted,
  630.    BenchmarkTime    * outTransactionTime){
  631.   
  632.   Ndb           * pNDB = (Ndb *) obj;  
  633.   NdbConnection * MyTransaction = 0;
  634.   NdbOperation  * MyOperation = 0;
  636.   GroupId        groupId;
  637.   ActiveSessions sessions;
  638.   Permission     permission;
  640.   BenchmarkTime start;
  641.   get_time(&start);
  643.   int check;
  644.   NdbRecAttr * check2;
  646.   MyTransaction = pNDB->startTransaction();
  647.   if (MyTransaction == NULL)   
  648.     error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), 0);
  650.   MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  651.   CHECK_NULL(MyOperation, "T5-1: getNdbOperation", 
  652.      MyTransaction);
  653.   
  654.   
  655.   check = MyOperation->readTupleExclusive();
  656.   CHECK_MINUS_ONE(check, "T5-1: readTuple", 
  657.   MyTransaction);
  658.   
  659.   check = MyOperation->equal(IND_SUBSCRIBER_NUMBER, 
  660.      inNumber);
  661.   CHECK_MINUS_ONE(check, "T5-1: equal subscriber",
  662.   MyTransaction);
  664.   check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION, 
  665.  (char *)outLocation);
  666.   CHECK_NULL(check2, "T5-1: getValue location", 
  667.      MyTransaction);
  669.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  670.  outChangedBy);
  671.   CHECK_NULL(check2, "T5-1: getValue changed_by", 
  672.      MyTransaction);
  674.   check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  675.                                  outChangedTime);
  676.   CHECK_NULL(check2, "T5-1: getValue changed_time",
  677.      MyTransaction);
  679.   check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
  680.  (char *)&groupId);
  681.   CHECK_NULL(check2, "T5-1: getValue group", 
  682.      MyTransaction);
  684.   check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
  685.  (char *)&sessions);
  686.   CHECK_NULL(check2, "T5-1: getValue sessions", 
  687.      MyTransaction);
  688.   
  689.   check = MyTransaction->execute( NoCommit ); 
  690.   CHECK_MINUS_ONE(check, "T5-1: NoCommit", 
  691.   MyTransaction);
  692.   
  693.     /* Operation 2 */
  695.   MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  696.   CHECK_NULL(MyOperation, "T5-2: getNdbOperation", 
  697.      MyTransaction);
  698.   
  699.   
  700.   check = MyOperation->readTuple();
  701.   CHECK_MINUS_ONE(check, "T5-2: readTuple", 
  702.   MyTransaction);
  703.   
  704.   check = MyOperation->equal(IND_GROUP_ID,
  705.      (char*)&groupId);
  706.   CHECK_MINUS_ONE(check, "T5-2: equal group",
  707.   MyTransaction);
  708.   
  709.   check2 = MyOperation->getValue(IND_GROUP_ALLOW_DELETE, 
  710.  (char *)&permission);
  711.   CHECK_NULL(check2, "T5-2: getValue allow_delete", 
  712.      MyTransaction);
  713.   
  714.   check = MyTransaction->execute( NoCommit ); 
  715.   CHECK_MINUS_ONE(check, "T5-2: NoCommit", 
  716.   MyTransaction);
  717.   
  718.   DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
  720.   if(((permission & inServerBit) == inServerBit) &&
  721.      ((sessions   & inServerBit) == inServerBit)){
  722.   
  723.     DEBUG("deleting - ");
  724.   
  725.     /* Operation 3 */
  726.     MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
  727.     CHECK_NULL(MyOperation, "T5-3: getNdbOperation", 
  728.        MyTransaction);
  729.     
  730.     check = MyOperation->deleteTuple();
  731.     CHECK_MINUS_ONE(check, "T5-3: deleteTuple", 
  732.     MyTransaction);
  733.     
  734.     check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
  735.        (char*)inNumber);
  736.     CHECK_MINUS_ONE(check, "T5-3: equal number",
  737.     MyTransaction);
  739.     check = MyOperation->equal(IND_SESSION_SERVER,
  740.        (char*)&inServerId);
  741.     CHECK_MINUS_ONE(check, "T5-3: equal server id",
  742.     MyTransaction);
  743.     
  744.     check = MyTransaction->execute( NoCommit ); 
  745.     CHECK_MINUS_ONE(check, "T5-3: NoCommit", 
  746.     MyTransaction);
  748.     /* Operation 4 */
  749.     MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  750.     CHECK_NULL(MyOperation, "T5-4: getNdbOperation", 
  751.        MyTransaction);
  752.     
  753.     check = MyOperation->interpretedUpdateTuple();
  754.     CHECK_MINUS_ONE(check, "T5-4: interpretedUpdateTuple", 
  755.     MyTransaction);
  756.     
  757.     check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
  758.        (char*)inNumber);
  759.     CHECK_MINUS_ONE(check, "T5-4: equal number",
  760.     MyTransaction);
  762.     check = MyOperation->subValue(IND_SUBSCRIBER_SESSIONS, 
  763.   (uint32)inServerBit);
  764.     CHECK_MINUS_ONE(check, "T5-4: dec value",
  765.     MyTransaction);
  766.         
  767.     check = MyTransaction->execute( NoCommit ); 
  768.     CHECK_MINUS_ONE(check, "T5-4: NoCommit", 
  769.     MyTransaction);
  771.     /* Operation 5 */
  772.     MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  773.     CHECK_NULL(MyOperation, "T5-5: getNdbOperation", 
  774.        MyTransaction);
  775.     
  776.     
  777.     check = MyOperation->interpretedUpdateTuple();
  778.     CHECK_MINUS_ONE(check, "T5-5: interpretedUpdateTuple", 
  779.     MyTransaction);
  780.     
  781.     check = MyOperation->equal(IND_SERVER_ID,
  782.        (char*)&inServerId);
  783.     CHECK_MINUS_ONE(check, "T5-5: equal serverId",
  784.     MyTransaction);
  786.     check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  787.        (char*)inSuffix);
  788.     CHECK_MINUS_ONE(check, "T5-5: equal suffix",
  789.     MyTransaction);
  791.     check = MyOperation->incValue(IND_SERVER_DELETES, (uint32)1);
  792.     CHECK_MINUS_ONE(check, "T5-5: inc value",
  793.     MyTransaction);
  795.     check = MyTransaction->execute( NoCommit ); 
  796.     CHECK_MINUS_ONE(check, "T5-5: NoCommit", 
  797.     MyTransaction);
  799.     (* outBranchExecuted) = 1;
  800.   } else {
  801.     DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
  802.     DEBUG1("%s", ((sessions   & inServerBit) ? "in session - " : "no in session - "));
  803.     (* outBranchExecuted) = 0;
  804.   }
  806.   if(!inDoRollback){
  807.     DEBUG("commitn");
  808.     check = MyTransaction->execute( Commit ); 
  809.     CHECK_MINUS_ONE(check, "T5: Commit", 
  810.     MyTransaction);
  811.   } else {
  812.     DEBUG("rollbackn");
  813.     check = MyTransaction->execute(Rollback);
  814.     CHECK_MINUS_ONE(check, "T5:Rollback", 
  815.     MyTransaction);
  816.     
  817.   }
  818.   
  819.   pNDB->closeTransaction(MyTransaction);
  820.   
  821.   get_time(outTransactionTime);
  822.   time_diff(outTransactionTime, &start);
  823.   return 0;
  824. }