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

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

MySQL数据库

开发平台：

Visual C++

SumaImpl.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 SUMA_IMPL_HPP
  18. #define SUMA_IMPL_HPP
  20. #include "SignalData.hpp"
  21. #include <NodeBitmask.hpp>
  24. class SubCreateReq {
  25.   /**
  26.    * Sender(s)/Reciver(s)
  27.    */
  28.   friend class Grep;
  29.   friend class SumaParticipant;
  30.   
  31.   friend bool printSUB_CREATE_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  32. public:
  33.   STATIC_CONST( SignalLength = 5 );
  34.   
  35.   enum SubscriptionType {
  36.     SingleTableScan  = 1,  // 
  37.     DatabaseSnapshot = 2, // All tables/all data (including new ones)
  38.     TableEvent  = 3,       //
  39.     SelectiveTableSnapshot  = 4,  // User defines tables
  40.     RemoveFlags  = 0xff,
  41.     GetFlags     = 0xff << 16,
  42.     AddTableFlag = 0x1 << 16,
  43.     RestartFlag  = 0x2 << 16
  44.   };
  45.   
  46.   Uint32 subscriberRef;
  47.   Uint32 subscriberData;
  48.   Uint32 subscriptionId;
  49.   Uint32 subscriptionKey;
  50.   Uint32 subscriptionType;
  51.   union {
  52.     Uint32 tableId; // Used when doing SingelTableScan
  53.   };
  54.   SECTION( ATTRIBUTE_LIST = 0); // Used when doing SingelTableScan  
  55.   SECTION( TABLE_LIST = 1 );  
  56.   
  57. };
  59. class SubCreateRef {
  60.   /**
  61.    * Sender(s)/Reciver(s)
  62.    */
  63.   friend class Grep;
  64.   friend class SumaParticipant;
  65.   
  66.   friend bool printSUB_CREATE_REF(FILE *, const Uint32 *, Uint32, Uint16);
  67. public:
  68.   STATIC_CONST( SignalLength = 6 );
  70.   Uint32 subscriberRef;
  71.   Uint32 subscriberData;
  72.   Uint32 subscriptionId;
  73.   Uint32 subscriptionKey;
  74.   Uint32 subscriptionType;
  75.   Uint32 err;
  77.   SECTION( ATTRIBUTE_LIST = 0); // Used when doing SingelTableScan
  78.   union {
  79.     Uint32 tableId; // Used when doing SingelTableScan
  80.   };
  81. };
  83. class SubCreateConf {
  84.   /**
  85.    * Sender(s)/Reciver(s)
  86.    */
  87.   friend class Grep;
  88.   friend class SumaParticipant;
  89.   
  90.   friend bool printSUB_CREATE_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  91. public:
  92.   STATIC_CONST( SignalLength = 3 );
  93.   
  94.   Uint32 subscriberData;
  95.   Uint32 subscriptionId;
  96.   Uint32 subscriptionKey;
  97. };
  99. class SubscriptionData {
  100. public:
  101.   enum Part {
  102.     MetaData = 1,
  103.     TableData = 2
  104.   };
  105. };
  107. class SubStartReq {
  108.   /**
  109.    * Sender(s)/Reciver(s)
  110.    */
  111.   friend class Suma;
  112.   
  113.   friend bool printSUB_START_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  114. public:
  115.   STATIC_CONST( SignalLength = 6 );
  116.   STATIC_CONST( SignalLength2 = SignalLength+1 );
  118.   Uint32 senderRef;
  119.   Uint32 senderData;
  120.   Uint32 subscriptionId;
  121.   Uint32 subscriptionKey;
  122.   Uint32 part;  // SubscriptionData::Part
  123.   Uint32 subscriberData;
  124.   Uint32 subscriberRef;
  125. };
  127. class SubStartRef {
  128.   /**
  129.    * Sender(s)/Reciver(s)
  130.    */
  131.   friend class Suma;
  132.   
  133.   friend bool printSUB_START_REF(FILE *, const Uint32 *, Uint32, Uint16);
  134. public:
  135.   enum ErrorCode {
  136.     Undefined = 0,
  137.     NF_FakeErrorREF = 11,
  138.     Busy = 701,
  139.     Temporary = 0x1 << 16
  140.   };
  141.   bool isTemporary() const;
  142.   void setTemporary();
  143.   ErrorCode setTemporary(ErrorCode ec);
  145.   STATIC_CONST( SignalLength = 7 );
  146.   STATIC_CONST( SignalLength2 = SignalLength+1 );
  147.   
  148.   Uint32 senderRef;
  149.   Uint32 senderData;
  150.   Uint32 subscriptionId;
  151.   Uint32 subscriptionKey;
  152.   Uint32 part;  // SubscriptionData::Part
  153.   Uint32 subscriberData;
  154.   union { // do not change the order here!
  155.     Uint32 err;
  156.     Uint32 errorCode;
  157.   };
  158.   // with SignalLength2
  159.   Uint32 subscriberRef;
  160. };
  161. inline bool SubStartRef::isTemporary() const
  162. { return (errorCode &  SubStartRef::Temporary) > 0; }
  163. inline void SubStartRef::setTemporary()
  164. { errorCode |=  SubStartRef::Temporary; }
  165. inline SubStartRef::ErrorCode SubStartRef::setTemporary(ErrorCode ec)
  166. { return (SubStartRef::ErrorCode) 
  167.     (errorCode = ((Uint32) ec | (Uint32)SubStartRef::Temporary)); }
  169. class SubStartConf {
  170.   /**
  171.    * Sender(s)/Reciver(s)
  172.    */
  173.   friend class Grep;
  174.   
  175.   friend bool printSUB_START_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  176. public:
  177.   STATIC_CONST( SignalLength = 7 );
  178.   STATIC_CONST( SignalLength2 = SignalLength+1 );
  180.   Uint32 senderRef;
  181.   Uint32 senderData;
  182.   Uint32 subscriptionId;
  183.   Uint32 subscriptionKey;
  184.   Uint32 firstGCI;
  185.   Uint32 part;  // SubscriptionData::Part
  186.   Uint32 subscriberData;
  187.   // with SignalLength2
  188.   Uint32 subscriberRef;
  189. };
  191. class SubStopReq {
  192.   /**
  193.    * Sender(s)/Reciver(s)
  194.    */
  195.   friend class Suma;
  196.   
  197.   friend bool printSUB_STOP_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  198. public:
  199.   STATIC_CONST( SignalLength = 7 );
  200.   Uint32 senderRef;
  201.   Uint32 senderData;
  202.   Uint32 subscriptionId;
  203.   Uint32 subscriptionKey;
  204.   Uint32 part;  // SubscriptionData::Part
  205.   Uint32 subscriberData;
  206.   Uint32 subscriberRef;
  207. };
  209. class SubStopRef {
  210.   /**
  211.    * Sender(s)/Reciver(s)
  212.    */
  213.   friend class Suma;
  214.   
  215.   friend bool printSUB_STOP_REF(FILE *, const Uint32 *, Uint32, Uint16);
  216. public:
  217.   enum ErrorCode {
  218.     Undefined = 0,
  219.     NF_FakeErrorREF = 11,
  220.     Busy = 701,
  221.     Temporary = 0x1 << 16
  222.   };
  223.   bool isTemporary() const;
  224.   void setTemporary();
  225.   ErrorCode setTemporary(ErrorCode ec);
  227.   STATIC_CONST( SignalLength = 8 );
  228.   
  229.   Uint32 senderRef;
  230.   Uint32 senderData;
  231.   Uint32 subscriptionId;
  232.   Uint32 subscriptionKey;
  233.   Uint32 part;  // SubscriptionData::Part
  234.   Uint32 subscriberData;
  235.   Uint32 subscriberRef;
  236.   union {
  237.     Uint32 err;
  238.     Uint32 errorCode;
  239.   };
  240. };
  241. inline bool SubStopRef::isTemporary() const
  242. { return (errorCode &  SubStopRef::Temporary) > 0; }
  243. inline void SubStopRef::setTemporary()
  244. { errorCode |=  SubStopRef::Temporary; }
  245. inline SubStopRef::ErrorCode SubStopRef::setTemporary(ErrorCode ec)
  246. { return (SubStopRef::ErrorCode) 
  247.     (errorCode = ((Uint32) ec | (Uint32)SubStopRef::Temporary)); }
  249. class SubStopConf {
  250.   /**
  251.    * Sender(s)/Reciver(s)
  252.    */
  253.   friend class Grep;
  254.   
  255.   friend bool printSUB_STOP_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  256. public:
  257.   STATIC_CONST( SignalLength = 7 );
  259.   Uint32 senderRef;
  260.   Uint32 senderData;
  261.   Uint32 subscriptionId;
  262.   Uint32 subscriptionKey;
  263.   Uint32 part;  // SubscriptionData::Part
  264.   Uint32 subscriberData;
  265.   Uint32 subscriberRef;
  266. };
  268. class SubSyncReq {
  269.   /**
  270.    * Sender(s)/Reciver(s)
  271.    */
  272.   friend class Suma;
  273.   friend class Grep;
  274.   
  275.   friend bool printSUB_SYNC_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  276. public:
  277.   STATIC_CONST( SignalLength = 4 );
  278.   
  279. public:
  280.   Uint32 subscriptionId;
  281.   Uint32 subscriptionKey;
  282.   Uint32 subscriberData;
  283.   Uint32 part; // SubscriptionData::Part
  284. };
  286. class SubSyncRef {
  287.   /**
  288.    * Sender(s)/Reciver(s)
  289.    */
  290.   friend class Suma;
  291.   friend class Grep;
  292.   
  293.   friend bool printSUB_SYNC_REF(FILE *, const Uint32 *, Uint32, Uint16);
  294. public:
  295.   enum ErrorCode {
  296.     Undefined = 0,
  297.     Temporary = 0x1 << 16
  298.   };
  299.   STATIC_CONST( SignalLength = 5 );
  300.   
  301.   Uint32 subscriptionId;
  302.   Uint32 subscriptionKey;
  303.   Uint32 part; // SubscriptionData::Part
  304.   Uint32 subscriberData;
  305.   union {
  306.     Uint32 errorCode;
  307.     Uint32 err;
  308.   };
  309. };
  311. class SubSyncConf {
  313.   /**
  314.    * Sender(s)/Reciver(s)
  315.    */
  316.   friend class Suma;
  317.   friend class Grep;
  318.   
  319.   friend bool printSUB_SYNC_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  320. public:
  321.   STATIC_CONST( SignalLength = 4 );
  322.   
  323.   Uint32 subscriptionId;
  324.   Uint32 subscriptionKey;
  325.   Uint32 part;  // SubscriptionData::Part
  326.   Uint32 subscriberData;
  327. };
  329. class SubMetaData {
  330.   /**
  331.    * Sender(s)/Reciver(s)
  332.    */
  333.   friend class SumaParticipant;
  334.   friend class Grep;
  335.   
  336.   friend bool printSUB_META_DATA(FILE *, const Uint32 *, Uint32, Uint16);
  337. public:
  338.   STATIC_CONST( SignalLength = 3 );
  339.   SECTION( DICT_TAB_INFO = 0 );
  340.   
  341.   Uint32 gci;
  342.   union { // Haven't decide what to call it
  343.     Uint32 senderData;
  344.     Uint32 subscriberData;
  345.   };
  346.   union {
  347.     Uint32 tableId;
  348.   };
  349. };
  351. class SubTableData {
  352.   /**
  353.    * Sender(s)/Reciver(s)
  354.    */
  355.   friend class SumaParticipant;
  356.   friend class Grep;
  357.   
  358.   friend bool printSUB_TABLE_DATA(FILE *, const Uint32 *, Uint32, Uint16);
  359. public:
  360.   STATIC_CONST( SignalLength = 7 );
  361.   
  362.   enum LogType {
  363.     SCAN = 1, 
  364.     LOG  = 2,
  365.     REMOVE_FLAGS = 0xff,
  366.     GCINOTCONSISTENT = 0x1 << 16
  367.   };
  368.   
  369.   void setGCINotConsistent() { logType |= (Uint32)GCINOTCONSISTENT; };
  370.   bool isGCIConsistent()
  371.   { return (logType & (Uint32)GCINOTCONSISTENT) == 0 ? true : false; };
  373.   union { // Haven't decide what to call it
  374.     Uint32 senderData;
  375.     Uint32 subscriberData;
  376.   };
  377.   Uint32 gci;
  378.   Uint32 tableId;
  379.   Uint32 operation;
  380.   Uint32 noOfAttributes;
  381.   Uint32 dataSize; 
  382.   Uint32 logType;
  383. };
  385. class SubSyncContinueReq {
  386.   /**
  387.    * Sender(s)/Reciver(s)
  388.    */
  389.   friend class SumaParticipant;
  390.   friend class Grep;
  391.   friend class Trix;
  392.   
  393.   friend bool printSUB_SYNC_CONTINUE_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  394. public:
  395.   STATIC_CONST( SignalLength = 2 );
  397.   union { // Haven't decide what to call it
  398.     Uint32 senderData;
  399.     Uint32 subscriberData;
  400.   };
  401.   Uint32 noOfRowsSent;
  402. };
  404. class SubSyncContinueRef {
  405.   /**
  406.    * Sender(s)/Reciver(s)
  407.    */
  408.   friend class SumaParticipant;
  409.   friend class Grep;
  410.   friend class Trix;
  411.   
  412.   friend bool printSUB_SYNC_CONTINUE_REF(FILE *, const Uint32 *, Uint32, Uint16);
  413. public:
  414.   STATIC_CONST( SignalLength = 2 );
  416.   Uint32 subscriptionId;
  417.   Uint32 subscriptionKey;
  418. };
  420. class SubSyncContinueConf {
  421.   /**
  422.    * Sender(s)/Reciver(s)
  423.    */
  424.   friend class SumaParticipant;
  425.   friend class Grep;
  426.   friend class Trix;
  427.   
  428.   friend bool printSUB_SYNC_CONTINUE_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  429. public:
  430.   STATIC_CONST( SignalLength = 2 );
  432.   Uint32 subscriptionId;
  433.   Uint32 subscriptionKey;
  434. };
  436. class SubGcpCompleteRep {
  438.   /**
  439.    * Sender(s)/Reciver(s)
  440.    */
  441.   friend class Dbdih;
  442.   friend class SumaParticipant;
  443.   friend class Grep;
  444.   friend class Trix;
  445.   
  446.   friend bool printSUB_GCP_COMPLETE_REP(FILE *, const Uint32 *, Uint32, Uint16);
  447. public:
  448.   STATIC_CONST( SignalLength = 3 );
  449.   
  450.   Uint32 gci;
  451.   Uint32 senderRef;
  452.   union { // Haven't decide what to call it
  453.     Uint32 senderData;
  454.     Uint32 subscriberData;
  455.   };
  456. };
  458. class SubGcpCompleteAcc {
  459.   /**
  460.    * Sender(s)/Reciver(s)
  461.    */
  462. public:
  463.   STATIC_CONST( SignalLength = SubGcpCompleteRep::SignalLength );
  465.   SubGcpCompleteRep rep;
  466. };
  468. class SubRemoveReq {
  469.   /**
  470.    * Sender(s)/Reciver(s)
  471.    */
  472.   friend class Grep;
  473.   friend class SumaParticipant;
  474.   
  475.   friend bool printSUB_REMOVE_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  476. public:
  477.   STATIC_CONST( SignalLength = 4 );
  478.   
  479.   Uint32 senderRef;
  480.   Uint32 senderData;
  481.   Uint32 subscriptionId;
  482.   Uint32 subscriptionKey;
  483. };
  485. class SubRemoveRef {
  486.   /**
  487.    * Sender(s)/Reciver(s)
  488.    */
  489.   friend class Grep;
  490.   friend class SumaParticipant;
  491.   
  492.   friend bool printSUB_REMOVE_REF(FILE *, const Uint32 *, Uint32, Uint16);
  493. public:
  494.   STATIC_CONST( SignalLength = 5 );
  495.   enum ErrorCode {
  496.     Undefined = 0,
  497.     NF_FakeErrorREF = 11,
  498.     Busy = 701,
  499.     Temporary = 0x1 << 16
  500.   };
  501.   bool isTemporary() const;
  502.   void setTemporary();
  503.   ErrorCode setTemporary(ErrorCode ec);
  505.   Uint32 senderRef;
  506.   Uint32 subscriptionId;
  507.   Uint32 subscriptionKey;
  508.   union {
  509.     Uint32 err;
  510.     Uint32 errorCode;
  511.   };
  512.   union { // Haven't decide what to call it
  513.     Uint32 senderData;
  514.     Uint32 subscriberData;
  515.   };
  516. };
  517. inline bool SubRemoveRef::isTemporary() const
  518. { return (err &  SubRemoveRef::Temporary) > 0; }
  519. inline void SubRemoveRef::setTemporary()
  520. { err |=  SubRemoveRef::Temporary; }
  521. inline SubRemoveRef::ErrorCode SubRemoveRef::setTemporary(ErrorCode ec)
  522. { return (SubRemoveRef::ErrorCode) 
  523.     (errorCode = ((Uint32) ec | (Uint32)SubRemoveRef::Temporary)); }
  525. class SubRemoveConf {
  526.   /**
  527.    * Sender(s)/Reciver(s)
  528.    */
  529.   friend class Grep;
  530.   friend class SumaParticipant;
  531.   
  532.   friend bool printSUB_REMOVE_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  533. public:
  534.   STATIC_CONST( SignalLength = 5 );
  535.   
  536.   Uint32 senderRef;
  537.   Uint32 subscriptionId;
  538.   Uint32 subscriptionKey;
  539.   Uint32 err;
  540.   union { // Haven't decide what to call it
  541.     Uint32 senderData;
  542.     Uint32 subscriberData;
  543.   };
  545. };
  548. class CreateSubscriptionIdReq {
  549.   friend class Grep;
  550.   friend class SumaParticipant;
  551.   
  552.   friend bool printCREATE_SUBSCRIPTION_ID_REQ(FILE *, const Uint32 *, 
  553.        Uint32, Uint16);
  554. public:
  555.   STATIC_CONST( SignalLength = 3 );
  556.   
  557.   Uint32 subscriptionId;
  558.   Uint32 subscriptionKey;
  559.   union { // Haven't decide what to call it
  560.     Uint32 senderData;
  561.     Uint32 subscriberData;
  562.   };
  563. };
  566. class CreateSubscriptionIdConf {
  567.   friend class Grep;
  568.   friend class SumaParticipant;
  569.   
  570.   friend bool printCREATE_SUBSCRIPTION_ID_CONF(FILE *, const Uint32 *, 
  571.        Uint32, Uint16);
  572. public:
  573.   STATIC_CONST( SignalLength = 3 );
  574.   
  575.   Uint32 subscriptionId;
  576.   Uint32 subscriptionKey;
  577.   union { // Haven't decide what to call it
  578.     Uint32 senderData;
  579.     Uint32 subscriberData;
  580.   };
  581. };
  584. class CreateSubscriptionIdRef {
  585.   friend class Grep;
  586.   friend class SumaParticipant;
  587.   
  588.   friend bool printCREATE_SUBSCRIPTION_ID_REF(FILE *, const Uint32 *, 
  589.        Uint32, Uint16);
  590. public:
  591.   STATIC_CONST( SignalLength = 4 );
  592.   
  593.   Uint32 subscriptionId;
  594.   Uint32 subscriptionKey;
  595.   Uint32 err;
  596.   union { // Haven't decide what to call it
  597.     Uint32 senderData;
  598.     Uint32 subscriberData;
  599.   };
  600. };
  602. class SumaStartMe {
  603. public:
  604.   STATIC_CONST( SignalLength = 1 );
  605.   Uint32 unused;
  606. };
  608. class SumaHandoverReq {
  609. public:
  610.   STATIC_CONST( SignalLength = 1 );
  611.   Uint32 gci;
  612. };
  614. class SumaHandoverConf {
  615. public:
  616.   STATIC_CONST( SignalLength = 1 );
  617.   Uint32 gci;
  618. };
  619. #endif