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

   1 /* Copyright (c) 2003-2006 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 TC_KEY_REQ_H
  17 #define TC_KEY_REQ_H
  18
  19 #include "SignalData.hpp"
  20
  21 /**
  22  * @class TcKeyReq
  23  * @brief Contains KeyInfo and AttrInfo and is commonly followed by more signals
  24  *
  25  * - SENDER:    API, NDBCNTR
  26  * - RECEIVER:  TC
  27  */
  28 class TcKeyReq {
  29   /**
  30    * Receiver(s)
  31    */
  32   friend class Dbtc;         // Receiver
  33
  34   /**
  35    * Sender(s)
  36    */
  37   friend class Ndbcntr;
  38   friend class NdbOperation;
  39   friend class NdbIndexOperation;
  40   friend class NdbScanOperation;
  41   friend class NdbBlob;
  42   friend class DbUtil;
  43
  44   /**
  45    * For printing
  46    */
  47   friend bool printTCKEYREQ(FILE *, const Uint32 *, Uint32, Uint16);
  48   friend bool printTCINDXREQ(FILE *, const Uint32 *, Uint32, Uint16);
  49
  50 public:
  51   /**
  52    * Length of signal
  53    */
  54   STATIC_CONST( StaticLength = 8 );
  55   STATIC_CONST( SignalLength = 25 );
  56   STATIC_CONST( MaxKeyInfo = 8 );
  57   STATIC_CONST( MaxAttrInfo = 5 );
  58   STATIC_CONST( MaxTotalAttrInfo = 0xFFFF );
  59
  60 private:
  61
  62   enum AbortOption {
  63     CommitIfFailFree = 0, AbortOnError = 0,
  64     CommitAsMuchAsPossible = 2, IgnoreError = 2
  65   };
  66
  67   typedef AbortOption CommitType;
  68
  69   /**
  70    * DATA VARIABLES
  71    */
  72
  73   // ----------------------------------------------------------------------
  74   //  Unconditional part = must be present in signal.  First 8 words
  75   // ----------------------------------------------------------------------
  76   Uint32 apiConnectPtr;        // DATA 0
  77   union {
  78     Uint32 senderData;
  79     UintR apiOperationPtr;      // DATA 1
  80   };
  81   /**
  82    * ATTRIBUTE INFO (attrinfo) LENGTH
  83    * This is the total length of all attribute info that is sent from
  84    * the application as part of this operation.
  85    * It includes all attribute info sent in possible attrinfo
  86    * signals as well as the attribute info sent in TCKEYREQ.
  87    */
  88   UintR attrLen;              // DATA 2   (also stores API Version)
  89   UintR tableId;              // DATA 3
  90   UintR requestInfo;          // DATA 4   Various transaction flags
  91   UintR tableSchemaVersion;   // DATA 5
  92   UintR transId1;             // DATA 6
  93   UintR transId2;             // DATA 7
  94
  95   // ----------------------------------------------------------------------
  96   //  Conditional part = can be present in signal.
  97   //  These four words will be sent only if their indicator is set.
  98   // ----------------------------------------------------------------------
  99   UintR scanInfo;             // DATA 8   Various flags for scans
 100   UintR distrGroupHashValue;  // DATA 9
 101   UintR distributionKeySize;  // DATA 10
 102   UintR storedProcId;         // DATA 11
 103
 104   // ----------------------------------------------------------------------
 105   //  Variable sized KEY and ATTRINFO part.
 106   //  These will be placed to pack the signal in an appropriate manner.
 107   // ----------------------------------------------------------------------
 108   UintR keyInfo[MaxKeyInfo];           // DATA 12 - 19
 109   UintR attrInfo[MaxAttrInfo];          // DATA 20 - 24
 110
 111   /**
 112    * Get:ers for attrLen
 113    */
 114
 115   static Uint16  getAPIVersion(const UintR & attrLen);
 116   static Uint16  getAttrinfoLen(const UintR & attrLen);
 117   static void setAPIVersion(UintR & attrLen, Uint16 apiVersion);
 118   static void setAttrinfoLen(UintR & attrLen, Uint16 aiLen);
 119
 120
 121   /**
 122    * Get:ers for requestInfo
 123    */
 124   static Uint8 getCommitFlag(const UintR & requestInfo);
 125   static Uint8 getAbortOption(const UintR & requestInfo);
 126   static Uint8 getStartFlag(const UintR & requestInfo);
 127   static Uint8 getSimpleFlag(const UintR & requestInfo);
 128   static Uint8 getDirtyFlag(const UintR & requestInfo);
 129   static Uint8 getInterpretedFlag(const UintR & requestInfo);
 130   static Uint8 getDistributionKeyFlag(const UintR & requestInfo);
 131   static Uint8 getScanIndFlag(const UintR & requestInfo);
 132   static Uint8 getOperationType(const UintR & requestInfo);
 133   static Uint8 getExecuteFlag(const UintR & requestInfo);
 134
 135   static Uint16 getKeyLength(const UintR & requestInfo);
 136   static Uint8  getAIInTcKeyReq(const UintR & requestInfo);
 137   static Uint8  getExecutingTrigger(const UintR & requestInfo);
 138   static UintR  getNoDiskFlag(const UintR & requestInfo);
 139
 140   /**
 141    * Get:ers for scanInfo
 142    */
 143   static Uint8  getTakeOverScanFlag(const UintR & scanInfo);
 144   static Uint16 getTakeOverScanFragment(const UintR & scanInfo);
 145   static Uint32 getTakeOverScanInfo(const UintR & scanInfo);
 146
 147
 148   /**
 149    * Set:ers for requestInfo
 150    */
 151   static void clearRequestInfo(UintR & requestInfo);
 152   static void setAbortOption(UintR & requestInfo, Uint32 type);
 153   static void setCommitFlag(UintR & requestInfo, Uint32 flag);
 154   static void setStartFlag(UintR & requestInfo, Uint32 flag);
 155   static void setSimpleFlag(UintR & requestInfo, Uint32 flag);
 156   static void setDirtyFlag(UintR & requestInfo, Uint32 flag);
 157   static void setInterpretedFlag(UintR & requestInfo, Uint32 flag);
 158   static void setDistributionKeyFlag(UintR & requestInfo, Uint32 flag);
 159   static void setScanIndFlag(UintR & requestInfo, Uint32 flag);
 160   static void setExecuteFlag(UintR & requestInfo, Uint32 flag);
 161   static void setOperationType(UintR & requestInfo, Uint32 type);
 162
 163   static void setKeyLength(UintR & requestInfo, Uint32 len);
 164   static void setAIInTcKeyReq(UintR & requestInfo, Uint32 len);
 165   static void setExecutingTrigger(UintR & requestInfo, Uint32 flag);
 166   static void setNoDiskFlag(UintR & requestInfo, UintR val);
 167
 168   /**
 169    * Set:ers for scanInfo
 170    */
 171   static void setTakeOverScanFlag(UintR & scanInfo, Uint8 flag);
 172   static void setTakeOverScanFragment(UintR & scanInfo, Uint16 fragment);
 173   static void setTakeOverScanInfo(UintR & scanInfo, Uint32 aScanInfo);
 174 };
 175
 176 /**
 177  * Request Info
 178  *
 179  a = Attr Info in TCKEYREQ - 3  Bits -> Max 7 (Bit 16-18)
 180  b = Distribution Key Ind  - 1  Bit 2
 181  c = Commit Indicator      - 1  Bit 4
 182  d = Dirty Indicator       - 1  Bit 0
 183  e = Scan Indicator        - 1  Bit 14
 184  f = Execute fired trigger - 1  Bit 19
 185  i = Interpreted Indicator - 1  Bit 15
 186  k = Key length            - 12 Bits -> Max 4095 (Bit 20 - 31)
 187  o = Operation Type        - 3  Bits -> Max 7 (Bit 5-7)
 188  l = Execute               - 1  Bit 10
 189  p = Simple Indicator      - 1  Bit 8
 190  s = Start Indicator       - 1  Bit 11
 191  y = Commit Type           - 2  Bit 12-13
 192  n = No disk flag          - 1  Bit 1
 193
 194            1111111111222222222233
 195  01234567890123456789012345678901
 196  dnb cooop lsyyeiaaafkkkkkkkkkkkk
 197 */
 198
 199 #define TCKEY_NODISK_SHIFT (1)
 200 #define COMMIT_SHIFT       (4)
 201 #define START_SHIFT        (11)
 202 #define SIMPLE_SHIFT       (8)
 203 #define DIRTY_SHIFT        (0)
 204 #define EXECUTE_SHIFT      (10)
 205 #define INTERPRETED_SHIFT  (15)
 206 #define DISTR_KEY_SHIFT    (2)
 207 #define SCAN_SHIFT         (14)
 208
 209 #define OPERATION_SHIFT   (5)
 210 #define OPERATION_MASK    (7)
 211
 212 #define AINFO_SHIFT       (16)
 213 #define AINFO_MASK        (7)
 214
 215 #define KEY_LEN_SHIFT     (20)
 216 #define KEY_LEN_MASK      (4095)
 217
 218 #define COMMIT_TYPE_SHIFT  (12)
 219 #define COMMIT_TYPE_MASK   (3)
 220
 221 #define EXECUTING_TRIGGER_SHIFT (19)
 222
 223 /**
 224  * Scan Info
 225  *
 226  t = Scan take over indicator -  1 Bit
 227  n = Take over node           - 12 Bits -> max 65535
 228  p = Scan Info                - 18 Bits -> max 4095
 229
 230            1111111111222222222233
 231  01234567890123456789012345678901
 232  tpppppppppppppppppp nnnnnnnnnnnn
 233 */
 234
 235 #define TAKE_OVER_SHIFT      (0)
 236
 237 #define TAKE_OVER_FRAG_SHIFT (20)
 238 #define TAKE_OVER_FRAG_MASK  (4095)
 239
 240 #define SCAN_INFO_SHIFT      (1)
 241 #define SCAN_INFO_MASK       (262143)
 242
 243 /**
 244  * Attr Len
 245  *
 246  n = Attrinfo length(words)   - 16 Bits -> max 65535
 247  a = API version no           - 16 Bits -> max 65535
 248
 249            1111111111222222222233
 250  01234567890123456789012345678901
 251  aaaaaaaaaaaaaaaannnnnnnnnnnnnnnn
 252 */
 253
 254 #define API_VER_NO_SHIFT     (16)
 255 #define API_VER_NO_MASK      (65535)
 256
 257 #define ATTRLEN_SHIFT        (0)
 258 #define ATTRLEN_MASK         (65535)
 259
 260 inline
 261 Uint8
 262 TcKeyReq::getCommitFlag(const UintR & requestInfo){
 263   return (Uint8)((requestInfo >> COMMIT_SHIFT) & 1);
 264 }
 265
 266 inline
 267 Uint8
 268 TcKeyReq::getAbortOption(const UintR & requestInfo){
 269   return (Uint8)((requestInfo >> COMMIT_TYPE_SHIFT) & COMMIT_TYPE_MASK);
 270 }
 271
 272 inline
 273 Uint8
 274 TcKeyReq::getStartFlag(const UintR & requestInfo){
 275   return (Uint8)((requestInfo >> START_SHIFT) & 1);
 276 }
 277
 278 inline
 279 Uint8
 280 TcKeyReq::getSimpleFlag(const UintR & requestInfo){
 281   return (Uint8)((requestInfo >> SIMPLE_SHIFT) & 1);
 282 }
 283
 284 inline
 285 Uint8
 286 TcKeyReq::getExecuteFlag(const UintR & requestInfo){
 287   return (Uint8)((requestInfo >> EXECUTE_SHIFT) & 1);
 288 }
 289
 290 inline
 291 Uint8
 292 TcKeyReq::getDirtyFlag(const UintR & requestInfo){
 293   return (Uint8)((requestInfo >> DIRTY_SHIFT) & 1);
 294 }
 295
 296 inline
 297 Uint8
 298 TcKeyReq::getInterpretedFlag(const UintR & requestInfo){
 299   return (Uint8)((requestInfo >> INTERPRETED_SHIFT) & 1);
 300 }
 301
 302 inline
 303 Uint8
 304 TcKeyReq::getDistributionKeyFlag(const UintR & requestInfo){
 305   return (Uint8)((requestInfo >> DISTR_KEY_SHIFT) & 1);
 306 }
 307
 308 inline
 309 Uint8
 310 TcKeyReq::getScanIndFlag(const UintR & requestInfo){
 311   return (Uint8)((requestInfo >> SCAN_SHIFT) & 1);
 312 }
 313
 314 inline
 315 Uint8
 316 TcKeyReq::getOperationType(const UintR & requestInfo){
 317   return (Uint8)((requestInfo >> OPERATION_SHIFT) & OPERATION_MASK);
 318 }
 319
 320 inline
 321 Uint16
 322 TcKeyReq::getKeyLength(const UintR & requestInfo){
 323   return (Uint16)((requestInfo >> KEY_LEN_SHIFT) & KEY_LEN_MASK);
 324 }
 325
 326 inline
 327 Uint8
 328 TcKeyReq::getAIInTcKeyReq(const UintR & requestInfo){
 329   return (Uint8)((requestInfo >> AINFO_SHIFT) & AINFO_MASK);
 330 }
 331
 332 inline
 333 Uint8
 334 TcKeyReq::getExecutingTrigger(const UintR & requestInfo){
 335   return (Uint8)((requestInfo >> EXECUTING_TRIGGER_SHIFT) & 1);
 336 }
 337
 338 inline
 339 void
 340 TcKeyReq::clearRequestInfo(UintR & requestInfo){
 341   requestInfo = 0;
 342 }
 343
 344 inline
 345 void
 346 TcKeyReq::setAbortOption(UintR & requestInfo, Uint32 type){
 347   ASSERT_MAX(type, COMMIT_TYPE_MASK, "TcKeyReq::setAbortOption");
 348   requestInfo &= ~(COMMIT_TYPE_MASK << COMMIT_TYPE_SHIFT);
 349   requestInfo |= (type << COMMIT_TYPE_SHIFT);
 350 }
 351
 352 inline
 353 void
 354 TcKeyReq::setCommitFlag(UintR & requestInfo, Uint32 flag){
 355   ASSERT_BOOL(flag, "TcKeyReq::setCommitFlag");
 356   requestInfo &= ~(1 << COMMIT_SHIFT);
 357   requestInfo |= (flag << COMMIT_SHIFT);
 358 }
 359
 360 inline
 361 void
 362 TcKeyReq::setStartFlag(UintR & requestInfo, Uint32 flag){
 363   ASSERT_BOOL(flag, "TcKeyReq::setStartFlag");
 364   requestInfo &= ~(1 << START_SHIFT);
 365   requestInfo |= (flag << START_SHIFT);
 366 }
 367
 368 inline
 369 void
 370 TcKeyReq::setSimpleFlag(UintR & requestInfo, Uint32 flag){
 371   ASSERT_BOOL(flag, "TcKeyReq::setSimpleFlag");
 372   requestInfo &= ~(1 << SIMPLE_SHIFT);
 373   requestInfo |= (flag << SIMPLE_SHIFT);
 374 }
 375
 376 inline
 377 void
 378 TcKeyReq::setDirtyFlag(UintR & requestInfo, Uint32 flag){
 379   ASSERT_BOOL(flag, "TcKeyReq::setDirstFlag");
 380   requestInfo &= ~(1 << DIRTY_SHIFT);
 381   requestInfo |= (flag << DIRTY_SHIFT);
 382 }
 383
 384 inline
 385 void
 386 TcKeyReq::setExecuteFlag(UintR & requestInfo, Uint32 flag){
 387   ASSERT_BOOL(flag, "TcKeyReq::setExecuteFlag");
 388   requestInfo &= ~(1 << EXECUTE_SHIFT);
 389   requestInfo |= (flag << EXECUTE_SHIFT);
 390 }
 391
 392 inline
 393 void
 394 TcKeyReq::setInterpretedFlag(UintR & requestInfo, Uint32 flag){
 395   ASSERT_BOOL(flag, "TcKeyReq::setInterpretedFlag");
 396   requestInfo &= ~(1 << INTERPRETED_SHIFT);
 397   requestInfo |= (flag << INTERPRETED_SHIFT);
 398 }
 399
 400 inline
 401 void
 402 TcKeyReq::setDistributionKeyFlag(UintR & requestInfo, Uint32 flag){
 403   ASSERT_BOOL(flag, "TcKeyReq::setDistributionKeyFlag");
 404   requestInfo &= ~(1 << DISTR_KEY_SHIFT);
 405   requestInfo |= (flag << DISTR_KEY_SHIFT);
 406 }
 407
 408 inline
 409 void
 410 TcKeyReq::setScanIndFlag(UintR & requestInfo, Uint32 flag){
 411   ASSERT_BOOL(flag, "TcKeyReq::setScanIndFlag");
 412   requestInfo &= ~(1 << SCAN_SHIFT);
 413   requestInfo |= (flag << SCAN_SHIFT);
 414 }
 415
 416 inline
 417 void
 418 TcKeyReq::setOperationType(UintR & requestInfo, Uint32 type){
 419   ASSERT_MAX(type, OPERATION_MASK, "TcKeyReq::setOperationType");
 420   requestInfo &= ~(OPERATION_MASK << OPERATION_SHIFT);
 421   requestInfo |= (type << OPERATION_SHIFT);
 422 }
 423
 424 inline
 425 void
 426 TcKeyReq::setKeyLength(UintR & requestInfo, Uint32 len){
 427   ASSERT_MAX(len, KEY_LEN_MASK, "TcKeyReq::setKeyLength");
 428   requestInfo &= ~(KEY_LEN_MASK << KEY_LEN_SHIFT);
 429   requestInfo |= (len << KEY_LEN_SHIFT);
 430 }
 431
 432 inline
 433 void
 434 TcKeyReq::setAIInTcKeyReq(UintR & requestInfo, Uint32 len){
 435   ASSERT_MAX(len, AINFO_MASK, "TcKeyReq::setAIInTcKeyReq");
 436   requestInfo &= ~(AINFO_MASK << AINFO_SHIFT);
 437   requestInfo |= (len << AINFO_SHIFT);
 438 }
 439
 440 inline
 441 void
 442 TcKeyReq::setExecutingTrigger(UintR & requestInfo, Uint32 flag){
 443   ASSERT_BOOL(flag, "TcKeyReq::setExecutingTrigger");
 444   requestInfo &= ~(1 << EXECUTING_TRIGGER_SHIFT);
 445   requestInfo |= (flag << EXECUTING_TRIGGER_SHIFT);
 446 }
 447
 448 inline
 449 Uint8
 450 TcKeyReq::getTakeOverScanFlag(const UintR & scanInfo){
 451   return (Uint8)((scanInfo >> TAKE_OVER_SHIFT) & 1);
 452 }
 453
 454 inline
 455 Uint16
 456 TcKeyReq::getTakeOverScanFragment(const UintR & scanInfo){
 457   return (Uint16)((scanInfo >> TAKE_OVER_FRAG_SHIFT) & TAKE_OVER_FRAG_MASK);
 458 }
 459
 460 inline
 461 Uint32
 462 TcKeyReq::getTakeOverScanInfo(const UintR & scanInfo){
 463   return (Uint32)((scanInfo >> SCAN_INFO_SHIFT) & SCAN_INFO_MASK);
 464 }
 465
 466
 467 inline
 468 void
 469 TcKeyReq::setTakeOverScanFlag(UintR & scanInfo, Uint8 flag){
 470   ASSERT_BOOL(flag, "TcKeyReq::setTakeOverScanFlag");
 471   scanInfo |= (flag << TAKE_OVER_SHIFT);
 472 }
 473
 474 inline
 475 void
 476 TcKeyReq::setTakeOverScanFragment(UintR & scanInfo, Uint16 node){
 477 //  ASSERT_MAX(node, TAKE_OVER_NODE_MASK, "TcKeyReq::setTakeOverScanNode");
 478   scanInfo |= (node << TAKE_OVER_FRAG_SHIFT);
 479 }
 480
 481 inline
 482 void
 483 TcKeyReq::setTakeOverScanInfo(UintR & scanInfo, Uint32 aScanInfo){
 484 //  ASSERT_MAX(aScanInfo, SCAN_INFO_MASK, "TcKeyReq::setTakeOverScanInfo");
 485   scanInfo |= (aScanInfo << SCAN_INFO_SHIFT);
 486 }
 487
 488
 489 inline
 490 Uint16
 491 TcKeyReq::getAPIVersion(const UintR & anAttrLen){
 492   return (Uint16)((anAttrLen >> API_VER_NO_SHIFT) & API_VER_NO_MASK);
 493 }
 494
 495 inline
 496 void
 497 TcKeyReq::setAPIVersion(UintR & anAttrLen, Uint16 apiVersion){
 498 // ASSERT_MAX(apiVersion, API_VER_NO_MASK, "TcKeyReq::setAPIVersion");
 499   anAttrLen |= (apiVersion << API_VER_NO_SHIFT);
 500 }
 501
 502 inline
 503 Uint16
 504 TcKeyReq::getAttrinfoLen(const UintR & anAttrLen){
 505   return (Uint16)((anAttrLen) & ATTRLEN_MASK);
 506 }
 507
 508 inline
 509 void
 510 TcKeyReq::setAttrinfoLen(UintR & anAttrLen, Uint16 aiLen){
 511 //  ASSERT_MAX(aiLen, ATTRLEN_MASK, "TcKeyReq::setAttrinfoLen");
 512   anAttrLen |= aiLen;
 513 }
 514
 515 inline
 516 UintR
 517 TcKeyReq::getNoDiskFlag(const UintR & requestInfo){
 518   return (requestInfo >> TCKEY_NODISK_SHIFT) & 1;
 519 }
 520
 521 inline
 522 void
 523 TcKeyReq::setNoDiskFlag(UintR & requestInfo, Uint32 flag){
 524   ASSERT_BOOL(flag, "TcKeyReq::setNoDiskFlag");
 525   requestInfo &= ~(1 << TCKEY_NODISK_SHIFT);
 526   requestInfo |= (flag << TCKEY_NODISK_SHIFT);
 527 }
 528
 529 #endif