release/src/router/mysql/storage/ndb/include/kernel/signaldata/AccScan.hpp

   1 /* Copyright (c) 2003-2007 MySQL AB
   2
   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; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #ifndef ACC_SCAN_HPP
  17 #define ACC_SCAN_HPP
  18
  19 #include "SignalData.hpp"
  20
  21 /*
  22  * Used by ACC and TUX scan.
  23  */
  24
  25 class AccScanReq {
  26   /**
  27    * Sender(s)
  28    */
  29   friend class Dblqh;
  30
  31   /**
  32    * Reciver(s)
  33    */
  34   friend class Dbacc;
  35   friend class Dbtux;
  36   friend class Dbtup;
  37 public:
  38   STATIC_CONST( SignalLength = 8 );
  39
  40 private:
  41   Uint32 senderData;
  42   Uint32 senderRef;
  43   Uint32 tableId;
  44   Uint32 fragmentNo;
  45   Uint32 requestInfo;
  46   Uint32 transId1;
  47   Uint32 transId2;
  48   union {
  49     Uint32 savePointId;
  50     Uint32 gci;
  51   };
  52   Uint32 maxPage;
  53
  54   /**
  55    * Previously there where also a scan type
  56    */
  57   static Uint32 getLockMode(const Uint32 & requestInfo);
  58   static Uint32 getReadCommittedFlag(const Uint32 & requestInfo);
  59   static Uint32 getDescendingFlag(const Uint32 & requestInfo);
  60
  61   static void setLockMode(Uint32 & requestInfo, Uint32 lockMode);
  62   static void setReadCommittedFlag(Uint32 & requestInfo, Uint32 readCommitted);
  63   static void setDescendingFlag(Uint32 & requestInfo, Uint32 descending);
  64
  65   static Uint32 getNoDiskScanFlag(const Uint32 & requestInfo);
  66   static void setNoDiskScanFlag(Uint32 & requestInfo, Uint32 nodisk);
  67
  68   static Uint32 getNRScanFlag(const Uint32 & requestInfo);
  69   static void setNRScanFlag(Uint32 & requestInfo, Uint32 nr);
  70
  71   static Uint32 getLcpScanFlag(const Uint32 & requestInfo);
  72   static void setLcpScanFlag(Uint32 & requestInfo, Uint32 nr);
  73 };
  74
  75 /**
  76  * Request Info
  77  *
  78  * l = Lock Mode             - 1  Bit 2
  79  * h = Read Committed        - 1  Bit 5
  80  * z = Descending (TUX)      - 1  Bit 6
  81  * d = No disk scan          - 1  Bit 7
  82  * n = Node recovery scan    - 1  Bit 8
  83  * c = LCP scan              - 1  Bit 9
  84  *
  85  *           1111111111222222222233
  86  * 01234567890123456789012345678901
  87  *   l  hzdn
  88  */
  89 #define AS_LOCK_MODE_SHIFT       (2)
  90 #define AS_LOCK_MODE_MASK        (1)
  91 #define AS_READ_COMMITTED_SHIFT  (5)
  92 #define AS_DESCENDING_SHIFT      (6)
  93 #define AS_NO_DISK_SCAN          (7)
  94 #define AS_NR_SCAN               (8)
  95 #define AS_LCP_SCAN              (9)
  96
  97 inline
  98 Uint32
  99 AccScanReq::getLockMode(const Uint32 & requestInfo){
 100   return (requestInfo >> AS_LOCK_MODE_SHIFT) & AS_LOCK_MODE_MASK;
 101 }
 102
 103 inline
 104 Uint32
 105 AccScanReq::getReadCommittedFlag(const Uint32 & requestInfo){
 106   return (requestInfo >> AS_READ_COMMITTED_SHIFT) & 1;
 107 }
 108
 109 inline
 110 Uint32
 111 AccScanReq::getDescendingFlag(const Uint32 & requestInfo){
 112   return (requestInfo >> AS_DESCENDING_SHIFT) & 1;
 113 }
 114
 115 inline
 116 void
 117 AccScanReq::setLockMode(UintR & requestInfo, UintR val){
 118   ASSERT_MAX(val, AS_LOCK_MODE_MASK, "AccScanReq::setLockMode");
 119   requestInfo |= (val << AS_LOCK_MODE_SHIFT);
 120 }
 121
 122 inline
 123 void
 124 AccScanReq::setReadCommittedFlag(UintR & requestInfo, UintR val){
 125   ASSERT_BOOL(val, "AccScanReq::setReadCommittedFlag");
 126   requestInfo |= (val << AS_READ_COMMITTED_SHIFT);
 127 }
 128
 129 inline
 130 void
 131 AccScanReq::setDescendingFlag(UintR & requestInfo, UintR val){
 132   ASSERT_BOOL(val, "AccScanReq::setDescendingFlag");
 133   requestInfo |= (val << AS_DESCENDING_SHIFT);
 134 }
 135
 136 inline
 137 Uint32
 138 AccScanReq::getNoDiskScanFlag(const Uint32 & requestInfo){
 139   return (requestInfo >> AS_NO_DISK_SCAN) & 1;
 140 }
 141
 142 inline
 143 void
 144 AccScanReq::setNoDiskScanFlag(UintR & requestInfo, UintR val){
 145   ASSERT_BOOL(val, "AccScanReq::setNoDiskScanFlag");
 146   requestInfo |= (val << AS_NO_DISK_SCAN);
 147 }
 148
 149 inline
 150 Uint32
 151 AccScanReq::getNRScanFlag(const Uint32 & requestInfo){
 152   return (requestInfo >> AS_NR_SCAN) & 1;
 153 }
 154
 155 inline
 156 void
 157 AccScanReq::setNRScanFlag(UintR & requestInfo, UintR val){
 158   ASSERT_BOOL(val, "AccScanReq::setNoDiskScanFlag");
 159   requestInfo |= (val << AS_NR_SCAN);
 160 }
 161
 162 inline
 163 Uint32
 164 AccScanReq::getLcpScanFlag(const Uint32 & requestInfo){
 165   return (requestInfo >> AS_LCP_SCAN) & 1;
 166 }
 167
 168 inline
 169 void
 170 AccScanReq::setLcpScanFlag(UintR & requestInfo, UintR val){
 171   ASSERT_BOOL(val, "AccScanReq::setNoDiskScanFlag");
 172   requestInfo |= (val << AS_LCP_SCAN);
 173 }
 174
 175 class AccScanConf {
 176   /**
 177    * Sender(s)
 178    */
 179   friend class Dbacc;
 180   friend class Dbtux;
 181   friend class Dbtup;
 182
 183   /**
 184    * Reciver(s)
 185    */
 186   friend class Dblqh;
 187
 188   enum {
 189     ZEMPTY_FRAGMENT = 0,
 190     ZNOT_EMPTY_FRAGMENT = 1
 191   };
 192
 193 public:
 194   STATIC_CONST( SignalLength = 8 );
 195
 196 private:
 197   Uint32 scanPtr;
 198   Uint32 accPtr;
 199   Uint32 unused1;
 200   Uint32 unused2;
 201   Uint32 unused3;
 202   Uint32 unused4;
 203   Uint32 unused5;
 204   Uint32 flag;
 205 };
 206
 207 class AccCheckScan {
 208   friend class Dbacc;
 209   friend class Dbtux;
 210   friend class Dbtup;
 211   friend class Dblqh;
 212   enum {
 213     ZCHECK_LCP_STOP = 0,
 214     ZNOT_CHECK_LCP_STOP = 1
 215   };
 216 public:
 217   STATIC_CONST( SignalLength = 2 );
 218 private:
 219   Uint32 accPtr;                // scanptr.i in ACC or TUX
 220   Uint32 checkLcpStop;          // from enum
 221 };
 222
 223 #endif