MySQL数据库

开发平台：
Visual C++

ScanTab.hpp：源码内容
							/* Copyright (C) 2003 MySQL AB
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
#ifndef SCAN_TAB_H
#define SCAN_TAB_H
#include "SignalData.hpp"
/**
 * 
 * SENDER:  API
 * RECIVER: Dbtc
 */
class ScanTabReq {
  /**
   * Reciver(s)
   */
  friend class Dbtc;         // Reciver
  /**
   * Sender(s)
   */
  friend class NdbConnection;
  friend class NdbScanOperation; 
  /**
   * For printing
   */
  friend bool printSCANTABREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
public:
  /**
   * Length of signal
   */
  STATIC_CONST( StaticLength = 11 );
private:
  // Type definitions
  /**
   * DATA VARIABLES
   */
  UintR apiConnectPtr;        // DATA 0
  UintR attrLenKeyLen;        // DATA 1
  UintR requestInfo;          // DATA 2
  UintR tableId;              // DATA 3
  UintR tableSchemaVersion;   // DATA 4
  UintR storedProcId;         // DATA 5
  UintR transId1;             // DATA 6
  UintR transId2;             // DATA 7
  UintR buddyConPtr;          // DATA 8
  UintR batch_byte_size;      // DATA 9
  UintR first_batch_size;     // DATA 10
  
  /**
   * Get:ers for requestInfo
   */
  static Uint8 getParallelism(const UintR & requestInfo);
  static Uint8 getLockMode(const UintR & requestInfo);
  static Uint8 getHoldLockFlag(const UintR & requestInfo);
  static Uint8 getReadCommittedFlag(const UintR & requestInfo);
  static Uint8 getRangeScanFlag(const UintR & requestInfo);
  static Uint8 getKeyinfoFlag(const UintR & requestInfo);
  static Uint16 getScanBatch(const UintR & requestInfo);
  /**
   * Set:ers for requestInfo
   */
  static void clearRequestInfo(UintR & requestInfo);
  static void setParallelism(UintR & requestInfo, Uint32 flag);
  static void setLockMode(UintR & requestInfo, Uint32 flag);
  static void setHoldLockFlag(UintR & requestInfo, Uint32 flag);
  static void setReadCommittedFlag(UintR & requestInfo, Uint32 flag);
  static void setRangeScanFlag(UintR & requestInfo, Uint32 flag);
  static void setKeyinfoFlag(UintR & requestInfo, Uint32 flag);
  static void setScanBatch(Uint32& requestInfo, Uint32 sz);
};
/**
 * Request Info
 *
 p = Parallelism           - 8  Bits -> Max 256 (Bit 0-7)
 l = Lock mode             - 1  Bit 8
 h = Hold lock mode        - 1  Bit 10
 c = Read Committed        - 1  Bit 11
 k = Keyinfo               - 1  Bit 12
 x = Range Scan (TUX)      - 1  Bit 15
 b = Scan batch            - 10 Bit 16-25 (max 1023)
           1111111111222222222233
 01234567890123456789012345678901
 ppppppppl hck  xbbbbbbbbbb
*/
#define PARALLELL_SHIFT     (0)
#define PARALLELL_MASK      (255)
#define LOCK_MODE_SHIFT     (8)
#define LOCK_MODE_MASK      (1)
#define HOLD_LOCK_SHIFT     (10)
#define HOLD_LOCK_MASK      (1)
#define KEYINFO_SHIFT       (12)
#define KEYINFO_MASK        (1)
#define READ_COMMITTED_SHIFT     (11)
#define READ_COMMITTED_MASK      (1)
#define RANGE_SCAN_SHIFT        (15)
#define RANGE_SCAN_MASK         (1)
#define SCAN_BATCH_SHIFT (16)
#define SCAN_BATCH_MASK  (1023)
inline
Uint8
ScanTabReq::getParallelism(const UintR & requestInfo){
  return (Uint8)((requestInfo >> PARALLELL_SHIFT) & PARALLELL_MASK);
}
inline
Uint8
ScanTabReq::getLockMode(const UintR & requestInfo){
  return (Uint8)((requestInfo >> LOCK_MODE_SHIFT) & LOCK_MODE_MASK);
}
inline
Uint8
ScanTabReq::getHoldLockFlag(const UintR & requestInfo){
  return (Uint8)((requestInfo >> HOLD_LOCK_SHIFT) & HOLD_LOCK_MASK);
}
inline
Uint8
ScanTabReq::getReadCommittedFlag(const UintR & requestInfo){
  return (Uint8)((requestInfo >> READ_COMMITTED_SHIFT) & READ_COMMITTED_MASK);
}
inline
Uint8
ScanTabReq::getRangeScanFlag(const UintR & requestInfo){
  return (Uint8)((requestInfo >> RANGE_SCAN_SHIFT) & RANGE_SCAN_MASK);
}
inline
Uint16
ScanTabReq::getScanBatch(const Uint32 & requestInfo){
  return (Uint16)((requestInfo >> SCAN_BATCH_SHIFT) & SCAN_BATCH_MASK);
}
inline
void 
ScanTabReq::clearRequestInfo(UintR & requestInfo){
  requestInfo = 0;
}
inline
void 
ScanTabReq::setParallelism(UintR & requestInfo, Uint32 type){
  ASSERT_MAX(type, PARALLELL_MASK, "ScanTabReq::setParallellism");
  requestInfo |= (type << PARALLELL_SHIFT);
}
inline
void 
ScanTabReq::setLockMode(UintR & requestInfo, Uint32 mode){
  ASSERT_MAX(mode, LOCK_MODE_MASK,  "ScanTabReq::setLockMode");
  requestInfo |= (mode << LOCK_MODE_SHIFT);
}
inline
void 
ScanTabReq::setHoldLockFlag(UintR & requestInfo, Uint32 flag){
  ASSERT_BOOL(flag, "ScanTabReq::setHoldLockFlag");
  requestInfo |= (flag << HOLD_LOCK_SHIFT);
}
inline
void 
ScanTabReq::setReadCommittedFlag(UintR & requestInfo, Uint32 flag){
  ASSERT_BOOL(flag, "ScanTabReq::setReadCommittedFlag");
  requestInfo |= (flag << READ_COMMITTED_SHIFT);
}
inline
void 
ScanTabReq::setRangeScanFlag(UintR & requestInfo, Uint32 flag){
  ASSERT_BOOL(flag, "ScanTabReq::setRangeScanFlag");
  requestInfo |= (flag << RANGE_SCAN_SHIFT);
}
inline
void
ScanTabReq::setScanBatch(Uint32 & requestInfo, Uint32 flag){
  ASSERT_MAX(flag, SCAN_BATCH_MASK,  "ScanTabReq::setScanBatch");
  requestInfo &= ~(SCAN_BATCH_MASK << SCAN_BATCH_SHIFT);
  requestInfo |= (flag << SCAN_BATCH_SHIFT);
}
inline
Uint8
ScanTabReq::getKeyinfoFlag(const UintR & requestInfo){
  return (Uint8)((requestInfo >> KEYINFO_SHIFT) & KEYINFO_MASK);
}
inline
void 
ScanTabReq::setKeyinfoFlag(UintR & requestInfo, Uint32 flag){
  ASSERT_BOOL(flag, "ScanTabReq::setKeyinfoFlag");
  requestInfo |= (flag << KEYINFO_SHIFT);
}
/**
 * 
 * SENDER:  Dbtc
 * RECIVER: API
 */
class ScanTabConf {
  /**
   * Reciver(s) 
   */
  friend class NdbConnection;         // Reciver
  /**
   * Sender(s)
   */
  friend class Dbtc; 
  /**
   * For printing
   */
  friend bool printSCANTABCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
public:
  /**
   * Length of signal
   */
  STATIC_CONST( SignalLength = 4 );
  STATIC_CONST( EndOfData = (1 << 31) );
  
private:
  // Type definitions
  /**
   * DATA VARIABLES
   */
  UintR apiConnectPtr;        // DATA 0
  UintR requestInfo;          // DATA 1
  UintR transId1;             // DATA 2
  UintR transId2;             // DATA 3
  struct OpData {
    Uint32 apiPtrI;
    Uint32 tcPtrI;
    Uint32 info;
  };
  static Uint32 getLength(Uint32 opDataInfo) { return opDataInfo >> 10; };
  static Uint32 getRows(Uint32 opDataInfo) { return opDataInfo & 1023;}
};
/**
 * request info
 *
 o = received operations        - 7  Bits -> Max 255 (Bit 0-7)
 s = status of scan             - 2  Bits -> Max ??? (Bit 8-?) 
           1111111111222222222233
 01234567890123456789012345678901
 ooooooooss
*/
#define OPERATIONS_SHIFT     (0)
#define OPERATIONS_MASK      (0xFF)
#define STATUS_SHIFT     (8)
#define STATUS_MASK      (0xFF)
/**
 * 
 * SENDER:  Dbtc
 * RECIVER: API
 */
class ScanTabRef {
  /**
   * Reciver(s)
   */
  friend class NdbConnection;         // Reciver
  /**
   * Sender(s)
   */
  friend class Dbtc; 
  /**
   * For printing
   */
  friend bool printSCANTABREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
public:
  /**
   * Length of signal
   */
  STATIC_CONST( SignalLength = 5 );
private:
  // Type definitions
  /**
   * DATA VARIABLES
   */
  UintR apiConnectPtr;        // DATA 0
  UintR transId1;             // DATA 1
  UintR transId2;             // DATA 2
  UintR errorCode;            // DATA 3
  UintR closeNeeded;          // DATA 4
 
};
/**
 * 
 * SENDER:  API
 * RECIVER: Dbtc
 */
class ScanNextReq {
  /**
   * Reciver(s)
   */
  friend class Dbtc;         // Reciver
  /**
   * Sender(s)
   */
  friend class NdbOperation; 
  /**
   * For printing
   */
  friend bool printSCANNEXTREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
public:
  /**
   * Length of signal
   */
  STATIC_CONST( SignalLength = 4 );
private:
  // Type definitions
  /**
   * DATA VARIABLES
   */
  UintR apiConnectPtr;        // DATA 0
  UintR stopScan;             // DATA 1
  UintR transId1;             // DATA 2
  UintR transId2;             // DATA 3
  // stopScan = 1, stop this scan
 
};
#endif

						