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

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

MySQL数据库

开发平台：

Visual C++

Restore.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 RESTORE_H
  18. #define RESTORE_H
  20. #include <ndb_global.h>
  21. #include <NdbOut.hpp>
  22. #include "../src/kernel/blocks/backup/BackupFormat.hpp"
  23. #include "../src/ndbapi/NdbDictionaryImpl.hpp"
  24. #include <NdbApi.hpp>
  26. #include <ndb_version.h>
  27. #include <version.h>
  29. static const char * delimiter = ";"; // Delimiter in file dump
  31. const int FileNameLenC = 256;
  32. const int TableNameLenC = 256;
  33. const int AttrNameLenC = 256;
  34. const Uint32 timeToWaitForNdbC = 10000;
  35. const Uint32 opsDefaultC = 1000;
  37. // Forward declarations
  38. //class AttributeDesc;
  39. struct AttributeDesc;
  40. struct AttributeData;
  41. struct AttributeS;
  43. struct AttributeData {
  44.   bool null;
  45.   Uint32 size;
  46.   union {
  47.     Int8 * int8_value;
  48.     Uint8 * u_int8_value;
  49.     
  50.     Int16 * int16_value;
  51.     Uint16 * u_int16_value;
  53.     Int32 * int32_value;
  54.     Uint32 * u_int32_value;
  55.     
  56.     Int64 * int64_value;
  57.     Uint64 * u_int64_value;
  59.     char * string_value;
  60.     
  61.     void* void_value;
  62.   };
  63. };
  65. struct AttributeDesc {
  66.   //private:
  67.   friend class TupleS;
  68.   friend class TableS;
  69.   friend class RestoreDataIterator;
  70.   friend class RestoreMetaData;
  71.   friend struct AttributeS;
  72.   Uint32 size; // bits       
  73.   Uint32 arraySize;
  74.   Uint32 attrId;
  75.   NdbDictionary::Column *m_column;
  77.   Uint32 m_nullBitIndex;
  78. public:
  79.   
  80.   AttributeDesc(NdbDictionary::Column *column);
  81.   AttributeDesc();
  83.   Uint32 getSizeInWords() const { return (size * arraySize + 31)/ 32;}
  84. }; // AttributeDesc
  86. struct AttributeS {
  87.   const AttributeDesc * Desc;
  88.   AttributeData Data;
  89. };
  91. class TupleS {
  92. private:
  93.   friend class RestoreDataIterator;
  94.   
  95.   class TableS *m_currentTable;
  96.   AttributeData *allAttrData;
  97.   bool prepareRecord(TableS &);
  98.   
  99. public:
  100.   TupleS() {
  101.     m_currentTable= 0;
  102.     allAttrData= 0;
  103.   };
  104.   ~TupleS()
  105.   {
  106.     if (allAttrData)
  107.       delete [] allAttrData;
  108.   };
  109.   TupleS(const TupleS& tuple); // disable copy constructor
  110.   TupleS & operator=(const TupleS& tuple);
  111.   int getNoOfAttributes() const;
  112.   TableS * getTable() const;
  113.   const AttributeDesc * getDesc(int i) const;
  114.   AttributeData * getData(int i) const;
  115. }; // class TupleS
  117. class TableS {
  118.   
  119.   friend class TupleS;
  120.   friend class RestoreMetaData;
  121.   friend class RestoreDataIterator;
  122.   
  123.   Uint32 schemaVersion;
  124.   Uint32 backupVersion;
  125.   Vector<AttributeDesc *> allAttributesDesc;
  126.   Vector<AttributeDesc *> m_fixedKeys;
  127.   //Vector<AttributeDesc *> m_variableKey; 
  128.   Vector<AttributeDesc *> m_fixedAttribs;
  129.   Vector<AttributeDesc *> m_variableAttribs;
  130.   
  131.   Uint32 m_noOfNullable;
  132.   Uint32 m_nullBitmaskSize;
  134.   Uint32 m_auto_val_id;
  135.   Uint64 m_max_auto_val;
  137.   int pos;
  139.   void createAttr(NdbDictionary::Column *column);
  141. public:
  142.   class NdbDictionary::Table* m_dictTable;
  143.   TableS (Uint32 version, class NdbTableImpl* dictTable);
  144.   ~TableS();
  146.   Uint32 getTableId() const { 
  147.     return m_dictTable->getTableId(); 
  148.   }
  149.   /*
  150.   void setMysqlTableName(char * tableName) {
  151.     strpcpy(mysqlTableName, tableName);
  152.   }
  153.   
  154.   char * 
  155.   void setMysqlDatabaseName(char * databaseName) {
  156.     strpcpy(mysqlDatabaseName, databaseName);
  157.   }
  159.   table.setMysqlDatabaseName(database);
  160.   */
  161.   void setBackupVersion(Uint32 version) { 
  162.     backupVersion = version;
  163.   }
  164.   
  165.   Uint32 getBackupVersion() const { 
  166.     return backupVersion;
  167.   }
  168.   
  169.   const char * getTableName() const { 
  170.     return m_dictTable->getName();
  171.   }
  172.   
  173.   int getNoOfAttributes() const { 
  174.     return allAttributesDesc.size();
  175.   };
  176.   
  177.   bool have_auto_inc() const {
  178.     return m_auto_val_id != ~(Uint32)0;
  179.   };
  181.   bool have_auto_inc(Uint32 id) const {
  182.     return m_auto_val_id == id;
  183.   };
  185.   Uint64 get_max_auto_val() const {
  186.     return m_max_auto_val;
  187.   };
  189.   void update_max_auto_val(const char *data, int size) {
  190.     union {
  191.       Uint8  u8;
  192.       Uint16 u16;
  193.       Uint32 u32;
  194.     } val;
  195.     Uint64 v;
  196.     switch(size){
  197.     case 64:
  198.       memcpy(&v,data,8);
  199.       break;
  200.     case 32:
  201.       memcpy(&val.u32,data,4);
  202.       v= val.u32;
  203.       break;
  204.     case 16:
  205.       memcpy(&val.u16,data,2);
  206.       v= val.u16;
  207.       break;
  208.     case 8:
  209.       memcpy(&val.u8,data,1);
  210.       v= val.u8;
  211.       break;
  212.     default:
  213.       return;
  214.     };
  215.     if(v > m_max_auto_val)
  216.       m_max_auto_val= v;
  217.   };
  218.   /**
  219.    * Get attribute descriptor
  220.    */
  221.   const AttributeDesc * operator[](int attributeId) const { 
  222.     return allAttributesDesc[attributeId]; 
  223.   }
  225.   TableS& operator=(TableS& org) ; 
  226. }; // TableS;
  228. class BackupFile {
  229. protected:
  230.   FILE * m_file;
  231.   char m_path[PATH_MAX];
  232.   char m_fileName[PATH_MAX];
  233.   bool m_hostByteOrder;
  234.   BackupFormat::FileHeader m_fileHeader;
  235.   BackupFormat::FileHeader m_expectedFileHeader;
  236.   
  237.   Uint32 m_nodeId;
  238.   
  239.   void * m_buffer;
  240.   void * m_buffer_ptr;
  241.   Uint32 m_buffer_sz;
  242.   Uint32 m_buffer_data_left;
  243.   void (* free_data_callback)();
  245.   bool openFile();
  246.   void setCtlFile(Uint32 nodeId, Uint32 backupId, const char * path);
  247.   void setDataFile(const BackupFile & bf, Uint32 no);
  248.   void setLogFile(const BackupFile & bf, Uint32 no);
  249.   
  250.   Uint32 buffer_get_ptr(void **p_buf_ptr, Uint32 size, Uint32 nmemb);
  251.   Uint32 buffer_read(void *ptr, Uint32 size, Uint32 nmemb);
  252.   Uint32 buffer_get_ptr_ahead(void **p_buf_ptr, Uint32 size, Uint32 nmemb);
  253.   Uint32 buffer_read_ahead(void *ptr, Uint32 size, Uint32 nmemb);
  255.   void setName(const char * path, const char * name);
  257.   BackupFile(void (* free_data_callback)() = 0);
  258.   ~BackupFile();
  259. public:
  260.   bool readHeader();
  261.   bool validateFooter();
  263.   const char * getPath() const { return m_path;}
  264.   const char * getFilename() const { return m_fileName;}
  265.   Uint32 getNodeId() const { return m_nodeId;}
  266.   const BackupFormat::FileHeader & getFileHeader() const { return m_fileHeader;}
  267.   bool Twiddle(const AttributeDesc *  attr_desc, AttributeData * attr_data, Uint32 arraySize = 0);
  268. };
  270. class RestoreMetaData : public BackupFile {
  272.   Vector<TableS *> allTables;
  273.   bool readMetaFileHeader();
  274.   bool readMetaTableDesc();
  276.   bool readGCPEntry();
  277.   Uint32 readMetaTableList();
  279.   Uint32 m_startGCP;
  280.   Uint32 m_stopGCP;
  281.   
  282.   bool parseTableDescriptor(const Uint32 * data, Uint32 len);
  284. public:
  285.   RestoreMetaData(const char * path, Uint32 nodeId, Uint32 bNo);
  286.   virtual ~RestoreMetaData();
  287.   
  288.   int loadContent();
  289.   
  290.   Uint32 getNoOfTables() const { return allTables.size();}
  291.   
  292.   const TableS * operator[](int i) const { return allTables[i];}
  293.   TableS * getTable(Uint32 tableId) const;
  295.   Uint32 getStopGCP() const;
  296. }; // RestoreMetaData
  299. class RestoreDataIterator : public BackupFile {
  300.   const RestoreMetaData & m_metaData;
  301.   Uint32 m_count;
  302.   TableS* m_currentTable;
  303.   TupleS m_tuple;
  305. public:
  307.   // Constructor
  308.   RestoreDataIterator(const RestoreMetaData &, void (* free_data_callback)());
  309.   ~RestoreDataIterator() {};
  310.   
  311.   // Read data file fragment header
  312.   bool readFragmentHeader(int & res);
  313.   bool validateFragmentFooter();
  315.   const TupleS *getNextTuple(int & res);
  316. };
  318. class LogEntry {
  319. public:
  320.   enum EntryType {
  321.     LE_INSERT,
  322.     LE_DELETE,
  323.     LE_UPDATE
  324.   };
  325.   EntryType m_type;
  326.   TableS * m_table;  
  327.   Vector<AttributeS*> m_values;
  328.   Vector<AttributeS*> m_values_e;
  329.   AttributeS *add_attr() {
  330.     AttributeS * attr;
  331.     if (m_values_e.size() > 0) {
  332.       attr = m_values_e[m_values_e.size()-1];
  333.       m_values_e.erase(m_values_e.size()-1);
  334.     }
  335.     else
  336.     {
  337.       attr = new AttributeS;
  338.     }
  339.     m_values.push_back(attr);
  340.     return attr;
  341.   }
  342.   void clear() {
  343.     for(Uint32 i= 0; i < m_values.size(); i++)
  344.       m_values_e.push_back(m_values[i]);
  345.     m_values.clear();
  346.   }
  347.   ~LogEntry()
  348.   {
  349.     Uint32 i;
  350.     for(i= 0; i< m_values.size(); i++)
  351.       delete m_values[i];
  352.     for(i= 0; i< m_values_e.size(); i++)
  353.       delete m_values_e[i];
  354.   }
  355.   Uint32 size() const { return m_values.size(); }
  356.   const AttributeS * operator[](int i) const { return m_values[i];}
  357. };
  359. class RestoreLogIterator : public BackupFile {
  360. private:
  361.   const RestoreMetaData & m_metaData;
  363.   Uint32 m_count;  
  364.   Uint32 m_last_gci;
  365.   LogEntry m_logEntry;
  366. public:
  367.   RestoreLogIterator(const RestoreMetaData &);
  368.   virtual ~RestoreLogIterator() {};
  370.   const LogEntry * getNextLogEntry(int & res);
  371. };
  373. NdbOut& operator<<(NdbOut& ndbout, const TableS&);
  374. NdbOut& operator<<(NdbOut& ndbout, const TupleS&);
  375. NdbOut& operator<<(NdbOut& ndbout, const LogEntry&);
  376. NdbOut& operator<<(NdbOut& ndbout, const RestoreMetaData&);
  378. #endif