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

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

MySQL数据库

开发平台：

Visual C++

ndb_async1.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 "userInterface.h"
  21. #include "macros.h"
  22. #include "ndb_schema.hpp"
  23. #include "ndb_error.hpp"
  25. #include <NdbApi.hpp>
  27. inline
  28. NdbConnection *
  29. startTransaction(Ndb * pNDB, 
  30.  ServerId inServerId, 
  31.  const SubscriberNumber inNumber){
  32.   
  33.   const int keyDataLenBytes    = sizeof(ServerId)+SUBSCRIBER_NUMBER_LENGTH;
  34.   const int keyDataLen_64Words = keyDataLenBytes >> 3;
  36.   Uint64 keyDataBuf[keyDataLen_64Words+1]; // The "+1" is for rounding...
  37.   
  38.   char     * keyDataBuf_charP = (char *)&keyDataBuf[0];
  39.   Uint32  * keyDataBuf_wo32P = (Uint32 *)&keyDataBuf[0];
  40.   
  41.   // Server Id comes first
  42.   keyDataBuf_wo32P[0] = inServerId;
  43.   // Then subscriber number
  44.   memcpy(&keyDataBuf_charP[sizeof(ServerId)], inNumber, 
  45.  SUBSCRIBER_NUMBER_LENGTH);
  47.   return pNDB->startTransaction(0, keyDataBuf_charP, keyDataLenBytes);
  48. }
  50. void T1_Callback(int result, NdbConnection * pCon, void * threadData);
  51. void T2_Callback(int result, NdbConnection * pCon, void * threadData);
  52. void T3_Callback_1(int result, NdbConnection * pCon, void * threadData);
  53. void T3_Callback_2(int result, NdbConnection * pCon, void * threadData);
  54. void T3_Callback_3(int result, NdbConnection * pCon, void * threadData);
  55. void T4_Callback_1(int result, NdbConnection * pCon, void * threadData);
  56. void T4_Callback_2(int result, NdbConnection * pCon, void * threadData);
  57. void T4_Callback_3(int result, NdbConnection * pCon, void * threadData);
  58. void T5_Callback_1(int result, NdbConnection * pCon, void * threadData);
  59. void T5_Callback_2(int result, NdbConnection * pCon, void * threadData);
  60. void T5_Callback_3(int result, NdbConnection * pCon, void * threadData);
  62. /**
  63.  * Transaction 1 - T1 
  64.  *
  65.  * Update location and changed by/time on a subscriber
  66.  *
  67.  * Input: 
  68.  *   SubscriberNumber,
  69.  *   Location,
  70.  *   ChangedBy,
  71.  *   ChangedTime
  72.  *
  73.  * Output:
  74.  */
  75. void
  76. start_T1(Ndb * pNDB, ThreadData * td){
  78.   DEBUG2("T1(%.*s): - Startingn", SUBSCRIBER_NUMBER_LENGTH, 
  79.  td->transactionData.number); 
  81.   int check;
  82.   NdbConnection * pCON = pNDB->startTransaction();
  83.   if (pCON != NULL) {
  84.     NdbOperation *MyOp = pCON->getNdbOperation(SUBSCRIBER_TABLE);
  85.     if (MyOp != NULL) {  
  86.       MyOp->updateTuple();  
  87.       MyOp->equal(IND_SUBSCRIBER_NUMBER, 
  88.   td->transactionData.number);
  89.       MyOp->setValue(IND_SUBSCRIBER_LOCATION, 
  90.      (char *)&td->transactionData.location);
  91.       MyOp->setValue(IND_SUBSCRIBER_CHANGED_BY, 
  92.      td->transactionData.changed_by);
  93.       MyOp->setValue(IND_SUBSCRIBER_CHANGED_TIME, 
  94.      td->transactionData.changed_time);
  95.       pCON->executeAsynchPrepare( Commit , T1_Callback, td);
  96.     } else {
  97.       CHECK_NULL(MyOp, "T1: getNdbOperation", pCON);
  98.     }//if
  99.   } else {
  100.     error_handler("T1-1: startTranscation", 
  101.   pNDB->getNdbErrorString(), 
  102.   pNDB->getNdbError());
  103.   }//if
  104. }
  106. void
  107. T1_Callback(int result, NdbConnection * pCON, void * threadData){
  108.   ThreadData * td = (ThreadData *)threadData;
  109.   
  110.   DEBUG2("T1(%.*s): - Completingn", SUBSCRIBER_NUMBER_LENGTH, 
  111.  td->transactionData.number); 
  113.   CHECK_MINUS_ONE(result, "T1: Commit", 
  114.   pCON);
  115.   td->pNDB->closeTransaction(pCON);
  116.   complete_T1(td);
  117. }
  119. /**
  120.  * Transaction 2 - T2
  121.  *
  122.  * Read from Subscriber:
  123.  *
  124.  * Input: 
  125.  *   SubscriberNumber
  126.  *
  127.  * Output:
  128.  *   Location
  129.  *   Changed by
  130.  *   Changed Timestamp
  131.  *   Name
  132.  */
  133. void
  134. start_T2(Ndb * pNDB, ThreadData * td){
  136.   DEBUG3("T2(%.*s, %p): - Startingn", SUBSCRIBER_NUMBER_LENGTH, 
  137.  td->transactionData.number, 
  138.  td->transactionData.location);
  139.   
  140.   int check;
  141.   NdbRecAttr * check2;
  142.   
  143.   NdbConnection * pCON = pNDB->startTransaction();
  144.   if (pCON == NULL)   
  145.     error_handler("T2-1: startTransaction", 
  146.   pNDB->getNdbErrorString(), 
  147.   pNDB->getNdbError());
  148.   
  149.   NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE);
  150.   CHECK_NULL(MyOp, "T2: getNdbOperation", 
  151.      pCON);
  152.   
  153.   MyOp->readTuple();
  154.   MyOp->equal(IND_SUBSCRIBER_NUMBER,
  155.       td->transactionData.number);
  156.   MyOp->getValue(IND_SUBSCRIBER_LOCATION, 
  157.  (char *)&td->transactionData.location);
  158.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  159.  td->transactionData.changed_by);
  160.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  161.  td->transactionData.changed_time);
  162.   MyOp->getValue(IND_SUBSCRIBER_NAME, 
  163.  td->transactionData.name);
  164.   pCON->executeAsynchPrepare( Commit, T2_Callback, td ); 
  165. }
  167. void
  168. T2_Callback(int result, NdbConnection * pCON, void * threadData){
  169.   ThreadData * td = (ThreadData *)threadData;
  170.   DEBUG3("T2(%.*s, %p): - Completingn", SUBSCRIBER_NUMBER_LENGTH, 
  171.  td->transactionData.number, 
  172.  td->transactionData.location);
  173.   
  174.   CHECK_MINUS_ONE(result, "T2: Commit", pCON);
  175.   td->pNDB->closeTransaction(pCON);
  176.   complete_T2(td);
  177. }
  179. /**
  180.  * Transaction 3 - T3
  181.  *
  182.  * Read session details
  183.  *
  184.  * Input:
  185.  *   SubscriberNumber
  186.  *   ServerId
  187.  *   ServerBit
  188.  *
  189.  * Output:
  190.  *   BranchExecuted
  191.  *   SessionDetails
  192.  *   ChangedBy
  193.  *   ChangedTime
  194.  *   Location
  195.  */
  196. void
  197. start_T3(Ndb * pNDB, ThreadData * td){
  199.   DEBUG3("T3(%.*s, %.2d): - Startingn", SUBSCRIBER_NUMBER_LENGTH, 
  200.  td->transactionData.number, 
  201.  td->transactionData.server_id);
  202.   
  203.   int check;
  204.   NdbRecAttr * check2;
  206.   NdbConnection * pCON = startTransaction(pNDB, 
  207.      td->transactionData.server_id, 
  208.      td->transactionData.number);
  209.   if (pCON == NULL)   
  210.     error_handler("T3-1: startTranscation", 
  211.   pNDB->getNdbErrorString(), 
  212.   pNDB->getNdbError());
  213.   
  214.   NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE);
  215.   CHECK_NULL(MyOp, "T3-1: getNdbOperation", 
  216.      pCON);
  217.   
  218.   MyOp->readTuple();
  219.   MyOp->equal(IND_SUBSCRIBER_NUMBER, 
  220.       td->transactionData.number);
  221.   MyOp->getValue(IND_SUBSCRIBER_LOCATION, 
  222.  (char *)&td->transactionData.location);
  223.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  224.  td->transactionData.changed_by);
  225.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  226.  td->transactionData.changed_time);
  227.   MyOp->getValue(IND_SUBSCRIBER_GROUP, 
  228.  (char *)&td->transactionData.group_id);
  229.   MyOp->getValue(IND_SUBSCRIBER_SESSIONS, 
  230.  (char *)&td->transactionData.sessions);
  231.   pCON->executeAsynchPrepare( NoCommit , T3_Callback_1, td); 
  232. }
  234. void
  235. T3_Callback_1(int result, NdbConnection * pCON, void * threadData){
  236.   ThreadData * td = (ThreadData *)threadData;
  237.   DEBUG3("T3(%.*s, %.2d): - Callback 1n", SUBSCRIBER_NUMBER_LENGTH, 
  238.  td->transactionData.number, 
  239.  td->transactionData.server_id);
  241.   CHECK_MINUS_ONE(result, "T3-1: NoCommit", pCON); 
  243.   NdbOperation * MyOp = pCON->getNdbOperation(GROUP_TABLE);
  244.   CHECK_NULL(MyOp, "T3-2: getNdbOperation", 
  245.      pCON);
  246.     
  247.   MyOp->readTuple();
  248.   MyOp->equal(IND_GROUP_ID,
  249.       (char*)&td->transactionData.group_id);
  250.   MyOp->getValue(IND_GROUP_ALLOW_READ, 
  251.  (char *)&td->transactionData.permission);
  252.   pCON->executeAsynchPrepare( NoCommit, T3_Callback_2, td ); 
  253. }
  255. void
  256. T3_Callback_2(int result, NdbConnection * pCON, void * threadData){
  257.   ThreadData * td = (ThreadData *)threadData;
  258.   
  259.   CHECK_MINUS_ONE(result, "T3-2: NoCommit", pCON); 
  260.   
  261.   Uint32 permission = td->transactionData.permission;
  262.   Uint32 sessions   = td->transactionData.sessions;
  263.   Uint32 server_bit = td->transactionData.server_bit;
  265.   if(((permission & server_bit) == server_bit) &&
  266.      ((sessions   & server_bit) == server_bit)){
  267.     
  268.     memcpy(td->transactionData.suffix,
  269.    &td->transactionData.number
  270.    [SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH],
  271.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  272.     DEBUG5("T3(%.*s, %.2d): - Callback 2 - reading(%.*s)n", 
  273.    SUBSCRIBER_NUMBER_LENGTH, 
  274.    td->transactionData.number, 
  275.    td->transactionData.server_id,
  276.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH, 
  277.    td->transactionData.suffix);
  278.     
  279.     /* Operation 3 */
  280.     NdbOperation * MyOp = pCON->getNdbOperation(SESSION_TABLE);
  281.     CHECK_NULL(MyOp, "T3-3: getNdbOperation", 
  282.        pCON);
  283.     
  284.     MyOp->simpleRead();
  285.     MyOp->equal(IND_SESSION_SUBSCRIBER,
  286. (char*)td->transactionData.number);
  287.     MyOp->equal(IND_SESSION_SERVER,
  288. (char*)&td->transactionData.server_id);
  289.     MyOp->getValue(IND_SESSION_DATA, 
  290.    (char *)td->transactionData.session_details);
  291.     
  292.     /* Operation 4 */
  293.     MyOp = pCON->getNdbOperation(SERVER_TABLE);
  294.     CHECK_NULL(MyOp, "T3-4: getNdbOperation", 
  295.        pCON);
  296.     
  297.     MyOp->interpretedUpdateTuple();
  298.     MyOp->equal(IND_SERVER_ID,
  299. (char*)&td->transactionData.server_id);
  300.     MyOp->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  301. (char*)td->transactionData.suffix);
  302.     MyOp->incValue(IND_SERVER_READS, (uint32)1);
  303.     td->transactionData.branchExecuted = 1;
  304.   } else {
  305.     DEBUG3("T3(%.*s, %.2d): - Callback 2 - no readn",
  306.    SUBSCRIBER_NUMBER_LENGTH, 
  307.    td->transactionData.number, 
  308.    td->transactionData.server_id);
  309.     td->transactionData.branchExecuted = 0;
  310.   }
  311.   pCON->executeAsynchPrepare( Commit, T3_Callback_3, td ); 
  312. }
  314. void
  315. T3_Callback_3(int result, NdbConnection * pCON, void * threadData){
  316.   ThreadData * td = (ThreadData *)threadData;  
  317.   DEBUG3("T3(%.*s, %.2d): - Completingn", SUBSCRIBER_NUMBER_LENGTH, 
  318.  td->transactionData.number, 
  319.  td->transactionData.server_id);
  320.   
  321.   CHECK_MINUS_ONE(result, "T3-3: Commit", pCON); 
  322.   
  323.   td->pNDB->closeTransaction(pCON);
  324.   complete_T3(td);
  325. }
  327. /**
  328.  * Transaction 4 - T4
  329.  * 
  330.  * Create session
  331.  *
  332.  * Input:
  333.  *   SubscriberNumber
  334.  *   ServerId
  335.  *   ServerBit
  336.  *   SessionDetails,
  337.  *   DoRollback
  338.  * Output:
  339.  *   ChangedBy
  340.  *   ChangedTime
  341.  *   Location
  342.  *   BranchExecuted
  343.  */
  344. void
  345. start_T4(Ndb * pNDB, ThreadData * td){
  347.   DEBUG3("T4(%.*s, %.2d): - Startingn", SUBSCRIBER_NUMBER_LENGTH, 
  348.  td->transactionData.number, 
  349.  td->transactionData.server_id);
  350.   
  351.   int check;
  352.   NdbRecAttr * check2;
  353.   
  354.   NdbConnection * pCON = startTransaction(pNDB, 
  355.   td->transactionData.server_id, 
  356.   td->transactionData.number);
  357.   if (pCON == NULL)   
  358.     error_handler("T4-1: startTranscation", 
  359.   pNDB->getNdbErrorString(), 
  360.   pNDB->getNdbError());
  361.   
  362.   NdbOperation *MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE);
  363.   CHECK_NULL(MyOp, "T4-1: getNdbOperation", 
  364.      pCON);
  365.   
  366.   MyOp->interpretedUpdateTuple();
  367.   MyOp->equal(IND_SUBSCRIBER_NUMBER, 
  368.       td->transactionData.number);
  369.   MyOp->getValue(IND_SUBSCRIBER_LOCATION, 
  370.  (char *)&td->transactionData.location);
  371.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  372.  td->transactionData.changed_by);
  373.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  374.  td->transactionData.changed_time);
  375.   MyOp->getValue(IND_SUBSCRIBER_GROUP,
  376.  (char *)&td->transactionData.group_id);
  377.   MyOp->getValue(IND_SUBSCRIBER_SESSIONS,
  378.  (char *)&td->transactionData.sessions); 
  379.   MyOp->incValue(IND_SUBSCRIBER_SESSIONS, 
  380.  (uint32)td->transactionData.server_bit);
  381.   pCON->executeAsynchPrepare( NoCommit , T4_Callback_1, td); 
  382. }
  384. void
  385. T4_Callback_1(int result, NdbConnection * pCON, void * threadData){
  386.   CHECK_MINUS_ONE(result, "T4-1: NoCommit", pCON); 
  387.   ThreadData * td = (ThreadData *)threadData;  
  388.   
  389.   DEBUG3("T4(%.*s, %.2d): - Callback 1n", 
  390.  SUBSCRIBER_NUMBER_LENGTH, 
  391.  td->transactionData.number, 
  392.  td->transactionData.server_id);
  395.   NdbOperation * MyOp = pCON->getNdbOperation(GROUP_TABLE);
  396.   CHECK_NULL(MyOp, "T4-2: getNdbOperation", 
  397.      pCON);
  398.   
  399.   MyOp->readTuple();
  400.   MyOp->equal(IND_GROUP_ID,
  401.       (char*)&td->transactionData.group_id);
  402.   MyOp->getValue(IND_GROUP_ALLOW_INSERT, 
  403.  (char *)&td->transactionData.permission);
  404.   pCON->executeAsynchPrepare( NoCommit , T4_Callback_2, td); 
  405. }
  407. void
  408. T4_Callback_2(int result, NdbConnection * pCON, void * threadData){
  409.   CHECK_MINUS_ONE(result, "T4-2: NoCommit", pCON); 
  410.   ThreadData * td = (ThreadData *)threadData;  
  412.   Uint32 permission = td->transactionData.permission;
  413.   Uint32 sessions   = td->transactionData.sessions;
  414.   Uint32 server_bit = td->transactionData.server_bit;
  415.   
  416.   if(((permission & server_bit) == server_bit) &&
  417.      ((sessions   & server_bit) == 0)){
  418.     
  419.     memcpy(td->transactionData.suffix,
  420.    &td->transactionData.number
  421.    [SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], 
  422.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  423.     
  424.     DEBUG5("T4(%.*s, %.2d): - Callback 2 - inserting(%.*s)n", 
  425.    SUBSCRIBER_NUMBER_LENGTH, 
  426.    td->transactionData.number, 
  427.    td->transactionData.server_id,
  428.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH, 
  429.    td->transactionData.suffix);
  430.     
  431.     /* Operation 3 */
  432.     
  433.     NdbOperation * MyOp = pCON->getNdbOperation(SESSION_TABLE);
  434.     CHECK_NULL(MyOp, "T4-3: getNdbOperation", 
  435.        pCON);
  436.     
  437.     MyOp->insertTuple();
  438.     MyOp->equal(IND_SESSION_SUBSCRIBER,
  439. (char*)td->transactionData.number);
  440.     MyOp->equal(IND_SESSION_SERVER,
  441. (char*)&td->transactionData.server_id);
  442.     MyOp->setValue(SESSION_DATA, 
  443.    (char *)td->transactionData.session_details);
  444.     /* Operation 4 */
  445.     
  446.     /* Operation 5 */
  447.     MyOp = pCON->getNdbOperation(SERVER_TABLE);
  448.     CHECK_NULL(MyOp, "T4-5: getNdbOperation", 
  449.        pCON);
  450.     
  451.     MyOp->interpretedUpdateTuple();
  452.     MyOp->equal(IND_SERVER_ID,
  453. (char*)&td->transactionData.server_id);
  454.     MyOp->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  455. (char*)td->transactionData.suffix);
  456.     MyOp->incValue(IND_SERVER_INSERTS, (uint32)1);
  457.     td->transactionData.branchExecuted = 1;
  458.   } else {
  459.     td->transactionData.branchExecuted = 0;
  460.     DEBUG5("T4(%.*s, %.2d): - Callback 2 - %s %sn",
  461.    SUBSCRIBER_NUMBER_LENGTH, 
  462.    td->transactionData.number, 
  463.    td->transactionData.server_id,
  464.    ((permission & server_bit) ? 
  465.     "permission - " : "no permission - "),
  466.    ((sessions   & server_bit) ? 
  467.     "in session - " : "no in session - "));
  468.   }
  469.   
  470.   if(!td->transactionData.do_rollback && td->transactionData.branchExecuted){
  471.     pCON->executeAsynchPrepare(Commit, T4_Callback_3, td); 
  472.   } else {
  473.     pCON->executeAsynchPrepare(Rollback, T4_Callback_3, td);
  474.   }
  475. }
  477. void
  478. T4_Callback_3(int result, NdbConnection * pCON, void * threadData){
  479.   CHECK_MINUS_ONE(result, "T4-3: Commit", pCON); 
  480.   ThreadData * td = (ThreadData *)threadData;  
  481.   
  482.   DEBUG3("T4(%.*s, %.2d): - Completingn", 
  483.  SUBSCRIBER_NUMBER_LENGTH, 
  484.  td->transactionData.number, 
  485.  td->transactionData.server_id);
  487.   td->pNDB->closeTransaction(pCON);
  488.   complete_T4(td);
  489. }
  491. /**
  492.  * Transaction 5 - T5
  493.  * 
  494.  * Delete session
  495.  *
  496.  * Input:
  497.  *   SubscriberNumber
  498.  *   ServerId
  499.  *   ServerBit
  500.  *   DoRollback
  501.  * Output:
  502.  *   ChangedBy
  503.  *   ChangedTime
  504.  *   Location
  505.  *   BranchExecuted
  506.  */
  507. void
  508. start_T5(Ndb * pNDB, ThreadData * td){
  510.   DEBUG3("T5(%.*s, %.2d): - Startingn", SUBSCRIBER_NUMBER_LENGTH, 
  511.  td->transactionData.number, 
  512.  td->transactionData.server_id);
  514.   int check;
  515.   NdbRecAttr * check2;
  516.   
  517.   NdbConnection * pCON = pNDB->startTransaction();
  518.   if (pCON == NULL)   
  519.     error_handler("T5-1: startTranscation", 
  520.   pNDB->getNdbErrorString(), 
  521.   pNDB->getNdbError());
  522.   
  523.   NdbOperation * MyOp= pCON->getNdbOperation(SUBSCRIBER_TABLE);
  524.   CHECK_NULL(MyOp, "T5-1: getNdbOperation", 
  525.      pCON);
  526.   
  527.   MyOp->interpretedUpdateTuple();
  528.   MyOp->equal(IND_SUBSCRIBER_NUMBER, 
  529.       td->transactionData.number);
  530.   MyOp->getValue(IND_SUBSCRIBER_LOCATION, 
  531.  (char *)&td->transactionData.location);
  532.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_BY, 
  533.  td->transactionData.changed_by);
  534.   MyOp->getValue(IND_SUBSCRIBER_CHANGED_TIME, 
  535.  td->transactionData.changed_time);
  536.   MyOp->getValue(IND_SUBSCRIBER_GROUP,
  537.  (char *)&td->transactionData.group_id);
  538.   MyOp->getValue(IND_SUBSCRIBER_SESSIONS,
  539.  (char *)&td->transactionData.sessions);
  540.   MyOp->subValue(IND_SUBSCRIBER_SESSIONS, 
  541.  (uint32)td->transactionData.server_bit);
  542.   pCON->executeAsynchPrepare( NoCommit, T5_Callback_1, td ); 
  543. }
  545. void
  546. T5_Callback_1(int result, NdbConnection * pCON, void * threadData){
  547.   CHECK_MINUS_ONE(result, "T5-1: NoCommit", pCON); 
  548.   ThreadData * td = (ThreadData *)threadData;  
  550.   DEBUG3("T5(%.*s, %.2d): - Callback 1n", 
  551.  SUBSCRIBER_NUMBER_LENGTH, 
  552.  td->transactionData.number, 
  553.  td->transactionData.server_id);
  554.   
  555.   NdbOperation * MyOp = pCON->getNdbOperation(GROUP_TABLE);
  556.   CHECK_NULL(MyOp, "T5-2: getNdbOperation", 
  557.      pCON);
  558.   
  559.   MyOp->readTuple();
  560.   MyOp->equal(IND_GROUP_ID,
  561.       (char*)&td->transactionData.group_id);
  562.   MyOp->getValue(IND_GROUP_ALLOW_DELETE, 
  563.  (char *)&td->transactionData.permission);
  564.   pCON->executeAsynchPrepare( NoCommit, T5_Callback_2, td ); 
  565. }
  567. void
  568. T5_Callback_2(int result, NdbConnection * pCON, void * threadData){
  569.   CHECK_MINUS_ONE(result, "T5-2: NoCommit", pCON); 
  570.   ThreadData * td = (ThreadData *)threadData;  
  572.   Uint32 permission = td->transactionData.permission;
  573.   Uint32 sessions   = td->transactionData.sessions;
  574.   Uint32 server_bit = td->transactionData.server_bit;
  576.   if(((permission & server_bit) == server_bit) &&
  577.      ((sessions   & server_bit) == server_bit)){
  578.     
  579.     memcpy(td->transactionData.suffix,
  580.    &td->transactionData.number
  581.    [SUBSCRIBER_NUMBER_LENGTH-SUBSCRIBER_NUMBER_SUFFIX_LENGTH], 
  582.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  583.   
  584.     DEBUG5("T5(%.*s, %.2d): - Callback 2 - deleting(%.*s)n", 
  585.    SUBSCRIBER_NUMBER_LENGTH, 
  586.    td->transactionData.number, 
  587.    td->transactionData.server_id,
  588.    SUBSCRIBER_NUMBER_SUFFIX_LENGTH, 
  589.    td->transactionData.suffix);
  590.     
  591.     /* Operation 3 */
  592.     NdbOperation * MyOp = pCON->getNdbOperation(SESSION_TABLE);
  593.     CHECK_NULL(MyOp, "T5-3: getNdbOperation", 
  594.        pCON);
  595.     
  596.     MyOp->deleteTuple();
  597.     MyOp->equal(IND_SESSION_SUBSCRIBER,
  598. (char*)td->transactionData.number);
  599.     MyOp->equal(IND_SESSION_SERVER,
  600. (char*)&td->transactionData.server_id);
  601.     /* Operation 4 */
  602.     
  603.     /* Operation 5 */
  604.     MyOp = pCON->getNdbOperation(SERVER_TABLE);
  605.     CHECK_NULL(MyOp, "T5-5: getNdbOperation", 
  606.        pCON);
  607.     
  608.     MyOp->interpretedUpdateTuple();
  609.     MyOp->equal(IND_SERVER_ID,
  610. (char*)&td->transactionData.server_id);
  611.     MyOp->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
  612. (char*)td->transactionData.suffix);
  613.     MyOp->incValue(IND_SERVER_DELETES, (uint32)1);
  614.     td->transactionData.branchExecuted = 1;
  615.   } else {
  616.     td->transactionData.branchExecuted = 0;
  618.     DEBUG5("T5(%.*s, %.2d): - Callback 2 - no delete - %s %sn", 
  619.    SUBSCRIBER_NUMBER_LENGTH, 
  620.    td->transactionData.number, 
  621.    td->transactionData.server_id,
  622.    ((permission & server_bit) ? 
  623.     "permission - " : "no permission - "),
  624.    ((sessions   & server_bit) ? 
  625.     "in session - " : "no in session - "));
  626.   }
  627.   
  628.   if(!td->transactionData.do_rollback && td->transactionData.branchExecuted){
  629.     pCON->executeAsynchPrepare(Commit, T5_Callback_3, td); 
  630.   } else {
  631.     pCON->executeAsynchPrepare(Rollback, T5_Callback_3, td);
  632.   }
  633. }
  635. void
  636. T5_Callback_3(int result, NdbConnection * pCON, void * threadData){
  637.   CHECK_MINUS_ONE(result, "T5-3: Commit", pCON); 
  638.   ThreadData * td = (ThreadData *)threadData;  
  640.   DEBUG3("T5(%.*s, %.2d): - Completingn", 
  641.  SUBSCRIBER_NUMBER_LENGTH, 
  642.  td->transactionData.number, 
  643.  td->transactionData.server_id);
  644.   
  645.   td->pNDB->closeTransaction(pCON);
  646.   complete_T5(td);
  647. }