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

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

MySQL数据库

开发平台：

Visual C++

DbUtil.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 DBUTIL_H
  18. #define DBUTIL_H
  20. #include <ndb_limits.h>
  21. #include <SimulatedBlock.hpp>
  22. #include <NodeBitmask.hpp>
  24. #include <ArrayList.hpp>
  25. #include <ArrayPool.hpp>
  26. #include <SLList.hpp>
  27. #include <DLList.hpp>
  28. #include <DLFifoList.hpp>
  29. #include <DataBuffer.hpp>
  30. #include <KeyTable.hpp>
  32. #include <signaldata/KeyInfo.hpp>
  33. #include <signaldata/AttrInfo.hpp>
  34. #include <signaldata/TcKeyReq.hpp>
  35. #include <signaldata/UtilPrepare.hpp>
  36. #include <signaldata/UtilExecute.hpp>
  37. #include <signaldata/UtilLock.hpp>
  38. #include <SimpleProperties.hpp>
  40. #define UTIL_WORDS_PER_PAGE 1023
  42. /**
  43.  * @class DbUtil 
  44.  * @brief Database utilities
  45.  *
  46.  * This block implements transactional services which can be used by other 
  47.  * blocks.
  48.  *
  49.  * @section secSequence   Module: The Sequence Service
  50.  *
  51.  * A sequence is a varaible stored in the database.  Each time it is 
  52.  * requested with "NextVal" it returns a unique number.  If requested 
  53.  * with "CurrVal" it returns the current number.
  54.  * 
  55.  * - Request: SEQUENCE_REQ 
  56.  *   Requests the 'NextVal' or 'CurrVal' for sequence variable 'sequenceId'.
  57.  *
  58.  * - Response: SEQUENCE_CONF / REF (if failure)
  59.  *   Returns value requested.
  60.  */
  61. class DbUtil : public SimulatedBlock
  62. {
  63. public:
  64.   DbUtil(const class Configuration & conf);
  65.   virtual ~DbUtil();
  66.   BLOCK_DEFINES(DbUtil);
  67.   
  68. protected:
  69.   /**
  70.    * Startup & Misc
  71.    */
  72.   void execSTTOR(Signal* signal);
  73.   void execNDB_STTOR(Signal* signal);
  74.   void execDUMP_STATE_ORD(Signal* signal);
  75.   void execCONTINUEB(Signal* signal);
  77.   /**
  78.    * Sequence Service : Public interface
  79.    */
  80.   void execUTIL_SEQUENCE_REQ(Signal* signal);
  81.   void execUTIL_SEQUENCE_REF(Signal* signal);
  82.   void execUTIL_SEQUENCE_CONF(Signal* signal);
  84.   /**
  85.    * Prepare Service : Public interface
  86.    */
  87.   void execUTIL_PREPARE_REQ(Signal* signal);
  88.   void execUTIL_PREPARE_CONF(Signal* signal);
  89.   void execUTIL_PREPARE_REF(Signal* signal);
  91.   /**
  92.    * Delete Service : Public interface
  93.    */
  94.   void execUTIL_DELETE_REQ(Signal* signal);
  95.   void execUTIL_DELETE_REF(Signal* signal);
  96.   void execUTIL_DELETE_CONF(Signal* signal);
  98.   /**
  99.    * Execute Service : Public interface
  100.    */
  101.   void execUTIL_EXECUTE_REQ(Signal* signal);
  102.   void execUTIL_EXECUTE_REF(Signal* signal);
  103.   void execUTIL_EXECUTE_CONF(Signal* signal);
  105.   /**
  106.    * Prepare Release Service : Public interface
  107.    */
  108.   void execUTIL_RELEASE_REQ(Signal* signal);
  109.   void execUTIL_RELEASE_CONF(Signal* signal);
  110.   void execUTIL_RELEASE_REF(Signal* signal);
  112.   /**
  113.    * Backend interface to a used TC service 
  114.    */
  115.   void execTCSEIZECONF(Signal* signal);
  116.   void execTCKEYCONF(Signal* signal);
  117.   void execTCKEYREF(Signal* signal);
  118.   void execTCROLLBACKREP(Signal* signal);
  119.   void execTCKEY_FAILCONF(Signal* signal);
  120.   void execTCKEY_FAILREF(Signal* signal);
  121.   void execTRANSID_AI(Signal* signal);
  123.   /**
  124.    * Backend interface to a used DICT service
  125.    */
  126.   void execGET_TABINFOREF(Signal*);
  127.   void execGET_TABINFO_CONF(Signal* signal);
  129. private:
  130.   
  131. public:
  132.   struct PreparedOperation;
  134.   typedef DataBuffer<11> KeyInfoBuffer;
  135.   typedef KeyInfoBuffer::ConstDataBufferIterator KeyInfoIterator;
  136.   typedef DataBuffer<11> AttrInfoBuffer;
  137.   typedef AttrInfoBuffer::ConstDataBufferIterator AttrInfoIterator;
  138.   typedef DataBuffer<11> ResultSetBuffer;
  139.   typedef DataBuffer<11>  ResultSetInfoBuffer;
  140.   typedef DataBuffer<1>  AttrMappingBuffer;
  141.   
  142.   /** 
  143.    * @struct  Page32
  144.    * @brief   For storing SimpleProperties objects and similar temporary data
  145.    */
  146.   struct Page32 {
  147.     Uint32  data[UTIL_WORDS_PER_PAGE];
  148.     Uint32  nextPool;                  // Note: This used as data when seized
  149.   };
  151.   /**
  152.    * @struct  Prepare
  153.    * @brief   Info regarding prepare request (contains a prepared operation)
  154.    *
  155.    * The prepare phase interprets the table and attribute names sent
  156.    * in the prepare request from the client and asks DICT for meta
  157.    * information.
  158.    */
  159.   struct Prepare {
  160.     Prepare(ArrayPool<Page32> & ap) : preparePages(ap) {}
  162.     /*** Client info ***/
  163.     Uint32 clientRef;
  164.     Uint32 clientData;
  166.     /** 
  167.      * SimpleProp sent in UTIL_PREPARE_REQ 
  168.      *
  169.      * Example format:
  170.      * - UtilPrepareReq::NoOfOperations=1
  171.      * - UtilPrepareReq::OperationType=UtilPrepareReq::Delete
  172.      * - UtilPrepareReq::TableName="SYSTAB_0"
  173.      * - UtilPrepareReq::AttributeName="SYSKEY_0"
  174.      */
  175.     Uint32 prepDataLen;
  176.     Array<Page32>  preparePages;  
  178.     /*** PreparedOperation constructed in Prepare phase ***/
  179.     Ptr<PreparedOperation> prepOpPtr;
  181.     union {
  182.       Uint32 nextPool;
  183.       Uint32 nextList;
  184.     };
  185.     Uint32 prevList;
  187.     void print() const {
  188.       ndbout << "[-Prepare-" << endl
  189.      << " clientRef: " << clientRef
  190.      << ", clientData: " << clientData
  191.      << "]" << endl;
  192.     }
  193.   };
  194.     
  195.   /**
  196.    * @struct  PreparedOperation
  197.    * @brief   Contains instantiated TcKeyReq signaldata for operation
  198.    * 
  199.    * The prepare phase is finished by storing the request in a
  200.    * PreparedOperation record.
  201.    */
  202.   struct PreparedOperation {
  203.     PreparedOperation(AttrMappingBuffer::DataBufferPool & am,
  204.       AttrInfoBuffer::DataBufferPool & ai,
  205.       ResultSetInfoBuffer::DataBufferPool & rs) :
  206.       releaseFlag(false), attrMapping(am), attrInfo(ai), rsInfo(rs)
  207.     {
  208.       pkBitmask.clear();
  209.     }
  211.     /*** Various Operation Info ***/
  212.     Uint32    keyLen;          // Length of primary key (fixed size is assumed)
  213.     Uint32    rsLen;           // Size of result set
  214.     Uint32    noOfKeyAttr;     // Number of key attributes
  215.     Uint32    noOfAttr;        // Number of attributes
  216.     bool      releaseFlag;     // flag if operation release after completion
  218.     /**
  219.      * Attribute Mapping
  220.      *
  221.      * This datastructure (buffer of AttributeHeader:s) are used to map 
  222.      * each execute request to a TCKEYREQ train of signals.
  223.      *
  224.      * The datastructure contains (AttributeId, Position) pairs, where
  225.      * - AttributeId  is id used in database, and
  226.      * - Position     is position of attribute value in TCKEYREQ keyinfo
  227.      *                part of the train of signals which will be send to TC.
  228.      *                Position == 0x3fff means it should *not* be sent
  229.      *                in keyinfo part.
  230.      */
  231.     AttrMappingBuffer    attrMapping;
  233.     /*** First signal in tckeyreq train ***/
  234.     Uint32    tckeyLenInBytes;    // TcKeyReq total signal length (in bytes)
  235.     Uint32    keyDataPos;         // Where to store keydata[] in tckey signal
  236.                                   // (in #words from base in tckey signal)
  237.     TcKeyReq  tckey;              // Signaldata for first signal in train
  238.     
  239.     /*** Attrinfo signals sent to TC (part of tckeyreq train) ***/
  240.     AttrInfoBuffer       attrInfo;
  242.     /*** Result of executed operation ***/
  243.     ResultSetInfoBuffer  rsInfo;    
  245.     Bitmask<MAX_ATTRIBUTES_IN_TABLE> pkBitmask;
  247.     union {
  248.       Uint32 nextPool;
  249.       Uint32 nextList;
  250.     };
  251.     Uint32 prevList;
  252.     
  253.     void print() const {
  254.       ndbout << "[-PreparedOperation-" << endl
  255.      << " keyLen: " << keyLen
  256.      << ", rsLen: " << rsLen
  257.      << ", noOfKeyAttr: " << noOfKeyAttr 
  258.      << ", noOfAttr: " << noOfAttr 
  259.      << ", tckeyLenInBytes: " << tckeyLenInBytes 
  260.      << ", keyDataPos: " << keyDataPos << endl
  261.      << "-AttrMapping- (AttrId, KeyPos)-pairs "
  262.      << "(Pos=3fff if non-key attr):" << endl;
  263.       attrMapping.print(stdout);
  264.       ndbout << "[-tckey- ";
  265.       printTCKEYREQ(stdout, (Uint32*)&tckey, 8, 0);
  266.       ndbout << "[-attrInfo- ";
  267.       attrInfo.print(stdout);
  268.       ndbout << "[-rsInfo- ";
  269.       rsInfo.print(stdout);
  270.       ndbout << "]]]]" << endl;
  271.     }
  272.   };
  273.   
  274.   /**
  275.    * @struct  Operation
  276.    * @brief   Used in execution (contains resultset and buffers for result)
  277.    */
  278.   struct Operation {
  279.     Operation(KeyInfoBuffer::DataBufferPool & ki, 
  280.       AttrInfoBuffer::DataBufferPool & ai,
  281.       ResultSetBuffer::DataBufferPool & _rs) :
  282.       prepOp_i(RNIL), keyInfo(ki), attrInfo(ai), rs(_rs) {}
  283.     
  284.     PreparedOperation *            prepOp;
  285.     Uint32                         prepOp_i;
  286.     KeyInfoBuffer                        keyInfo;
  287.     AttrInfoBuffer                       attrInfo;
  288.     ResultSetBuffer                      rs;
  289.     ResultSetBuffer::DataBufferIterator  rsIterator;
  290.     
  291.     Uint32 transPtrI;
  292.     
  293.     Uint32 rsRecv;
  294.     Uint32 rsExpect;
  295.     inline bool complete() const { return rsRecv == rsExpect; }
  296.     
  297.     union {
  298.       Uint32 nextPool;
  299.       Uint32 nextList;
  300.     };
  302.     void print() const {
  303.       ndbout << "[-Operation-" << endl
  304.      << " transPtrI: " << transPtrI
  305.      << ", rsRecv: " << rsRecv;
  306.       ndbout << "[-PreparedOperation-" << endl;
  307.       prepOp->print();
  308.       ndbout << "[-keyInfo-" << endl;
  309.       keyInfo.print(stdout);
  310.       ndbout << "[-attrInfo-" << endl;
  311.       attrInfo.print(stdout);
  312.       ndbout << "]]" << endl;
  313.     }
  314.   };
  316.   /**
  317.    * @struct  Transaction
  318.    * @brief   Used in execution (contains list of operations)
  319.    */
  320.   struct Transaction {
  321.     Transaction(ArrayPool<Page32> & ap, ArrayPool<Operation> & op) :
  322.       executePages(ap), operations(op) {}
  324.     Uint32 clientRef;
  325.     Uint32 clientData;
  326.     Array<Page32>  executePages;  
  328.     Uint32 gsn;         // Request type (SEQUENCE, DELETE, etc)
  329.     union {
  330.       /**
  331.        * Sequence transaction
  332.        */
  333.       struct {
  334. Uint32 sequenceId;
  335. Uint32 requestType;
  336.       } sequence;
  337.     };
  338.     
  339.     Uint32 connectPtr;
  340.     Uint32 transId[2];
  341.     SLList<Operation> operations;
  343.     Uint32 errorCode;
  344.     Uint32 noOfRetries;
  345.     Uint32 sent;        // No of operations sent
  346.     Uint32 recv;        // No of completed operations received
  347.     inline bool complete() const { return sent == recv; };
  349.     union {
  350.       Uint32 nextPool;
  351.       Uint32 nextList;
  352.     };
  353.     Uint32 prevList;
  355.     void print() const {
  356.       ndbout << "[-Transaction-" << endl
  357.      << " clientRef: " << clientRef
  358.      << ", clientData: " << clientData
  359.      << ", gsn: " << gsn 
  360.      << ", errorCode: " << errorCode 
  361.      << endl 
  362.      << " sent: " << sent << " operations" 
  363.      << ", recv: " << recv << " completed operations";
  364.       OperationPtr opPtr;
  365.       this->operations.first(opPtr);
  366.       while(opPtr.i != RNIL){
  367. ndbout << "[-Operation-" << endl;
  368. opPtr.p->print();
  369.         this->operations.next(opPtr);
  370.       }
  371.       ndbout << "]" << endl;
  372.     }
  373.   };
  375.   typedef Ptr<Page32>             Page32Ptr;
  376.   typedef Ptr<Prepare>            PreparePtr;
  377.   typedef Ptr<Transaction>        TransactionPtr;
  378.   typedef Ptr<Operation>          OperationPtr;
  379.   typedef Ptr<PreparedOperation>  PreparedOperationPtr;
  381.   Uint32                          c_transId[2];
  382.   ArrayPool<Page32>               c_pagePool;
  383.   ArrayPool<Prepare>              c_preparePool;
  384.   ArrayPool<Operation>            c_operationPool;
  385.   ArrayPool<PreparedOperation>    c_preparedOperationPool;
  386.   ArrayPool<Transaction>          c_transactionPool;
  388.   DataBuffer<1>::DataBufferPool   c_attrMappingPool;
  389.   DataBuffer<11>::DataBufferPool  c_dataBufPool;
  390.   DLList<Prepare>                 c_runningPrepares;
  391.   DLList<PreparedOperation>       c_runningPreparedOperations;
  392.   DLList<Transaction>             c_seizingTransactions; // Being seized at TC
  393.   DLList<Transaction>             c_runningTransactions; // Seized and now exec.
  394.   
  395.   void getTransId(Transaction *);
  396.   void initResultSet(ResultSetBuffer &, const ResultSetInfoBuffer &);
  397.   void runTransaction(Signal* signal, TransactionPtr);
  398.   void runOperation(Signal* signal, TransactionPtr &, OperationPtr &, Uint32);
  399.   void sendKeyInfo(Signal* signal, 
  400.    KeyInfo* keyInfo,
  401.    const KeyInfoBuffer & keyBuf,
  402.    KeyInfoIterator & kit);
  403.   void sendAttrInfo(Signal*, 
  404.     AttrInfo* attrInfo, 
  405.     const AttrInfoBuffer &,
  406.     AttrInfoIterator & ait);
  407.   int getResultSet(Signal* signal, const Transaction * transP,
  408.    struct LinearSectionPtr sectionsPtr[]);
  409.   void finishTransaction(Signal*, TransactionPtr);
  410.   void releaseTransaction(TransactionPtr transPtr);
  411.   void hardcodedPrepare();
  412.   void connectTc(Signal* signal);
  413.   void reportSequence(Signal*, const Transaction *);
  414.   void readPrepareProps(Signal* signal, 
  415. SimpleProperties::Reader* reader, 
  416. Uint32 senderData);
  417.   void prepareOperation(Signal*, PreparePtr);
  418.   void sendUtilPrepareRef(Signal*, UtilPrepareRef::ErrorCode, Uint32, Uint32);
  419.   void sendUtilExecuteRef(Signal*, UtilExecuteRef::ErrorCode, 
  420.   Uint32, Uint32, Uint32);
  421.   void releasePrepare(PreparePtr);
  422.   void releasePreparedOperation(PreparedOperationPtr);
  424.   /***************************************************************************
  425.    * Lock manager
  426.    */
  427.   struct LockQueueElement {
  428.     Uint32 m_senderData;
  429.     Uint32 m_senderRef;
  430.     union {
  431.       Uint32 nextPool;
  432.       Uint32 nextList;
  433.     };
  434.     Uint32 prevList;
  435.   };
  436.   typedef Ptr<LockQueueElement> LockQueueElementPtr;
  438.   struct LockQueue {
  439.     LockQueue(){}
  440.     LockQueue(Uint32 id) : m_queue() { m_lockId = id; m_lockKey = 0;}
  441.     union {
  442.       Uint32 m_lockId;
  443.       Uint32 key;
  444.     };
  445.     Uint32 m_lockKey;
  446.     DLFifoList<LockQueueElement>::Head m_queue;
  447.     union {
  448.       Uint32 nextHash;
  449.       Uint32 nextPool;
  450.     };
  451.     Uint32 prevHash;
  452.     
  453.     Uint32 hashValue() const {
  454.       return m_lockId;
  455.     }
  456.     bool equal(const LockQueue & rec) const {
  457.       return m_lockId == rec.m_lockId;
  458.     }
  459.   };
  460.   typedef Ptr<LockQueue> LockQueuePtr;
  461.   
  462.   
  463.   ArrayPool<LockQueue> c_lockQueuePool;
  464.   ArrayPool<LockQueueElement> c_lockElementPool;
  465.   KeyTable<LockQueue> c_lockQueues;
  466.   
  467.   void execUTIL_CREATE_LOCK_REQ(Signal* signal);
  468.   void execUTIL_DESTORY_LOCK_REQ(Signal* signal);
  469.   void execUTIL_LOCK_REQ(Signal* signal);
  470.   void execUTIL_UNLOCK_REQ(Signal* signal);
  471.   
  472.   void sendLOCK_REF(Signal*, const UtilLockReq * req, UtilLockRef::ErrorCode);
  473.   void sendLOCK_CONF(Signal*, LockQueue *, LockQueueElement *);
  475.   void sendUNLOCK_REF(Signal*, const UtilUnlockReq*, UtilUnlockRef::ErrorCode);
  476.   void sendUNLOCK_CONF(Signal*, LockQueue *, LockQueueElement *);
  478.   // For testing of mutex:es
  479.   void mutex_created(Signal* signal, Uint32 mutexId, Uint32 retVal);
  480.   void mutex_destroyed(Signal* signal, Uint32 mutexId, Uint32 retVal);
  481.   void mutex_locked(Signal* signal, Uint32 mutexId, Uint32 retVal);
  482.   void mutex_unlocked(Signal* signal, Uint32 mutexId, Uint32 retVal);
  483. };
  485. #endif