MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
LqhKey.hpp
1 /*
2  Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3 
4  This program is free software; you can redistribute it and/or modify
5  it under the terms of the GNU General Public License as published by
6  the Free Software Foundation; version 2 of the License.
7 
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.
12 
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17 
18 #ifndef LQH_KEY_H
19 #define LQH_KEY_H
20 
21 #include "SignalData.hpp"
22 #include <trigger_definitions.h>
23 
24 class LqhKeyReq {
28  friend class Dblqh; // Reciver
29 
33  friend class Dbspj;
34  friend class Dbtc;
35  friend class Restore;
36 
40  friend bool printLQHKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
41 
42 public:
43  STATIC_CONST( FixedSignalLength = 11 );
44  STATIC_CONST( MaxKeyInfo = 4 );
45  STATIC_CONST( MaxAttrInfo = 5);
46 
47  /* Long LQHKEYREQ definitions */
48  STATIC_CONST( KeyInfoSectionNum = 0 );
49  STATIC_CONST( AttrInfoSectionNum = 1 );
50 
51  STATIC_CONST( UnlockKeyLen = 2 );
52 
53 private:
54 
58 //-------------------------------------------------------------
59 // Unconditional part. First 10 words
60 //-------------------------------------------------------------
61  UintR clientConnectPtr; // DATA 0
62  UintR attrLen; // DATA 1
63  UintR hashValue; // DATA 2
64  UintR requestInfo; // DATA 3
65  UintR tcBlockref; // DATA 4
66  UintR tableSchemaVersion; // DATA 5
67  UintR fragmentData; // DATA 6
68  UintR transId1; // DATA 7
69  UintR transId2; // DATA 8
70  UintR savePointId; // DATA 9
71  union {
76  UintR noFiredTriggers; // DATA 10
77  Uint32 scanInfo; // DATA 10
78  };
79 
80 //-------------------------------------------------------------
81 // Variable sized key part. Those will be placed to
82 // pack the signal in an appropriate manner.
83 //-------------------------------------------------------------
84  UintR variableData[10]; // DATA 11 - 21
85 
86  static UintR getAttrLen(const UintR & scanInfoAttrLen);
87  static UintR getScanTakeOverFlag(const UintR & scanInfoAttrLen);
88  static UintR getStoredProcFlag(const UintR & scanData);
89  static UintR getDistributionKey(const UintR & scanData);
90  static UintR getReorgFlag(const UintR& scanData);
91  static void setReorgFlag(UintR& scanData, Uint32 val);
92 
93  static UintR getTableId(const UintR & tableSchemaVersion);
94  static UintR getSchemaVersion(const UintR & tableSchemaVersion);
95 
96  static UintR getFragmentId(const UintR & fragmentData);
97  static UintR getNextReplicaNodeId(const UintR & fragmentData);
98 
99  static Uint8 getLockType(const UintR & requestInfo);
100  static Uint8 getDirtyFlag(const UintR & requestInfo);
101  static Uint8 getInterpretedFlag(const UintR & requestInfo);
102  static Uint8 getSimpleFlag(const UintR & requestInfo);
103  static Uint8 getOperation(const UintR & requestInfo);
104  static Uint8 getSeqNoReplica(const UintR & requestInfo);
105  static Uint8 getLastReplicaNo(const UintR & requestInfo);
106  static Uint8 getAIInLqhKeyReq(const UintR & requestInfo);
107  static UintR getKeyLen(const UintR & requestInfo);
108  static UintR getSameClientAndTcFlag(const UintR & requestInfo);
109  static UintR getReturnedReadLenAIFlag(const UintR & requestInfo);
110  static UintR getApplicationAddressFlag(const UintR & requestInfo);
111  static UintR getMarkerFlag(const UintR & requestInfo);
112  static UintR getNoDiskFlag(const UintR & requestInfo);
113 
118  static void setAttrLen(UintR & scanInfoAttrLen, UintR val);
119  static void setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val);
120  static void setStoredProcFlag(UintR & scanData, UintR val);
121  static void setDistributionKey(UintR & scanData, UintR val);
122 
123  static void setTableId(UintR & tableSchemaVersion, UintR val);
124  static void setSchemaVersion(UintR & tableSchemaVersion, UintR val);
125 
126  static void setFragmentId(UintR & fragmentData, UintR val);
127  static void setNextReplicaNodeId(UintR & fragmentData, UintR val);
128 
129  static void setLockType(UintR & requestInfo, UintR val);
130  static void setDirtyFlag(UintR & requestInfo, UintR val);
131  static void setInterpretedFlag(UintR & requestInfo, UintR val);
132  static void setSimpleFlag(UintR & requestInfo, UintR val);
133  static void setOperation(UintR & requestInfo, UintR val);
134  static void setSeqNoReplica(UintR & requestInfo, UintR val);
135  static void setLastReplicaNo(UintR & requestInfo, UintR val);
136  static void setAIInLqhKeyReq(UintR & requestInfo, UintR val);
137  static void setKeyLen(UintR & requestInfo, UintR val);
138  static void setSameClientAndTcFlag(UintR & requestInfo, UintR val);
139  static void setReturnedReadLenAIFlag(UintR & requestInfo, UintR val);
140  static void setApplicationAddressFlag(UintR & requestInfo, UintR val);
141  static void setMarkerFlag(UintR & requestInfo, UintR val);
142  static void setNoDiskFlag(UintR & requestInfo, UintR val);
143 
144  static UintR getRowidFlag(const UintR & requestInfo);
145  static void setRowidFlag(UintR & requestInfo, UintR val);
146 
150  static UintR getGCIFlag(const UintR & requestInfo);
151  static void setGCIFlag(UintR & requestInfo, UintR val);
152 
153  static UintR getNrCopyFlag(const UintR & requestInfo);
154  static void setNrCopyFlag(UintR & requestInfo, UintR val);
155 
156  static UintR getQueueOnRedoProblemFlag(const UintR & requestInfo);
157  static void setQueueOnRedoProblemFlag(UintR & requestInfo, UintR val);
158 
162  static UintR getNormalProtocolFlag(const UintR & requestInfo);
163  static void setNormalProtocolFlag(UintR & requestInfo, UintR val);
164 
168  static UintR getCorrFactorFlag(const UintR & requestInfo);
169  static void setCorrFactorFlag(UintR & requestInfo, UintR val);
170 
174  static UintR getDeferredConstraints(const UintR & requestInfo);
175  static void setDeferredConstraints(UintR & requestInfo, UintR val);
176 };
177 
220 #define RI_KEYLEN_SHIFT (0)
221 #define RI_KEYLEN_MASK (1023)
222 #define RI_LAST_REPL_SHIFT (10)
223 #define RI_LAST_REPL_MASK (3)
224 #define RI_LOCK_TYPE_SHIFT (12)
225 #define RI_LOCK_TYPE_MASK (7)
226 #define RI_APPL_ADDR_SHIFT (15)
227 #define RI_DIRTY_SHIFT (16)
228 #define RI_INTERPRETED_SHIFT (17)
229 #define RI_SIMPLE_SHIFT (18)
230 #define RI_OPERATION_SHIFT (19)
231 #define RI_OPERATION_MASK (7)
232 #define RI_SEQ_REPLICA_SHIFT (22)
233 #define RI_SEQ_REPLICA_MASK (3)
234 #define RI_AI_IN_THIS_SHIFT (24)
235 #define RI_AI_IN_THIS_MASK (7)
236 #define RI_SAME_CLIENT_SHIFT (27)
237 #define RI_RETURN_AI_SHIFT (28)
238 #define RI_MARKER_SHIFT (29)
239 #define RI_NODISK_SHIFT (30)
240 #define RI_ROWID_SHIFT (31)
241 #define RI_GCI_SHIFT (12)
242 #define RI_NR_COPY_SHIFT (13)
243 #define RI_QUEUE_REDO_SHIFT (14)
244 #define RI_CORR_FACTOR_VALUE (24)
245 #define RI_NORMAL_DIRTY (25)
246 #define RI_DEFERRED_CONSTAINTS (26)
247 
264 #define SI_ATTR_LEN_MASK (65535)
265 #define SI_ATTR_LEN_SHIFT (0)
266 #define SI_STORED_PROC_SHIFT (16)
267 #define SI_DISTR_KEY_MASK (255)
268 #define SI_DISTR_KEY_SHIFT (17)
269 #define SI_SCAN_TO_SHIFT (25)
270 #define SI_REORG_SHIFT (26)
271 #define SI_REORG_MASK (3)
272 
273 inline
274 UintR
275 LqhKeyReq::getAttrLen(const UintR & scanData)
276 {
277  return (scanData >> SI_ATTR_LEN_SHIFT) & SI_ATTR_LEN_MASK;
278 }
279 
280 inline
281 Uint32
282 LqhKeyReq::getScanTakeOverFlag(const UintR & scanData)
283 {
284  return (scanData >> SI_SCAN_TO_SHIFT) & 1;
285 }
286 
287 inline
288 UintR
289 LqhKeyReq::getStoredProcFlag(const UintR & scanData){
290  return (scanData >> SI_STORED_PROC_SHIFT) & 1;
291 }
292 
293 inline
294 UintR
295 LqhKeyReq::getDistributionKey(const UintR & scanData){
296  return (scanData >> SI_DISTR_KEY_SHIFT) & SI_DISTR_KEY_MASK;
297 }
298 
299 inline
300 UintR LqhKeyReq::getTableId(const UintR & tableSchemaVersion)
301 {
302  return tableSchemaVersion & 0xFFFF;
303 }
304 
305 inline
306 UintR LqhKeyReq::getSchemaVersion(const UintR & tableSchemaVersion)
307 {
308  return tableSchemaVersion >> 16;
309 }
310 
311 inline
312 UintR LqhKeyReq::getFragmentId(const UintR & fragmentData)
313 {
314  return fragmentData & 0xFFFF;
315 }
316 
317 inline
318 UintR LqhKeyReq::getNextReplicaNodeId(const UintR & fragmentData)
319 {
320  return fragmentData >> 16;
321 }
322 
323 inline
324 Uint8 LqhKeyReq::getLastReplicaNo(const UintR & requestInfo)
325 {
326  return (requestInfo >> RI_LAST_REPL_SHIFT) & RI_LAST_REPL_MASK;
327 }
328 
329 inline
330 Uint8 LqhKeyReq::getLockType(const UintR & requestInfo)
331 {
332  return (requestInfo >> RI_LOCK_TYPE_SHIFT) & RI_LOCK_TYPE_MASK;
333 }
334 
335 inline
336 Uint8 LqhKeyReq::getDirtyFlag(const UintR & requestInfo)
337 {
338  return (requestInfo >> RI_DIRTY_SHIFT) & 1;
339 }
340 
341 inline
342 Uint8 LqhKeyReq::getInterpretedFlag(const UintR & requestInfo)
343 {
344  return (requestInfo >> RI_INTERPRETED_SHIFT) & 1;
345 }
346 
347 inline
348 Uint8 LqhKeyReq::getSimpleFlag(const UintR & requestInfo)
349 {
350  return (requestInfo >> RI_SIMPLE_SHIFT) & 1;
351 }
352 
353 inline
354 Uint8 LqhKeyReq::getOperation(const UintR & requestInfo)
355 {
356  return (requestInfo >> RI_OPERATION_SHIFT) & RI_OPERATION_MASK;
357 }
358 
359 inline
360 Uint8 LqhKeyReq::getSeqNoReplica(const UintR & requestInfo)
361 {
362  return (requestInfo >> RI_SEQ_REPLICA_SHIFT) & RI_SEQ_REPLICA_MASK;
363 }
364 
365 
366 inline
367 Uint8 LqhKeyReq::getAIInLqhKeyReq(const UintR & requestInfo)
368 {
369  return (requestInfo >> RI_AI_IN_THIS_SHIFT) & RI_AI_IN_THIS_MASK;
370 }
371 
372 inline
373 UintR LqhKeyReq::getKeyLen(const UintR & requestInfo)
374 {
375  return (requestInfo >> RI_KEYLEN_SHIFT) & RI_KEYLEN_MASK;
376 }
377 
378 inline
379 UintR
380 LqhKeyReq::getSameClientAndTcFlag(const UintR & requestInfo)
381 {
382  return (requestInfo >> RI_SAME_CLIENT_SHIFT) & 1;
383 }
384 
385 inline
386 UintR LqhKeyReq::getReturnedReadLenAIFlag(const UintR & requestInfo)
387 {
388  return (requestInfo >> RI_RETURN_AI_SHIFT) & 1;
389 }
390 
391 inline
392 UintR
393 LqhKeyReq::getApplicationAddressFlag(const UintR & requestInfo){
394  return (requestInfo >> RI_APPL_ADDR_SHIFT) & 1;
395 }
396 
397 inline
398 void
399 LqhKeyReq::setAttrLen(UintR & scanInfoAttrLen, UintR val){
400  ASSERT_MAX(val, SI_ATTR_LEN_MASK, "LqhKeyReq::setAttrLen");
401  scanInfoAttrLen |= (val << SI_ATTR_LEN_SHIFT);
402 }
403 
404 
405 inline
406 void
407 LqhKeyReq::setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val){
408  ASSERT_BOOL(val, "LqhKeyReq::setScanTakeOverFlag");
409  scanInfoAttrLen |= (val << SI_SCAN_TO_SHIFT);
410 }
411 
412 inline
413 void
414 LqhKeyReq::setStoredProcFlag(UintR & scanData, UintR val){
415  ASSERT_BOOL(val, "LqhKeyReq::setStoredProcFlag");
416  scanData |= (val << SI_STORED_PROC_SHIFT);
417 }
418 
419 inline
420 void
421 LqhKeyReq::setDistributionKey(UintR & scanData, UintR val){
422  ASSERT_MAX(val, SI_DISTR_KEY_MASK, "LqhKeyReq::setDistributionKey");
423  scanData |= (val << SI_DISTR_KEY_SHIFT);
424 }
425 
426 inline
427 Uint32
428 LqhKeyReq::getReorgFlag(const UintR & scanData){
429  return (scanData >> SI_REORG_SHIFT) & SI_REORG_MASK;
430 }
431 
432 inline
433 void
434 LqhKeyReq::setReorgFlag(UintR & scanData, UintR val){
435  ASSERT_MAX(val, SI_REORG_MASK, "LqhKeyReq::setMovingFlag");
436  scanData |= (val << SI_REORG_SHIFT);
437 }
438 
439 #if 0
440 inline
441 void
442 
443 LqhKeyReq::setTableId(UintR & tableSchemaVersion, UintR val){
444 
445 }
446 inline
447 void
448 LqhKeyReq::setSchemaVersion(UintR & tableSchemaVersion, UintR val);
449 
450 inline
451 void
452 LqhKeyReq::setFragmentId(UintR & fragmentData, UintR val);
453 
454 inline
455 void
456 LqhKeyReq::setNextReplicaNodeId(UintR & fragmentData, UintR val);
457 #endif
458 
459 inline
460 void
461 LqhKeyReq::setLockType(UintR & requestInfo, UintR val){
462  ASSERT_MAX(val, RI_LOCK_TYPE_MASK, "LqhKeyReq::setLockType");
463  requestInfo |= (val << RI_LOCK_TYPE_SHIFT);
464 }
465 
466 inline
467 void
468 LqhKeyReq::setDirtyFlag(UintR & requestInfo, UintR val){
469  ASSERT_BOOL(val, "LqhKeyReq::setDirtyFlag");
470  requestInfo |= (val << RI_DIRTY_SHIFT);
471 }
472 
473 inline
474 void
475 LqhKeyReq::setInterpretedFlag(UintR & requestInfo, UintR val){
476  ASSERT_BOOL(val, "LqhKeyReq::setInterpretedFlag");
477  requestInfo |= (val << RI_INTERPRETED_SHIFT);
478 }
479 
480 inline
481 void
482 LqhKeyReq::setSimpleFlag(UintR & requestInfo, UintR val){
483  ASSERT_BOOL(val, "LqhKeyReq::setSimpleFlag");
484  requestInfo |= (val << RI_SIMPLE_SHIFT);
485 }
486 
487 inline
488 void
489 LqhKeyReq::setOperation(UintR & requestInfo, UintR val){
490  ASSERT_MAX(val, RI_OPERATION_MASK, "LqhKeyReq::setOperation");
491  requestInfo |= (val << RI_OPERATION_SHIFT);
492 }
493 
494 inline
495 void
496 LqhKeyReq::setSeqNoReplica(UintR & requestInfo, UintR val){
497  ASSERT_MAX(val, RI_SEQ_REPLICA_MASK, "LqhKeyReq::setSeqNoReplica");
498  requestInfo |= (val << RI_SEQ_REPLICA_SHIFT);
499 }
500 
501 inline
502 void
503 LqhKeyReq::setLastReplicaNo(UintR & requestInfo, UintR val){
504  ASSERT_MAX(val, RI_LAST_REPL_MASK, "LqhKeyReq::setLastReplicaNo");
505  requestInfo |= (val << RI_LAST_REPL_SHIFT);
506 }
507 
508 inline
509 void
510 LqhKeyReq::setAIInLqhKeyReq(UintR & requestInfo, UintR val){
511  ASSERT_MAX(val, RI_AI_IN_THIS_MASK, "LqhKeyReq::setAIInLqhKeyReq");
512  requestInfo |= (val << RI_AI_IN_THIS_SHIFT);
513 }
514 
515 inline
516 void
517 LqhKeyReq::setKeyLen(UintR & requestInfo, UintR val){
518  ASSERT_MAX(val, RI_KEYLEN_MASK, "LqhKeyReq::setKeyLen");
519  requestInfo |= (val << RI_KEYLEN_SHIFT);
520 }
521 
522 inline
523 void
524 LqhKeyReq::setSameClientAndTcFlag(UintR & requestInfo, UintR val){
525  ASSERT_BOOL(val, "LqhKeyReq::setSameClientAndTcFlag");
526  requestInfo |= (val << RI_SAME_CLIENT_SHIFT);
527 }
528 
529 inline
530 void
531 LqhKeyReq::setReturnedReadLenAIFlag(UintR & requestInfo, UintR val){
532  ASSERT_BOOL(val, "LqhKeyReq::setReturnedReadLenAIFlag");
533  requestInfo |= (val << RI_RETURN_AI_SHIFT);
534 }
535 
536 inline
537 void
538 LqhKeyReq::setApplicationAddressFlag(UintR & requestInfo, UintR val){
539  ASSERT_BOOL(val, "LqhKeyReq::setApplicationAddressFlag");
540  requestInfo |= (val << RI_APPL_ADDR_SHIFT);
541 }
542 
543 /**** */
544 
545 inline
546 void
547 LqhKeyReq::setMarkerFlag(UintR & requestInfo, UintR val){
548  ASSERT_BOOL(val, "LqhKeyReq::setMarkerFlag");
549  requestInfo |= (val << RI_MARKER_SHIFT);
550 }
551 
552 inline
553 UintR
554 LqhKeyReq::getMarkerFlag(const UintR & requestInfo){
555  return (requestInfo >> RI_MARKER_SHIFT) & 1;
556 }
557 
558 inline
559 void
560 LqhKeyReq::setNoDiskFlag(UintR & requestInfo, UintR val){
561  ASSERT_BOOL(val, "LqhKeyReq::setNoDiskFlag");
562  requestInfo |= (val << RI_NODISK_SHIFT);
563 }
564 
565 inline
566 UintR
567 LqhKeyReq::getNoDiskFlag(const UintR & requestInfo){
568  return (requestInfo >> RI_NODISK_SHIFT) & 1;
569 }
570 
571 inline
572 void
573 LqhKeyReq::setRowidFlag(UintR & requestInfo, UintR val){
574  ASSERT_BOOL(val, "LqhKeyReq::setRowidFlag");
575  requestInfo |= (val << RI_ROWID_SHIFT);
576 }
577 
578 inline
579 UintR
580 LqhKeyReq::getRowidFlag(const UintR & requestInfo){
581  return (requestInfo >> RI_ROWID_SHIFT) & 1;
582 }
583 
584 inline
585 void
586 LqhKeyReq::setGCIFlag(UintR & requestInfo, UintR val){
587  ASSERT_BOOL(val, "LqhKeyReq::setGciFlag");
588  requestInfo |= (val << RI_GCI_SHIFT);
589 }
590 
591 inline
592 UintR
593 LqhKeyReq::getGCIFlag(const UintR & requestInfo){
594  return (requestInfo >> RI_GCI_SHIFT) & 1;
595 }
596 
597 inline
598 void
599 LqhKeyReq::setNrCopyFlag(UintR & requestInfo, UintR val){
600  ASSERT_BOOL(val, "LqhKeyReq::setNrCopyFlag");
601  requestInfo |= (val << RI_NR_COPY_SHIFT);
602 }
603 
604 inline
605 UintR
606 LqhKeyReq::getNrCopyFlag(const UintR & requestInfo){
607  return (requestInfo >> RI_NR_COPY_SHIFT) & 1;
608 }
609 
610 inline
611 void
612 LqhKeyReq::setNormalProtocolFlag(UintR & requestInfo, UintR val){
613  ASSERT_BOOL(val, "LqhKeyReq::setNrCopyFlag");
614  requestInfo |= (val << RI_NORMAL_DIRTY);
615 }
616 
617 inline
618 UintR
619 LqhKeyReq::getNormalProtocolFlag(const UintR & requestInfo){
620  return (requestInfo >> RI_NORMAL_DIRTY) & 1;
621 }
622 
623 inline
624 void
625 LqhKeyReq::setCorrFactorFlag(UintR & requestInfo, UintR val){
626  ASSERT_BOOL(val, "LqhKeyReq::setCorrFactorFlag");
627  requestInfo |= (val << RI_CORR_FACTOR_VALUE);
628 }
629 
630 inline
631 UintR
632 LqhKeyReq::getCorrFactorFlag(const UintR & requestInfo){
633  return (requestInfo >> RI_CORR_FACTOR_VALUE) & 1;
634 }
635 
636 inline
637 void
638 LqhKeyReq::setDeferredConstraints(UintR & requestInfo, UintR val){
639  ASSERT_BOOL(val, "LqhKeyReq::setDeferredConstraints");
640  requestInfo |= (val << RI_DEFERRED_CONSTAINTS);
641 }
642 
643 inline
644 UintR
645 LqhKeyReq::getDeferredConstraints(const UintR & requestInfo){
646  return (requestInfo >> RI_DEFERRED_CONSTAINTS) & 1;
647 }
648 
649 inline
650 Uint32
651 table_version_major_lqhkeyreq(Uint32 x)
652 {
653  // LQHKEYREQ only contains 16-bit schema version...
654  return x & 0xFFFF;
655 }
656 
657 
658 inline
659 void
660 LqhKeyReq::setQueueOnRedoProblemFlag(UintR & requestInfo, UintR val){
661  ASSERT_BOOL(val, "LqhKeyReq::setQueueOnRedoProblem");
662  requestInfo |= (val << RI_QUEUE_REDO_SHIFT);
663 }
664 
665 inline
666 UintR
667 LqhKeyReq::getQueueOnRedoProblemFlag(const UintR & requestInfo){
668  return (requestInfo >> RI_QUEUE_REDO_SHIFT) & 1;
669 }
670 
671 class LqhKeyConf {
675  friend class Dbtc;
676  friend class Restore;
677  friend class Dbspj;
678 
682  friend class Dblqh;
683 
684  // Sent in a packed signal
685  friend class PackedSignal;
689  friend bool printPACKED_SIGNAL(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
690  friend bool printLQHKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
691 
692 public:
693  STATIC_CONST( SignalLength = 7 );
694 
695 private:
696 
700  Uint32 connectPtr;
701  Uint32 opPtr;
702  Uint32 userRef;
703  union {
708  Uint32 readLen;
709  Uint32 unlockTcRef;
710  };
711  Uint32 transId1;
712  Uint32 transId2;
713  Uint32 noFiredTriggers; // bit 31 defered trigger
714 
715  static Uint32 getFiredCount(Uint32 v) {
716  return NoOfFiredTriggers::getFiredCount(v);
717  }
718  static Uint32 getDeferredBit(Uint32 v) {
719  return NoOfFiredTriggers::getDeferredBit(v);
720  }
721  static void setDeferredBit(Uint32 & v) {
722  NoOfFiredTriggers::setDeferredBit(v);
723  }
724 };
725 
726 class LqhKeyRef {
730  friend class Dbtc;
731  friend class Dbspj;
732  friend class Restore;
733 
737  friend class Dblqh;
738 
742  friend bool printLQHKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
743 
744 public:
745  STATIC_CONST( SignalLength = 5 );
746 
747 private:
748 
752  Uint32 userRef;
753  Uint32 connectPtr;
754  Uint32 errorCode;
755  Uint32 transId1;
756  Uint32 transId2;
757 };
758 
759 #endif