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

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

MySQL数据库

开发平台：

Visual C++

Backup.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 BACKUP_H
  18. #define BACKUP_H
  20. #include <ndb_limits.h>
  21. #include <SimulatedBlock.hpp>
  23. #include "FsBuffer.hpp"
  24. #include "BackupFormat.hpp"
  26. #include <NodeBitmask.hpp>
  27. #include <SimpleProperties.hpp>
  29. #include <SLList.hpp>
  30. #include <ArrayList.hpp>
  31. #include <SignalCounter.hpp>
  32. #include <blocks/mutexes.hpp>
  34. #include <NdbTCP.h>
  36. /**
  37.  * Backup - This block manages database backup and restore
  38.  */
  39. class Backup : public SimulatedBlock
  40. {
  41. public:
  42.   Backup(const Configuration & conf);
  43.   virtual ~Backup();
  44.   BLOCK_DEFINES(Backup);
  45.   
  46. protected:
  48.   void execSTTOR(Signal* signal);
  49.   void execDUMP_STATE_ORD(Signal* signal);
  50.   void execREAD_NODESCONF(Signal* signal);
  51.   void execNODE_FAILREP(Signal* signal);
  52.   void execINCL_NODEREQ(Signal* signal);
  53.   void execCONTINUEB(Signal* signal);
  54.   
  55.   /**
  56.    * Testing
  57.    */
  58.   void execBACKUP_REF(Signal* signal);
  59.   void execBACKUP_CONF(Signal* signal);
  60.   void execBACKUP_ABORT_REP(Signal* signal);
  61.   void execBACKUP_COMPLETE_REP(Signal* signal);
  62.   
  63.   /**
  64.    * Signals sent from master
  65.    */
  66.   void execDEFINE_BACKUP_REQ(Signal* signal);
  67.   void execBACKUP_DATA(Signal* signal);
  68.   void execSTART_BACKUP_REQ(Signal* signal);
  69.   void execBACKUP_FRAGMENT_REQ(Signal* signal);
  70.   void execSTOP_BACKUP_REQ(Signal* signal);
  71.   void execBACKUP_STATUS_REQ(Signal* signal);
  72.   void execABORT_BACKUP_ORD(Signal* signal);
  73.  
  74.   /**
  75.    * The actual scan
  76.    */
  77.   void execSCAN_HBREP(Signal* signal);
  78.   void execTRANSID_AI(Signal* signal);
  79.   void execSCAN_FRAGREF(Signal* signal);
  80.   void execSCAN_FRAGCONF(Signal* signal);
  82.   /**
  83.    * Trigger logging
  84.    */
  85.   void execBACKUP_TRIG_REQ(Signal* signal);
  86.   void execTRIG_ATTRINFO(Signal* signal);
  87.   void execFIRE_TRIG_ORD(Signal* signal);
  88.   
  89.   /**
  90.    * DICT signals
  91.    */
  92.   void execLIST_TABLES_CONF(Signal* signal);
  93.   void execGET_TABINFOREF(Signal* signal);
  94.   void execGET_TABINFO_CONF(Signal* signal);
  95.   void execCREATE_TRIG_REF(Signal* signal);
  96.   void execCREATE_TRIG_CONF(Signal* signal);
  97.   void execALTER_TRIG_REF(Signal* signal);
  98.   void execALTER_TRIG_CONF(Signal* signal);
  99.   void execDROP_TRIG_REF(Signal* signal);
  100.   void execDROP_TRIG_CONF(Signal* signal);
  102.   /**
  103.    * DIH signals
  104.    */
  105.   void execDI_FCOUNTCONF(Signal* signal);
  106.   void execDIGETPRIMCONF(Signal* signal);
  108.   /**
  109.    * FS signals
  110.    */
  111.   void execFSOPENREF(Signal* signal);
  112.   void execFSOPENCONF(Signal* signal);
  114.   void execFSCLOSEREF(Signal* signal);
  115.   void execFSCLOSECONF(Signal* signal);
  116.   
  117.   void execFSAPPENDREF(Signal* signal);
  118.   void execFSAPPENDCONF(Signal* signal);
  119.   
  120.   void execFSREMOVEREF(Signal* signal);
  121.   void execFSREMOVECONF(Signal* signal);
  123.   /**
  124.    * Master functinallity
  125.    */
  126.   void execBACKUP_REQ(Signal* signal);
  127.   void execABORT_BACKUP_REQ(Signal* signal);
  128.   
  129.   void execDEFINE_BACKUP_REF(Signal* signal);
  130.   void execDEFINE_BACKUP_CONF(Signal* signal);
  132.   void execSTART_BACKUP_REF(Signal* signal);
  133.   void execSTART_BACKUP_CONF(Signal* signal);
  135.   void execBACKUP_FRAGMENT_REF(Signal* signal);
  136.   void execBACKUP_FRAGMENT_CONF(Signal* signal);
  138.   void execSTOP_BACKUP_REF(Signal* signal);
  139.   void execSTOP_BACKUP_CONF(Signal* signal);
  140.   
  141.   void execBACKUP_STATUS_CONF(Signal* signal);
  143.   void execUTIL_SEQUENCE_REF(Signal* signal);
  144.   void execUTIL_SEQUENCE_CONF(Signal* signal);
  146.   void execWAIT_GCP_REF(Signal* signal);
  147.   void execWAIT_GCP_CONF(Signal* signal);
  148.   
  149.   
  150. private:
  151.   void defineBackupMutex_locked(Signal* signal, Uint32 ptrI,Uint32 retVal);
  152.   void dictCommitTableMutex_locked(Signal* signal, Uint32 ptrI,Uint32 retVal);
  154. public:
  155.   struct Node {
  156.     Uint32 nodeId;
  157.     Uint32 alive;
  158.     Uint32 nextList;
  159.     union { Uint32 prevList; Uint32 nextPool; };
  160.   };
  161.   typedef Ptr<Node> NodePtr;
  163. #define BACKUP_WORDS_PER_PAGE 8191
  164.   struct Page32 {
  165.     Uint32 data[BACKUP_WORDS_PER_PAGE];
  166.     Uint32 nextPool;
  167.   };
  168.   typedef Ptr<Page32> Page32Ptr;
  170.   struct Attribute {
  171.     struct Data {
  172.       Uint8 nullable;
  173.       Uint8 fixed;
  174.       Uint8 unused; 
  175.       Uint8 unused2;
  176.       Uint32 sz32;       // No of 32 bit words
  177.       Uint32 offset;     // Relative DataFixedAttributes/DataFixedKeys
  178.       Uint32 offsetNull; // In NullBitmask
  179.     } data;
  180.     Uint32 nextPool;
  181.   };
  182.   typedef Ptr<Attribute> AttributePtr;
  183.   
  184.   struct Fragment {
  185.     Uint32 tableId;
  186.     Uint32 node;
  187.     Uint16 scanned;  // 0 = not scanned x = scanned by node x
  188.     Uint16 scanning; // 0 = not scanning x = scanning on node x
  189.     Uint32 nextPool;
  190.   };
  191.   typedef Ptr<Fragment> FragmentPtr;
  193.   struct Table {
  194.     Table(ArrayPool<Attribute> &, ArrayPool<Fragment> &);
  195.     
  196.     Uint32 tableId;
  197.     Uint32 schemaVersion;
  198.     Uint32 frag_mask;
  199.     Uint32 tableType;
  200.     Uint32 noOfNull;
  201.     Uint32 noOfAttributes;
  202.     Uint32 noOfVariable;
  203.     Uint32 sz_FixedAttributes;
  204.     Uint32 triggerIds[3];
  205.     bool   triggerAllocated[3];
  206.     
  207.     Array<Attribute> attributes;
  208.     Array<Fragment> fragments;
  210.     Uint32 nextList;
  211.     union { Uint32 nextPool; Uint32 prevList; };
  212.   };
  213.   typedef Ptr<Table> TablePtr;
  215.   struct OperationRecord {
  216.   public:
  217.     OperationRecord(Backup & b) : backup(b) {}
  219.     /**
  220.      * Once per table
  221.      */
  222.     void init(const TablePtr & ptr);
  223.     
  224.     /**
  225.      * Once per fragment
  226.      */
  227.     bool newFragment(Uint32 tableId, Uint32 fragNo);
  228.     bool fragComplete(Uint32 tableId, Uint32 fragNo);
  229.     
  230.     /**
  231.      * Once per scan frag (next) req/conf
  232.      */
  233.     bool newScan();
  234.     bool scanConf(Uint32 noOfOps, Uint32 opLen);
  235.     bool closeScan();
  236.     
  237.     /**
  238.      * Per record
  239.      */
  240.     void newRecord(Uint32 * base);
  241.     bool finished();
  242.     
  243.     /**
  244.      * Per attribute
  245.      */
  246.     void     nullAttribute(Uint32 nullOffset);
  247.     Uint32 * newNullable(Uint32 attrId, Uint32 sz);
  248.     Uint32 * newAttrib(Uint32 offset, Uint32 sz);
  249.     Uint32 * newVariable(Uint32 id, Uint32 sz);
  250.     
  251.   private:
  252.     Uint32* base; 
  253.     Uint32* dst_Length;
  254.     Uint32* dst_Bitmask;
  255.     Uint32* dst_FixedAttribs;
  256.     BackupFormat::DataFile::VariableData* dst_VariableData;
  257.     
  258.     Uint32 noOfAttributes; // No of Attributes
  259.     Uint32 attrLeft;       // No of attributes left
  261.     Uint32 opNoDone;
  262.     Uint32 opNoConf;
  263.     Uint32 opLen;
  265.   public:
  266.     Uint32* dst;
  267.     Uint32 attrSzLeft;  // No of words missing for current attribute
  268.     Uint32 attrSzTotal; // No of AI words received
  269.     Uint32 tablePtr;    // Ptr.i to current table
  271.     FsBuffer dataBuffer;
  272.     Uint32 noOfRecords;
  273.     Uint32 noOfBytes;
  274.     Uint32 maxRecordSize;
  275.     
  276.   private:
  277.     Uint32* scanStart;
  278.     Uint32* scanStop;
  280.     /**
  281.      * sizes of part
  282.      */
  283.     Uint32 sz_Bitmask;
  284.     Uint32 sz_FixedAttribs;
  286.   public:
  287.     union { Uint32 nextPool; Uint32 nextList; };
  288.     Uint32 prevList;
  289.   private:
  291.     Backup & backup;
  292.     BlockNumber number() const { return backup.number(); }
  293.     void progError(int line, int cause, const char * extra) { 
  294.       backup.progError(line, cause, extra); 
  295.     }
  296.   };
  297.   friend struct OperationRecord;
  299.   struct TriggerRecord {
  300.     TriggerRecord() { event = ~0;}
  301.     OperationRecord * operation;
  302.     BackupFormat::LogFile::LogEntry * logEntry;
  303.     Uint32 maxRecordSize;
  304.     Uint32 tableId;
  305.     Uint32 tab_ptr_i;
  306.     Uint32 event;
  307.     Uint32 backupPtr;
  308.     Uint32 errorCode;
  309.     union { Uint32 nextPool; Uint32 nextList; };
  310.   };
  311.   typedef Ptr<TriggerRecord> TriggerPtr;
  312.   
  313.   /**
  314.    * BackupFile - At least 3 per backup
  315.    */
  316.   struct BackupFile {
  317.     BackupFile(Backup & backup, ArrayPool<Page32> & pp) 
  318.       : operation(backup),  pages(pp) {}
  319.     
  320.     Uint32 backupPtr; // Pointer to backup record
  321.     Uint32 tableId;
  322.     Uint32 fragmentNo;
  323.     Uint32 filePointer;
  324.     Uint32 errorCode;
  325.     BackupFormat::FileType fileType;
  326.     OperationRecord operation;
  327.     
  328.     Array<Page32> pages;
  329.     Uint32 nextList;
  330.     union { Uint32 prevList; Uint32 nextPool; };
  331.     
  332.     Uint8 fileOpened;
  333.     Uint8 fileRunning;
  334.     Uint8 fileClosing;
  335.     Uint8 scanRunning;
  336.   }; 
  337.   typedef Ptr<BackupFile> BackupFilePtr;
  338.  
  340.   /**
  341.    * State for BackupRecord
  342.    */
  343.   enum State {
  344.     INITIAL,
  345.     DEFINING, // Defining backup content and parameters
  346.     DEFINED,  // DEFINE_BACKUP_CONF sent in slave, received all in master
  347.     STARTED,  // Creating triggers
  348.     SCANNING, // Scanning fragments
  349.     STOPPING, // Closing files
  350.     CLEANING, // Cleaning resources
  351.     ABORTING  // Aborting backup
  352.   };
  354.   static const Uint32 validSlaveTransitionsCount;
  355.   static const Uint32 validMasterTransitionsCount;
  356.   static const State validSlaveTransitions[];
  357.   static const State validMasterTransitions[];
  358.   
  359.   class CompoundState {
  360.   public:
  361.     CompoundState(Backup & b, 
  362.   const State valid[],
  363.   Uint32 count, Uint32 _id) 
  364.       : backup(b)
  365.       , validTransitions(valid),
  366. noOfValidTransitions(count), id(_id)
  367.     { 
  368.       state = INITIAL;
  369.       abortState = state;
  370.     }
  371.     
  372.     void setState(State s);
  373.     State getState() const { return state;}
  374.     State getAbortState() const { return abortState;}
  375.     
  376.     void forceState(State s);
  377.     
  378.     BlockNumber number() const { return backup.number(); }
  379.     void progError(int line, int cause, const char * extra) { 
  380.       backup.progError(line, cause, extra); 
  381.     }
  382.   private:
  383.     Backup & backup;
  384.     State state;     
  385.     State abortState;     /**
  386.      When state == ABORTING, this contains the state 
  387.      when the abort started
  388.   */
  389.     const State * validTransitions;
  390.     const Uint32 noOfValidTransitions;
  391.     const Uint32 id;
  392.   };
  393.   friend class CompoundState;
  394.   
  395.   /**
  396.    * Backup record
  397.    *
  398.    * One record per backup
  399.    */
  400.   struct BackupRecord {
  401.     BackupRecord(Backup& b, ArrayPool<Page32> & pp, 
  402.  ArrayPool<Table> & tp, 
  403.  ArrayPool<BackupFile> & bp,
  404.  ArrayPool<TriggerRecord> & trp) 
  405.       : slaveState(b, validSlaveTransitions, validSlaveTransitionsCount,1)
  406.       , tables(tp), triggers(trp), files(bp), pages(pp)
  407.       , masterData(b), backup(b)
  408.       {
  409.       }
  410.     
  411.     Uint32 m_gsn;
  412.     CompoundState slaveState; 
  413.     
  414.     Uint32 clientRef;
  415.     Uint32 clientData;
  416.     Uint32 flags;
  417.     Uint32 backupId;
  418.     Uint32 backupKey[2];
  419.     Uint32 masterRef;
  420.     Uint32 errorCode;
  421.     NdbNodeBitmask nodes;
  422.     
  423.     Uint64 noOfBytes;
  424.     Uint64 noOfRecords;
  425.     Uint64 noOfLogBytes;
  426.     Uint64 noOfLogRecords;
  427.     
  428.     Uint32 startGCP;
  429.     Uint32 currGCP;
  430.     Uint32 stopGCP;
  431.     DLList<Table> tables;
  432.     SLList<TriggerRecord> triggers;
  433.     
  434.     SLList<BackupFile> files; 
  435.     Uint32 ctlFilePtr;  // Ptr.i to ctl-file
  436.     Uint32 logFilePtr;  // Ptr.i to log-file
  437.     Uint32 dataFilePtr; // Ptr.i to first data-file
  438.     
  439.     Uint32 backupDataLen;  // Used for (un)packing backup request
  440.     Array<Page32> pages;   // Used for (un)packing backup request
  441.     SimpleProperties props;// Used for (un)packing backup request
  442.     
  443.     struct MasterData {
  444.       MasterData(Backup & b) 
  445. {
  446. }
  447.       MutexHandle2<BACKUP_DEFINE_MUTEX> m_defineBackupMutex;
  448.       MutexHandle2<DICT_COMMIT_TABLE_MUTEX> m_dictCommitTableMutex;
  450.       Uint32 gsn;
  451.       SignalCounter sendCounter;
  452.       Uint32 errorCode;
  453.       struct {
  454. Uint32 tableId;
  455.       } createTrig;
  456.       struct {
  457. Uint32 tableId;
  458.       } dropTrig;
  459.       struct {
  460. Uint32 tableId;
  461.       } alterTrig;
  462.       union {
  463. struct {
  464.   Uint32 startBackup;
  465. } waitGCP;
  466. struct {
  467.   Uint32 signalNo;
  468.   Uint32 noOfSignals;
  469.   Uint32 tablePtr;
  470. } startBackup;
  471. struct {
  472.   Uint32 dummy;
  473. } stopBackup;
  474.       };
  475.     } masterData;
  476.     
  477.     Uint32 nextList;
  478.     union { Uint32 prevList; Uint32 nextPool; };
  480.     void setErrorCode(Uint32 errCode){
  481.       if(errorCode == 0)
  482. errorCode = errCode;
  483.     }
  485.     bool checkError() const {
  486.       return errorCode != 0;
  487.     }
  489.     Backup & backup;
  490.     BlockNumber number() const { return backup.number(); }
  491.     void progError(int line, int cause, const char * extra) { 
  492.       backup.progError(line, cause, extra); 
  493.     }
  494.   };
  495.   friend struct BackupRecord;
  496.   typedef Ptr<BackupRecord> BackupRecordPtr;
  498.   struct Config {
  499.     Uint32 m_dataBufferSize;
  500.     Uint32 m_logBufferSize;
  501.     Uint32 m_minWriteSize;
  502.     Uint32 m_maxWriteSize;
  503.   };
  504.   
  505.   /**
  506.    * Variables
  507.    */
  508.   Uint32 * c_startOfPages;
  509.   NodeId c_masterNodeId;
  510.   SLList<Node> c_nodes;
  511.   NdbNodeBitmask c_aliveNodes;
  512.   DLList<BackupRecord> c_backups;
  513.   Config c_defaults;
  514.   Uint32 m_diskless;
  516.   STATIC_CONST(NO_OF_PAGES_META_FILE = 2);
  518.   /**
  519.    * Pools
  520.    */
  521.   ArrayPool<Table> c_tablePool;
  522.   ArrayPool<Attribute> c_attributePool;  
  523.   ArrayPool<BackupRecord> c_backupPool;
  524.   ArrayPool<BackupFile> c_backupFilePool;
  525.   ArrayPool<Page32> c_pagePool;
  526.   ArrayPool<Fragment> c_fragmentPool;
  527.   ArrayPool<Node> c_nodePool;
  528.   ArrayPool<TriggerRecord> c_triggerPool;
  530.   Uint32 calculate_frag_mask(Uint32);
  532.   void checkFile(Signal*, BackupFilePtr);
  533.   void checkScan(Signal*, BackupFilePtr);
  534.   void fragmentCompleted(Signal*, BackupFilePtr);
  535.   
  536.   void backupAllData(Signal* signal, BackupRecordPtr);
  537.   
  538.   void getFragmentInfo(Signal*, BackupRecordPtr, TablePtr, Uint32 fragNo);
  539.   void getFragmentInfoDone(Signal*, BackupRecordPtr);
  540.   
  541.   void openFiles(Signal* signal, BackupRecordPtr ptr);
  542.   void openFilesReply(Signal*, BackupRecordPtr ptr, BackupFilePtr);
  543.   void closeFiles(Signal*, BackupRecordPtr ptr);
  544.   void closeFilesDone(Signal*, BackupRecordPtr ptr);  
  545.   
  546.   void sendDefineBackupReq(Signal *signal, BackupRecordPtr ptr);
  548.   void defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId);
  549.   void createTrigReply(Signal* signal, BackupRecordPtr ptr);
  550.   void alterTrigReply(Signal* signal, BackupRecordPtr ptr);
  551.   void startBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32, Uint32);
  552.   void stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId);
  553.   
  554.   void defineBackupRef(Signal*, BackupRecordPtr, Uint32 errCode = 0);
  555.   void backupFragmentRef(Signal * signal, BackupFilePtr filePtr);
  557.   void nextFragment(Signal*, BackupRecordPtr);
  558.   
  559.   void sendCreateTrig(Signal*, BackupRecordPtr ptr, TablePtr tabPtr);
  560.   void createAttributeMask(TablePtr tab, Bitmask<MAXNROFATTRIBUTESINWORDS>&);
  561.   void sendStartBackup(Signal*, BackupRecordPtr, TablePtr);
  562.   void sendAlterTrig(Signal*, BackupRecordPtr ptr);
  564.   void sendDropTrig(Signal*, BackupRecordPtr ptr);
  565.   void sendDropTrig(Signal* signal, BackupRecordPtr ptr, TablePtr tabPtr);
  566.   void dropTrigReply(Signal*, BackupRecordPtr ptr);
  567.   
  568.   void sendSignalAllWait(BackupRecordPtr ptr, Uint32 gsn, Signal *signal, 
  569.  Uint32 signalLength,
  570.  bool executeDirect = false);
  571.   bool haveAllSignals(BackupRecordPtr ptr, Uint32 gsn, Uint32 nodeId);
  573.   void sendStopBackup(Signal*, BackupRecordPtr ptr);
  574.   void sendAbortBackupOrd(Signal* signal, BackupRecordPtr ptr, Uint32 errCode);
  575.   void sendAbortBackupOrdSlave(Signal* signal, BackupRecordPtr ptr, 
  576.        Uint32 errCode);
  577.   void masterAbort(Signal*, BackupRecordPtr ptr);
  578.   void masterSendAbortBackup(Signal*, BackupRecordPtr ptr);
  579.   void slaveAbort(Signal*, BackupRecordPtr ptr);
  580.   
  581.   void abortFile(Signal* signal, BackupRecordPtr ptr, BackupFilePtr filePtr);
  582.   void abortFileHook(Signal* signal, BackupFilePtr filePtr, bool scanDone);
  583.   
  584.   bool verifyNodesAlive(BackupRecordPtr, const NdbNodeBitmask& aNodeBitMask);
  585.   bool checkAbort(BackupRecordPtr ptr);
  586.   void checkNodeFail(Signal* signal,
  587.      BackupRecordPtr ptr,
  588.      NodeId newCoord,
  589.      Uint32 theFailedNodes[NodeBitmask::Size]);
  590.   void masterTakeOver(Signal* signal, BackupRecordPtr ptr);
  593.   NodeId getMasterNodeId() const { return c_masterNodeId; }
  594.   bool findTable(const BackupRecordPtr &, TablePtr &, Uint32 tableId) const;
  595.   TablePtr parseTableDescription(Signal*, BackupRecordPtr ptr, Uint32 len);
  596.   
  597.   bool insertFileHeader(BackupFormat::FileType, BackupRecord*, BackupFile*);
  598.   void sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode);
  599.   void sendBackupRef(BlockReference ref, Uint32 flags, Signal *signal,
  600.      Uint32 senderData, Uint32 errorCode);
  601.   void dumpUsedResources();
  602.   void cleanup(Signal*, BackupRecordPtr ptr);
  603.   void abort_scan(Signal*, BackupRecordPtr ptr);
  604.   void removeBackup(Signal*, BackupRecordPtr ptr);
  606.   void sendSTTORRY(Signal*);
  607.   void createSequence(Signal* signal);
  608.   void createSequenceReply(Signal*, class UtilSequenceConf *);
  609. };
  611. inline
  612. void
  613. Backup::OperationRecord::newRecord(Uint32 * p){
  614.   base = p;
  615.   dst_Length       = p; p += 1;
  616.   dst_Bitmask      = p; p += sz_Bitmask;
  617.   dst_FixedAttribs = p; p += sz_FixedAttribs;
  618.   dst_VariableData = (BackupFormat::DataFile::VariableData*)p;
  619.   BitmaskImpl::clear(sz_Bitmask, dst_Bitmask);
  620.   attrLeft = noOfAttributes;
  621.   attrSzLeft = attrSzTotal = 0;
  622. }
  624. inline
  625. Uint32 *
  626. Backup::OperationRecord::newAttrib(Uint32 offset, Uint32 sz){
  627.   attrLeft--;
  628.   attrSzLeft = sz;
  629.   dst = dst_FixedAttribs + offset;
  630.   return dst;
  631. }
  633. inline
  634. void
  635. Backup::OperationRecord::nullAttribute(Uint32 offsetNull){
  636.   attrLeft --;
  637.   BitmaskImpl::set(sz_Bitmask, dst_Bitmask, offsetNull);
  638. }
  640. inline
  641. Uint32 *
  642. Backup::OperationRecord::newNullable(Uint32 id, Uint32 sz){
  643.   attrLeft--;
  644.   attrSzLeft = sz;
  645.   
  646.   dst = &dst_VariableData->Data[0];
  647.   dst_VariableData->Sz = htonl(sz);
  648.   dst_VariableData->Id = htonl(id);
  649.   
  650.   dst_VariableData = (BackupFormat::DataFile::VariableData *)(dst + sz);
  651.   
  652.   // Clear all bits on newRecord -> dont need to clear this
  653.   // BitmaskImpl::clear(sz_Bitmask, dst_Bitmask, offsetNull);
  654.   return dst;
  655. }
  657. inline
  658. Uint32 *
  659. Backup::OperationRecord::newVariable(Uint32 id, Uint32 sz){
  660.   attrLeft--;
  661.   attrSzLeft = sz;
  662.   
  663.   dst = &dst_VariableData->Data[0];
  664.   dst_VariableData->Sz = htonl(sz);
  665.   dst_VariableData->Id = htonl(id);
  666.   
  667.   dst_VariableData = (BackupFormat::DataFile::VariableData *)(dst + sz);
  668.   return dst;
  669. }
  671. inline
  672. bool
  673. Backup::OperationRecord::finished(){
  674.   if(attrLeft != 0 || attrSzLeft != 0){
  675.     return false;
  676.   }
  677.   
  678.   opLen += attrSzTotal;
  679.   opNoDone++;
  680.   
  681.   scanStop = dst = (Uint32 *)dst_VariableData;
  682.   
  683.   const Uint32 len = (dst - base - 1);
  684.   * dst_Length = htonl(len);
  685.   
  686.   noOfRecords++;
  687.   
  688.   return true;
  689. }
  691. #endif