ScanFrag.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:8k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef SCAN_FRAG_HPP
  14. #define SCAN_FRAG_HPP
  15. #include "SignalData.hpp"
  16. #include "ndb_limits.h"
  17. class ScanFragReq {
  18.   /**
  19.    * Sender(s)
  20.    */
  21.   friend class Dbtc;
  22.   friend class Backup;
  23.   friend class Suma;
  24.   /**
  25.    * Reciver(s)
  26.    */
  27.   friend class Dblqh;
  28. public:
  29.   STATIC_CONST( SignalLength = 12 );
  30.   
  31.   friend bool printSCAN_FRAGREQ(FILE *, const Uint32*, Uint32, Uint16);
  32.   
  33. public:
  34.   Uint32 senderData;
  35.   Uint32 resultRef;       // Where to send the result
  36.   Uint32 savePointId;
  37.   Uint32 requestInfo;
  38.   Uint32 tableId;
  39.   Uint32 fragmentNoKeyLen;
  40.   Uint32 schemaVersion;
  41.   Uint32 transId1;
  42.   Uint32 transId2;
  43.   Uint32 clientOpPtr;
  44.   Uint32 batch_size_rows;
  45.   Uint32 batch_size_bytes;
  46.   
  47.   static Uint32 getLockMode(const Uint32 & requestInfo);
  48.   static Uint32 getHoldLockFlag(const Uint32 & requestInfo);
  49.   static Uint32 getKeyinfoFlag(const Uint32 & requestInfo);
  50.   static Uint32 getReadCommittedFlag(const Uint32 & requestInfo);
  51.   static Uint32 getRangeScanFlag(const Uint32 & requestInfo);
  52.   static Uint32 getAttrLen(const Uint32 & requestInfo);
  53.   static Uint32 getScanPrio(const Uint32 & requestInfo);
  54.   
  55.   static void setLockMode(Uint32 & requestInfo, Uint32 lockMode);
  56.   static void setHoldLockFlag(Uint32 & requestInfo, Uint32 holdLock);
  57.   static void setKeyinfoFlag(Uint32 & requestInfo, Uint32 keyinfo);
  58.   static void setReadCommittedFlag(Uint32 & requestInfo, Uint32 readCommitted);
  59.   static void setRangeScanFlag(Uint32 & requestInfo, Uint32 rangeScan);
  60.   static void setAttrLen(Uint32 & requestInfo, Uint32 attrLen);
  61.   static void setScanPrio(Uint32& requestInfo, Uint32 prio);
  62. };
  63. class KeyInfo20 {
  64.   /**
  65.    * Sender(s)
  66.    */
  67.   friend class Dblqh;
  68.   /**
  69.    * Reciver(s)
  70.    */
  71.   friend class Backup;
  72.   friend class NdbOperation;
  73.   friend class NdbScanReceiver;
  74. public:
  75.   STATIC_CONST( HeaderLength = 5);
  76.   STATIC_CONST( DataLength = 20 );
  77.   
  78.   static Uint32 setScanInfo(Uint32 noOfOps, Uint32 scanNo);
  79.   static Uint32 getScanNo(Uint32 scanInfo);
  80.   static Uint32 getScanOp(Uint32 scanInfo);
  81.   
  82. public:
  83.   Uint32 clientOpPtr;
  84.   Uint32 keyLen;
  85.   Uint32 scanInfo_Node;
  86.   Uint32 transId1;
  87.   Uint32 transId2;
  88.   Uint32 keyData[DataLength];
  89. };
  90. class ScanFragConf {
  91.   /**
  92.    * Sender(s)
  93.    */
  94.   friend class Dblqh;
  95.   /**
  96.    * Reciver(s)
  97.    */
  98.   friend class Dbtc;
  99.   friend class Backup;
  100.   friend class Suma;
  101. public:
  102.   STATIC_CONST( SignalLength = 6 );
  103.   
  104. public:
  105.   Uint32 senderData;
  106.   Uint32 completedOps;
  107.   Uint32 fragmentCompleted;
  108.   Uint32 transId1;
  109.   Uint32 transId2;
  110.   Uint32 total_len;
  111. };
  112. class ScanFragRef {
  113.   /**
  114.    * Sender(s)
  115.    */
  116.   friend class Dblqh;
  117.   /**
  118.    * Reciver(s)
  119.    */
  120.   friend class Dbtc;
  121.   friend class Backup;
  122.   friend class Suma;
  123. public:
  124.   STATIC_CONST( SignalLength = 4 );
  125. public:
  126.   enum ErrorCode {
  127.     ZNO_FREE_TC_CONREC_ERROR = 484,
  128.     ZTOO_FEW_CONCURRENT_OPERATIONS = 485,
  129.     ZTOO_MANY_CONCURRENT_OPERATIONS = 486,
  130.     ZSCAN_NO_FRAGMENT_ERROR = 487,
  131.     ZTOO_MANY_ACTIVE_SCAN_ERROR = 488,
  132.     ZNO_FREE_SCANREC_ERROR = 489,
  133.     ZWRONG_BATCH_SIZE = 1230,
  134.     ZSTANDBY_SCAN_ERROR = 1209,
  135.     ZSCAN_BOOK_ACC_OP_ERROR = 1219,
  136.     ZUNKNOWN_TRANS_ERROR = 1227
  137.   };
  138.   
  139.   Uint32 senderData;
  140.   Uint32 transId1;
  141.   Uint32 transId2;
  142.   Uint32 errorCode;
  143. };
  144. /**
  145.  * This is part of Scan Fragment protocol
  146.  *
  147.  * Not to be confused with ScanNextReq in Scan Table protocol
  148.  */
  149. class ScanFragNextReq {
  150.   /**
  151.    * Sender(s)
  152.    */
  153.   friend class Dbtc;
  154.   friend class Backup;
  155.   friend class Suma;
  156.   
  157.   /**
  158.    * Reciver(s)
  159.    */
  160.   friend class Dblqh;
  161.   friend bool printSCANFRAGNEXTREQ(FILE * output, const Uint32 * theData, 
  162.    Uint32 len, Uint16 receiverBlockNo);
  163. public:
  164.   STATIC_CONST( SignalLength = 6 );
  165.   
  166. public:
  167.   Uint32 senderData;
  168.   Uint32 closeFlag;
  169.   Uint32 transId1;
  170.   Uint32 transId2;
  171.   Uint32 batch_size_rows;
  172.   Uint32 batch_size_bytes;
  173. };
  174. /**
  175.  * Request Info
  176.  *
  177.  * a = Length of attrinfo    - 16 Bits (16-31)
  178.  * l = Lock Mode             - 1  Bit 5
  179.  * h = Hold lock             - 1  Bit 7
  180.  * k = Keyinfo               - 1  Bit 8
  181.  * r = read committed        - 1  Bit 9
  182.  * x = range scan            - 1  Bit 6
  183.  * p = Scan prio             - 4  Bits (12-15) -> max 15
  184.  *
  185.  *           1111111111222222222233
  186.  * 01234567890123456789012345678901
  187.  *      lxhkr  ppppaaaaaaaaaaaaaaaa 
  188.  */
  189. #define SF_LOCK_MODE_SHIFT   (5)
  190. #define SF_LOCK_MODE_MASK    (1)
  191. #define SF_HOLD_LOCK_SHIFT   (7)
  192. #define SF_KEYINFO_SHIFT     (8)
  193. #define SF_READ_COMMITTED_SHIFT  (9)
  194. #define SF_RANGE_SCAN_SHIFT (6)
  195. #define SF_ATTR_LEN_SHIFT    (16)
  196. #define SF_ATTR_LEN_MASK     (65535)
  197. #define SF_PRIO_SHIFT 12
  198. #define SF_PRIO_MASK 15
  199. inline 
  200. Uint32
  201. ScanFragReq::getLockMode(const Uint32 & requestInfo){
  202.   return (requestInfo >> SF_LOCK_MODE_SHIFT) & SF_LOCK_MODE_MASK;
  203. }
  204. inline
  205. Uint32
  206. ScanFragReq::getHoldLockFlag(const Uint32 & requestInfo){
  207.   return (requestInfo >> SF_HOLD_LOCK_SHIFT) & 1;
  208. }
  209. inline
  210. Uint32
  211. ScanFragReq::getKeyinfoFlag(const Uint32 & requestInfo){
  212.   return (requestInfo >> SF_KEYINFO_SHIFT) & 1;
  213. }
  214. inline
  215. Uint32
  216. ScanFragReq::getRangeScanFlag(const Uint32 & requestInfo){
  217.   return (requestInfo >> SF_RANGE_SCAN_SHIFT) & 1;
  218. }
  219. inline
  220. Uint32
  221. ScanFragReq::getReadCommittedFlag(const Uint32 & requestInfo){
  222.   return (requestInfo >> SF_READ_COMMITTED_SHIFT) & 1;
  223. }
  224. inline 
  225. Uint32
  226. ScanFragReq::getAttrLen(const Uint32 & requestInfo){
  227.   return (requestInfo >> SF_ATTR_LEN_SHIFT) & SF_ATTR_LEN_MASK;
  228. }
  229. inline
  230. Uint32
  231. ScanFragReq::getScanPrio(const Uint32 & requestInfo){
  232.   return (requestInfo >> SF_PRIO_SHIFT) & SF_PRIO_MASK;
  233. }
  234. inline
  235. void
  236. ScanFragReq::setScanPrio(UintR & requestInfo, UintR val){
  237.   ASSERT_MAX(val, SF_PRIO_MASK, "ScanFragReq::setScanPrio");
  238.   requestInfo |= (val << SF_PRIO_SHIFT);
  239. }
  240. inline
  241. void
  242. ScanFragReq::setLockMode(UintR & requestInfo, UintR val){
  243.   ASSERT_MAX(val, SF_LOCK_MODE_MASK, "ScanFragReq::setLockMode");
  244.   requestInfo |= (val << SF_LOCK_MODE_SHIFT);
  245. }
  246. inline
  247. void
  248. ScanFragReq::setHoldLockFlag(UintR & requestInfo, UintR val){
  249.   ASSERT_BOOL(val, "ScanFragReq::setHoldLockFlag");
  250.   requestInfo |= (val << SF_HOLD_LOCK_SHIFT);
  251. }
  252. inline
  253. void
  254. ScanFragReq::setKeyinfoFlag(UintR & requestInfo, UintR val){
  255.   ASSERT_BOOL(val, "ScanFragReq::setKeyinfoFlag");
  256.   requestInfo |= (val << SF_KEYINFO_SHIFT);
  257. }
  258. inline
  259. void
  260. ScanFragReq::setReadCommittedFlag(UintR & requestInfo, UintR val){
  261.   ASSERT_BOOL(val, "ScanFragReq::setReadCommittedFlag");
  262.   requestInfo |= (val << SF_READ_COMMITTED_SHIFT);
  263. }
  264. inline
  265. void
  266. ScanFragReq::setRangeScanFlag(UintR & requestInfo, UintR val){
  267.   ASSERT_BOOL(val, "ScanFragReq::setRangeScanFlag");
  268.   requestInfo |= (val << SF_RANGE_SCAN_SHIFT);
  269. }
  270. inline
  271. void
  272. ScanFragReq::setAttrLen(UintR & requestInfo, UintR val){
  273.   ASSERT_MAX(val, SF_ATTR_LEN_MASK, "ScanFragReq::setAttrLen");
  274.   requestInfo |= (val << SF_ATTR_LEN_SHIFT);
  275. }
  276. inline
  277. Uint32
  278. KeyInfo20::setScanInfo(Uint32 opNo, Uint32 scanNo){
  279.   ASSERT_MAX(opNo, 1023, "KeyInfo20::setScanInfo");
  280.   ASSERT_MAX(scanNo, 255, "KeyInfo20::setScanInfo");
  281.   return (opNo << 8) + scanNo;
  282. }
  283. inline
  284. Uint32
  285. KeyInfo20::getScanNo(Uint32 scanInfo){
  286.   return scanInfo & 0xFF;
  287. }
  288. inline
  289. Uint32
  290. KeyInfo20::getScanOp(Uint32 scanInfo){
  291.   return (scanInfo >> 8) & 0x3FF;
  292. }
  293. #endif