开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
LqhKey.hpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：14k
源码类别：

MySQL数据库

开发平台：

Visual C++

LqhKey.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  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.
  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef LQH_KEY_H
  18. #define LQH_KEY_H
  20. #include "SignalData.hpp"
  22. class LqhKeyReq {
  23.   /**
  24.    * Reciver(s)
  25.    */
  26.   friend class Dblqh;         // Reciver
  28.   /**
  29.    * Sender(s)
  30.    */
  31.   friend class Dbtc;      
  33.   /**
  34.    * For printing
  35.    */
  36.   friend bool printLQHKEYREQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
  38. public:
  39.   STATIC_CONST( FixedSignalLength = 11 );
  41. private:
  43.   /**
  44.    * DATA VARIABLES
  45.    */
  46. //-------------------------------------------------------------
  47. // Unconditional part. First 10 words
  48. //-------------------------------------------------------------
  49.   UintR clientConnectPtr; // DATA 0
  50.   UintR attrLen;         // DATA 1
  51.   UintR hashValue; // DATA 2
  52.   UintR requestInfo;    // DATA 3
  53.   UintR tcBlockref; // DATA 4
  54.   UintR tableSchemaVersion; // DATA 5
  55.   UintR fragmentData; // DATA 6
  56.   UintR transId1; // DATA 7
  57.   UintR transId2; // DATA 8
  58.   UintR savePointId;            // DATA 9
  59.   union {
  60.     /**
  61.      * When sent from  TC -> LQH this variable contains scanInfo
  62.      * When send from LQH -> LQH this variable contains noFiredTriggers
  63.      */
  64.     UintR noFiredTriggers; // DATA 10 
  65.     Uint32 scanInfo;            // DATA 10
  66.   };
  68. //-------------------------------------------------------------
  69. // Variable sized key part. Those will be placed to
  70. // pack the signal in an appropriate manner.
  71. //-------------------------------------------------------------
  72.   UintR variableData[10];           // DATA 11 - 21
  74.   static UintR getAttrLen(const UintR & scanInfoAttrLen);
  75.   static UintR getScanTakeOverFlag(const UintR & scanInfoAttrLen);
  76.   static UintR getStoredProcFlag(const UintR & scanData);
  77.   static UintR getDistributionKey(const UintR & scanData);
  78.   
  79.   static UintR getTableId(const UintR & tableSchemaVersion);
  80.   static UintR getSchemaVersion(const UintR & tableSchemaVersion);
  82.   static UintR getFragmentId(const UintR & fragmentData);
  83.   static UintR getNextReplicaNodeId(const UintR & fragmentData);
  85.   static Uint8 getLockType(const UintR & requestInfo);
  86.   static Uint8 getDirtyFlag(const UintR & requestInfo);
  87.   static Uint8 getInterpretedFlag(const UintR & requestInfo);
  88.   static Uint8 getSimpleFlag(const UintR & requestInfo);
  89.   static Uint8 getOperation(const UintR & requestInfo);
  90.   static Uint8 getSeqNoReplica(const UintR & requestInfo);
  91.   static Uint8 getLastReplicaNo(const UintR & requestInfo);
  92.   static Uint8 getAIInLqhKeyReq(const UintR & requestInfo);
  93.   static UintR getKeyLen(const UintR & requestInfo);
  94.   static UintR getSameClientAndTcFlag(const UintR & requestInfo);
  95.   static UintR getReturnedReadLenAIFlag(const UintR & requestInfo);
  96.   static UintR getApplicationAddressFlag(const UintR & requestInfo);
  97.   static UintR getMarkerFlag(const UintR & requestInfo);
  99.   /**
  100.    * Setters
  101.    */
  103.   static void setAttrLen(UintR & scanInfoAttrLen, UintR val);
  104.   static void setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val);
  105.   static void setStoredProcFlag(UintR & scanData, UintR val);
  106.   static void setDistributionKey(UintR & scanData, UintR val);
  107.   
  108.   static void setTableId(UintR & tableSchemaVersion, UintR val);
  109.   static void setSchemaVersion(UintR & tableSchemaVersion, UintR val);
  111.   static void setFragmentId(UintR & fragmentData, UintR val);
  112.   static void setNextReplicaNodeId(UintR & fragmentData, UintR val);
  114.   static void setLockType(UintR & requestInfo, UintR val);
  115.   static void setDirtyFlag(UintR & requestInfo, UintR val);
  116.   static void setInterpretedFlag(UintR & requestInfo, UintR val);
  117.   static void setSimpleFlag(UintR & requestInfo, UintR val);
  118.   static void setOperation(UintR & requestInfo, UintR val);
  119.   static void setSeqNoReplica(UintR & requestInfo, UintR val);
  120.   static void setLastReplicaNo(UintR & requestInfo, UintR val);
  121.   static void setAIInLqhKeyReq(UintR & requestInfo, UintR val);
  122.   static void setKeyLen(UintR & requestInfo, UintR val);
  123.   static void setSameClientAndTcFlag(UintR & requestInfo, UintR val);
  124.   static void setReturnedReadLenAIFlag(UintR & requestInfo, UintR val);
  125.   static void setApplicationAddressFlag(UintR & requestInfo, UintR val);
  126.   static void setMarkerFlag(UintR & requestInfo, UintR val);
  127. };
  129. /**
  130.  * Request Info
  131.  *
  132.  * k = Key len                - 10 Bits (0-9) max 1023
  133.  * l = Last Replica No        - 2  Bits -> Max 3 (10-11)
  134.  * t = Lock type              - 3  Bits -> Max 7 (12-14)
  135.  * p = Application Addr. Ind  - 1  Bit (15)
  136.  * d = Dirty indicator        - 1  Bit (16)
  137.  * i = Interpreted indicator  - 1  Bit (17)
  138.  * s = Simple indicator       - 1  Bit (18)
  139.  * o = Operation              - 3  Bits (19-21)
  140.  * r = Sequence replica       - 2  Bits (22-23)
  141.  * a = Attr Info in LQHKEYREQ - 3  Bits (24-26)
  142.  * c = Same client and tc     - 1  Bit (27)
  143.  * u = Read Len Return Ind    - 1  Bit (28)
  144.  * m = Commit ack marker      - 1  Bit (29)
  145.  * - = Unused                 - 2  Bits (30-31)
  146.  *
  147.  *           1111111111222222222233
  148.  * 01234567890123456789012345678901
  149.  * kkkkkkkkkklltttpdisooorraaacum--
  150.  */
  152. #define RI_KEYLEN_SHIFT      (0)
  153. #define RI_KEYLEN_MASK       (1023)
  154. #define RI_LAST_REPL_SHIFT   (10)
  155. #define RI_LAST_REPL_MASK    (3)
  156. #define RI_LOCK_TYPE_SHIFT   (12)
  157. #define RI_LOCK_TYPE_MASK    (7)
  158. #define RI_APPL_ADDR_SHIFT   (15)
  159. #define RI_DIRTY_SHIFT       (16)
  160. #define RI_INTERPRETED_SHIFT (17)
  161. #define RI_SIMPLE_SHIFT      (18)
  162. #define RI_OPERATION_SHIFT   (19)
  163. #define RI_OPERATION_MASK    (7)
  164. #define RI_SEQ_REPLICA_SHIFT (22)
  165. #define RI_SEQ_REPLICA_MASK  (3)
  166. #define RI_AI_IN_THIS_SHIFT  (24)
  167. #define RI_AI_IN_THIS_MASK   (7)
  168. #define RI_SAME_CLIENT_SHIFT (27)
  169. #define RI_RETURN_AI_SHIFT   (28)
  170. #define RI_MARKER_SHIFT      (29)
  172. /**
  173.  * Scan Info
  174.  *
  175.  * a = Attr Len                 - 16 Bits -> max 65535 (0-15)
  176.  * p = Stored Procedure Ind     -  1 Bit (16)
  177.  * d = Distribution key         -  8 Bit  -> max 255 (17-24)
  178.  * t = Scan take over indicator -  1 Bit (25)
  179.  *
  180.  *           1111111111222222222233
  181.  * 01234567890123456789012345678901
  182.  * aaaaaaaaaaaaaaaapddddddddt             
  183.  */
  185. #define SI_ATTR_LEN_MASK     (65535)
  186. #define SI_ATTR_LEN_SHIFT    (0)
  187. #define SI_STORED_PROC_SHIFT (16)
  188. #define SI_DISTR_KEY_MASK    (255)
  189. #define SI_DISTR_KEY_SHIFT   (17)
  190. #define SI_SCAN_TO_SHIFT     (25)
  191. #define SI_SCAN_INFO_MASK    (63)
  192. #define SI_SCAN_INFO_SHIFT   (26)
  194. inline 
  195. UintR
  196. LqhKeyReq::getAttrLen(const UintR & scanData)
  197. {
  198.   return (scanData >> SI_ATTR_LEN_SHIFT) & SI_ATTR_LEN_MASK;
  199. }
  201. inline 
  202. Uint32
  203. LqhKeyReq::getScanTakeOverFlag(const UintR & scanData)
  204. {
  205.   return (scanData >> SI_SCAN_TO_SHIFT) & 1;
  206. }
  208. inline
  209. UintR
  210. LqhKeyReq::getStoredProcFlag(const UintR & scanData){
  211.   return (scanData >> SI_STORED_PROC_SHIFT) & 1;
  212. }
  214. inline
  215. UintR
  216. LqhKeyReq::getDistributionKey(const UintR & scanData){
  217.   return (scanData >> SI_DISTR_KEY_SHIFT) & SI_DISTR_KEY_MASK;
  218. }
  220. inline 
  221. UintR LqhKeyReq::getTableId(const UintR & tableSchemaVersion)
  222. {
  223.  return tableSchemaVersion & 0xFFFF;
  224. }
  226. inline 
  227. UintR LqhKeyReq::getSchemaVersion(const UintR & tableSchemaVersion)
  228. {
  229.   return tableSchemaVersion >> 16;
  230. }
  232. inline 
  233. UintR LqhKeyReq::getFragmentId(const UintR & fragmentData)
  234. {
  235.   return fragmentData & 0xFFFF;
  236. }
  238. inline 
  239. UintR LqhKeyReq::getNextReplicaNodeId(const UintR & fragmentData)
  240. {
  241.  return fragmentData >> 16;
  242. }
  244. inline 
  245. Uint8 LqhKeyReq::getLastReplicaNo(const UintR & requestInfo)
  246. {
  247.  return (requestInfo >> RI_LAST_REPL_SHIFT) & RI_LAST_REPL_MASK;
  248. }
  250. inline 
  251. Uint8 LqhKeyReq::getLockType(const UintR & requestInfo)
  252. {
  253.   return (requestInfo >> RI_LOCK_TYPE_SHIFT) & RI_LOCK_TYPE_MASK;
  254. }
  256. inline 
  257. Uint8 LqhKeyReq::getDirtyFlag(const UintR & requestInfo)
  258. {
  259.   return (requestInfo >> RI_DIRTY_SHIFT) & 1;
  260. }
  262. inline 
  263. Uint8 LqhKeyReq::getInterpretedFlag(const UintR & requestInfo)
  264. {
  265.   return (requestInfo >> RI_INTERPRETED_SHIFT) & 1;
  266. }
  268. inline 
  269. Uint8 LqhKeyReq::getSimpleFlag(const UintR & requestInfo)
  270. {
  271.   return (requestInfo >> RI_SIMPLE_SHIFT) & 1;
  272. }
  274. inline 
  275. Uint8 LqhKeyReq::getOperation(const UintR & requestInfo)
  276. {
  277.   return (requestInfo >> RI_OPERATION_SHIFT) & RI_OPERATION_MASK;
  278. }
  280. inline 
  281. Uint8 LqhKeyReq::getSeqNoReplica(const UintR & requestInfo)
  282. {
  283.   return (requestInfo >> RI_SEQ_REPLICA_SHIFT) & RI_SEQ_REPLICA_MASK;
  284. }
  287. inline 
  288. Uint8 LqhKeyReq::getAIInLqhKeyReq(const UintR & requestInfo)
  289. {
  290.   return (requestInfo >> RI_AI_IN_THIS_SHIFT) & RI_AI_IN_THIS_MASK;
  291. }
  293. inline 
  294. UintR LqhKeyReq::getKeyLen(const UintR & requestInfo)
  295. {
  296.   return (requestInfo >> RI_KEYLEN_SHIFT) & RI_KEYLEN_MASK;
  297. }
  299. inline 
  300. UintR 
  301. LqhKeyReq::getSameClientAndTcFlag(const UintR & requestInfo)
  302. {
  303.   return (requestInfo >> RI_SAME_CLIENT_SHIFT) & 1;
  304. }
  306. inline 
  307. UintR LqhKeyReq::getReturnedReadLenAIFlag(const UintR & requestInfo)
  308. {
  309.   return (requestInfo >> RI_RETURN_AI_SHIFT) & 1;
  310. }
  312. inline
  313. UintR 
  314. LqhKeyReq::getApplicationAddressFlag(const UintR & requestInfo){
  315.   return (requestInfo >> RI_APPL_ADDR_SHIFT) & 1;
  316. }
  318. inline
  319. void
  320. LqhKeyReq::setAttrLen(UintR & scanInfoAttrLen, UintR val){
  321.   ASSERT_MAX(val, SI_ATTR_LEN_MASK, "LqhKeyReq::setAttrLen");
  322.   scanInfoAttrLen |= (val << SI_ATTR_LEN_SHIFT);
  323. }
  326. inline
  327. void
  328. LqhKeyReq::setScanTakeOverFlag(UintR & scanInfoAttrLen, UintR val){
  329.   ASSERT_BOOL(val, "LqhKeyReq::setScanTakeOverFlag");
  330.   scanInfoAttrLen |= (val << SI_SCAN_TO_SHIFT);
  331. }
  332. inline
  333. void
  335. LqhKeyReq::setStoredProcFlag(UintR & scanData, UintR val){
  336.   ASSERT_BOOL(val, "LqhKeyReq::setStoredProcFlag");
  337.   scanData |= (val << SI_STORED_PROC_SHIFT);
  338. }
  340. inline
  341. void
  343. LqhKeyReq::setDistributionKey(UintR & scanData, UintR val){
  344.   ASSERT_MAX(val, SI_DISTR_KEY_MASK, "LqhKeyReq::setDistributionKey");
  345.   scanData |= (val << SI_DISTR_KEY_SHIFT);
  346. }
  348. #if 0  
  349. inline
  350. void
  352. LqhKeyReq::setTableId(UintR & tableSchemaVersion, UintR val){
  353.   
  354. }
  355. inline
  356. void
  357. LqhKeyReq::setSchemaVersion(UintR & tableSchemaVersion, UintR val);
  359. inline
  360. void
  361. LqhKeyReq::setFragmentId(UintR & fragmentData, UintR val);
  363. inline
  364. void
  365. LqhKeyReq::setNextReplicaNodeId(UintR & fragmentData, UintR val);
  366. #endif
  368. inline
  369. void
  370. LqhKeyReq::setLockType(UintR & requestInfo, UintR val){
  371.   ASSERT_MAX(val, RI_LOCK_TYPE_MASK, "LqhKeyReq::setLockType");
  372.   requestInfo |= (val << RI_LOCK_TYPE_SHIFT);
  373. }
  375. inline
  376. void
  377. LqhKeyReq::setDirtyFlag(UintR & requestInfo, UintR val){
  378.   ASSERT_BOOL(val, "LqhKeyReq::setDirtyFlag");
  379.   requestInfo |= (val << RI_DIRTY_SHIFT);
  380. }
  382. inline
  383. void
  384. LqhKeyReq::setInterpretedFlag(UintR & requestInfo, UintR val){
  385.   ASSERT_BOOL(val, "LqhKeyReq::setInterpretedFlag");
  386.   requestInfo |= (val << RI_INTERPRETED_SHIFT);
  387. }
  389. inline
  390. void
  391. LqhKeyReq::setSimpleFlag(UintR & requestInfo, UintR val){
  392.   ASSERT_BOOL(val, "LqhKeyReq::setSimpleFlag");
  393.   requestInfo |= (val << RI_SIMPLE_SHIFT);
  394. }
  396. inline
  397. void
  398. LqhKeyReq::setOperation(UintR & requestInfo, UintR val){
  399.   ASSERT_MAX(val, RI_OPERATION_MASK, "LqhKeyReq::setOperation");
  400.   requestInfo |= (val << RI_OPERATION_SHIFT);
  401. }
  403. inline
  404. void
  405. LqhKeyReq::setSeqNoReplica(UintR & requestInfo, UintR val){
  406.   ASSERT_MAX(val, RI_SEQ_REPLICA_MASK, "LqhKeyReq::setSeqNoReplica");
  407.   requestInfo |= (val << RI_SEQ_REPLICA_SHIFT);
  408. }
  410. inline
  411. void
  412. LqhKeyReq::setLastReplicaNo(UintR & requestInfo, UintR val){
  413.   ASSERT_MAX(val, RI_LAST_REPL_MASK, "LqhKeyReq::setLastReplicaNo");
  414.   requestInfo |= (val << RI_LAST_REPL_SHIFT);
  415. }
  417. inline
  418. void
  419. LqhKeyReq::setAIInLqhKeyReq(UintR & requestInfo, UintR val){
  420.   ASSERT_MAX(val, RI_AI_IN_THIS_MASK, "LqhKeyReq::setAIInLqhKeyReq");
  421.   requestInfo |= (val << RI_AI_IN_THIS_SHIFT);
  422. }
  424. inline
  425. void
  426. LqhKeyReq::setKeyLen(UintR & requestInfo, UintR val){
  427.   ASSERT_MAX(val, RI_KEYLEN_MASK, "LqhKeyReq::setKeyLen");
  428.   requestInfo |= (val << RI_KEYLEN_SHIFT);
  429. }
  431. inline
  432. void
  433. LqhKeyReq::setSameClientAndTcFlag(UintR & requestInfo, UintR val){
  434.   ASSERT_BOOL(val, "LqhKeyReq::setSameClientAndTcFlag");
  435.   requestInfo |= (val << RI_SAME_CLIENT_SHIFT);
  436. }
  438. inline
  439. void
  440. LqhKeyReq::setReturnedReadLenAIFlag(UintR & requestInfo, UintR val){
  441.   ASSERT_BOOL(val, "LqhKeyReq::setReturnedReadLenAIFlag");
  442.   requestInfo |= (val << RI_RETURN_AI_SHIFT);
  443. }
  445. inline
  446. void
  447. LqhKeyReq::setApplicationAddressFlag(UintR & requestInfo, UintR val){
  448.   ASSERT_BOOL(val, "LqhKeyReq::setApplicationAddressFlag");
  449.   requestInfo |= (val << RI_APPL_ADDR_SHIFT);
  450. }
  452. /**** */
  454. inline
  455. void
  456. LqhKeyReq::setMarkerFlag(UintR & requestInfo, UintR val){
  457.   ASSERT_BOOL(val, "LqhKeyReq::setMarkerFlag");
  458.   requestInfo |= (val << RI_MARKER_SHIFT);
  459. }
  461. inline
  462. UintR 
  463. LqhKeyReq::getMarkerFlag(const UintR & requestInfo){
  464.   return (requestInfo >> RI_MARKER_SHIFT) & 1;
  465. }
  467. class LqhKeyConf {
  468.   /**
  469.    * Reciver(s)
  470.    */
  471.   friend class Dbtc;
  473.   /**
  474.    * Sender(s)
  475.    */
  476.   friend class Dblqh;
  478.   // Sent in a packed signal
  479.   friend class PackedSignal;
  480.   /**
  481.    * For printing
  482.    */
  483.   friend bool printPACKED_SIGNAL(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
  484.   friend bool printLQHKEYCONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
  486. public:
  487.   STATIC_CONST( SignalLength = 7 );
  489. private:
  491.   /**
  492.    * DATA VARIABLES
  493.    */
  494.   Uint32 connectPtr;
  495.   Uint32 opPtr;
  496.   Uint32 userRef;
  497.   Uint32 readLen;
  498.   Uint32 transId1;
  499.   Uint32 transId2;
  500.   Uint32 noFiredTriggers;
  501. };
  503. class LqhKeyRef {
  504.   /**
  505.    * Reciver(s)
  506.    */
  507.   friend class Dbtc;      
  509.   /**
  510.    * Sender(s)
  511.    */
  512.   friend class Dblqh;
  514.   /**
  515.    * For printing
  516.    */
  517.   friend bool printLQHKEYREF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo);
  519. public:
  520.   STATIC_CONST( SignalLength = 5 );
  522. private:
  524.   /**
  525.    * DATA VARIABLES
  526.    */
  527.   Uint32 userRef;
  528.   Uint32 connectPtr;
  529.   Uint32 errorCode;
  530.   Uint32 transId1;
  531.   Uint32 transId2;
  532. };
  534. #endif