MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ndb_user_transaction3.cpp
1 /*
2  Copyright (C) 2005, 2006 MySQL AB
3  All rights reserved. Use is subject to license terms.
4 
5  This program is free software; you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation; version 2 of the License.
8 
9  This program is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  GNU General Public License for more details.
13 
14  You should have received a copy of the GNU General Public License
15  along with this program; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 
19 //#define DEBUG_ON
20 
21 extern "C" {
22 #include "user_transaction.h"
23 };
24 
25 #include "macros.h"
26 #include "ndb_schema.hpp"
27 #include "ndb_error.hpp"
28 
29 #include <time.h>
30 #include <NdbApi.hpp>
31 
45 int
46 T1(void * obj,
47  const SubscriberNumber number,
48  const Location new_location,
49  const ChangedBy changed_by,
50  const ChangedTime changed_time,
51  BenchmarkTime * transaction_time){
52 
53  Ndb * pNDB = (Ndb *) obj;
54 
55  BenchmarkTime start;
56  get_time(&start);
57 
58  int check;
59  NdbRecAttr * check2;
60 
61  NdbConnection * MyTransaction = pNDB->startTransaction();
62  if (MyTransaction == NULL)
63  error_handler("T1: startTranscation", pNDB->getNdbErrorString(), 0);
64 
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);
76 
77  check = MyOperation->setValue(IND_SUBSCRIBER_LOCATION,
78  (char *)&new_location);
79  CHECK_MINUS_ONE(check, "T1: setValue location",
80  MyTransaction);
81 
82  check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_BY,
83  changed_by);
84  CHECK_MINUS_ONE(check, "T1: setValue changed_by",
85  MyTransaction);
86 
87  check = MyOperation->setValue(IND_SUBSCRIBER_CHANGED_TIME,
88  changed_time);
89  CHECK_MINUS_ONE(check, "T1: setValue changed_time",
90  MyTransaction);
91 
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 }
102 
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){
125 
126  Ndb * pNDB = (Ndb *) obj;
127 
128  BenchmarkTime start;
129  get_time(&start);
130 
131  int check;
132  NdbRecAttr * check2;
133 
134  NdbConnection * MyTransaction = pNDB->startTransaction();
135  if (MyTransaction == NULL)
136  error_handler("T2: startTranscation", pNDB->getNdbErrorString(), 0);
137 
138  NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
139  CHECK_NULL(MyOperation, "T2: getNdbOperation",
140  MyTransaction);
141 
142 
143  check = MyOperation->readTuple();
144  CHECK_MINUS_ONE(check, "T2: readTuple",
145  MyTransaction);
146 
147  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
148  number);
149  CHECK_MINUS_ONE(check, "T2: equal subscriber",
150  MyTransaction);
151 
152  check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION,
153  (char *)readLocation);
154  CHECK_NULL(check2, "T2: getValue location",
155  MyTransaction);
156 
157  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY,
158  changed_by);
159  CHECK_NULL(check2, "T2: getValue changed_by",
160  MyTransaction);
161 
162  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME,
163  changed_time);
164  CHECK_NULL(check2, "T2: getValue changed_time",
165  MyTransaction);
166 
167  check2 = MyOperation->getValue(IND_SUBSCRIBER_NAME,
168  subscriberName);
169  CHECK_NULL(check2, "T2: getValue name",
170  MyTransaction);
171 
172  check = MyTransaction->execute( Commit );
173  CHECK_MINUS_ONE(check, "T2: Commit",
174  MyTransaction);
175 
176  pNDB->closeTransaction(MyTransaction);
177 
178  get_time(transaction_time);
179  time_diff(transaction_time, &start);
180  return 0;
181 }
182 
200 int
201 T3(void * obj,
202  const SubscriberNumber inNumber,
203  const SubscriberSuffix inSuffix,
204  const ServerId inServerId,
205  const ServerBit inServerBit,
206  SessionDetails outSessionDetails,
207  ChangedBy outChangedBy,
208  ChangedTime outChangedTime,
209  Location * outLocation,
210  BranchExecuted * outBranchExecuted,
211  BenchmarkTime * outTransactionTime){
212 
213  Ndb * pNDB = (Ndb *) obj;
214 
215  GroupId groupId;
216  ActiveSessions sessions;
217  Permission permission;
218 
219  BenchmarkTime start;
220  get_time(&start);
221 
222  int check;
223  NdbRecAttr * check2;
224 
225  NdbConnection * MyTransaction = pNDB->startTransaction();
226  if (MyTransaction == NULL)
227  error_handler("T3-1: startTranscation", pNDB->getNdbErrorString(), 0);
228 
229  NdbOperation *MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
230  CHECK_NULL(MyOperation, "T3-1: getNdbOperation",
231  MyTransaction);
232 
233 
234  check = MyOperation->readTuple();
235  CHECK_MINUS_ONE(check, "T3-1: readTuple",
236  MyTransaction);
237 
238  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
239  inNumber);
240  CHECK_MINUS_ONE(check, "T3-1: equal subscriber",
241  MyTransaction);
242 
243  check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION,
244  (char *)outLocation);
245  CHECK_NULL(check2, "T3-1: getValue location",
246  MyTransaction);
247 
248  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY,
249  outChangedBy);
250  CHECK_NULL(check2, "T3-1: getValue changed_by",
251  MyTransaction);
252 
253  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME,
254  outChangedTime);
255  CHECK_NULL(check2, "T3-1: getValue changed_time",
256  MyTransaction);
257 
258  check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
259  (char *)&groupId);
260  CHECK_NULL(check2, "T3-1: getValue group",
261  MyTransaction);
262 
263  check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
264  (char *)&sessions);
265  CHECK_NULL(check2, "T3-1: getValue sessions",
266  MyTransaction);
267 
268  check = MyTransaction->execute( NoCommit );
269  CHECK_MINUS_ONE(check, "T3-1: NoCommit",
270  MyTransaction);
271 
272  /* Operation 2 */
273 
274  MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
275  CHECK_NULL(MyOperation, "T3-2: getNdbOperation",
276  MyTransaction);
277 
278 
279  check = MyOperation->readTuple();
280  CHECK_MINUS_ONE(check, "T3-2: readTuple",
281  MyTransaction);
282 
283  check = MyOperation->equal(IND_GROUP_ID,
284  (char*)&groupId);
285  CHECK_MINUS_ONE(check, "T3-2: equal group",
286  MyTransaction);
287 
288  check2 = MyOperation->getValue(IND_GROUP_ALLOW_READ,
289  (char *)&permission);
290  CHECK_NULL(check2, "T3-2: getValue allow_read",
291  MyTransaction);
292 
293  check = MyTransaction->execute( NoCommit );
294  CHECK_MINUS_ONE(check, "T3-2: NoCommit",
295  MyTransaction);
296 
297  DEBUG3("T3(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
298 
299  if(((permission & inServerBit) == inServerBit) &&
300  ((sessions & inServerBit) == inServerBit)){
301 
302  DEBUG("reading - ");
303 
304  /* Operation 3 */
305 
306  MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
307  CHECK_NULL(MyOperation, "T3-3: getNdbOperation",
308  MyTransaction);
309 
310  check = MyOperation->readTuple();
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);
318 
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 
331  MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
332  CHECK_NULL(MyOperation, "T3-4: getNdbOperation",
333  MyTransaction);
334 
335  check = MyOperation->interpretedUpdateTuple();
336  CHECK_MINUS_ONE(check, "T3-4: interpretedUpdateTuple",
337  MyTransaction);
338 
339  check = MyOperation->equal(IND_SERVER_ID,
340  (char*)&inServerId);
341  CHECK_MINUS_ONE(check, "T3-4: equal serverId",
342  MyTransaction);
343 
344  check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
345  (char*)inSuffix);
346  CHECK_MINUS_ONE(check, "T3-4: equal suffix",
347  MyTransaction);
348 
349  check = MyOperation->incValue(IND_SERVER_READS, (uint32)1);
350  CHECK_MINUS_ONE(check, "T3-4: inc value",
351  MyTransaction);
352 
353  (* outBranchExecuted) = 1;
354  } else {
355  (* outBranchExecuted) = 0;
356  }
357  DEBUG("commit\n");
358  check = MyTransaction->execute( Commit );
359  CHECK_MINUS_ONE(check, "T3: Commit",
360  MyTransaction);
361 
362  pNDB->closeTransaction(MyTransaction);
363 
364  get_time(outTransactionTime);
365  time_diff(outTransactionTime, &start);
366  return 0;
367 }
368 
369 
387 int
388 T4(void * obj,
389  const SubscriberNumber inNumber,
390  const SubscriberSuffix inSuffix,
391  const ServerId inServerId,
392  const ServerBit inServerBit,
393  const SessionDetails inSessionDetails,
394  ChangedBy outChangedBy,
395  ChangedTime outChangedTime,
396  Location * outLocation,
397  DoRollback inDoRollback,
398  BranchExecuted * outBranchExecuted,
399  BenchmarkTime * outTransactionTime){
400 
401  Ndb * pNDB = (Ndb *) obj;
402 
403  GroupId groupId;
404  ActiveSessions sessions;
405  Permission permission;
406 
407  BenchmarkTime start;
408  get_time(&start);
409 
410  int check;
411  NdbRecAttr * check2;
412 
413  NdbConnection * MyTransaction = pNDB->startTransaction();
414  if (MyTransaction == NULL)
415  error_handler("T4-1: startTranscation", pNDB->getNdbErrorString(), 0);
416 
417  DEBUG3("T4(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
418 
419  NdbOperation * MyOperation = 0;
420 
421  MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
422  CHECK_NULL(MyOperation, "T4-1: getNdbOperation",
423  MyTransaction);
424 
425  check = MyOperation->readTupleExclusive();
426  CHECK_MINUS_ONE(check, "T4-1: readTuple",
427  MyTransaction);
428 
429  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
430  inNumber);
431  CHECK_MINUS_ONE(check, "T4-1: equal subscriber",
432  MyTransaction);
433 
434  check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION,
435  (char *)outLocation);
436  CHECK_NULL(check2, "T4-1: getValue location",
437  MyTransaction);
438 
439  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY,
440  outChangedBy);
441  CHECK_NULL(check2, "T4-1: getValue changed_by",
442  MyTransaction);
443 
444  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME,
445  outChangedTime);
446  CHECK_NULL(check2, "T4-1: getValue changed_time",
447  MyTransaction);
448 
449  check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
450  (char *)&groupId);
451  CHECK_NULL(check2, "T4-1: getValue group",
452  MyTransaction);
453 
454  check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
455  (char *)&sessions);
456  CHECK_NULL(check2, "T4-1: getValue sessions",
457  MyTransaction);
458 
459  check = MyTransaction->execute( NoCommit );
460  CHECK_MINUS_ONE(check, "T4-1: NoCommit",
461  MyTransaction);
462 
463  /* Operation 2 */
464  MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
465  CHECK_NULL(MyOperation, "T4-2: getNdbOperation",
466  MyTransaction);
467 
468  check = MyOperation->readTuple();
469  CHECK_MINUS_ONE(check, "T4-2: readTuple",
470  MyTransaction);
471 
472  check = MyOperation->equal(IND_GROUP_ID,
473  (char*)&groupId);
474  CHECK_MINUS_ONE(check, "T4-2: equal group",
475  MyTransaction);
476 
477  check2 = MyOperation->getValue(IND_GROUP_ALLOW_INSERT,
478  (char *)&permission);
479  CHECK_NULL(check2, "T4-2: getValue allow_insert",
480  MyTransaction);
481 
482  check = MyTransaction->execute( NoCommit );
483  CHECK_MINUS_ONE(check, "T4-2: NoCommit",
484  MyTransaction);
485 
486  if(((permission & inServerBit) == inServerBit) &&
487  ((sessions & inServerBit) == 0)){
488 
489  DEBUG("inserting - ");
490 
491  /* Operation 3 */
492  MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
493  CHECK_NULL(MyOperation, "T4-3: getNdbOperation",
494  MyTransaction);
495 
496  check = MyOperation->insertTuple();
497  CHECK_MINUS_ONE(check, "T4-3: insertTuple",
498  MyTransaction);
499 
500  check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
501  (char*)inNumber);
502  CHECK_MINUS_ONE(check, "T4-3: equal number",
503  MyTransaction);
504 
505  check = MyOperation->equal(IND_SESSION_SERVER,
506  (char*)&inServerId);
507  CHECK_MINUS_ONE(check, "T4-3: equal server id",
508  MyTransaction);
509 
510  check = MyOperation->setValue(SESSION_DATA,
511  (char *)inSessionDetails);
512  CHECK_MINUS_ONE(check, "T4-3: setValue session details",
513  MyTransaction);
514 
515  /* Operation 4 */
516  MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
517  CHECK_NULL(MyOperation, "T4-4: getNdbOperation",
518  MyTransaction);
519 
520  check = MyOperation->interpretedUpdateTuple();
521  CHECK_MINUS_ONE(check, "T4-4: interpretedUpdateTuple",
522  MyTransaction);
523 
524  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
525  (char*)inNumber);
526  CHECK_MINUS_ONE(check, "T4-4: equal number",
527  MyTransaction);
528 
529  check = MyOperation->incValue(IND_SUBSCRIBER_SESSIONS,
530  (uint32)inServerBit);
531  CHECK_MINUS_ONE(check, "T4-4: inc value",
532  MyTransaction);
533 
534  /* Operation 5 */
535  MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
536  CHECK_NULL(MyOperation, "T4-5: getNdbOperation",
537  MyTransaction);
538 
539  check = MyOperation->interpretedUpdateTuple();
540  CHECK_MINUS_ONE(check, "T4-5: interpretedUpdateTuple",
541  MyTransaction);
542 
543  check = MyOperation->equal(IND_SERVER_ID,
544  (char*)&inServerId);
545  CHECK_MINUS_ONE(check, "T4-5: equal serverId",
546  MyTransaction);
547 
548  check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
549  (char*)inSuffix);
550  CHECK_MINUS_ONE(check, "T4-5: equal suffix",
551  MyTransaction);
552 
553  check = MyOperation->incValue(IND_SERVER_INSERTS, (uint32)1);
554  CHECK_MINUS_ONE(check, "T4-5: inc value",
555  MyTransaction);
556 
557  (* outBranchExecuted) = 1;
558  } else {
559  DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
560  DEBUG1("%s", ((sessions & inServerBit) ? "in session - " : "no in session - "));
561  (* outBranchExecuted) = 0;
562  }
563 
564  if(!inDoRollback){
565  DEBUG("commit\n");
566  check = MyTransaction->execute( Commit );
567  CHECK_MINUS_ONE(check, "T4: Commit",
568  MyTransaction);
569  } else {
570  DEBUG("rollback\n");
571  check = MyTransaction->execute(Rollback);
572  CHECK_MINUS_ONE(check, "T4:Rollback",
573  MyTransaction);
574 
575  }
576 
577  pNDB->closeTransaction(MyTransaction);
578 
579  get_time(outTransactionTime);
580  time_diff(outTransactionTime, &start);
581  return 0;
582 }
583 
584 
601 int
602 T5(void * obj,
603  const SubscriberNumber inNumber,
604  const SubscriberSuffix inSuffix,
605  const ServerId inServerId,
606  const ServerBit inServerBit,
607  ChangedBy outChangedBy,
608  ChangedTime outChangedTime,
609  Location * outLocation,
610  DoRollback inDoRollback,
611  BranchExecuted * outBranchExecuted,
612  BenchmarkTime * outTransactionTime){
613 
614  Ndb * pNDB = (Ndb *) obj;
615  NdbConnection * MyTransaction = 0;
616  NdbOperation * MyOperation = 0;
617 
618  GroupId groupId;
619  ActiveSessions sessions;
620  Permission permission;
621 
622  BenchmarkTime start;
623  get_time(&start);
624 
625  int check;
626  NdbRecAttr * check2;
627 
628  MyTransaction = pNDB->startTransaction();
629  if (MyTransaction == NULL)
630  error_handler("T5-1: startTranscation", pNDB->getNdbErrorString(), 0);
631 
632  MyOperation= MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
633  CHECK_NULL(MyOperation, "T5-1: getNdbOperation",
634  MyTransaction);
635 
636 
637  check = MyOperation->readTupleExclusive();
638  CHECK_MINUS_ONE(check, "T5-1: readTuple",
639  MyTransaction);
640 
641  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
642  inNumber);
643  CHECK_MINUS_ONE(check, "T5-1: equal subscriber",
644  MyTransaction);
645 
646  check2 = MyOperation->getValue(IND_SUBSCRIBER_LOCATION,
647  (char *)outLocation);
648  CHECK_NULL(check2, "T5-1: getValue location",
649  MyTransaction);
650 
651  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_BY,
652  outChangedBy);
653  CHECK_NULL(check2, "T5-1: getValue changed_by",
654  MyTransaction);
655 
656  check2 = MyOperation->getValue(IND_SUBSCRIBER_CHANGED_TIME,
657  outChangedTime);
658  CHECK_NULL(check2, "T5-1: getValue changed_time",
659  MyTransaction);
660 
661  check2 = MyOperation->getValue(IND_SUBSCRIBER_GROUP,
662  (char *)&groupId);
663  CHECK_NULL(check2, "T5-1: getValue group",
664  MyTransaction);
665 
666  check2 = MyOperation->getValue(IND_SUBSCRIBER_SESSIONS,
667  (char *)&sessions);
668  CHECK_NULL(check2, "T5-1: getValue sessions",
669  MyTransaction);
670 
671  check = MyTransaction->execute( NoCommit );
672  CHECK_MINUS_ONE(check, "T5-1: NoCommit",
673  MyTransaction);
674 
675  /* Operation 2 */
676 
677  MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
678  CHECK_NULL(MyOperation, "T5-2: getNdbOperation",
679  MyTransaction);
680 
681 
682  check = MyOperation->readTuple();
683  CHECK_MINUS_ONE(check, "T5-2: readTuple",
684  MyTransaction);
685 
686  check = MyOperation->equal(IND_GROUP_ID,
687  (char*)&groupId);
688  CHECK_MINUS_ONE(check, "T5-2: equal group",
689  MyTransaction);
690 
691  check2 = MyOperation->getValue(IND_GROUP_ALLOW_DELETE,
692  (char *)&permission);
693  CHECK_NULL(check2, "T5-2: getValue allow_delete",
694  MyTransaction);
695 
696  check = MyTransaction->execute( NoCommit );
697  CHECK_MINUS_ONE(check, "T5-2: NoCommit",
698  MyTransaction);
699 
700  DEBUG3("T5(%.*s, %.2d): ", SUBSCRIBER_NUMBER_LENGTH, inNumber, inServerId);
701 
702  if(((permission & inServerBit) == inServerBit) &&
703  ((sessions & inServerBit) == inServerBit)){
704 
705  DEBUG("deleting - ");
706 
707  /* Operation 3 */
708  MyOperation = MyTransaction->getNdbOperation(SESSION_TABLE);
709  CHECK_NULL(MyOperation, "T5-3: getNdbOperation",
710  MyTransaction);
711 
712  check = MyOperation->deleteTuple();
713  CHECK_MINUS_ONE(check, "T5-3: deleteTuple",
714  MyTransaction);
715 
716  check = MyOperation->equal(IND_SESSION_SUBSCRIBER,
717  (char*)inNumber);
718  CHECK_MINUS_ONE(check, "T5-3: equal number",
719  MyTransaction);
720 
721  check = MyOperation->equal(IND_SESSION_SERVER,
722  (char*)&inServerId);
723  CHECK_MINUS_ONE(check, "T5-3: equal server id",
724  MyTransaction);
725 
726  /* Operation 4 */
727  MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
728  CHECK_NULL(MyOperation, "T5-4: getNdbOperation",
729  MyTransaction);
730 
731  check = MyOperation->interpretedUpdateTuple();
732  CHECK_MINUS_ONE(check, "T5-4: interpretedUpdateTuple",
733  MyTransaction);
734 
735  check = MyOperation->equal(IND_SUBSCRIBER_NUMBER,
736  (char*)inNumber);
737  CHECK_MINUS_ONE(check, "T5-4: equal number",
738  MyTransaction);
739 
740  check = MyOperation->subValue(IND_SUBSCRIBER_SESSIONS,
741  (uint32)inServerBit);
742  CHECK_MINUS_ONE(check, "T5-4: dec value",
743  MyTransaction);
744 
745  /* Operation 5 */
746  MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
747  CHECK_NULL(MyOperation, "T5-5: getNdbOperation",
748  MyTransaction);
749 
750 
751  check = MyOperation->interpretedUpdateTuple();
752  CHECK_MINUS_ONE(check, "T5-5: interpretedUpdateTuple",
753  MyTransaction);
754 
755  check = MyOperation->equal(IND_SERVER_ID,
756  (char*)&inServerId);
757  CHECK_MINUS_ONE(check, "T5-5: equal serverId",
758  MyTransaction);
759 
760  check = MyOperation->equal(IND_SERVER_SUBSCRIBER_SUFFIX,
761  (char*)inSuffix);
762  CHECK_MINUS_ONE(check, "T5-5: equal suffix",
763  MyTransaction);
764 
765  check = MyOperation->incValue(IND_SERVER_DELETES, (uint32)1);
766  CHECK_MINUS_ONE(check, "T5-5: inc value",
767  MyTransaction);
768 
769  (* outBranchExecuted) = 1;
770  } else {
771  DEBUG1("%s", ((permission & inServerBit) ? "permission - " : "no permission - "));
772  DEBUG1("%s", ((sessions & inServerBit) ? "in session - " : "no in session - "));
773  (* outBranchExecuted) = 0;
774  }
775 
776  if(!inDoRollback){
777  DEBUG("commit\n");
778  check = MyTransaction->execute( Commit );
779  CHECK_MINUS_ONE(check, "T5: Commit",
780  MyTransaction);
781  } else {
782  DEBUG("rollback\n");
783  check = MyTransaction->execute(Rollback);
784  CHECK_MINUS_ONE(check, "T5:Rollback",
785  MyTransaction);
786 
787  }
788 
789  pNDB->closeTransaction(MyTransaction);
790 
791  get_time(outTransactionTime);
792  time_diff(outTransactionTime, &start);
793  return 0;
794 }
795