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

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

MySQL数据库

开发平台：

Visual C++

Restore.cpp：源码内容
  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. #include "Restore.hpp"
  18. #include <NdbTCP.h>
  19. #include <OutputStream.hpp>
  20. #include <Bitmask.hpp>
  22. #include <AttributeHeader.hpp>
  23. #include <trigger_definitions.h>
  24. #include <SimpleProperties.hpp>
  25. #include <signaldata/DictTabInfo.hpp>
  27. Uint16 Twiddle16(Uint16 in); // Byte shift 16-bit data
  28. Uint32 Twiddle32(Uint32 in); // Byte shift 32-bit data
  29. Uint64 Twiddle64(Uint64 in); // Byte shift 64-bit data
  31. bool
  32. BackupFile::Twiddle(const AttributeDesc* attr_desc, AttributeData* attr_data, Uint32 arraySize){
  33.   Uint32 i;
  35.   if(m_hostByteOrder)
  36.     return true;
  37.   
  38.   if(arraySize == 0){
  39.     arraySize = attr_desc->arraySize;
  40.   }
  41.   
  42.   switch(attr_desc->size){
  43.   case 8:
  44.     
  45.     return true;
  46.   case 16:
  47.     for(i = 0; i<arraySize; i++){
  48.       attr_data->u_int16_value[i] = Twiddle16(attr_data->u_int16_value[i]);
  49.     }
  50.     return true;
  51.   case 32:
  52.     for(i = 0; i<arraySize; i++){
  53.       attr_data->u_int32_value[i] = Twiddle32(attr_data->u_int32_value[i]);
  54.     }
  55.     return true;
  56.   case 64:
  57.     for(i = 0; i<arraySize; i++){
  58.       attr_data->u_int64_value[i] = Twiddle64(attr_data->u_int64_value[i]);
  59.     }
  60.     return true;
  61.   default:
  62.     return false;
  63.   } // switch
  65. } // Twiddle
  67. FilteredNdbOut err(* new FileOutputStream(stderr), 0, 0);
  68. FilteredNdbOut info(* new FileOutputStream(stdout), 1, 1);
  69. FilteredNdbOut debug(* new FileOutputStream(stdout), 2, 0);
  71. // To decide in what byte order data is
  72. const Uint32 magicByteOrder = 0x12345678;
  73. const Uint32 swappedMagicByteOrder = 0x78563412;
  75. RestoreMetaData::RestoreMetaData(const char* path, Uint32 nodeId, Uint32 bNo) {
  76.   
  77.   debug << "RestoreMetaData constructor" << endl;
  78.   setCtlFile(nodeId, bNo, path);
  79. }
  81. RestoreMetaData::~RestoreMetaData(){
  82.   for(Uint32 i= 0; i < allTables.size(); i++)
  83.     delete allTables[i];
  84.   allTables.clear();
  85. }
  87. TableS * 
  88. RestoreMetaData::getTable(Uint32 tableId) const {
  89.   for(Uint32 i= 0; i < allTables.size(); i++)
  90.     if(allTables[i]->getTableId() == tableId)
  91.       return allTables[i];
  92.   return NULL;
  93. }
  95. Uint32
  96. RestoreMetaData::getStopGCP() const {
  97.   return m_stopGCP;
  98. }
  100. int
  101. RestoreMetaData::loadContent() 
  102. {
  103.   Uint32 noOfTables = readMetaTableList();
  104.   if(noOfTables == 0) {
  105.     return 1;
  106.   }
  107.   for(Uint32 i = 0; i<noOfTables; i++){
  108.     if(!readMetaTableDesc()){
  109.       return 0;
  110.     }
  111.   }
  112.   if(!readGCPEntry())
  113.     return 0;
  114.   return 1;
  115. }
  117. Uint32
  118. RestoreMetaData::readMetaTableList() {
  119.   
  120.   Uint32 sectionInfo[2];
  121.   
  122.   if (buffer_read(&sectionInfo, sizeof(sectionInfo), 1) != 1){
  123.     err << "readMetaTableList read header error" << endl;
  124.     return 0;
  125.   }
  126.   sectionInfo[0] = ntohl(sectionInfo[0]);
  127.   sectionInfo[1] = ntohl(sectionInfo[1]);
  129.   const Uint32 tabCount = sectionInfo[1] - 2;
  131.   void *tmp;
  132.   if (buffer_get_ptr(&tmp, 4, tabCount) != tabCount){
  133.     err << "readMetaTableList read tabCount error" << endl;
  134.     return 0;
  135.   }
  136.   
  137.   return tabCount;
  138. }
  140. bool
  141. RestoreMetaData::readMetaTableDesc() {
  142.   
  143.   Uint32 sectionInfo[2];
  144.   
  145.   // Read section header 
  146.   if (buffer_read(&sectionInfo, sizeof(sectionInfo), 1) != 1){
  147.     err << "readMetaTableDesc read header error" << endl;
  148.     return false;
  149.   } // if
  150.   sectionInfo[0] = ntohl(sectionInfo[0]);
  151.   sectionInfo[1] = ntohl(sectionInfo[1]);
  152.   
  153.   assert(sectionInfo[0] == BackupFormat::TABLE_DESCRIPTION);
  154.   
  155.   // Read dictTabInfo buffer
  156.   const Uint32 len = (sectionInfo[1] - 2);
  157.   void *ptr;
  158.   if (buffer_get_ptr(&ptr, 4, len) != len){
  159.     err << "readMetaTableDesc read error" << endl;
  160.     return false;
  161.   } // if
  162.   
  163.   return parseTableDescriptor((Uint32*)ptr, len);      
  164. }
  166. bool
  167. RestoreMetaData::readGCPEntry() {
  169.   Uint32 data[4];
  170.   
  171.   BackupFormat::CtlFile::GCPEntry * dst = 
  172.     (BackupFormat::CtlFile::GCPEntry *)&data[0];
  173.   
  174.   if(buffer_read(dst, 4, 4) != 4){
  175.     err << "readGCPEntry read error" << endl;
  176.     return false;
  177.   }
  178.   
  179.   dst->SectionType = ntohl(dst->SectionType);
  180.   dst->SectionLength = ntohl(dst->SectionLength);
  181.   
  182.   if(dst->SectionType != BackupFormat::GCP_ENTRY){
  183.     err << "readGCPEntry invalid format" << endl;
  184.     return false;
  185.   }
  186.   
  187.   dst->StartGCP = ntohl(dst->StartGCP);
  188.   dst->StopGCP = ntohl(dst->StopGCP);
  189.   
  190.   m_startGCP = dst->StartGCP;
  191.   m_stopGCP = dst->StopGCP;
  192.   return true;
  193. }
  195. TableS::TableS(Uint32 version, NdbTableImpl* tableImpl)
  196.   : m_dictTable(tableImpl)
  197. {
  198.   m_dictTable = tableImpl;
  199.   m_noOfNullable = m_nullBitmaskSize = 0;
  200.   m_auto_val_id= ~(Uint32)0;
  201.   m_max_auto_val= 0;
  202.   backupVersion = version;
  203.   
  204.   for (int i = 0; i < tableImpl->getNoOfColumns(); i++)
  205.     createAttr(tableImpl->getColumn(i));
  206. }
  208. TableS::~TableS()
  209. {
  210.   for (Uint32 i= 0; i < allAttributesDesc.size(); i++)
  211.     delete allAttributesDesc[i];
  212. }
  214. // Parse dictTabInfo buffer and pushback to to vector storage 
  215. bool
  216. RestoreMetaData::parseTableDescriptor(const Uint32 * data, Uint32 len)
  217. {
  218.   NdbTableImpl* tableImpl = 0;
  219.   int ret = NdbDictInterface::parseTableInfo(&tableImpl, data, len, false);
  221.   if (ret != 0) {
  222.     err << "parseTableInfo " << " failed" << endl;
  223.     return false;
  224.   }
  225.   if(tableImpl == 0)
  226.     return false;
  228.   debug << "parseTableInfo " << tableImpl->getName() << " done" << endl;
  230.   TableS * table = new TableS(m_fileHeader.NdbVersion, tableImpl);
  231.   if(table == NULL) {
  232.     return false;
  233.   }
  235.   debug << "Parsed table id " << table->getTableId() << endl;
  236.   debug << "Parsed table #attr " << table->getNoOfAttributes() << endl;
  237.   debug << "Parsed table schema version not used " << endl;
  239.   debug << "Pushing table " << table->getTableName() << endl;
  240.   debug << "   with " << table->getNoOfAttributes() << " attributes" << endl;
  241.   
  242.   allTables.push_back(table);
  244.   return true;
  245. }
  247. // Constructor
  248. RestoreDataIterator::RestoreDataIterator(const RestoreMetaData & md, void (* _free_data_callback)())
  249.   : BackupFile(_free_data_callback), m_metaData(md)
  250. {
  251.   debug << "RestoreDataIterator constructor" << endl;
  252.   setDataFile(md, 0);
  253. }
  255. TupleS & TupleS::operator=(const TupleS& tuple)
  256. {
  257.   prepareRecord(*tuple.m_currentTable);
  259.   if (allAttrData)
  260.     memcpy(allAttrData, tuple.allAttrData, getNoOfAttributes()*sizeof(AttributeData));
  261.   
  262.   return *this;
  263. }
  264. int TupleS::getNoOfAttributes() const {
  265.   if (m_currentTable == 0)
  266.     return 0;
  267.   return m_currentTable->getNoOfAttributes();
  268. }
  270. TableS * TupleS::getTable() const {
  271.   return m_currentTable;
  272. }
  274. const AttributeDesc * TupleS::getDesc(int i) const {
  275.   return m_currentTable->allAttributesDesc[i];
  276. }
  278. AttributeData * TupleS::getData(int i) const{
  279.   return &(allAttrData[i]);
  280. }
  282. bool
  283. TupleS::prepareRecord(TableS & tab){
  284.   if (allAttrData) {
  285.     if (getNoOfAttributes() == tab.getNoOfAttributes())
  286.     {
  287.       m_currentTable = &tab;
  288.       return true;
  289.     }
  290.     delete [] allAttrData;
  291.     m_currentTable= 0;
  292.   }
  293.   
  294.   allAttrData = new AttributeData[tab.getNoOfAttributes()];
  295.   if (allAttrData == 0)
  296.     return false;
  297.   
  298.   m_currentTable = &tab;
  300.   return true;
  301. }
  303. const TupleS *
  304. RestoreDataIterator::getNextTuple(int  & res)
  305. {
  306.   Uint32  dataLength = 0;
  307.   // Read record length
  308.   if (buffer_read(&dataLength, sizeof(dataLength), 1) != 1){
  309.     err << "getNextTuple:Error reading length  of data part" << endl;
  310.     res = -1;
  311.     return NULL;
  312.   } // if
  313.   
  314.   // Convert length from network byte order
  315.   dataLength = ntohl(dataLength);
  316.   const Uint32 dataLenBytes = 4 * dataLength;
  317.   
  318.   if (dataLength == 0) {
  319.     // Zero length for last tuple
  320.     // End of this data fragment
  321.     debug << "End of fragment" << endl;
  322.     res = 0;
  323.     return NULL;
  324.   } // if
  326.   // Read tuple data
  327.   void *_buf_ptr;
  328.   if (buffer_get_ptr(&_buf_ptr, 1, dataLenBytes) != dataLenBytes) {
  329.     err << "getNextTuple:Read error: " << endl;
  330.     res = -1;
  331.     return NULL;
  332.   }
  333.   
  334.   Uint32 *buf_ptr = (Uint32*)_buf_ptr, *ptr = buf_ptr;
  335.   ptr += m_currentTable->m_nullBitmaskSize;
  336.   Uint32 i;
  337.   for(i= 0; i < m_currentTable->m_fixedKeys.size(); i++){
  338.     assert(ptr < buf_ptr + dataLength);
  339.  
  340.     const Uint32 attrId = m_currentTable->m_fixedKeys[i]->attrId;
  342.     AttributeData * attr_data = m_tuple.getData(attrId);
  343.     const AttributeDesc * attr_desc = m_tuple.getDesc(attrId);
  345.     const Uint32 sz = attr_desc->getSizeInWords();
  347.     attr_data->null = false;
  348.     attr_data->void_value = ptr;
  350.     if(!Twiddle(attr_desc, attr_data))
  351.       {
  352. res = -1;
  353. return NULL;
  354.       }
  355.     ptr += sz;
  356.   }
  358.   for(i = 0; i < m_currentTable->m_fixedAttribs.size(); i++){
  359.     assert(ptr < buf_ptr + dataLength);
  361.     const Uint32 attrId = m_currentTable->m_fixedAttribs[i]->attrId;
  363.     AttributeData * attr_data = m_tuple.getData(attrId);
  364.     const AttributeDesc * attr_desc = m_tuple.getDesc(attrId);
  366.     const Uint32 sz = attr_desc->getSizeInWords();
  368.     attr_data->null = false;
  369.     attr_data->void_value = ptr;
  371.     if(!Twiddle(attr_desc, attr_data))
  372.       {
  373. res = -1;
  374. return NULL;
  375.       }
  377.     ptr += sz;
  378.   }
  380.   for(i = 0; i < m_currentTable->m_variableAttribs.size(); i++){
  381.     const Uint32 attrId = m_currentTable->m_variableAttribs[i]->attrId;
  383.     AttributeData * attr_data = m_tuple.getData(attrId);
  384.     const AttributeDesc * attr_desc = m_tuple.getDesc(attrId);
  385.     
  386.     if(attr_desc->m_column->getNullable()){
  387.       const Uint32 ind = attr_desc->m_nullBitIndex;
  388.       if(BitmaskImpl::get(m_currentTable->m_nullBitmaskSize, 
  389.   buf_ptr,ind)){
  390. attr_data->null = true;
  391. attr_data->void_value = NULL;
  392. continue;
  393.       }
  394.     }
  396.     assert(ptr < buf_ptr + dataLength);
  398.     typedef BackupFormat::DataFile::VariableData VarData;
  399.     VarData * data = (VarData *)ptr;
  400.     Uint32 sz = ntohl(data->Sz);
  401.     Uint32 id = ntohl(data->Id);
  402.     assert(id == attrId);
  403.     
  404.     attr_data->null = false;
  405.     attr_data->void_value = &data->Data[0];
  407.     /**
  408.      * Compute array size
  409.      */
  410.     const Uint32 arraySize = (4 * sz) / (attr_desc->size / 8);
  411.     assert(arraySize >= attr_desc->arraySize);
  412.     if(!Twiddle(attr_desc, attr_data, attr_desc->arraySize))
  413.       {
  414. res = -1;
  415. return NULL;
  416.       }
  418.     ptr += (sz + 2);
  419.   }
  421.   m_count ++;  
  422.   res = 0;
  423.   return &m_tuple;
  424. } // RestoreDataIterator::getNextTuple
  426. BackupFile::BackupFile(void (* _free_data_callback)()) 
  427.   : free_data_callback(_free_data_callback)
  428. {
  429.   m_file = 0;
  430.   m_path[0] = 0;
  431.   m_fileName[0] = 0;
  433.   m_buffer_sz = 64*1024;
  434.   m_buffer = malloc(m_buffer_sz);
  435.   m_buffer_ptr = m_buffer;
  436.   m_buffer_data_left = 0;
  437. }
  439. BackupFile::~BackupFile(){
  440.   if(m_file != 0)
  441.     fclose(m_file);
  442.   if(m_buffer != 0)
  443.     free(m_buffer);
  444. }
  446. bool
  447. BackupFile::openFile(){
  448.   if(m_file != NULL){
  449.     fclose(m_file);
  450.     m_file = 0;
  451.   }
  452.   
  453.   m_file = fopen(m_fileName, "r");
  454.   return m_file != 0;
  455. }
  457. Uint32 BackupFile::buffer_get_ptr_ahead(void **p_buf_ptr, Uint32 size, Uint32 nmemb)
  458. {
  459.   Uint32 sz = size*nmemb;
  460.   if (sz > m_buffer_data_left) {
  462.     if (free_data_callback)
  463.       (*free_data_callback)();
  465.     memcpy(m_buffer, m_buffer_ptr, m_buffer_data_left);
  467.     size_t r = fread(((char *)m_buffer) + m_buffer_data_left, 1, m_buffer_sz - m_buffer_data_left, m_file);
  468.     m_buffer_data_left += r;
  469.     m_buffer_ptr = m_buffer;
  471.     if (sz > m_buffer_data_left)
  472.       sz = size * (m_buffer_data_left / size);
  473.   }
  475.   *p_buf_ptr = m_buffer_ptr;
  477.   return sz/size;
  478. }
  479. Uint32 BackupFile::buffer_get_ptr(void **p_buf_ptr, Uint32 size, Uint32 nmemb)
  480. {
  481.   Uint32 r = buffer_get_ptr_ahead(p_buf_ptr, size, nmemb);
  483.   m_buffer_ptr = ((char*)m_buffer_ptr)+(r*size);
  484.   m_buffer_data_left -= (r*size);
  486.   return r;
  487. }
  489. Uint32 BackupFile::buffer_read_ahead(void *ptr, Uint32 size, Uint32 nmemb)
  490. {
  491.   void *buf_ptr;
  492.   Uint32 r = buffer_get_ptr_ahead(&buf_ptr, size, nmemb);
  493.   memcpy(ptr, buf_ptr, r*size);
  495.   return r;
  496. }
  498. Uint32 BackupFile::buffer_read(void *ptr, Uint32 size, Uint32 nmemb)
  499. {
  500.   void *buf_ptr;
  501.   Uint32 r = buffer_get_ptr(&buf_ptr, size, nmemb);
  502.   memcpy(ptr, buf_ptr, r*size);
  504.   return r;
  505. }
  507. void
  508. BackupFile::setCtlFile(Uint32 nodeId, Uint32 backupId, const char * path){
  509.   m_nodeId = nodeId;
  510.   m_expectedFileHeader.BackupId = backupId;
  511.   m_expectedFileHeader.FileType = BackupFormat::CTL_FILE;
  513.   char name[PATH_MAX]; const Uint32 sz = sizeof(name);
  514.   BaseString::snprintf(name, sz, "BACKUP-%d.%d.ctl", backupId, nodeId);  
  515.   setName(path, name);
  516. }
  518. void
  519. BackupFile::setDataFile(const BackupFile & bf, Uint32 no){
  520.   m_nodeId = bf.m_nodeId;
  521.   m_expectedFileHeader = bf.m_fileHeader;
  522.   m_expectedFileHeader.FileType = BackupFormat::DATA_FILE;
  523.   
  524.   char name[PATH_MAX]; const Uint32 sz = sizeof(name);
  525.   BaseString::snprintf(name, sz, "BACKUP-%d-%d.%d.Data", 
  526.    m_expectedFileHeader.BackupId, no, m_nodeId);
  527.   setName(bf.m_path, name);
  528. }
  530. void
  531. BackupFile::setLogFile(const BackupFile & bf, Uint32 no){
  532.   m_nodeId = bf.m_nodeId;
  533.   m_expectedFileHeader = bf.m_fileHeader;
  534.   m_expectedFileHeader.FileType = BackupFormat::LOG_FILE;
  535.   
  536.   char name[PATH_MAX]; const Uint32 sz = sizeof(name);
  537.   BaseString::snprintf(name, sz, "BACKUP-%d.%d.log", 
  538.    m_expectedFileHeader.BackupId, m_nodeId);
  539.   setName(bf.m_path, name);
  540. }
  542. void
  543. BackupFile::setName(const char * p, const char * n){
  544.   const Uint32 sz = sizeof(m_path);
  545.   if(p != 0 && strlen(p) > 0){
  546.     if(p[strlen(p)-1] == '/'){
  547.       BaseString::snprintf(m_path, sz, "%s", p);
  548.     } else {
  549.       BaseString::snprintf(m_path, sz, "%s%s", p, "/");
  550.     }
  551.   } else {
  552.     m_path[0] = 0;
  553.   }
  555.   BaseString::snprintf(m_fileName, sizeof(m_fileName), "%s%s", m_path, n);
  556.   debug << "Filename = " << m_fileName << endl;
  557. }
  559. bool
  560. BackupFile::readHeader(){
  561.   if(!openFile()){
  562.     return false;
  563.   }
  564.   
  565.   if(buffer_read(&m_fileHeader, sizeof(m_fileHeader), 1) != 1){
  566.     err << "readDataFileHeader: Error reading header" << endl;
  567.     return false;
  568.   }
  569.   
  570.   // Convert from network to host byte order for platform compatibility
  571.   m_fileHeader.NdbVersion  = ntohl(m_fileHeader.NdbVersion);
  572.   m_fileHeader.SectionType = ntohl(m_fileHeader.SectionType);
  573.   m_fileHeader.SectionLength = ntohl(m_fileHeader.SectionLength);
  574.   m_fileHeader.FileType = ntohl(m_fileHeader.FileType);
  575.   m_fileHeader.BackupId = ntohl(m_fileHeader.BackupId);
  576.   m_fileHeader.BackupKey_0 = ntohl(m_fileHeader.BackupKey_0);
  577.   m_fileHeader.BackupKey_1 = ntohl(m_fileHeader.BackupKey_1);
  579.   debug << "FileHeader: " << m_fileHeader.Magic << " " <<
  580.     m_fileHeader.NdbVersion << " " <<
  581.     m_fileHeader.SectionType << " " <<
  582.     m_fileHeader.SectionLength << " " <<
  583.     m_fileHeader.FileType << " " <<
  584.     m_fileHeader.BackupId << " " <<
  585.     m_fileHeader.BackupKey_0 << " " <<
  586.     m_fileHeader.BackupKey_1 << " " <<
  587.     m_fileHeader.ByteOrder << endl;
  588.   
  589.   debug << "ByteOrder is " << m_fileHeader.ByteOrder << endl;
  590.   debug << "magicByteOrder is " << magicByteOrder << endl;
  591.   
  592.   if (m_fileHeader.FileType != m_expectedFileHeader.FileType){
  593.     abort();
  594.   }
  595.   
  596.   // Check for BackupFormat::FileHeader::ByteOrder if swapping is needed
  597.   if (m_fileHeader.ByteOrder == magicByteOrder) {
  598.     m_hostByteOrder = true;
  599.   } else if (m_fileHeader.ByteOrder == swappedMagicByteOrder){
  600.     m_hostByteOrder = false;
  601.   } else {
  602.     abort();
  603.   }
  604.   
  605.   return true;
  606. } // BackupFile::readHeader
  608. bool
  609. BackupFile::validateFooter(){
  610.   return true;
  611. }
  613. bool RestoreDataIterator::readFragmentHeader(int & ret)
  614. {
  615.   BackupFormat::DataFile::FragmentHeader Header;
  616.   
  617.   debug << "RestoreDataIterator::getNextFragment" << endl;
  618.   
  619.   if (buffer_read(&Header, sizeof(Header), 1) != 1){
  620.     ret = 0;
  621.     return false;
  622.   } // if
  623.   
  624.   Header.SectionType  = ntohl(Header.SectionType);
  625.   Header.SectionLength  = ntohl(Header.SectionLength);
  626.   Header.TableId  = ntohl(Header.TableId);
  627.   Header.FragmentNo  = ntohl(Header.FragmentNo);
  628.   Header.ChecksumType  = ntohl(Header.ChecksumType);
  629.   
  630.   debug << "FragmentHeader: " << Header.SectionType 
  631. << " " << Header.SectionLength 
  632. << " " << Header.TableId 
  633. << " " << Header.FragmentNo 
  634. << " " << Header.ChecksumType << endl;
  635.   
  636.   m_currentTable = m_metaData.getTable(Header.TableId);
  637.   if(m_currentTable == 0){
  638.     ret = -1;
  639.     return false;
  640.   }
  641.   
  642.   if(!m_tuple.prepareRecord(*m_currentTable))
  643.   {
  644.     ret =-1;
  645.     return false;
  646.   }
  648.   info << "_____________________________________________________" << endl
  649.        << "Restoring data in table: " << m_currentTable->getTableName() 
  650.        << "(" << Header.TableId << ") fragment " 
  651.        << Header.FragmentNo << endl;
  652.   
  653.   m_count = 0;
  654.   ret = 0;
  656.   return true;
  657. } // RestoreDataIterator::getNextFragment
  660. bool
  661. RestoreDataIterator::validateFragmentFooter() {
  662.   BackupFormat::DataFile::FragmentFooter footer;
  663.   
  664.   if (buffer_read(&footer, sizeof(footer), 1) != 1){
  665.     err << "getFragmentFooter:Error reading fragment footer" << endl;
  666.     return false;
  667.   } 
  668.   
  669.   // TODO: Handle footer, nothing yet
  670.   footer.SectionType  = ntohl(footer.SectionType);
  671.   footer.SectionLength  = ntohl(footer.SectionLength);
  672.   footer.TableId  = ntohl(footer.TableId);
  673.   footer.FragmentNo  = ntohl(footer.FragmentNo);
  674.   footer.NoOfRecords  = ntohl(footer.NoOfRecords);
  675.   footer.Checksum  = ntohl(footer.Checksum);
  677.   assert(m_count == footer.NoOfRecords);
  678.   
  679.   return true;
  680. } // RestoreDataIterator::getFragmentFooter
  682. AttributeDesc::AttributeDesc(NdbDictionary::Column *c)
  683.   : m_column(c)
  684. {
  685.   size = 8*NdbColumnImpl::getImpl(* c).m_attrSize;
  686.   arraySize = NdbColumnImpl::getImpl(* c).m_arraySize;
  687. }
  689. void TableS::createAttr(NdbDictionary::Column *column)
  690. {
  691.   AttributeDesc * d = new AttributeDesc(column);
  692.   if(d == NULL) {
  693.     ndbout_c("Restore: Failed to allocate memory");
  694.     abort();
  695.   }
  696.   d->attrId = allAttributesDesc.size();
  697.   allAttributesDesc.push_back(d);
  699.   if (d->m_column->getAutoIncrement())
  700.     m_auto_val_id= d->attrId;
  702.   if(d->m_column->getPrimaryKey() && backupVersion <= MAKE_VERSION(4,1,7))
  703.   {
  704.     m_fixedKeys.push_back(d);
  705.     return;
  706.   }
  707.   
  708.   if(!d->m_column->getNullable())
  709.   {
  710.     m_fixedAttribs.push_back(d);
  711.     return;
  712.   }
  714.   /* Nullable attr*/
  715.   d->m_nullBitIndex = m_noOfNullable; 
  716.   m_noOfNullable++;
  717.   m_nullBitmaskSize = (m_noOfNullable + 31) / 32;
  718.   m_variableAttribs.push_back(d);
  719. } // TableS::createAttr
  721. Uint16 Twiddle16(Uint16 in)
  722. {
  723.   Uint16 retVal = 0;
  725.   retVal = ((in & 0xFF00) >> 8) |
  726.     ((in & 0x00FF) << 8);
  728.   return(retVal);
  729. } // Twiddle16
  731. Uint32 Twiddle32(Uint32 in)
  732. {
  733.   Uint32 retVal = 0;
  735.   retVal = ((in & 0x000000FF) << 24) | 
  736.     ((in & 0x0000FF00) << 8)  |
  737.     ((in & 0x00FF0000) >> 8)  |
  738.     ((in & 0xFF000000) >> 24);
  739.   
  740.   return(retVal);
  741. } // Twiddle32
  743. Uint64 Twiddle64(Uint64 in)
  744. {
  745.   Uint64 retVal = 0;
  747.   retVal = 
  748.     ((in & (Uint64)0x00000000000000FFLL) << 56) | 
  749.     ((in & (Uint64)0x000000000000FF00LL) << 40) | 
  750.     ((in & (Uint64)0x0000000000FF0000LL) << 24) | 
  751.     ((in & (Uint64)0x00000000FF000000LL) << 8) | 
  752.     ((in & (Uint64)0x000000FF00000000LL) >> 8) | 
  753.     ((in & (Uint64)0x0000FF0000000000LL) >> 24) | 
  754.     ((in & (Uint64)0x00FF000000000000LL) >> 40) | 
  755.     ((in & (Uint64)0xFF00000000000000LL) >> 56);
  757.   return(retVal);
  758. } // Twiddle64
  761. RestoreLogIterator::RestoreLogIterator(const RestoreMetaData & md)
  762.   : m_metaData(md) 
  763. {
  764.   debug << "RestoreLog constructor" << endl;
  765.   setLogFile(md, 0);
  767.   m_count = 0;
  768.   m_last_gci = 0;
  769. }
  771. const LogEntry *
  772. RestoreLogIterator::getNextLogEntry(int & res) {
  773.   // Read record length
  774.   typedef BackupFormat::LogFile::LogEntry LogE;
  776.   LogE * logE= 0;
  777.   Uint32 len= ~0;
  778.   const Uint32 stopGCP = m_metaData.getStopGCP();
  779.   do {
  780.     if (buffer_read_ahead(&len, sizeof(Uint32), 1) != 1){
  781.       res= -1;
  782.       return 0;
  783.     }
  784.     len= ntohl(len);
  786.     Uint32 data_len = sizeof(Uint32) + len*4;
  787.     if (buffer_get_ptr((void **)(&logE), 1, data_len) != data_len) {
  788.       res= -2;
  789.       return 0;
  790.     }
  791.     
  792.     if(len == 0){
  793.       res= 0;
  794.       return 0;
  795.     }
  797.     logE->TableId= ntohl(logE->TableId);
  798.     logE->TriggerEvent= ntohl(logE->TriggerEvent);
  799.     
  800.     const bool hasGcp= (logE->TriggerEvent & 0x10000) != 0;
  801.     logE->TriggerEvent &= 0xFFFF;
  802.     
  803.     if(hasGcp){
  804.       len--;
  805.       m_last_gci = ntohl(logE->Data[len-2]);
  806.     }
  807.   } while(m_last_gci > stopGCP + 1);
  808.   
  809.   m_logEntry.m_table = m_metaData.getTable(logE->TableId);
  810.   switch(logE->TriggerEvent){
  811.   case TriggerEvent::TE_INSERT:
  812.     m_logEntry.m_type = LogEntry::LE_INSERT;
  813.     break;
  814.   case TriggerEvent::TE_UPDATE:
  815.     m_logEntry.m_type = LogEntry::LE_UPDATE;
  816.     break;
  817.   case TriggerEvent::TE_DELETE:
  818.     m_logEntry.m_type = LogEntry::LE_DELETE;
  819.     break;
  820.   default:
  821.     res = -1;
  822.     return NULL;
  823.   }
  825.   const TableS * tab = m_logEntry.m_table;
  826.   m_logEntry.clear();
  828.   AttributeHeader * ah = (AttributeHeader *)&logE->Data[0];
  829.   AttributeHeader *end = (AttributeHeader *)&logE->Data[len - 2];
  830.   AttributeS *  attr;
  831.   while(ah < end){
  832.     attr= m_logEntry.add_attr();
  833.     if(attr == NULL) {
  834.       ndbout_c("Restore: Failed to allocate memory");
  835.       res = -1;
  836.       return 0;
  837.     }
  839.     attr->Desc = (* tab)[ah->getAttributeId()];
  840.     assert(attr->Desc != 0);
  842.     const Uint32 sz = ah->getDataSize();
  843.     if(sz == 0){
  844.       attr->Data.null = true;
  845.       attr->Data.void_value = NULL;
  846.     } else {
  847.       attr->Data.null = false;
  848.       attr->Data.void_value = ah->getDataPtr();
  849.     }
  850.     
  851.     Twiddle(attr->Desc, &(attr->Data));
  852.     
  853.     ah = ah->getNext();
  854.   }
  856.   m_count ++;
  857.   res = 0;
  858.   return &m_logEntry;
  859. }
  861. NdbOut &
  862. operator<<(NdbOut& ndbout, const AttributeS& attr){
  863.   const AttributeData & data = attr.Data;
  864.   const AttributeDesc & desc = *(attr.Desc);
  866.   if (data.null)
  867.   {
  868.     ndbout << "<NULL>";
  869.     return ndbout;
  870.   }
  871.   
  872.   NdbRecAttr tmprec(0);
  873.   tmprec.setup(desc.m_column, (char *)data.void_value);
  874.   ndbout << tmprec;
  876.   return ndbout;
  877. }
  879. // Print tuple data
  880. NdbOut& 
  881. operator<<(NdbOut& ndbout, const TupleS& tuple)
  882. {
  883.   ndbout << tuple.getTable()->getTableName() << "; ";
  884.   for (int i = 0; i < tuple.getNoOfAttributes(); i++) 
  885.   {
  886.     AttributeData * attr_data = tuple.getData(i);
  887.     const AttributeDesc * attr_desc = tuple.getDesc(i);
  888.     const AttributeS attr = {attr_desc, *attr_data};
  889.     debug << i << " " << attr_desc->m_column->getName();
  890.     ndbout << attr;
  891.     
  892.     if (i != (tuple.getNoOfAttributes() - 1))
  893.       ndbout << delimiter << " ";
  894.   } // for
  895.   return ndbout;
  896. }
  898. // Print tuple data
  899. NdbOut& 
  900. operator<<(NdbOut& ndbout, const LogEntry& logE)
  901. {
  902.   switch(logE.m_type)
  903.   {
  904.   case LogEntry::LE_INSERT:
  905.     ndbout << "INSERT " << logE.m_table->getTableName() << " ";
  906.     break;
  907.   case LogEntry::LE_DELETE:
  908.     ndbout << "DELETE " << logE.m_table->getTableName() << " ";
  909.     break;
  910.   case LogEntry::LE_UPDATE:
  911.     ndbout << "UPDATE " << logE.m_table->getTableName() << " ";
  912.     break;
  913.   default:
  914.     ndbout << "Unknown log entry type (not insert, delete or update)" ;
  915.   }
  916.   
  917.   for (Uint32 i= 0; i < logE.size();i++) 
  918.   {
  919.     const AttributeS * attr = logE[i];
  920.     ndbout << attr->Desc->m_column->getName() << "=";
  921.     ndbout << (* attr);
  922.     if (i < (logE.size() - 1))
  923.       ndbout << ", ";
  924.   }
  925.   return ndbout;
  926. }
  929. NdbOut & 
  930. operator<<(NdbOut& ndbout, const TableS & table){
  931.   ndbout << endl << "Table: " << table.getTableName() << endl;
  932.   for (int j = 0; j < table.getNoOfAttributes(); j++) 
  933.   {
  934.     const AttributeDesc * desc = table[j];
  935.     ndbout << desc->m_column->getName() << ": "
  936.    << (Uint32) desc->m_column->getType();
  937.     ndbout << " key: "  << (Uint32) desc->m_column->getPrimaryKey();
  938.     ndbout << " array: " << desc->arraySize;
  939.     ndbout << " size: " << desc->size << endl;
  940.   } // for
  941.   return ndbout;
  942. }
  944. template class Vector<TableS*>;
  945. template class Vector<AttributeS*>;
  946. template class Vector<AttributeDesc*>;