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

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

MySQL数据库

开发平台：

Visual C++

NdbDictionaryImpl.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 "NdbDictionaryImpl.hpp"
  18. #include "API.hpp"
  19. #include <NdbOut.hpp>
  20. #include "NdbApiSignal.hpp"
  21. #include "TransporterFacade.hpp"
  22. #include <signaldata/GetTabInfo.hpp>
  23. #include <signaldata/DictTabInfo.hpp>
  24. #include <signaldata/CreateTable.hpp>
  25. #include <signaldata/CreateIndx.hpp>
  26. #include <signaldata/CreateEvnt.hpp>
  27. #include <signaldata/SumaImpl.hpp>
  28. #include <signaldata/DropTable.hpp>
  29. #include <signaldata/AlterTable.hpp>
  30. #include <signaldata/DropIndx.hpp>
  31. #include <signaldata/ListTables.hpp>
  32. #include <SimpleProperties.hpp>
  33. #include <Bitmask.hpp>
  34. #include <AttributeList.hpp>
  35. #include <NdbEventOperation.hpp>
  36. #include "NdbEventOperationImpl.hpp"
  37. #include <NdbBlob.hpp>
  38. #include "NdbBlobImpl.hpp"
  39. #include <AttributeHeader.hpp>
  40. #include <my_sys.h>
  42. #define DEBUG_PRINT 0
  43. #define INCOMPATIBLE_VERSION -2
  45. //#define EVENT_DEBUG
  47. /**
  48.  * Column
  49.  */
  50. NdbColumnImpl::NdbColumnImpl()
  51.   : NdbDictionary::Column(* this), m_attrId(-1), m_facade(this)
  52. {
  53.   init();
  54. }
  56. NdbColumnImpl::NdbColumnImpl(NdbDictionary::Column & f)
  57.   : NdbDictionary::Column(* this), m_attrId(-1), m_facade(&f)
  58. {
  59.   init();
  60. }
  62. NdbColumnImpl&
  63. NdbColumnImpl::operator=(const NdbColumnImpl& col)
  64. {
  65.   m_attrId = col.m_attrId;
  66.   m_name = col.m_name;
  67.   m_type = col.m_type;
  68.   m_precision = col.m_precision;
  69.   m_cs = col.m_cs;
  70.   m_scale = col.m_scale;
  71.   m_length = col.m_length;
  72.   m_pk = col.m_pk;
  73.   m_tupleKey = col.m_tupleKey;
  74.   m_distributionKey = col.m_distributionKey;
  75.   m_distributionGroup = col.m_distributionGroup;
  76.   m_distributionGroupBits = col.m_distributionGroupBits;
  77.   m_nullable = col.m_nullable;
  78.   m_indexOnly = col.m_indexOnly;
  79.   m_autoIncrement = col.m_autoIncrement;
  80.   m_autoIncrementInitialValue = col.m_autoIncrementInitialValue;
  81.   m_defaultValue = col.m_defaultValue;
  82.   m_attrType = col.m_attrType; 
  83.   m_attrSize = col.m_attrSize; 
  84.   m_arraySize = col.m_arraySize;
  85.   m_keyInfoPos = col.m_keyInfoPos;
  86.   m_blobTable = col.m_blobTable;
  87.   // Do not copy m_facade !!
  89.   return *this;
  90. }
  92. void
  93. NdbColumnImpl::init(Type t)
  94. {
  95.   // do not use default_charset_info as it may not be initialized yet
  96.   // use binary collation until NDB tests can handle charsets
  97.   CHARSET_INFO* default_cs = &my_charset_bin;
  98.   m_type = t;
  99.   switch (m_type) {
  100.   case Tinyint:
  101.   case Tinyunsigned:
  102.   case Smallint:
  103.   case Smallunsigned:
  104.   case Mediumint:
  105.   case Mediumunsigned:
  106.   case Int:
  107.   case Unsigned:
  108.   case Bigint:
  109.   case Bigunsigned:
  110.   case Float:
  111.   case Double:
  112.     m_precision = 0;
  113.     m_scale = 0;
  114.     m_length = 1;
  115.     m_cs = NULL;
  116.     break;
  117.   case Olddecimal:
  118.   case Olddecimalunsigned:
  119.     m_precision = 10;
  120.     m_scale = 0;
  121.     m_length = 1;
  122.     m_cs = NULL;
  123.     break;
  124.   case Char:
  125.   case Varchar:
  126.     m_precision = 0;
  127.     m_scale = 0;
  128.     m_length = 1;
  129.     m_cs = default_cs;
  130.     break;
  131.   case Binary:
  132.   case Varbinary:
  133.   case Datetime:
  134.   case Date:
  135.     m_precision = 0;
  136.     m_scale = 0;
  137.     m_length = 1;
  138.     m_cs = NULL;
  139.     break;
  140.   case Blob:
  141.     m_precision = 256;
  142.     m_scale = 8000;
  143.     m_length = 4;
  144.     m_cs = NULL;
  145.     break;
  146.   case Text:
  147.     m_precision = 256;
  148.     m_scale = 8000;
  149.     m_length = 4;
  150.     m_cs = default_cs;
  151.     break;
  152.   case Time:
  153.   case Year:
  154.   case Timestamp:
  155.     m_precision = 0;
  156.     m_scale = 0;
  157.     m_length = 1;
  158.     m_cs = NULL;
  159.     break;
  160.   case Undefined:
  161.     assert(false);
  162.     break;
  163.   }
  164.   m_pk = false;
  165.   m_nullable = false;
  166.   m_tupleKey = false;
  167.   m_indexOnly = false;
  168.   m_distributionKey = false;
  169.   m_distributionGroup = false;
  170.   m_distributionGroupBits = 8;
  171.   m_keyInfoPos = 0;
  172.   // next 2 are set at run time
  173.   m_attrSize = 0;
  174.   m_arraySize = 0;
  175.   m_autoIncrement = false;
  176.   m_autoIncrementInitialValue = 1;
  177.   m_blobTable = NULL;
  178. }
  180. NdbColumnImpl::~NdbColumnImpl()
  181. {
  182. }
  184. bool
  185. NdbColumnImpl::equal(const NdbColumnImpl& col) const 
  186. {
  187.   if(strcmp(m_name.c_str(), col.m_name.c_str()) != 0){
  188.     return false;
  189.   }
  190.   if(m_type != col.m_type){
  191.     return false;
  192.   }
  193.   if(m_pk != col.m_pk){
  194.     return false;
  195.   }
  196.   if(m_nullable != col.m_nullable){
  197.     return false;
  198.   }
  199.   if(m_pk){
  200.     if(m_tupleKey != col.m_tupleKey){
  201.       return false;
  202.     }
  203.     if(m_indexOnly != col.m_indexOnly){
  204.       return false;
  205.     }
  206.     if(m_distributionKey != col.m_distributionKey){
  207.       return false;
  208.     }
  209.     if(m_distributionGroup != col.m_distributionGroup){
  210.       return false;
  211.     }
  212.     if(m_distributionGroup && 
  213.        (m_distributionGroupBits != col.m_distributionGroupBits)){
  214.       return false;
  215.     }
  216.   }
  217.   if (m_precision != col.m_precision ||
  218.       m_scale != col.m_scale ||
  219.       m_length != col.m_length ||
  220.       m_cs != col.m_cs) {
  221.     return false;
  222.   }
  223.   if (m_autoIncrement != col.m_autoIncrement){
  224.     return false;
  225.   }
  226.   if(strcmp(m_defaultValue.c_str(), col.m_defaultValue.c_str()) != 0){
  227.     return false;
  228.   }
  230.   return true;
  231. }
  233. NdbDictionary::Column *
  234. NdbColumnImpl::create_psuedo(const char * name){
  235.   NdbDictionary::Column * col = new NdbDictionary::Column();
  236.   col->setName(name);
  237.   if(!strcmp(name, "NDB$FRAGMENT")){
  238.     col->setType(NdbDictionary::Column::Unsigned);
  239.     col->m_impl.m_attrId = AttributeHeader::FRAGMENT;
  240.     col->m_impl.m_attrSize = 4;
  241.     col->m_impl.m_arraySize = 1;
  242.   } else if(!strcmp(name, "NDB$ROW_COUNT")){
  243.     col->setType(NdbDictionary::Column::Bigunsigned);
  244.     col->m_impl.m_attrId = AttributeHeader::ROW_COUNT;
  245.     col->m_impl.m_attrSize = 8;
  246.     col->m_impl.m_arraySize = 1;
  247.   } else if(!strcmp(name, "NDB$COMMIT_COUNT")){
  248.     col->setType(NdbDictionary::Column::Bigunsigned);
  249.     col->m_impl.m_attrId = AttributeHeader::COMMIT_COUNT;
  250.     col->m_impl.m_attrSize = 8;
  251.     col->m_impl.m_arraySize = 1;
  252.   } else {
  253.     abort();
  254.   }
  255.   return col;
  256. }
  258. /**
  259.  * NdbTableImpl
  260.  */
  262. NdbTableImpl::NdbTableImpl()
  263.   : NdbDictionary::Table(* this), m_facade(this)
  264. {
  265.   init();
  266. }
  268. NdbTableImpl::NdbTableImpl(NdbDictionary::Table & f)
  269.   : NdbDictionary::Table(* this), m_facade(&f)
  270. {
  271.   init();
  272. }
  274. NdbTableImpl::~NdbTableImpl()
  275. {
  276.   if (m_index != 0) {
  277.     delete m_index;
  278.     m_index = 0;
  279.   }
  280.   for (unsigned i = 0; i < m_columns.size(); i++)
  281.     delete m_columns[i];  
  282. }
  284. void
  285. NdbTableImpl::init(){
  286.   clearNewProperties();
  287.   m_frm.clear();
  288.   m_fragmentType = NdbDictionary::Object::FragAllSmall;
  289.   m_logging = true;
  290.   m_kvalue = 6;
  291.   m_minLoadFactor = 78;
  292.   m_maxLoadFactor = 80;
  294.   m_index = 0;
  295.   m_indexType = NdbDictionary::Index::Undefined;
  296.   
  297.   m_noOfKeys = 0;
  298.   m_fragmentCount = 0;
  299.   m_sizeOfKeysInWords = 0;
  300.   m_noOfBlobs = 0;
  301. }
  303. bool
  304. NdbTableImpl::equal(const NdbTableImpl& obj) const 
  305. {
  306.   if ((m_internalName.c_str() == NULL) || 
  307.       (strcmp(m_internalName.c_str(), "") == 0) ||
  308.       (obj.m_internalName.c_str() == NULL) || 
  309.       (strcmp(obj.m_internalName.c_str(), "") == 0)) {
  310.     // Shallow equal
  311.     if(strcmp(getName(), obj.getName()) != 0){
  312.       return false;    
  313.     }
  314.   } else 
  315.     // Deep equal
  316.     if(strcmp(m_internalName.c_str(), obj.m_internalName.c_str()) != 0){
  317.       return false;
  318.   }
  319.   if(m_fragmentType != obj.m_fragmentType){
  320.     return false;
  321.   }
  322.   if(m_columns.size() != obj.m_columns.size()){
  323.     return false;
  324.   }
  326.   for(unsigned i = 0; i<obj.m_columns.size(); i++){
  327.     if(!m_columns[i]->equal(* obj.m_columns[i])){
  328.       return false;
  329.     }
  330.   }
  331.   
  332.   if(m_logging != obj.m_logging){
  333.     return false;
  334.   }
  336.   if(m_kvalue != obj.m_kvalue){
  337.     return false;
  338.   }
  340.   if(m_minLoadFactor != obj.m_minLoadFactor){
  341.     return false;
  342.   }
  344.   if(m_maxLoadFactor != obj.m_maxLoadFactor){
  345.     return false;
  346.   }
  347.   
  348.   return true;
  349. }
  351. void
  352. NdbTableImpl::assign(const NdbTableImpl& org)
  353. {
  354.   m_tableId = org.m_tableId;
  355.   m_internalName.assign(org.m_internalName);
  356.   m_externalName.assign(org.m_externalName);
  357.   m_newExternalName.assign(org.m_newExternalName);
  358.   m_frm.assign(org.m_frm.get_data(), org.m_frm.length());
  359.   m_fragmentType = org.m_fragmentType;
  360.   m_fragmentCount = org.m_fragmentCount;
  362.   for(unsigned i = 0; i<org.m_columns.size(); i++){
  363.     NdbColumnImpl * col = new NdbColumnImpl();
  364.     const NdbColumnImpl * iorg = org.m_columns[i];
  365.     (* col) = (* iorg);
  366.     m_columns.push_back(col);
  367.   }
  369.   m_logging = org.m_logging;
  370.   m_kvalue = org.m_kvalue;
  371.   m_minLoadFactor = org.m_minLoadFactor;
  372.   m_maxLoadFactor = org.m_maxLoadFactor;
  373.   
  374.   if (m_index != 0)
  375.     delete m_index;
  376.   m_index = org.m_index;
  377.   
  378.   m_noOfKeys = org.m_noOfKeys;
  379.   m_sizeOfKeysInWords = org.m_sizeOfKeysInWords;
  380.   m_noOfBlobs = org.m_noOfBlobs;
  382.   m_version = org.m_version;
  383.   m_status = org.m_status;
  384. }
  386. void NdbTableImpl::setName(const char * name)
  387. {
  388.   m_newExternalName.assign(name);
  389. }
  391. const char * 
  392. NdbTableImpl::getName() const
  393. {
  394.   if (m_newExternalName.empty())
  395.     return m_externalName.c_str();
  396.   else
  397.     return m_newExternalName.c_str();
  398. }
  400. void NdbTableImpl::clearNewProperties()
  401. {
  402.   m_newExternalName.assign("");
  403.   m_changeMask = 0;
  404. }
  406. void NdbTableImpl::copyNewProperties()
  407. {
  408.   if (!m_newExternalName.empty()) {
  409.     m_externalName.assign(m_newExternalName);
  410.     AlterTableReq::setNameFlag(m_changeMask, true);
  411.   }
  412. }
  414. void
  415. NdbTableImpl::buildColumnHash(){
  416.   const Uint32 size = m_columns.size();
  418.   int i;
  419.   for(i = 31; i >= 0; i--){
  420.     if(((1 << i) & size) != 0){
  421.       m_columnHashMask = (1 << (i + 1)) - 1;
  422.       break;
  423.     }
  424.   }
  426.   Vector<Uint32> hashValues;
  427.   Vector<Vector<Uint32> > chains; chains.fill(size, hashValues);
  428.   for(i = 0; i< (int) size; i++){
  429.     Uint32 hv = Hash(m_columns[i]->getName()) & 0xFFFE;
  430.     Uint32 bucket = hv & m_columnHashMask;
  431.     bucket = (bucket < size ? bucket : bucket - size);
  432.     assert(bucket < size);
  433.     hashValues.push_back(hv);
  434.     chains[bucket].push_back(i);
  435.   }
  437.   m_columnHash.clear();
  438.   Uint32 tmp = 1; 
  439.   m_columnHash.fill((unsigned)size-1, tmp);   // Default no chaining
  441.   Uint32 pos = 0; // In overflow vector
  442.   for(i = 0; i< (int) size; i++){
  443.     Uint32 sz = chains[i].size();
  444.     if(sz == 1){
  445.       Uint32 col = chains[i][0];
  446.       Uint32 hv = hashValues[col];
  447.       Uint32 bucket = hv & m_columnHashMask;
  448.       bucket = (bucket < size ? bucket : bucket - size);
  449.       m_columnHash[bucket] = (col << 16) | hv | 1;
  450.     } else if(sz > 1){
  451.       Uint32 col = chains[i][0];
  452.       Uint32 hv = hashValues[col];
  453.       Uint32 bucket = hv & m_columnHashMask;
  454.       bucket = (bucket < size ? bucket : bucket - size);
  455.       m_columnHash[bucket] = (sz << 16) | (((size - bucket) + pos) << 1);
  456.       for(size_t j = 0; j<sz; j++, pos++){
  457. Uint32 col = chains[i][j];
  458. Uint32 hv = hashValues[col];
  459. m_columnHash.push_back((col << 16) | hv);
  460.       }
  461.     }
  462.   }
  464.   m_columnHash.push_back(0); // Overflow when looping in end of array
  466. #if 0
  467.   for(size_t i = 0; i<m_columnHash.size(); i++){
  468.     Uint32 tmp = m_columnHash[i];
  469.     int col = -1;
  470.     if(i < size && (tmp & 1) == 1){
  471.       col = (tmp >> 16);
  472.     } else if(i >= size){
  473.       col = (tmp >> 16);
  474.     }
  475.     ndbout_c("m_columnHash[%d] %s = %x", 
  476.      i, col > 0 ? m_columns[col]->getName() : "" , m_columnHash[i]);
  477.   }
  478. #endif
  479. }
  480.   
  481. /**
  482.  * NdbIndexImpl
  483.  */
  485. NdbIndexImpl::NdbIndexImpl() : 
  486.   NdbDictionary::Index(* this), 
  487.   m_facade(this)
  488. {
  489.   m_logging = true;
  490. }
  492. NdbIndexImpl::NdbIndexImpl(NdbDictionary::Index & f) : 
  493.   NdbDictionary::Index(* this), 
  494.   m_facade(&f)
  495. {
  496.   m_logging = true;
  497. }
  499. NdbIndexImpl::~NdbIndexImpl(){
  500.   for (unsigned i = 0; i < m_columns.size(); i++)
  501.     delete m_columns[i];  
  502. }
  504. void NdbIndexImpl::setName(const char * name)
  505. {
  506.   m_externalName.assign(name);
  507. }
  509. const char * 
  510. NdbIndexImpl::getName() const
  511. {
  512.   return m_externalName.c_str();
  513. }
  514.  
  515. void 
  516. NdbIndexImpl::setTable(const char * table)
  517. {
  518.   m_tableName.assign(table);
  519. }
  520.  
  521. const char * 
  522. NdbIndexImpl::getTable() const
  523. {
  524.   return m_tableName.c_str();
  525. }
  527. const NdbTableImpl *
  528. NdbIndexImpl::getIndexTable() const
  529. {
  530.   return m_table;
  531. }
  533. /**
  534.  * NdbEventImpl
  535.  */
  537. NdbEventImpl::NdbEventImpl() : 
  538.   NdbDictionary::Event(* this),
  539.   m_facade(this)
  540. {
  541.   mi_type = 0;
  542.   m_dur = NdbDictionary::Event::ED_UNDEFINED;
  543.   eventOp = NULL;
  544.   m_tableImpl = NULL;
  545. }
  547. NdbEventImpl::NdbEventImpl(NdbDictionary::Event & f) : 
  548.   NdbDictionary::Event(* this),
  549.   m_facade(&f)
  550. {
  551.   mi_type = 0;
  552.   m_dur = NdbDictionary::Event::ED_UNDEFINED;
  553.   eventOp = NULL;
  554.   m_tableImpl = NULL;
  555. }
  557. NdbEventImpl::~NdbEventImpl()
  558. {
  559.   for (unsigned i = 0; i < m_columns.size(); i++)
  560.     delete  m_columns[i];
  561. }
  563. void NdbEventImpl::setName(const char * name)
  564. {
  565.   m_externalName.assign(name);
  566. }
  568. void 
  569. NdbEventImpl::setTable(const char * table)
  570. {
  571.   m_tableName.assign(table);
  572. }
  574. const char * 
  575. NdbEventImpl::getTable() const
  576. {
  577.   return m_tableName.c_str();
  578. }
  580. const char * 
  581. NdbEventImpl::getName() const
  582. {
  583.   return m_externalName.c_str();
  584. } 
  586. void
  587. NdbEventImpl::addTableEvent(const NdbDictionary::Event::TableEvent t =  NdbDictionary::Event::TE_ALL)
  588. {
  589.   switch (t) {
  590.   case NdbDictionary::Event::TE_INSERT : mi_type |= 1; break;
  591.   case NdbDictionary::Event::TE_DELETE : mi_type |= 2; break;
  592.   case NdbDictionary::Event::TE_UPDATE : mi_type |= 4; break;
  593.   default: mi_type = 4 | 2 | 1; // all types
  594.   }
  595. }
  597. void
  598. NdbEventImpl::setDurability(const NdbDictionary::Event::EventDurability d)
  599. {
  600.   m_dur = d;
  601. }
  603. /**
  604.  * NdbDictionaryImpl
  605.  */
  607. NdbDictionaryImpl::NdbDictionaryImpl(Ndb &ndb)
  608.   : NdbDictionary::Dictionary(* this), 
  609.     m_facade(this), 
  610.     m_receiver(m_error),
  611.     m_ndb(ndb)
  612. {
  613.   m_globalHash = 0;
  614.   m_local_table_data_size= 0;
  615. }
  617. NdbDictionaryImpl::NdbDictionaryImpl(Ndb &ndb,
  618.      NdbDictionary::Dictionary & f)
  619.   : NdbDictionary::Dictionary(* this), 
  620.     m_facade(&f), 
  621.     m_receiver(m_error),
  622.     m_ndb(ndb)
  623. {
  624.   m_globalHash = 0;
  625.   m_local_table_data_size= 0;
  626. }
  628. static int f_dictionary_count = 0;
  630. NdbDictionaryImpl::~NdbDictionaryImpl()
  631. {
  632.   NdbElement_t<Ndb_local_table_info> * curr = m_localHash.m_tableHash.getNext(0);
  633.   if(m_globalHash){
  634.     while(curr != 0){
  635.       m_globalHash->lock();
  636.       m_globalHash->release(curr->theData->m_table_impl);
  637.       Ndb_local_table_info::destroy(curr->theData);
  638.       m_globalHash->unlock();
  639.       
  640.       curr = m_localHash.m_tableHash.getNext(curr);
  641.     }
  642.     
  643.     m_globalHash->lock();
  644.     if(--f_dictionary_count == 0){
  645.       delete NdbDictionary::Column::FRAGMENT; 
  646.       delete NdbDictionary::Column::ROW_COUNT;
  647.       delete NdbDictionary::Column::COMMIT_COUNT;
  648.       NdbDictionary::Column::FRAGMENT= 0;
  649.       NdbDictionary::Column::ROW_COUNT= 0;
  650.       NdbDictionary::Column::COMMIT_COUNT= 0;
  651.     }
  652.     m_globalHash->unlock();
  653.   } else {
  654.     assert(curr == 0);
  655.   }
  656. }
  658. Ndb_local_table_info *
  659. NdbDictionaryImpl::fetchGlobalTableImpl(const char * internalTableName)
  660. {
  661.   NdbTableImpl *impl;
  663.   m_globalHash->lock();
  664.   impl = m_globalHash->get(internalTableName);
  665.   m_globalHash->unlock();
  667.   if (impl == 0){
  668.     impl = m_receiver.getTable(internalTableName,
  669.        m_ndb.usingFullyQualifiedNames());
  670.     m_globalHash->lock();
  671.     m_globalHash->put(internalTableName, impl);
  672.     m_globalHash->unlock();
  673.     
  674.     if(impl == 0){
  675.       return 0;
  676.     }
  677.   }
  679.   Ndb_local_table_info *info=
  680.     Ndb_local_table_info::create(impl, m_local_table_data_size);
  682.   m_localHash.put(internalTableName, info);
  684.   m_ndb.theFirstTupleId[impl->getTableId()] = ~0;
  685.   m_ndb.theLastTupleId[impl->getTableId()]  = ~0;
  686.   
  687.   return info;
  688. }
  690. #if 0
  691. bool
  692. NdbDictionaryImpl::setTransporter(class TransporterFacade * tf)
  693. {
  694.   if(tf != 0){
  695.     m_globalHash = &tf->m_globalDictCache;
  696.     return m_receiver.setTransporter(tf);
  697.   }
  698.   
  699.   return false;
  700. }
  701. #endif
  703. bool
  704. NdbDictionaryImpl::setTransporter(class Ndb* ndb, 
  705.   class TransporterFacade * tf)
  706. {
  707.   m_globalHash = &tf->m_globalDictCache;
  708.   if(m_receiver.setTransporter(ndb, tf)){
  709.     m_globalHash->lock();
  710.     if(f_dictionary_count++ == 0){
  711.       NdbDictionary::Column::FRAGMENT= 
  712. NdbColumnImpl::create_psuedo("NDB$FRAGMENT");
  713.       NdbDictionary::Column::ROW_COUNT= 
  714. NdbColumnImpl::create_psuedo("NDB$ROW_COUNT");
  715.       NdbDictionary::Column::COMMIT_COUNT= 
  716. NdbColumnImpl::create_psuedo("NDB$COMMIT_COUNT");
  717.     }
  718.     m_globalHash->unlock();
  719.     return true;
  720.   }
  721.   return false;
  722. }
  724. NdbTableImpl * 
  725. NdbDictionaryImpl::getIndexTable(NdbIndexImpl * index, 
  726.  NdbTableImpl * table)
  727. {
  728.   const char * internalName = 
  729.     m_ndb.internalizeIndexName(table, index->getName());
  730.   
  731.   return getTable(m_ndb.externalizeTableName(internalName));
  732. }
  734. #if 0
  735. bool
  736. NdbDictInterface::setTransporter(class TransporterFacade * tf)
  737. {
  738.   if(tf == 0)
  739.     return false;
  740.   
  741.   Guard g(tf->theMutexPtr);
  742.   
  743.   m_blockNumber = tf->open(this,
  744.    execSignal,
  745.    execNodeStatus);
  746.   
  747.   if ( m_blockNumber == -1 ) {
  748.     m_error.code = 4105;
  749.     return false; // no more free blocknumbers
  750.   }//if
  751.   Uint32 theNode = tf->ownId();
  752.   m_reference = numberToRef(m_blockNumber, theNode);
  753.   m_transporter = tf;
  754.   m_waiter.m_mutex = tf->theMutexPtr;
  756.   return true;
  757. }
  758. #endif
  760. bool
  761. NdbDictInterface::setTransporter(class Ndb* ndb, class TransporterFacade * tf)
  762. {
  763.   m_reference = ndb->getReference();
  764.   m_transporter = tf;
  765.   m_waiter.m_mutex = tf->theMutexPtr;
  766.   
  767.   return true;
  768. }
  770. NdbDictInterface::~NdbDictInterface()
  771. {
  772. }
  774. void 
  775. NdbDictInterface::execSignal(void* dictImpl, 
  776.      class NdbApiSignal* signal, 
  777.      class LinearSectionPtr ptr[3])
  778. {
  779.   NdbDictInterface * tmp = (NdbDictInterface*)dictImpl;
  780.   
  781.   const Uint32 gsn = signal->readSignalNumber();
  782.   switch(gsn){
  783.   case GSN_GET_TABINFOREF:
  784.     tmp->execGET_TABINFO_REF(signal, ptr);
  785.     break;
  786.   case GSN_GET_TABINFO_CONF:
  787.     tmp->execGET_TABINFO_CONF(signal, ptr);
  788.     break;
  789.   case GSN_CREATE_TABLE_REF:
  790.     tmp->execCREATE_TABLE_REF(signal, ptr);
  791.     break;
  792.   case GSN_CREATE_TABLE_CONF:
  793.     tmp->execCREATE_TABLE_CONF(signal, ptr);
  794.     break;
  795.   case GSN_DROP_TABLE_REF:
  796.     tmp->execDROP_TABLE_REF(signal, ptr);
  797.     break;
  798.   case GSN_DROP_TABLE_CONF:
  799.     tmp->execDROP_TABLE_CONF(signal, ptr);
  800.     break;
  801.   case GSN_ALTER_TABLE_REF:
  802.     tmp->execALTER_TABLE_REF(signal, ptr);
  803.     break;
  804.   case GSN_ALTER_TABLE_CONF:
  805.     tmp->execALTER_TABLE_CONF(signal, ptr);
  806.     break;
  807.   case GSN_CREATE_INDX_REF:
  808.     tmp->execCREATE_INDX_REF(signal, ptr);
  809.     break;
  810.   case GSN_CREATE_INDX_CONF:
  811.     tmp->execCREATE_INDX_CONF(signal, ptr);
  812.     break;
  813.   case GSN_DROP_INDX_REF:
  814.     tmp->execDROP_INDX_REF(signal, ptr);
  815.     break;
  816.   case GSN_DROP_INDX_CONF:
  817.     tmp->execDROP_INDX_CONF(signal, ptr);
  818.     break;
  819.   case GSN_CREATE_EVNT_REF:
  820.     tmp->execCREATE_EVNT_REF(signal, ptr);
  821.     break;
  822.   case GSN_CREATE_EVNT_CONF:
  823.     tmp->execCREATE_EVNT_CONF(signal, ptr);
  824.     break;
  825.   case GSN_SUB_START_CONF:
  826.     tmp->execSUB_START_CONF(signal, ptr);
  827.     break;
  828.   case GSN_SUB_START_REF:
  829.     tmp->execSUB_START_REF(signal, ptr);
  830.     break;
  831.   case GSN_SUB_TABLE_DATA:
  832.     tmp->execSUB_TABLE_DATA(signal, ptr);
  833.     break;
  834.   case GSN_SUB_GCP_COMPLETE_REP:
  835.     tmp->execSUB_GCP_COMPLETE_REP(signal, ptr);
  836.     break;
  837.   case GSN_SUB_STOP_CONF:
  838.     tmp->execSUB_STOP_CONF(signal, ptr);
  839.     break;
  840.   case GSN_SUB_STOP_REF:
  841.     tmp->execSUB_STOP_REF(signal, ptr);
  842.     break;
  843.   case GSN_DROP_EVNT_REF:
  844.     tmp->execDROP_EVNT_REF(signal, ptr);
  845.     break;
  846.   case GSN_DROP_EVNT_CONF:
  847.     tmp->execDROP_EVNT_CONF(signal, ptr);
  848.     break;
  849.   case GSN_LIST_TABLES_CONF:
  850.     tmp->execLIST_TABLES_CONF(signal, ptr);
  851.     break;
  852.   default:
  853.     abort();
  854.   }
  855. }
  857. void
  858. NdbDictInterface::execNodeStatus(void* dictImpl, Uint32 aNode,
  859.  bool alive, bool nfCompleted)
  860. {
  861.   NdbDictInterface * tmp = (NdbDictInterface*)dictImpl;
  862.   
  863.   if(!alive && !nfCompleted){
  864.     return;
  865.   }
  866.   
  867.   if (!alive && nfCompleted){
  868.     tmp->m_waiter.nodeFail(aNode);
  869.   }
  870. }
  872. int
  873. NdbDictInterface::dictSignal(NdbApiSignal* signal, 
  874.      LinearSectionPtr ptr[3],int noLSP,
  875.      const int useMasterNodeId,
  876.      const Uint32 RETRIES,
  877.      const WaitSignalType wst,
  878.      const int theWait,
  879.      const int *errcodes,
  880.      const int noerrcodes,
  881.      const int temporaryMask)
  882. {
  883.   DBUG_ENTER("NdbDictInterface::dictSignal");
  884.   DBUG_PRINT("enter", ("useMasterNodeId: %d", useMasterNodeId));
  885.   for(Uint32 i = 0; i<RETRIES; i++){
  886.     //if (useMasterNodeId == 0)
  887.     m_buffer.clear();
  889.     // Protected area
  890.     m_transporter->lock_mutex();
  891.     Uint32 aNodeId;
  892.     if (useMasterNodeId) {
  893.       if ((m_masterNodeId == 0) ||
  894.   (!m_transporter->get_node_alive(m_masterNodeId))) {
  895. m_masterNodeId = m_transporter->get_an_alive_node();
  896.       }//if
  897.       aNodeId = m_masterNodeId;
  898.     } else {
  899.       aNodeId = m_transporter->get_an_alive_node();
  900.     }
  901.     if(aNodeId == 0){
  902.       m_error.code = 4009;
  903.       m_transporter->unlock_mutex();
  904.       DBUG_RETURN(-1);
  905.     }
  906.     {
  907.       int r;
  908.       if (ptr) {
  909. #ifdef EVENT_DEBUG
  910. printf("Long signal %d ptr", noLSP);
  911. for (int q=0;q<noLSP;q++) {
  912.   printf(" sz %d", ptr[q].sz);
  913. }
  914. printf("n");
  915. #endif
  916. r = m_transporter->sendFragmentedSignal(signal, aNodeId, ptr, noLSP);
  917.       } else {
  918. #ifdef EVENT_DEBUG
  919. printf("Short signaln");
  920. #endif
  921. r = m_transporter->sendSignal(signal, aNodeId);
  922.       }
  923.       if(r != 0){
  924. m_transporter->unlock_mutex();
  925. continue;
  926.       }
  927.     }
  928.     
  929.     m_error.code = 0;
  930.     
  931.     m_waiter.m_node = aNodeId;
  932.     m_waiter.m_state = wst;
  934.     m_waiter.wait(theWait);
  935.     m_transporter->unlock_mutex();    
  936.     // End of Protected area  
  937.     
  938.     if(m_waiter.m_state == NO_WAIT && m_error.code == 0){
  939.       // Normal return
  940.       DBUG_RETURN(0);
  941.     }
  942.     
  943.     /**
  944.      * Handle error codes
  945.      */
  946.     if(m_waiter.m_state == WAIT_NODE_FAILURE)
  947.       continue;
  949.     if(m_waiter.m_state == WST_WAIT_TIMEOUT)
  950.     {
  951.       m_error.code = 4008;
  952.       DBUG_RETURN(-1);
  953.     }
  954.     
  955.     if ( (temporaryMask & m_error.code) != 0 ) {
  956.       continue;
  957.     }
  958.     if (errcodes) {
  959.       int doContinue = 0;
  960.       for (int j=0; j < noerrcodes; j++)
  961. if(m_error.code == errcodes[j]) {
  962.   doContinue = 1;
  963.   continue;
  964. }
  965.       if (doContinue)
  966. continue;
  967.     }
  969.     DBUG_RETURN(-1);
  970.   }
  971.   DBUG_RETURN(-1);
  972. }
  974. /*****************************************************************
  975.  * get tab info
  976.  */
  977. NdbTableImpl * 
  978. NdbDictInterface::getTable(int tableId, bool fullyQualifiedNames)
  979. {
  980.   NdbApiSignal tSignal(m_reference);
  981.   GetTabInfoReq * const req = CAST_PTR(GetTabInfoReq, tSignal.getDataPtrSend());
  982.   
  983.   req->senderRef = m_reference;
  984.   req->senderData = 0;
  985.   req->requestType = 
  986.     GetTabInfoReq::RequestById | GetTabInfoReq::LongSignalConf;
  987.   req->tableId = tableId;
  988.   tSignal.theReceiversBlockNumber = DBDICT;
  989.   tSignal.theVerId_signalNumber   = GSN_GET_TABINFOREQ;
  990.   tSignal.theLength = GetTabInfoReq::SignalLength;
  991.   
  992.   return getTable(&tSignal, 0, 0, fullyQualifiedNames);
  993. }
  995. NdbTableImpl * 
  996. NdbDictInterface::getTable(const char * name, bool fullyQualifiedNames)
  997. {
  998.   NdbApiSignal tSignal(m_reference);
  999.   GetTabInfoReq * const req = CAST_PTR(GetTabInfoReq, tSignal.getDataPtrSend());
  1000.   
  1001.   const Uint32 strLen = strlen(name) + 1; // NULL Terminated
  1002.   if(strLen > MAX_TAB_NAME_SIZE) {//sizeof(req->tableName)){
  1003.     m_error.code = 4307;
  1004.     return 0;
  1005.   }
  1007.   // avoid alignment problem and memory overrun
  1008.   Uint32 name_buf[(MAX_TAB_NAME_SIZE + 3) / 4];
  1009.   strncpy((char*)name_buf, name, sizeof(name_buf)); // strncpy null-pads
  1010.   name = (char*)name_buf;
  1012.   req->senderRef = m_reference;
  1013.   req->senderData = 0;
  1014.   req->requestType = 
  1015.     GetTabInfoReq::RequestByName | GetTabInfoReq::LongSignalConf;
  1016.   req->tableNameLen = strLen;
  1017.   tSignal.theReceiversBlockNumber = DBDICT;
  1018.   tSignal.theVerId_signalNumber   = GSN_GET_TABINFOREQ;
  1019.   //  tSignal.theLength = GetTabInfoReq::HeaderLength + ((strLen + 3) / 4);
  1020.   tSignal.theLength = GetTabInfoReq::SignalLength;
  1021.   LinearSectionPtr ptr[1];
  1022.   ptr[0].p  = (Uint32*)name;
  1023.   ptr[0].sz = (strLen + 3) / 4;
  1024.   
  1025.   return getTable(&tSignal, ptr, 1, fullyQualifiedNames);
  1026. }
  1028. NdbTableImpl *
  1029. NdbDictInterface::getTable(class NdbApiSignal * signal, 
  1030.    LinearSectionPtr ptr[3],
  1031.    Uint32 noOfSections, bool fullyQualifiedNames)
  1032. {
  1033.   //GetTabInfoReq * const req = CAST_PTR(GetTabInfoReq, signal->getDataPtrSend());
  1034.   int r = dictSignal(signal,ptr,noOfSections,
  1035.      0/*do not use masternode id*/,
  1036.      100,
  1037.      WAIT_GET_TAB_INFO_REQ,
  1038.      WAITFOR_RESPONSE_TIMEOUT,
  1039.      NULL,0);
  1040.   if (r) return 0;
  1042.   NdbTableImpl * rt = 0;
  1043.   m_error.code = parseTableInfo(&rt, 
  1044.    (Uint32*)m_buffer.get_data(), 
  1045.    m_buffer.length() / 4, fullyQualifiedNames);
  1046.   rt->buildColumnHash();
  1047.   return rt;
  1048. }
  1050. void
  1051. NdbDictInterface::execGET_TABINFO_CONF(NdbApiSignal * signal, 
  1052.        LinearSectionPtr ptr[3])
  1053. {
  1054.   const GetTabInfoConf* conf = CAST_CONSTPTR(GetTabInfoConf, signal->getDataPtr());
  1055.   if(signal->isFirstFragment()){
  1056.     m_fragmentId = signal->getFragmentId();
  1057.     m_buffer.grow(4 * conf->totalLen);
  1058.   } else {
  1059.     if(m_fragmentId != signal->getFragmentId()){
  1060.       abort();
  1061.     }
  1062.   }
  1063.   
  1064.   const Uint32 i = GetTabInfoConf::DICT_TAB_INFO;
  1065.   m_buffer.append(ptr[i].p, 4 * ptr[i].sz);
  1067.   if(!signal->isLastFragment()){
  1068.     return;
  1069.   }  
  1070.   
  1071.   m_waiter.signal(NO_WAIT);
  1072. }
  1074. void
  1075. NdbDictInterface::execGET_TABINFO_REF(NdbApiSignal * signal,
  1076.       LinearSectionPtr ptr[3])
  1077. {
  1078.   const GetTabInfoRef* ref = CAST_CONSTPTR(GetTabInfoRef, signal->getDataPtr());
  1080.   m_error.code = ref->errorCode;
  1081.   m_waiter.signal(NO_WAIT);
  1082. }
  1084. /*****************************************************************
  1085.  * Pack/Unpack tables
  1086.  */
  1087. struct ApiKernelMapping {
  1088.   Int32 kernelConstant;
  1089.   Int32 apiConstant;
  1090. };
  1092. Uint32
  1093. getApiConstant(Int32 kernelConstant, const ApiKernelMapping map[], Uint32 def)
  1094. {
  1095.   int i = 0;
  1096.   while(map[i].kernelConstant != kernelConstant){
  1097.     if(map[i].kernelConstant == -1 &&
  1098.        map[i].apiConstant == -1){
  1099.       return def;
  1100.     }
  1101.     i++;
  1102.   }
  1103.   return map[i].apiConstant;
  1104. }
  1106. Uint32
  1107. getKernelConstant(Int32 apiConstant, const ApiKernelMapping map[], Uint32 def)
  1108. {
  1109.   int i = 0;
  1110.   while(map[i].apiConstant != apiConstant){
  1111.     if(map[i].kernelConstant == -1 &&
  1112.        map[i].apiConstant == -1){
  1113.       return def;
  1114.     }
  1115.     i++;
  1116.   }
  1117.   return map[i].kernelConstant;
  1118. }
  1120. static const
  1121. ApiKernelMapping 
  1122. fragmentTypeMapping[] = {
  1123.   { DictTabInfo::AllNodesSmallTable,  NdbDictionary::Object::FragAllSmall },
  1124.   { DictTabInfo::AllNodesMediumTable, NdbDictionary::Object::FragAllMedium },
  1125.   { DictTabInfo::AllNodesLargeTable,  NdbDictionary::Object::FragAllLarge },
  1126.   { DictTabInfo::SingleFragment,      NdbDictionary::Object::FragSingle },
  1127.   { -1, -1 }
  1128. };
  1130. static const
  1131. ApiKernelMapping
  1132. objectTypeMapping[] = {
  1133.   { DictTabInfo::SystemTable,        NdbDictionary::Object::SystemTable },
  1134.   { DictTabInfo::UserTable,          NdbDictionary::Object::UserTable },
  1135.   { DictTabInfo::UniqueHashIndex,    NdbDictionary::Object::UniqueHashIndex },
  1136.   { DictTabInfo::HashIndex,          NdbDictionary::Object::HashIndex }, 
  1137.   { DictTabInfo::UniqueOrderedIndex, NdbDictionary::Object::UniqueOrderedIndex },
  1138.   { DictTabInfo::OrderedIndex,       NdbDictionary::Object::OrderedIndex },
  1139.   { DictTabInfo::HashIndexTrigger,   NdbDictionary::Object::HashIndexTrigger },
  1140.   { DictTabInfo::IndexTrigger,       NdbDictionary::Object::IndexTrigger },
  1141.   { DictTabInfo::SubscriptionTrigger,NdbDictionary::Object::SubscriptionTrigger },
  1142.   { DictTabInfo::ReadOnlyConstraint ,NdbDictionary::Object::ReadOnlyConstraint },
  1143.   { -1, -1 }
  1144. };
  1146. static const
  1147. ApiKernelMapping
  1148. objectStateMapping[] = {
  1149.   { DictTabInfo::StateOffline,       NdbDictionary::Object::StateOffline },
  1150.   { DictTabInfo::StateBuilding,      NdbDictionary::Object::StateBuilding },
  1151.   { DictTabInfo::StateDropping,      NdbDictionary::Object::StateDropping },
  1152.   { DictTabInfo::StateOnline,        NdbDictionary::Object::StateOnline },
  1153.   { DictTabInfo::StateBackup,        NdbDictionary::Object::StateBackup },
  1154.   { DictTabInfo::StateBroken,        NdbDictionary::Object::StateBroken }, 
  1155.   { -1, -1 }
  1156. };
  1158. static const
  1159. ApiKernelMapping
  1160. objectStoreMapping[] = {
  1161.   { DictTabInfo::StoreTemporary,     NdbDictionary::Object::StoreTemporary },
  1162.   { DictTabInfo::StorePermanent,     NdbDictionary::Object::StorePermanent },
  1163.   { -1, -1 }
  1164. };
  1166. static const
  1167. ApiKernelMapping
  1168. indexTypeMapping[] = {
  1169.   { DictTabInfo::UniqueHashIndex,    NdbDictionary::Index::UniqueHashIndex },  
  1170.   { DictTabInfo::HashIndex,          NdbDictionary::Index::HashIndex },  
  1171.   { DictTabInfo::UniqueOrderedIndex, NdbDictionary::Index::UniqueOrderedIndex},
  1172.   { DictTabInfo::OrderedIndex,       NdbDictionary::Index::OrderedIndex },
  1173.   { -1, -1 }
  1174. };
  1176. // TODO: remove, api-kernel type codes must match now
  1177. static const
  1178. ApiKernelMapping
  1179. columnTypeMapping[] = {
  1180.   { DictTabInfo::ExtTinyint,         NdbDictionary::Column::Tinyint },
  1181.   { DictTabInfo::ExtTinyunsigned,    NdbDictionary::Column::Tinyunsigned },
  1182.   { DictTabInfo::ExtSmallint,        NdbDictionary::Column::Smallint },
  1183.   { DictTabInfo::ExtSmallunsigned,   NdbDictionary::Column::Smallunsigned },
  1184.   { DictTabInfo::ExtMediumint,       NdbDictionary::Column::Mediumint },
  1185.   { DictTabInfo::ExtMediumunsigned,  NdbDictionary::Column::Mediumunsigned },
  1186.   { DictTabInfo::ExtInt,             NdbDictionary::Column::Int },
  1187.   { DictTabInfo::ExtUnsigned,        NdbDictionary::Column::Unsigned },
  1188.   { DictTabInfo::ExtBigint,          NdbDictionary::Column::Bigint },
  1189.   { DictTabInfo::ExtBigunsigned,     NdbDictionary::Column::Bigunsigned },
  1190.   { DictTabInfo::ExtFloat,           NdbDictionary::Column::Float },
  1191.   { DictTabInfo::ExtDouble,          NdbDictionary::Column::Double },
  1192.   { DictTabInfo::ExtOlddecimal,      NdbDictionary::Column::Olddecimal },
  1193.   { DictTabInfo::ExtOlddecimalunsigned, NdbDictionary::Column::Olddecimalunsigned },
  1194.   { DictTabInfo::ExtChar,            NdbDictionary::Column::Char },
  1195.   { DictTabInfo::ExtVarchar,         NdbDictionary::Column::Varchar },
  1196.   { DictTabInfo::ExtBinary,          NdbDictionary::Column::Binary },
  1197.   { DictTabInfo::ExtVarbinary,       NdbDictionary::Column::Varbinary },
  1198.   { DictTabInfo::ExtDatetime,        NdbDictionary::Column::Datetime },
  1199.   { DictTabInfo::ExtDate,            NdbDictionary::Column::Date },
  1200.   { DictTabInfo::ExtBlob,            NdbDictionary::Column::Blob },
  1201.   { DictTabInfo::ExtText,            NdbDictionary::Column::Text },
  1202.   { DictTabInfo::ExtTime,            NdbDictionary::Column::Time },
  1203.   { DictTabInfo::ExtYear,            NdbDictionary::Column::Year },
  1204.   { DictTabInfo::ExtTimestamp,       NdbDictionary::Column::Timestamp },
  1205.   { -1, -1 }
  1206. };
  1208. int
  1209. NdbDictInterface::parseTableInfo(NdbTableImpl ** ret,
  1210.  const Uint32 * data, Uint32 len,
  1211.  bool fullyQualifiedNames)
  1212. {
  1213.   SimplePropertiesLinearReader it(data, len);
  1214.   DictTabInfo::Table tableDesc; tableDesc.init();
  1215.   SimpleProperties::UnpackStatus s;
  1216.   s = SimpleProperties::unpack(it, &tableDesc, 
  1217.        DictTabInfo::TableMapping, 
  1218.        DictTabInfo::TableMappingSize, 
  1219.        true, true);
  1220.   
  1221.   if(s != SimpleProperties::Break){
  1222.     return 703;
  1223.   }
  1224.   const char * internalName = tableDesc.TableName;
  1225.   const char * externalName = Ndb::externalizeTableName(internalName, fullyQualifiedNames);
  1227.   NdbTableImpl * impl = new NdbTableImpl();
  1228.   impl->m_tableId = tableDesc.TableId;
  1229.   impl->m_version = tableDesc.TableVersion;
  1230.   impl->m_status = NdbDictionary::Object::Retrieved;
  1231.   impl->m_internalName.assign(internalName);
  1232.   impl->m_externalName.assign(externalName);
  1234.   impl->m_frm.assign(tableDesc.FrmData, tableDesc.FrmLen);
  1235.   
  1236.   impl->m_fragmentType = (NdbDictionary::Object::FragmentType)
  1237.     getApiConstant(tableDesc.FragmentType, 
  1238.    fragmentTypeMapping, 
  1239.    (Uint32)NdbDictionary::Object::FragUndefined);
  1240.   
  1241.   impl->m_logging = tableDesc.TableLoggedFlag;
  1242.   impl->m_kvalue = tableDesc.TableKValue;
  1243.   impl->m_minLoadFactor = tableDesc.MinLoadFactor;
  1244.   impl->m_maxLoadFactor = tableDesc.MaxLoadFactor;
  1245.   impl->m_fragmentCount = tableDesc.FragmentCount;
  1247.   impl->m_indexType = (NdbDictionary::Index::Type)
  1248.     getApiConstant(tableDesc.TableType,
  1249.    indexTypeMapping,
  1250.    NdbDictionary::Index::Undefined);
  1251.   
  1252.   if(impl->m_indexType == NdbDictionary::Index::Undefined){
  1253.   } else {
  1254.     const char * externalPrimary = 
  1255.       Ndb::externalizeTableName(tableDesc.PrimaryTable, fullyQualifiedNames);
  1256.     impl->m_primaryTable.assign(externalPrimary);
  1257.   }
  1258.   
  1259.   Uint32 keyInfoPos = 0;
  1260.   Uint32 keyCount = 0;
  1261.   Uint32 blobCount = 0;
  1262.   
  1263.   for(Uint32 i = 0; i < tableDesc.NoOfAttributes; i++) {
  1264.     DictTabInfo::Attribute attrDesc; attrDesc.init();
  1265.     s = SimpleProperties::unpack(it, 
  1266.  &attrDesc, 
  1267.  DictTabInfo::AttributeMapping, 
  1268.  DictTabInfo::AttributeMappingSize, 
  1269.  true, true);
  1270.     if(s != SimpleProperties::Break){
  1271.       delete impl;
  1272.       return 703;
  1273.     }
  1274.     
  1275.     NdbColumnImpl * col = new NdbColumnImpl();
  1276.     col->m_attrId = attrDesc.AttributeId;
  1277.     col->setName(attrDesc.AttributeName);
  1278.     col->m_type = (NdbDictionary::Column::Type)
  1279.       getApiConstant(attrDesc.AttributeExtType,
  1280.                      columnTypeMapping,
  1281.                      NdbDictionary::Column::Undefined);
  1282.     if (col->m_type == NdbDictionary::Column::Undefined) {
  1283.       delete impl;
  1284.       return 703;
  1285.     }
  1286.     col->m_extType = attrDesc.AttributeExtType;
  1287.     col->m_precision = (attrDesc.AttributeExtPrecision & 0xFFFF);
  1288.     col->m_scale = attrDesc.AttributeExtScale;
  1289.     col->m_length = attrDesc.AttributeExtLength;
  1290.     // charset in upper half of precision
  1291.     unsigned cs_number = (attrDesc.AttributeExtPrecision >> 16);
  1292.     // charset is defined exactly for char types
  1293.     if (col->getCharType() != (cs_number != 0)) {
  1294.       delete impl;
  1295.       return 703;
  1296.     }
  1297.     if (col->getCharType()) {
  1298.       col->m_cs = get_charset(cs_number, MYF(0));
  1299.       if (col->m_cs == NULL) {
  1300.         delete impl;
  1301.         return 743;
  1302.       }
  1303.     }
  1305.     // translate to old kernel types and sizes
  1306.     if (! attrDesc.translateExtType()) {
  1307.       delete impl;
  1308.       return 703;
  1309.     }
  1310.     col->m_attrType =attrDesc.AttributeType;
  1311.     col->m_attrSize = (1 << attrDesc.AttributeSize) / 8;
  1312.     col->m_arraySize = attrDesc.AttributeArraySize;
  1313.     
  1314.     col->m_pk = attrDesc.AttributeKeyFlag;
  1315.     col->m_tupleKey = 0;
  1316.     col->m_distributionKey = attrDesc.AttributeDKey;
  1317.     col->m_distributionGroup = attrDesc.AttributeDGroup;
  1318.     col->m_distributionGroupBits = 16;
  1319.     col->m_nullable = attrDesc.AttributeNullableFlag;
  1320.     col->m_indexOnly = (attrDesc.AttributeStoredInd ? false : true);
  1321.     col->m_autoIncrement = (attrDesc.AttributeAutoIncrement ? true : false);
  1322.     col->m_autoIncrementInitialValue = ~0;
  1323.     col->m_defaultValue.assign(attrDesc.AttributeDefaultValue);
  1325.     if(attrDesc.AttributeKeyFlag){
  1326.       col->m_keyInfoPos = keyInfoPos + 1;
  1327.       keyInfoPos += ((col->m_attrSize * col->m_arraySize + 3) / 4);
  1328.       keyCount++;
  1329.     } else {
  1330.       col->m_keyInfoPos = 0;
  1331.     }
  1332.     if (col->getBlobType())
  1333.       blobCount++;
  1334.     NdbColumnImpl * null = 0;
  1335.     impl->m_columns.fill(attrDesc.AttributeId, null);
  1336.     if(impl->m_columns[attrDesc.AttributeId] != 0){
  1337.       delete col;
  1338.       delete impl;
  1339.       return 703;
  1340.     }
  1341.     impl->m_columns[attrDesc.AttributeId] = col;
  1342.     it.next();
  1343.   }
  1345.   impl->m_noOfKeys = keyCount;
  1346.   impl->m_keyLenInWords = keyInfoPos;
  1347.   impl->m_sizeOfKeysInWords = keyInfoPos;
  1348.   impl->m_noOfBlobs = blobCount;
  1349.   * ret = impl;
  1350.   return 0;
  1351. }
  1353. /*****************************************************************
  1354.  * Create table and alter table
  1355.  */
  1356. int
  1357. NdbDictionaryImpl::createTable(NdbTableImpl &t)
  1358. { 
  1359.   if (m_receiver.createTable(m_ndb, t) != 0)
  1360.     return -1;
  1361.   if (t.m_noOfBlobs == 0)
  1362.     return 0;
  1363.   // update table def from DICT
  1364.   Ndb_local_table_info *info=
  1365.     get_local_table_info(t.m_internalName.c_str(),false);
  1366.   if (info == NULL) {
  1367.     m_error.code = 709;
  1368.     return -1;
  1369.   }
  1370.   if (createBlobTables(*(info->m_table_impl)) != 0) {
  1371.     int save_code = m_error.code;
  1372.     (void)dropTable(t);
  1373.     m_error.code = save_code;
  1374.     return -1;
  1375.   }
  1376.   return 0;
  1377. }
  1379. int
  1380. NdbDictionaryImpl::createBlobTables(NdbTableImpl &t)
  1381. {
  1382.   for (unsigned i = 0; i < t.m_columns.size(); i++) {
  1383.     NdbColumnImpl & c = *t.m_columns[i];
  1384.     if (! c.getBlobType() || c.getPartSize() == 0)
  1385.       continue;
  1386.     NdbTableImpl bt;
  1387.     NdbBlob::getBlobTable(bt, &t, &c);
  1388.     if (createTable(bt) != 0)
  1389.       return -1;
  1390.     // Save BLOB table handle
  1391.     Ndb_local_table_info *info=
  1392.       get_local_table_info(bt.m_internalName.c_str(),false);
  1393.     if (info == 0) {
  1394.       return -1;
  1395.     }
  1396.     c.m_blobTable = info->m_table_impl;
  1397.   }
  1398.   
  1399.   return 0;
  1400. }
  1402. int
  1403. NdbDictionaryImpl::addBlobTables(NdbTableImpl &t)
  1404. {
  1405.   unsigned n= t.m_noOfBlobs;
  1406.   // optimized for blob column being the last one
  1407.   // and not looking for more than one if not neccessary
  1408.   for (unsigned i = t.m_columns.size(); i > 0 && n > 0;) {
  1409.     i--;
  1410.     NdbColumnImpl & c = *t.m_columns[i];
  1411.     if (! c.getBlobType() || c.getPartSize() == 0)
  1412.       continue;
  1413.     n--;
  1414.     char btname[NdbBlobImpl::BlobTableNameSize];
  1415.     NdbBlob::getBlobTableName(btname, &t, &c);
  1416.     // Save BLOB table handle
  1417.     NdbTableImpl * cachedBlobTable = getTable(btname);
  1418.     if (cachedBlobTable == 0) {
  1419.       return -1;
  1420.     }
  1421.     c.m_blobTable = cachedBlobTable;
  1422.   }
  1423.   
  1424.   return 0;
  1425. }
  1427. int 
  1428. NdbDictInterface::createTable(Ndb & ndb,
  1429.       NdbTableImpl & impl)
  1430. {
  1431.   return createOrAlterTable(ndb, impl, false);
  1432. }
  1434. int NdbDictionaryImpl::alterTable(NdbTableImpl &impl)
  1435. {
  1436.   BaseString internalName = impl.m_internalName;
  1437.   const char * originalInternalName = internalName.c_str();
  1438.   BaseString externalName = impl.m_externalName;
  1439.   const char * originalExternalName = externalName.c_str();
  1441.   DBUG_ENTER("NdbDictionaryImpl::alterTable");
  1442.   Ndb_local_table_info * local = 0;
  1443.   if((local= get_local_table_info(originalInternalName, false)) == 0)
  1444.   {
  1445.     m_error.code = 709;
  1446.     DBUG_RETURN(-1);
  1447.   }
  1449.   // Alter the table
  1450.   int ret = m_receiver.alterTable(m_ndb, impl);
  1451.   if(ret == 0){
  1452.     // Remove cached information and let it be refreshed at next access
  1453.     m_globalHash->lock();
  1454.     local->m_table_impl->m_status = NdbDictionary::Object::Invalid;
  1455.     m_globalHash->drop(local->m_table_impl);
  1456.     m_globalHash->unlock();
  1457.     m_localHash.drop(originalInternalName);
  1458.   }
  1459.   DBUG_RETURN(ret);
  1460. }
  1462. int 
  1463. NdbDictInterface::alterTable(Ndb & ndb,
  1464.       NdbTableImpl & impl)
  1465. {
  1466.   return createOrAlterTable(ndb, impl, true);
  1467. }
  1469. int 
  1470. NdbDictInterface::createOrAlterTable(Ndb & ndb,
  1471.      NdbTableImpl & impl,
  1472.      bool alter)
  1473. {
  1474.   DBUG_ENTER("NdbDictInterface::createOrAlterTable");
  1475.   unsigned i;
  1476.   if((unsigned)impl.getNoOfPrimaryKeys() > NDB_MAX_NO_OF_ATTRIBUTES_IN_KEY){
  1477.     m_error.code = 4317;
  1478.     DBUG_RETURN(-1);
  1479.   }
  1480.   unsigned sz = impl.m_columns.size();
  1481.   if (sz > NDB_MAX_ATTRIBUTES_IN_TABLE){
  1482.     m_error.code = 4318;
  1483.     DBUG_RETURN(-1);
  1484.   }
  1486.   impl.copyNewProperties();
  1487.   //validate();
  1488.   //aggregate();
  1490.   const char * internalName = 
  1491.     ndb.internalizeTableName(impl.m_externalName.c_str());
  1492.   impl.m_internalName.assign(internalName);
  1493.   UtilBufferWriter w(m_buffer);
  1494.   DictTabInfo::Table tmpTab; tmpTab.init();
  1495.   BaseString::snprintf(tmpTab.TableName, 
  1496.    sizeof(tmpTab.TableName), 
  1497.    internalName);
  1499.   bool haveAutoIncrement = false;
  1500.   Uint64 autoIncrementValue = 0;
  1501.   for(i = 0; i<sz; i++){
  1502.     const NdbColumnImpl * col = impl.m_columns[i];
  1503.     if(col == 0)
  1504.       continue;
  1505.     if (col->m_autoIncrement) {
  1506.       if (haveAutoIncrement) {
  1507.         m_error.code = 4335;
  1508.         DBUG_RETURN(-1);
  1509.       }
  1510.       haveAutoIncrement = true;
  1511.       autoIncrementValue = col->m_autoIncrementInitialValue;
  1512.      }
  1513.   }
  1515.   // Check max length of frm data
  1516.   if (impl.m_frm.length() > MAX_FRM_DATA_SIZE){
  1517.     m_error.code = 1229;
  1518.     DBUG_RETURN(-1);
  1519.   }
  1520.   tmpTab.FrmLen = impl.m_frm.length();
  1521.   memcpy(tmpTab.FrmData, impl.m_frm.get_data(), impl.m_frm.length());
  1523.   tmpTab.TableLoggedFlag = impl.m_logging;
  1524.   tmpTab.TableKValue = impl.m_kvalue;
  1525.   tmpTab.MinLoadFactor = impl.m_minLoadFactor;
  1526.   tmpTab.MaxLoadFactor = impl.m_maxLoadFactor;
  1527.   tmpTab.TableType = DictTabInfo::UserTable;
  1528.   tmpTab.NoOfAttributes = sz;
  1529.   
  1530.   tmpTab.FragmentType = getKernelConstant(impl.m_fragmentType,
  1531.   fragmentTypeMapping,
  1532.   DictTabInfo::AllNodesSmallTable);
  1533.   tmpTab.TableVersion = rand();
  1535.   SimpleProperties::UnpackStatus s;
  1536.   s = SimpleProperties::pack(w, 
  1537.      &tmpTab,
  1538.      DictTabInfo::TableMapping, 
  1539.      DictTabInfo::TableMappingSize, true);
  1540.   
  1541.   if(s != SimpleProperties::Eof){
  1542.     abort();
  1543.   }
  1544.   
  1545.   for(i = 0; i<sz; i++){
  1546.     const NdbColumnImpl * col = impl.m_columns[i];
  1547.     if(col == 0)
  1548.       continue;
  1549.     
  1550.     DictTabInfo::Attribute tmpAttr; tmpAttr.init();
  1551.     BaseString::snprintf(tmpAttr.AttributeName, sizeof(tmpAttr.AttributeName), 
  1552.      col->m_name.c_str());
  1553.     tmpAttr.AttributeId = i;
  1554.     tmpAttr.AttributeKeyFlag = col->m_pk || col->m_tupleKey;
  1555.     tmpAttr.AttributeNullableFlag = col->m_nullable;
  1556.     tmpAttr.AttributeStoredInd = (col->m_indexOnly ? 0 : 1);
  1557.     tmpAttr.AttributeDKey = col->m_distributionKey;
  1558.     tmpAttr.AttributeDGroup = col->m_distributionGroup;
  1560.     tmpAttr.AttributeExtType =
  1561.       getKernelConstant(col->m_type,
  1562.                         columnTypeMapping,
  1563.                         DictTabInfo::ExtUndefined);
  1564.     tmpAttr.AttributeExtPrecision = ((unsigned)col->m_precision & 0xFFFF);
  1565.     tmpAttr.AttributeExtScale = col->m_scale;
  1566.     tmpAttr.AttributeExtLength = col->m_length;
  1567.     // charset is defined exactly for char types
  1568.     if (col->getCharType() != (col->m_cs != NULL)) {
  1569.       m_error.code = 703;
  1570.       DBUG_RETURN(-1);
  1571.     }
  1572.     // primary key type check
  1573.     if (col->m_pk && ! NdbSqlUtil::usable_in_pk(col->m_type, col->m_cs)) {
  1574.       m_error.code = 743;
  1575.       DBUG_RETURN(-1);
  1576.     }
  1577.     // charset in upper half of precision
  1578.     if (col->getCharType()) {
  1579.       tmpAttr.AttributeExtPrecision |= (col->m_cs->number << 16);
  1580.     }
  1582.     // DICT will ignore and recompute this
  1583.     (void)tmpAttr.translateExtType();
  1585.     tmpAttr.AttributeAutoIncrement = col->m_autoIncrement;
  1586.     BaseString::snprintf(tmpAttr.AttributeDefaultValue, 
  1587.      sizeof(tmpAttr.AttributeDefaultValue),
  1588.      col->m_defaultValue.c_str());
  1589.     s = SimpleProperties::pack(w, 
  1590.        &tmpAttr,
  1591.        DictTabInfo::AttributeMapping, 
  1592.        DictTabInfo::AttributeMappingSize, true);
  1593.     w.add(DictTabInfo::AttributeEnd, 1);
  1594.   }
  1596.   NdbApiSignal tSignal(m_reference);
  1597.   tSignal.theReceiversBlockNumber = DBDICT;
  1598.   
  1599.   LinearSectionPtr ptr[3];
  1600.   ptr[0].p = (Uint32*)m_buffer.get_data();
  1601.   ptr[0].sz = m_buffer.length() / 4;
  1602.   int ret;
  1603.   if (alter)
  1604.   {
  1605.     AlterTableReq * const req = 
  1606.       CAST_PTR(AlterTableReq, tSignal.getDataPtrSend());
  1607.     
  1608.     req->senderRef = m_reference;
  1609.     req->senderData = 0;
  1610.     req->changeMask = impl.m_changeMask;
  1611.     req->tableId = impl.m_tableId;
  1612.     req->tableVersion = impl.m_version;;
  1613.     tSignal.theVerId_signalNumber   = GSN_ALTER_TABLE_REQ;
  1614.     tSignal.theLength = AlterTableReq::SignalLength;
  1615.     ret= alterTable(&tSignal, ptr);
  1616.   }
  1617.   else
  1618.   {
  1619.     CreateTableReq * const req = 
  1620.       CAST_PTR(CreateTableReq, tSignal.getDataPtrSend());
  1621.     
  1622.     req->senderRef = m_reference;
  1623.     req->senderData = 0;
  1624.     tSignal.theVerId_signalNumber   = GSN_CREATE_TABLE_REQ;
  1625.     tSignal.theLength = CreateTableReq::SignalLength;
  1626.     ret= createTable(&tSignal, ptr);
  1628.     if (ret)
  1629.       DBUG_RETURN(ret);
  1631.     if (haveAutoIncrement) {
  1632.       if (!ndb.setAutoIncrementValue(impl.m_externalName.c_str(),
  1633.      autoIncrementValue)) {
  1634. if (ndb.theError.code == 0) {
  1635.   m_error.code = 4336;
  1636.   ndb.theError = m_error;
  1637. } else
  1638.   m_error= ndb.theError;
  1639. ret = -1; // errorcode set in initialize_autoincrement
  1640.       }
  1641.     }
  1642.   }
  1643.   DBUG_RETURN(ret);
  1644. }
  1646. int
  1647. NdbDictInterface::createTable(NdbApiSignal* signal, LinearSectionPtr ptr[3])
  1648. {
  1649. #if DEBUG_PRINT
  1650.   ndbout_c("BufferLen = %d", ptr[0].sz);
  1651.   SimplePropertiesLinearReader r(ptr[0].p, ptr[0].sz);
  1652.   r.printAll(ndbout);
  1653. #endif
  1654.   const int noErrCodes = 2;
  1655.   int errCodes[noErrCodes] = 
  1656.      {CreateTableRef::Busy,
  1657.       CreateTableRef::NotMaster};
  1658.   return dictSignal(signal,ptr,1,
  1659.     1/*use masternode id*/,
  1660.     100,
  1661.     WAIT_CREATE_INDX_REQ,
  1662.     WAITFOR_RESPONSE_TIMEOUT,
  1663.     errCodes,noErrCodes);
  1664. }
  1667. void
  1668. NdbDictInterface::execCREATE_TABLE_CONF(NdbApiSignal * signal,
  1669. LinearSectionPtr ptr[3])
  1670. {
  1671.   const CreateTableConf* const conf=
  1672.     CAST_CONSTPTR(CreateTableConf, signal->getDataPtr());
  1673.   Uint32 tableId= conf->tableId;
  1674.   Uint32 tableVersion= conf->tableVersion;
  1675.   
  1676.   m_waiter.signal(NO_WAIT);  
  1677. }
  1679. void
  1680. NdbDictInterface::execCREATE_TABLE_REF(NdbApiSignal * signal,
  1681.        LinearSectionPtr ptr[3])
  1682. {
  1683.   const CreateTableRef* const ref=
  1684.     CAST_CONSTPTR(CreateTableRef, signal->getDataPtr());
  1685.   m_error.code = ref->errorCode;
  1686.   m_masterNodeId = ref->masterNodeId;
  1687.   m_waiter.signal(NO_WAIT);  
  1688. }
  1690. int
  1691. NdbDictInterface::alterTable(NdbApiSignal* signal, LinearSectionPtr ptr[3])
  1692. {
  1693. #if DEBUG_PRINT
  1694.   ndbout_c("BufferLen = %d", ptr[0].sz);
  1695.   SimplePropertiesLinearReader r(ptr[0].p, ptr[0].sz);
  1696.   r.printAll(ndbout);
  1697. #endif
  1698.   const int noErrCodes = 2;
  1699.   int errCodes[noErrCodes] =
  1700.     {AlterTableRef::NotMaster,
  1701.      AlterTableRef::Busy};
  1702.   int r = dictSignal(signal,ptr,1,
  1703.      1/*use masternode id*/,
  1704.      100,WAIT_ALTER_TAB_REQ,
  1705.      WAITFOR_RESPONSE_TIMEOUT,
  1706.      errCodes, noErrCodes);
  1707.   if(m_error.code == AlterTableRef::InvalidTableVersion) {
  1708.     // Clear caches and try again
  1709.     return INCOMPATIBLE_VERSION;
  1710.   }
  1712.   return r;
  1713. }
  1715. void
  1716. NdbDictInterface::execALTER_TABLE_CONF(NdbApiSignal * signal,
  1717.                                        LinearSectionPtr ptr[3])
  1718. {
  1719.   //AlterTableConf* const conf = CAST_CONSTPTR(AlterTableConf, signal->getDataPtr());
  1720.   m_waiter.signal(NO_WAIT);
  1721. }
  1723. void
  1724. NdbDictInterface::execALTER_TABLE_REF(NdbApiSignal * signal,
  1725.       LinearSectionPtr ptr[3])
  1726. {
  1727.   const AlterTableRef * const ref = 
  1728.     CAST_CONSTPTR(AlterTableRef, signal->getDataPtr());
  1729.   m_error.code = ref->errorCode;
  1730.   m_masterNodeId = ref->masterNodeId;
  1731.   m_waiter.signal(NO_WAIT);
  1732. }
  1734. /*****************************************************************
  1735.  * Drop table
  1736.  */
  1737. int
  1738. NdbDictionaryImpl::dropTable(const char * name)
  1739. {
  1740.   DBUG_ENTER("NdbDictionaryImpl::dropTable");
  1741.   DBUG_PRINT("enter",("name: %s", name));
  1742.   NdbTableImpl * tab = getTable(name);
  1743.   if(tab == 0){
  1744.     return -1;
  1745.   }
  1746.   int ret = dropTable(* tab);
  1747.   // If table stored in cache is incompatible with the one in the kernel
  1748.   // we must clear the cache and try again
  1749.   if (ret == INCOMPATIBLE_VERSION) {
  1750.     const char * internalTableName = m_ndb.internalizeTableName(name);
  1752.     DBUG_PRINT("info",("INCOMPATIBLE_VERSION internal_name: %s", internalTableName));
  1753.     m_localHash.drop(internalTableName);
  1754.     m_globalHash->lock();
  1755.     tab->m_status = NdbDictionary::Object::Invalid;
  1756.     m_globalHash->drop(tab);
  1757.     m_globalHash->unlock();   
  1758.     DBUG_RETURN(dropTable(name));
  1759.   }
  1761.   DBUG_RETURN(ret);
  1762. }
  1764. int
  1765. NdbDictionaryImpl::dropTable(NdbTableImpl & impl)
  1766. {
  1767.   int res;
  1768.   const char * name = impl.getName();
  1769.   if(impl.m_status == NdbDictionary::Object::New){
  1770.     return dropTable(name);
  1771.   }
  1773.   if (impl.m_indexType != NdbDictionary::Index::Undefined) {
  1774.     m_receiver.m_error.code = 1228;
  1775.     return -1;
  1776.   }
  1778.   List list;
  1779.   if ((res = listIndexes(list, impl.m_tableId)) == -1){
  1780.     return -1;
  1781.   }
  1782.   for (unsigned i = 0; i < list.count; i++) {
  1783.     const List::Element& element = list.elements[i];
  1784.     if ((res = dropIndex(element.name, name)) == -1)
  1785.     {
  1786.       return -1;
  1787.     }
  1788.   }
  1789.   
  1790.   if (impl.m_noOfBlobs != 0) {
  1791.     if (dropBlobTables(impl) != 0){
  1792.       return -1;
  1793.     }
  1794.   }
  1795.   
  1796.   int ret = m_receiver.dropTable(impl);  
  1797.   if(ret == 0 || m_error.code == 709){
  1798.     const char * internalTableName = impl.m_internalName.c_str();
  1800.     
  1801.     m_localHash.drop(internalTableName);
  1802.     m_globalHash->lock();
  1803.     impl.m_status = NdbDictionary::Object::Invalid;
  1804.     m_globalHash->drop(&impl);
  1805.     m_globalHash->unlock();
  1807.     return 0;
  1808.   }
  1809.   
  1810.   return ret;
  1811. }
  1813. int
  1814. NdbDictionaryImpl::dropBlobTables(NdbTableImpl & t)
  1815. {
  1816.   DBUG_ENTER("NdbDictionaryImpl::dropBlobTables");
  1817.   for (unsigned i = 0; i < t.m_columns.size(); i++) {
  1818.     NdbColumnImpl & c = *t.m_columns[i];
  1819.     if (! c.getBlobType() || c.getPartSize() == 0)
  1820.       continue;
  1821.     char btname[NdbBlobImpl::BlobTableNameSize];
  1822.     NdbBlob::getBlobTableName(btname, &t, &c);
  1823.     if (dropTable(btname) != 0) {
  1824.       if (m_error.code != 709){
  1825. DBUG_PRINT("exit",("error %u - exiting",m_error.code));
  1826.         DBUG_RETURN(-1);
  1827.       }
  1828.       DBUG_PRINT("info",("error %u - continuing",m_error.code));
  1829.     }
  1830.   }
  1831.   DBUG_RETURN(0);
  1832. }
  1834. int
  1835. NdbDictInterface::dropTable(const NdbTableImpl & impl)
  1836. {
  1837.   NdbApiSignal tSignal(m_reference);
  1838.   tSignal.theReceiversBlockNumber = DBDICT;
  1839.   tSignal.theVerId_signalNumber   = GSN_DROP_TABLE_REQ;
  1840.   tSignal.theLength = DropTableReq::SignalLength;
  1841.   
  1842.   DropTableReq * const req = CAST_PTR(DropTableReq, tSignal.getDataPtrSend());
  1843.   req->senderRef = m_reference;
  1844.   req->senderData = 0;
  1845.   req->tableId = impl.m_tableId;
  1846.   req->tableVersion = impl.m_version;
  1848.   return dropTable(&tSignal, 0);
  1849. }
  1851. int
  1852. NdbDictInterface::dropTable(NdbApiSignal* signal, LinearSectionPtr ptr[3])
  1853. {
  1854.   const int noErrCodes = 3;
  1855.   int errCodes[noErrCodes] =
  1856.          {DropTableRef::NoDropTableRecordAvailable,
  1857.           DropTableRef::NotMaster,
  1858.           DropTableRef::Busy};
  1859.   int r = dictSignal(signal,NULL,0,
  1860.      1/*use masternode id*/,
  1861.      100,WAIT_DROP_TAB_REQ,
  1862.      WAITFOR_RESPONSE_TIMEOUT,
  1863.      errCodes, noErrCodes);
  1864.   if(m_error.code == DropTableRef::InvalidTableVersion) {
  1865.     // Clear caches and try again
  1866.     return INCOMPATIBLE_VERSION;
  1867.   }
  1868.   return r;
  1869. }
  1871. void
  1872. NdbDictInterface::execDROP_TABLE_CONF(NdbApiSignal * signal,
  1873.        LinearSectionPtr ptr[3])
  1874. {
  1875.   //DropTableConf* const conf = CAST_CONSTPTR(DropTableConf, signal->getDataPtr());
  1877.   m_waiter.signal(NO_WAIT);  
  1878. }
  1880. void
  1881. NdbDictInterface::execDROP_TABLE_REF(NdbApiSignal * signal,
  1882.       LinearSectionPtr ptr[3])
  1883. {
  1884.   const DropTableRef* const ref = CAST_CONSTPTR(DropTableRef, signal->getDataPtr());
  1885.   m_error.code = ref->errorCode;
  1886.   m_masterNodeId = ref->masterNodeId;
  1887.   m_waiter.signal(NO_WAIT);  
  1888. }
  1890. int
  1891. NdbDictionaryImpl::invalidateObject(NdbTableImpl & impl)
  1892. {
  1893.   const char * internalTableName = impl.m_internalName.c_str();
  1895.   m_localHash.drop(internalTableName);  
  1896.   m_globalHash->lock();
  1897.   impl.m_status = NdbDictionary::Object::Invalid;
  1898.   m_globalHash->drop(&impl);
  1899.   m_globalHash->unlock();
  1900.   return 0;
  1901. }
  1903. int
  1904. NdbDictionaryImpl::removeCachedObject(NdbTableImpl & impl)
  1905. {
  1906.   const char * internalTableName = impl.m_internalName.c_str();
  1908.   m_localHash.drop(internalTableName);  
  1909.   m_globalHash->lock();
  1910.   m_globalHash->release(&impl);
  1911.   m_globalHash->unlock();
  1912.   return 0;
  1913. }
  1915. /*****************************************************************
  1916.  * Get index info
  1917.  */
  1918. NdbIndexImpl*
  1919. NdbDictionaryImpl::getIndexImpl(const char * externalName, 
  1920. const char * internalName)
  1921. {
  1922.   Ndb_local_table_info * info = get_local_table_info(internalName,
  1923.      false);
  1924.   if(info == 0){
  1925.     m_error.code = 4243;
  1926.     return 0;
  1927.   }
  1928.   NdbTableImpl * tab = info->m_table_impl;
  1930.   if(tab->m_indexType == NdbDictionary::Index::Undefined){
  1931.     // Not an index
  1932.     m_error.code = 4243;
  1933.     return 0;
  1934.   }
  1936.   NdbTableImpl* prim = getTable(tab->m_primaryTable.c_str());
  1937.   if(prim == 0){
  1938.     m_error.code = 4243;
  1939.     return 0;
  1940.   }
  1941.   
  1942.   /**
  1943.    * Create index impl
  1944.    */
  1945.   NdbIndexImpl* idx;
  1946.   if(NdbDictInterface::create_index_obj_from_table(&idx, tab, prim) == 0){
  1947.     idx->m_table = tab;
  1948.     idx->m_externalName.assign(externalName);
  1949.     idx->m_internalName.assign(internalName);
  1950.     // TODO Assign idx to tab->m_index
  1951.     // Don't do it right now since assign can't asign a table with index
  1952.     // tab->m_index = idx;
  1953.     return idx;
  1954.   }
  1955.   return 0;
  1956. }
  1958. int
  1959. NdbDictInterface::create_index_obj_from_table(NdbIndexImpl** dst,
  1960.       const NdbTableImpl* tab,
  1961.       const NdbTableImpl* prim){
  1962.   NdbIndexImpl *idx = new NdbIndexImpl();
  1963.   idx->m_version = tab->m_version;
  1964.   idx->m_status = tab->m_status;
  1965.   idx->m_indexId = tab->m_tableId;
  1966.   idx->m_externalName.assign(tab->getName());
  1967.   idx->m_tableName.assign(prim->m_externalName);
  1968.   idx->m_type = tab->m_indexType;
  1969.   idx->m_logging = tab->m_logging;
  1970.   // skip last attribute (NDB$PK or NDB$TNODE)
  1971.   for(unsigned i = 0; i+1<tab->m_columns.size(); i++){
  1972.     NdbColumnImpl* col = new NdbColumnImpl;
  1973.     // Copy column definition
  1974.     *col = *tab->m_columns[i];
  1975.     idx->m_columns.push_back(col);
  1976.     /**
  1977.      * reverse map
  1978.      */
  1979.     int key_id = prim->getColumn(col->getName())->getColumnNo();
  1980.     int fill = -1;
  1981.     idx->m_key_ids.fill(key_id, fill);
  1982.     idx->m_key_ids[key_id] = i;
  1983.     col->m_keyInfoPos = key_id;
  1984.   }
  1986.   * dst = idx;
  1987.   return 0;
  1988. }
  1990. /*****************************************************************
  1991.  * Create index
  1992.  */
  1993. int
  1994. NdbDictionaryImpl::createIndex(NdbIndexImpl &ix)
  1995. {
  1996.   NdbTableImpl* tab = getTable(ix.getTable());
  1997.   if(tab == 0){
  1998.     m_error.code = 4249;
  1999.     return -1;
  2000.   }
  2001.   
  2002.   return m_receiver.createIndex(m_ndb, ix, * tab);
  2003. }
  2005. int 
  2006. NdbDictInterface::createIndex(Ndb & ndb,
  2007.       NdbIndexImpl & impl, 
  2008.       const NdbTableImpl & table)
  2009. {
  2010.   //validate();
  2011.   //aggregate();
  2012.   unsigned i;
  2013.   UtilBufferWriter w(m_buffer);
  2014.   const size_t len = strlen(impl.m_externalName.c_str()) + 1;
  2015.   if(len > MAX_TAB_NAME_SIZE) {
  2016.     m_error.code = 4241;
  2017.     return -1;
  2018.   }
  2019.   const char * internalName = 
  2020.     ndb.internalizeIndexName(&table, impl.getName());
  2021.   
  2022.   impl.m_internalName.assign(internalName);
  2024.   w.add(DictTabInfo::TableName, internalName);
  2025.   w.add(DictTabInfo::TableLoggedFlag, impl.m_logging);
  2027.   NdbApiSignal tSignal(m_reference);
  2028.   tSignal.theReceiversBlockNumber = DBDICT;
  2029.   tSignal.theVerId_signalNumber   = GSN_CREATE_INDX_REQ;
  2030.   tSignal.theLength = CreateIndxReq::SignalLength;
  2031.   
  2032.   CreateIndxReq * const req = CAST_PTR(CreateIndxReq, tSignal.getDataPtrSend());
  2033.   
  2034.   req->setUserRef(m_reference);
  2035.   req->setConnectionPtr(0);
  2036.   req->setRequestType(CreateIndxReq::RT_USER);
  2037.   
  2038.   Uint32 it = getKernelConstant(impl.m_type,
  2039. indexTypeMapping,
  2040. DictTabInfo::UndefTableType);
  2041.   
  2042.   if(it == DictTabInfo::UndefTableType){
  2043.     m_error.code = 4250;
  2044.     return -1;
  2045.   }
  2046.   req->setIndexType((DictTabInfo::TableType) it);
  2047.   
  2048.   req->setTableId(table.m_tableId);
  2049.   req->setOnline(true);
  2050.   AttributeList attributeList;
  2051.   attributeList.sz = impl.m_columns.size();
  2052.   for(i = 0; i<attributeList.sz; i++){
  2053.     const NdbColumnImpl* col = 
  2054.       table.getColumn(impl.m_columns[i]->m_name.c_str());
  2055.     if(col == 0){
  2056.       m_error.code = 4247;
  2057.       return -1;
  2058.     }
  2059.     // Copy column definition
  2060.     *impl.m_columns[i] = *col;
  2062.     if(col->m_pk && col->m_indexOnly){
  2063.       m_error.code = 4245;
  2064.       return -1;
  2065.     }
  2066.     // index key type check
  2067.     if (it == DictTabInfo::UniqueHashIndex &&
  2068.         ! NdbSqlUtil::usable_in_hash_index(col->m_type, col->m_cs) ||
  2069.         it == DictTabInfo::OrderedIndex &&
  2070.         ! NdbSqlUtil::usable_in_ordered_index(col->m_type, col->m_cs)) {
  2071.       m_error.code = 743;
  2072.       return -1;
  2073.     }
  2074.     attributeList.id[i] = col->m_attrId;
  2075.   }
  2076.   if (it == DictTabInfo::UniqueHashIndex) {
  2077.     // Sort index attributes according to primary table (using insertion sort)
  2078.     for(i = 1; i < attributeList.sz; i++) {
  2079.       unsigned int temp = attributeList.id[i];
  2080.       unsigned int j = i;
  2081.       while((j > 0) && (attributeList.id[j - 1] > temp)) {
  2082. attributeList.id[j] = attributeList.id[j - 1];
  2083. j--;
  2084.       }
  2085.       attributeList.id[j] = temp;
  2086.     }
  2087.     // Check for illegal duplicate attributes
  2088.     for(i = 0; i<attributeList.sz; i++) {
  2089.       if ((i != (attributeList.sz - 1)) && 
  2090.   (attributeList.id[i] == attributeList.id[i+1])) {
  2091. m_error.code = 4258;
  2092. return -1;
  2093.       }
  2094.     }
  2095.   }
  2096.   LinearSectionPtr ptr[3];
  2097.   ptr[0].p = (Uint32*)&attributeList;
  2098.   ptr[0].sz = 1 + attributeList.sz;
  2099.   ptr[1].p = (Uint32*)m_buffer.get_data();
  2100.   ptr[1].sz = m_buffer.length() >> 2;                //BUG?
  2101.   return createIndex(&tSignal, ptr);
  2102. }
  2104. int
  2105. NdbDictInterface::createIndex(NdbApiSignal* signal, 
  2106.       LinearSectionPtr ptr[3])
  2107. {
  2108.   const int noErrCodes = 2;
  2109.   int errCodes[noErrCodes] = {CreateIndxRef::Busy, CreateIndxRef::NotMaster};
  2110.   return dictSignal(signal,ptr,2,
  2111.     1 /*use masternode id*/,
  2112.     100,
  2113.     WAIT_CREATE_INDX_REQ,
  2114.     -1,
  2115.     errCodes,noErrCodes);
  2116. }
  2118. void
  2119. NdbDictInterface::execCREATE_INDX_CONF(NdbApiSignal * signal,
  2120.        LinearSectionPtr ptr[3])
  2121. {
  2122.   //CreateTableConf* const conf = CAST_CONSTPTR(CreateTableConf, signal->getDataPtr());
  2123.   
  2124.   m_waiter.signal(NO_WAIT);  
  2125. }
  2127. void
  2128. NdbDictInterface::execCREATE_INDX_REF(NdbApiSignal * signal,
  2129.       LinearSectionPtr ptr[3])
  2130. {
  2131.   const CreateIndxRef* const ref = CAST_CONSTPTR(CreateIndxRef, signal->getDataPtr());
  2132.   m_error.code = ref->getErrorCode();
  2133.   if(m_error.code == ref->NotMaster)
  2134.     m_masterNodeId= ref->masterNodeId;
  2135.   m_waiter.signal(NO_WAIT);  
  2136. }
  2138. /*****************************************************************
  2139.  * Drop index
  2140.  */
  2141. int
  2142. NdbDictionaryImpl::dropIndex(const char * indexName, 
  2143.      const char * tableName)
  2144. {
  2145.   NdbIndexImpl * idx = getIndex(indexName, tableName);
  2146.   if (idx == 0) {
  2147.     m_error.code = 4243;
  2148.     return -1;
  2149.   }
  2150.   int ret = dropIndex(*idx, tableName);
  2151.   // If index stored in cache is incompatible with the one in the kernel
  2152.   // we must clear the cache and try again
  2153.   if (ret == INCOMPATIBLE_VERSION) {
  2154.     const char * internalIndexName = (tableName)
  2155.       ?
  2156.       m_ndb.internalizeIndexName(getTable(tableName), indexName)
  2157.       :
  2158.       m_ndb.internalizeTableName(indexName); // Index is also a table
  2159.     
  2160.     m_localHash.drop(internalIndexName);
  2161.     m_globalHash->lock();
  2162.     idx->m_table->m_status = NdbDictionary::Object::Invalid;
  2163.     m_globalHash->drop(idx->m_table);
  2164.     m_globalHash->unlock();   
  2165.     return dropIndex(indexName, tableName);
  2166.   }
  2167.   
  2168.   return ret;
  2169. }
  2171. int
  2172. NdbDictionaryImpl::dropIndex(NdbIndexImpl & impl, const char * tableName)
  2173. {
  2174.   const char * indexName = impl.getName();
  2175.   if (tableName || m_ndb.usingFullyQualifiedNames()) {
  2176.     NdbTableImpl * timpl = impl.m_table;
  2177.     
  2178.     if (timpl == 0) {
  2179.       m_error.code = 709;
  2180.       return -1;
  2181.     }
  2183.     const char * internalIndexName = (tableName)
  2184.       ?
  2185.       m_ndb.internalizeIndexName(getTable(tableName), indexName)
  2186.       :
  2187.       m_ndb.internalizeTableName(indexName); // Index is also a table
  2189.     if(impl.m_status == NdbDictionary::Object::New){
  2190.       return dropIndex(indexName, tableName);
  2191.     }
  2192.     
  2193.     int ret = m_receiver.dropIndex(impl, *timpl);
  2194.     if(ret == 0){
  2195.       m_localHash.drop(internalIndexName);
  2196.       m_globalHash->lock();
  2197.       impl.m_table->m_status = NdbDictionary::Object::Invalid;
  2198.       m_globalHash->drop(impl.m_table);
  2199.       m_globalHash->unlock();
  2200.     }
  2201.     return ret;
  2202.   }
  2204.   m_error.code = 4243;
  2205.   return -1;
  2206. }
  2208. int
  2209. NdbDictInterface::dropIndex(const NdbIndexImpl & impl, 
  2210.     const NdbTableImpl & timpl)
  2211. {
  2212.   NdbApiSignal tSignal(m_reference);
  2213.   tSignal.theReceiversBlockNumber = DBDICT;
  2214.   tSignal.theVerId_signalNumber   = GSN_DROP_INDX_REQ;
  2215.   tSignal.theLength = DropIndxReq::SignalLength;
  2217.   DropIndxReq * const req = CAST_PTR(DropIndxReq, tSignal.getDataPtrSend());
  2218.   req->setUserRef(m_reference);
  2219.   req->setConnectionPtr(0);
  2220.   req->setRequestType(DropIndxReq::RT_USER);
  2221.   req->setTableId(~0);  // DICT overwrites
  2222.   req->setIndexId(timpl.m_tableId);
  2223.   req->setIndexVersion(timpl.m_version);
  2225.   return dropIndex(&tSignal, 0);
  2226. }
  2228. int
  2229. NdbDictInterface::dropIndex(NdbApiSignal* signal, LinearSectionPtr ptr[3])
  2230. {
  2231.   const int noErrCodes = 2;
  2232.   int errCodes[noErrCodes] = {DropIndxRef::Busy, DropIndxRef::NotMaster};
  2233.   int r = dictSignal(signal,NULL,0,
  2234.      1/*Use masternode id*/,
  2235.      100,
  2236.      WAIT_DROP_INDX_REQ,
  2237.      WAITFOR_RESPONSE_TIMEOUT,
  2238.      errCodes,noErrCodes);
  2239.   if(m_error.code == DropIndxRef::InvalidIndexVersion) {
  2240.     // Clear caches and try again
  2241.     return INCOMPATIBLE_VERSION;
  2242.   }
  2243.   return r;
  2244. }
  2246. void
  2247. NdbDictInterface::execDROP_INDX_CONF(NdbApiSignal * signal,
  2248.        LinearSectionPtr ptr[3])
  2249. {
  2250.   m_waiter.signal(NO_WAIT);  
  2251. }
  2253. void
  2254. NdbDictInterface::execDROP_INDX_REF(NdbApiSignal * signal,
  2255.       LinearSectionPtr ptr[3])
  2256. {
  2257.   const DropIndxRef* const ref = CAST_CONSTPTR(DropIndxRef, signal->getDataPtr());
  2258.   m_error.code = ref->getErrorCode();
  2259.   if(m_error.code == ref->NotMaster)
  2260.     m_masterNodeId= ref->masterNodeId;
  2261.   m_waiter.signal(NO_WAIT);  
  2262. }
  2264. /*****************************************************************
  2265.  * Create event
  2266.  */
  2268. int
  2269. NdbDictionaryImpl::createEvent(NdbEventImpl & evnt)
  2270. {
  2271.   int i;
  2272.   NdbTableImpl* tab = getTable(evnt.getTable());
  2274.   if(tab == 0){
  2275.     //    m_error.code = 3249;
  2276.     ndbout_c(":createEvent: table %s not found", evnt.getTable());
  2277. #ifdef EVENT_DEBUG
  2278.     ndbout_c("NdbDictionaryImpl::createEvent: table not found: %s", evnt.getTable());
  2279. #endif
  2280.     return -1;
  2281.   }
  2283.   evnt.m_tableId = tab->m_tableId;
  2284.   evnt.m_tableImpl = tab;
  2285. #ifdef EVENT_DEBUG
  2286.   ndbout_c("Event on tableId=%d", evnt.m_tableId);
  2287. #endif
  2289.   NdbTableImpl &table = *evnt.m_tableImpl;
  2292.   int attributeList_sz = evnt.m_attrIds.size();
  2294.   for (i = 0; i < attributeList_sz; i++) {
  2295.     NdbColumnImpl *col_impl = table.getColumn(evnt.m_attrIds[i]);
  2296.     if (col_impl) {
  2297.       evnt.m_facade->addColumn(*(col_impl->m_facade));
  2298.     } else {
  2299.       ndbout_c("Attr id %u in table %s not found", evnt.m_attrIds[i],
  2300.        evnt.getTable());
  2301.       return -1;
  2302.     }
  2303.   }
  2305.   evnt.m_attrIds.clear();
  2307.   attributeList_sz = evnt.m_columns.size();
  2308. #ifdef EVENT_DEBUG
  2309.   ndbout_c("creating event %s", evnt.m_externalName.c_str());
  2310.   ndbout_c("no of columns %d", evnt.m_columns.size());
  2311. #endif
  2312.   int pk_count = 0;
  2313.   evnt.m_attrListBitmask.clear();
  2315.   for(i = 0; i<attributeList_sz; i++){
  2316.     const NdbColumnImpl* col = 
  2317.       table.getColumn(evnt.m_columns[i]->m_name.c_str());
  2318.     if(col == 0){
  2319.       m_error.code = 4247;
  2320.       return -1;
  2321.     }
  2322.     // Copy column definition
  2323.     *evnt.m_columns[i] = *col;
  2324.     
  2325.     if(col->m_pk){
  2326.       pk_count++;
  2327.     }
  2328.     
  2329.     evnt.m_attrListBitmask.set(col->m_attrId);
  2330.   }
  2331.   
  2332.   // Sort index attributes according to primary table (using insertion sort)
  2333.   for(i = 1; i < attributeList_sz; i++) {
  2334.     NdbColumnImpl* temp = evnt.m_columns[i];
  2335.     unsigned int j = i;
  2336.     while((j > 0) && (evnt.m_columns[j - 1]->m_attrId > temp->m_attrId)) {
  2337.       evnt.m_columns[j] = evnt.m_columns[j - 1];
  2338.       j--;
  2339.     }
  2340.     evnt.m_columns[j] = temp;
  2341.   }
  2342.   // Check for illegal duplicate attributes
  2343.   for(i = 1; i<attributeList_sz; i++) {
  2344.     if (evnt.m_columns[i-1]->m_attrId == evnt.m_columns[i]->m_attrId) {
  2345.       m_error.code = 4258;
  2346.       return -1;
  2347.     }
  2348.   }
  2349.   
  2350. #ifdef EVENT_DEBUG
  2351.   char buf[128] = {0};
  2352.   evnt.m_attrListBitmask.getText(buf);
  2353.   ndbout_c("createEvent: mask = %s", buf);
  2354. #endif
  2356.   // NdbDictInterface m_receiver;
  2357.   return m_receiver.createEvent(m_ndb, evnt, 0 /* getFlag unset */);
  2358. }
  2360. int
  2361. NdbDictInterface::createEvent(class Ndb & ndb,
  2362.       NdbEventImpl & evnt,
  2363.       int getFlag)
  2364. {
  2365.   NdbApiSignal tSignal(m_reference);
  2366.   tSignal.theReceiversBlockNumber = DBDICT;
  2367.   tSignal.theVerId_signalNumber   = GSN_CREATE_EVNT_REQ;
  2368.   if (getFlag)
  2369.     tSignal.theLength = CreateEvntReq::SignalLengthGet;
  2370.   else
  2371.     tSignal.theLength = CreateEvntReq::SignalLengthCreate;
  2373.   CreateEvntReq * const req = CAST_PTR(CreateEvntReq, tSignal.getDataPtrSend());
  2374.   
  2375.   req->setUserRef(m_reference);
  2376.   req->setUserData(0);
  2378.   if (getFlag) {
  2379.     // getting event from Dictionary
  2380.     req->setRequestType(CreateEvntReq::RT_USER_GET);
  2381.   } else {
  2382.     // creating event in Dictionary
  2383.     req->setRequestType(CreateEvntReq::RT_USER_CREATE);
  2384.     req->setTableId(evnt.m_tableId);
  2385.     req->setAttrListBitmask(evnt.m_attrListBitmask);
  2386.     req->setEventType(evnt.mi_type);
  2387.   }
  2389.   UtilBufferWriter w(m_buffer);
  2391.   const size_t len = strlen(evnt.m_externalName.c_str()) + 1;
  2392.   if(len > MAX_TAB_NAME_SIZE) {
  2393.     m_error.code = 4241;
  2394.     return -1;
  2395.   }
  2397.   w.add(SimpleProperties::StringValue, evnt.m_externalName.c_str());
  2399.   if (getFlag == 0)
  2400.     w.add(SimpleProperties::StringValue,
  2401.   ndb.internalizeTableName(evnt.m_tableName.c_str()));
  2403.   LinearSectionPtr ptr[3];
  2404.   ptr[0].p = (Uint32*)m_buffer.get_data();
  2405.   ptr[0].sz = (m_buffer.length()+3) >> 2;
  2407.   int ret = createEvent(&tSignal, ptr, 1);
  2409.   if (ret) {
  2410.     return ret;
  2411.   }
  2413.   char *dataPtr = (char *)m_buffer.get_data();
  2414.   unsigned int lenCreateEvntConf = *((unsigned int *)dataPtr);
  2415.   dataPtr += sizeof(lenCreateEvntConf);
  2416.   CreateEvntConf const * evntConf = (CreateEvntConf *)dataPtr;
  2417.   dataPtr += lenCreateEvntConf;
  2418.   
  2419.   //  NdbEventImpl *evntImpl = (NdbEventImpl *)evntConf->getUserData();
  2421.   if (getFlag) {
  2422.     evnt.m_tableId         = evntConf->getTableId();
  2423.     evnt.m_attrListBitmask = evntConf->getAttrListBitmask();
  2424.     evnt.mi_type           = evntConf->getEventType();
  2425.     evnt.setTable(dataPtr);
  2426.   } else {
  2427.     if (evnt.m_tableId         != evntConf->getTableId() ||
  2428. //evnt.m_attrListBitmask != evntConf->getAttrListBitmask() ||
  2429. evnt.mi_type           != evntConf->getEventType()) {
  2430.       ndbout_c("ERROR*************");
  2431.       return 1;
  2432.     }
  2433.   }
  2435.   evnt.m_eventId         = evntConf->getEventId();
  2436.   evnt.m_eventKey        = evntConf->getEventKey();
  2438.   return ret;
  2439. }
  2441. int
  2442. NdbDictInterface::createEvent(NdbApiSignal* signal,
  2443.       LinearSectionPtr ptr[3], int noLSP)
  2444. {
  2445.   const int noErrCodes = 1;
  2446.   int errCodes[noErrCodes] = {CreateEvntRef::Busy};
  2447.   return dictSignal(signal,ptr,noLSP,
  2448.     1 /*use masternode id*/,
  2449.     100,
  2450.     WAIT_CREATE_INDX_REQ /*WAIT_CREATE_EVNT_REQ*/,
  2451.     -1,
  2452.     errCodes,noErrCodes, CreateEvntRef::Temporary);
  2453. }
  2455. int
  2456. NdbDictionaryImpl::executeSubscribeEvent(NdbEventImpl & ev)
  2457. {
  2458.   // NdbDictInterface m_receiver;
  2459.   return m_receiver.executeSubscribeEvent(m_ndb, ev);
  2460. }
  2462. int
  2463. NdbDictInterface::executeSubscribeEvent(class Ndb & ndb,
  2464.  NdbEventImpl & evnt)
  2465. {
  2466.   NdbApiSignal tSignal(m_reference);
  2467.   //  tSignal.theReceiversBlockNumber = SUMA;
  2468.   tSignal.theReceiversBlockNumber = DBDICT;
  2469.   tSignal.theVerId_signalNumber   = GSN_SUB_START_REQ;
  2470.   tSignal.theLength = SubStartReq::SignalLength2;
  2471.   
  2472.   SubStartReq * sumaStart = CAST_PTR(SubStartReq, tSignal.getDataPtrSend());
  2474.   sumaStart->subscriptionId   = evnt.m_eventId;
  2475.   sumaStart->subscriptionKey  = evnt.m_eventKey;
  2476.   sumaStart->part             = SubscriptionData::TableData;
  2477.   sumaStart->subscriberData   = evnt.m_bufferId & 0xFF;
  2478.   sumaStart->subscriberRef    = m_reference;
  2480.   return executeSubscribeEvent(&tSignal, NULL);
  2481. }
  2483. int
  2484. NdbDictInterface::executeSubscribeEvent(NdbApiSignal* signal,
  2485. LinearSectionPtr ptr[3])
  2486. {
  2487.   return dictSignal(signal,NULL,0,
  2488.     1 /*use masternode id*/,
  2489.     100,
  2490.     WAIT_CREATE_INDX_REQ /*WAIT_CREATE_EVNT_REQ*/,
  2491.     -1,
  2492.     NULL,0);
  2493. }
  2495. int
  2496. NdbDictionaryImpl::stopSubscribeEvent(NdbEventImpl & ev)
  2497. {
  2498.   // NdbDictInterface m_receiver;
  2499.   return m_receiver.stopSubscribeEvent(m_ndb, ev);
  2500. }
  2502. int
  2503. NdbDictInterface::stopSubscribeEvent(class Ndb & ndb,
  2504.      NdbEventImpl & evnt)
  2505. {
  2506. #ifdef EVENT_DEBUG
  2507.   ndbout_c("SUB_STOP_REQ");
  2508. #endif
  2510.   NdbApiSignal tSignal(m_reference);
  2511.   //  tSignal.theReceiversBlockNumber = SUMA;
  2512.   tSignal.theReceiversBlockNumber = DBDICT;
  2513.   tSignal.theVerId_signalNumber   = GSN_SUB_STOP_REQ;
  2514.   tSignal.theLength = SubStopReq::SignalLength;
  2515.   
  2516.   SubStopReq * sumaStop = CAST_PTR(SubStopReq, tSignal.getDataPtrSend());
  2518.   sumaStop->subscriptionId  = evnt.m_eventId;
  2519.   sumaStop->subscriptionKey = evnt.m_eventKey;
  2520.   sumaStop->subscriberData  = evnt.m_bufferId & 0xFF;
  2521.   sumaStop->part            = (Uint32) SubscriptionData::TableData;
  2522.   sumaStop->subscriberRef   = m_reference;
  2524.   return stopSubscribeEvent(&tSignal, NULL);
  2525. }
  2527. int
  2528. NdbDictInterface::stopSubscribeEvent(NdbApiSignal* signal,
  2529.      LinearSectionPtr ptr[3])
  2530. {
  2531.   return dictSignal(signal,NULL,0,
  2532.     1 /*use masternode id*/,
  2533.     100,
  2534.     WAIT_CREATE_INDX_REQ /*WAIT_SUB_STOP__REQ*/,
  2535.     -1,
  2536.     NULL,0);
  2537. }
  2539. NdbEventImpl * 
  2540. NdbDictionaryImpl::getEvent(const char * eventName)
  2541. {
  2542.   NdbEventImpl *ev =  new NdbEventImpl();
  2544.   if (ev == NULL) {
  2545.     return NULL;
  2546.   }
  2548.   ev->setName(eventName);
  2550.   int ret = m_receiver.createEvent(m_ndb, *ev, 1 /* getFlag set */);
  2552.   if (ret) {
  2553.     delete ev;
  2554.     return NULL;
  2555.   }
  2557.   // We only have the table name with internal name
  2558.   ev->setTable(m_ndb.externalizeTableName(ev->getTable()));
  2559.   ev->m_tableImpl = getTable(ev->getTable());
  2561.   // get the columns from the attrListBitmask
  2563.   NdbTableImpl &table = *ev->m_tableImpl;
  2564.   AttributeMask & mask = ev->m_attrListBitmask;
  2565.   int attributeList_sz = mask.count();
  2566.   int id = -1;
  2568. #ifdef EVENT_DEBUG
  2569.   ndbout_c("NdbDictionaryImpl::getEvent attributeList_sz = %d",
  2570.    attributeList_sz);
  2571.   char buf[128] = {0};
  2572.   mask.getText(buf);
  2573.   ndbout_c("mask = %s", buf);
  2574. #endif
  2576.   for(int i = 0; i < attributeList_sz; i++) {
  2577.     id++; while (!mask.get(id)) id++;
  2579.     const NdbColumnImpl* col = table.getColumn(id);
  2580.     if(col == 0) {
  2581. #ifdef EVENT_DEBUG
  2582.       ndbout_c("NdbDictionaryImpl::getEvent could not find column id %d", id);
  2583. #endif
  2584.       m_error.code = 4247;
  2585.       delete ev;
  2586.       return NULL;
  2587.     }
  2588.     NdbColumnImpl* new_col = new NdbColumnImpl;
  2589.     // Copy column definition
  2590.     *new_col = *col;
  2592.     ev->m_columns.push_back(new_col);
  2593.   }
  2595.   return ev;
  2596. }
  2598. void
  2599. NdbDictInterface::execCREATE_EVNT_CONF(NdbApiSignal * signal,
  2600.        LinearSectionPtr ptr[3])
  2601. {
  2602. #ifdef EVENT_DEBUG
  2603.   ndbout << "NdbDictionaryImpl.cpp: execCREATE_EVNT_CONF" << endl;
  2604. #endif
  2605.   m_buffer.clear();
  2606.   unsigned int len = signal->getLength() << 2;
  2607.   m_buffer.append((char *)&len, sizeof(len));
  2608.   m_buffer.append(signal->getDataPtr(), len);
  2610.   if (signal->m_noOfSections > 0) {
  2611.     m_buffer.append((char *)ptr[0].p, strlen((char *)ptr[0].p)+1);
  2612.   }
  2614.   m_waiter.signal(NO_WAIT);
  2615. }
  2617. void
  2618. NdbDictInterface::execCREATE_EVNT_REF(NdbApiSignal * signal,
  2619.       LinearSectionPtr ptr[3])
  2620. {
  2621. #ifdef EVENT_DEBUG
  2622.   ndbout << "NdbDictionaryImpl.cpp: execCREATE_EVNT_REF" << endl;
  2623.   ndbout << "Exiting" << endl;
  2624.   exit(-1);
  2625. #endif
  2627.   const CreateEvntRef* const ref = CAST_CONSTPTR(CreateEvntRef, signal->getDataPtr());
  2628.   m_error.code = ref->getErrorCode();
  2629. #ifdef EVENT_DEBUG
  2630.   ndbout_c("execCREATE_EVNT_REF");
  2631.   ndbout_c("ErrorCode %u", ref->getErrorCode());
  2632.   ndbout_c("Errorline %u", ref->getErrorLine());
  2633.   ndbout_c("ErrorNode %u", ref->getErrorNode());
  2634. #endif
  2635.   m_waiter.signal(NO_WAIT);  
  2636. }
  2638. void
  2639. NdbDictInterface::execSUB_STOP_CONF(NdbApiSignal * signal,
  2640.       LinearSectionPtr ptr[3])
  2641. {
  2642. #ifdef EVENT_DEBUG
  2643.   ndbout << "Got GSN_SUB_STOP_CONF" << endl;
  2644. #endif
  2645.   //  SubRemoveConf * const sumaRemoveConf = CAST_CONSTPTR(SubRemoveConf, signal->getDataPtr());
  2647.   //  Uint32 subscriptionId = sumaRemoveConf->subscriptionId;
  2648.   //  Uint32 subscriptionKey = sumaRemoveConf->subscriptionKey;
  2649.   //  Uint32 senderData = sumaRemoveConf->senderData;
  2651.   m_waiter.signal(NO_WAIT);
  2652. }
  2654. void
  2655. NdbDictInterface::execSUB_STOP_REF(NdbApiSignal * signal,
  2656.      LinearSectionPtr ptr[3])
  2657. {
  2658. #ifdef EVENT_DEBUG
  2659.   ndbout << "Got GSN_SUB_STOP_REF" << endl;
  2660. #endif
  2661.   //  SubRemoveConf * const sumaRemoveRef = CAST_CONSTPTR(SubRemoveRef, signal->getDataPtr());
  2663.   //  Uint32 subscriptionId = sumaRemoveRef->subscriptionId;
  2664.   //  Uint32 subscriptionKey = sumaRemoveRef->subscriptionKey;
  2665.   //  Uint32 senderData = sumaRemoveRef->senderData;
  2667.   m_error.code = 1;
  2668.   m_waiter.signal(NO_WAIT);
  2669. }
  2671. void
  2672. NdbDictInterface::execSUB_START_CONF(NdbApiSignal * signal,
  2673.      LinearSectionPtr ptr[3])
  2674. {
  2675. #ifdef EVENT_DEBUG
  2676.   ndbout << "Got GSN_SUB_START_CONF" << endl;
  2677. #endif
  2678.   const SubStartConf * const sumaStartConf = CAST_CONSTPTR(SubStartConf, signal->getDataPtr());
  2680.   //  Uint32 subscriptionId = sumaStartConf->subscriptionId;
  2681.   //  Uint32 subscriptionKey = sumaStartConf->subscriptionKey;
  2682.   SubscriptionData::Part part = 
  2683.   (SubscriptionData::Part)sumaStartConf->part;
  2684.   //  Uint32 subscriberData = sumaStartConf->subscriberData;
  2686.   switch(part) {
  2687.   case SubscriptionData::MetaData: {
  2688. #ifdef EVENT_DEBUG
  2689.     ndbout << "SubscriptionData::MetaData" << endl;
  2690. #endif
  2691.     m_error.code = 1;
  2692.     break;
  2693.   }
  2694.   case SubscriptionData::TableData: {
  2695. #ifdef EVENT_DEBUG
  2696.     ndbout << "SubscriptionData::TableData" << endl;
  2697. #endif
  2698.     break;
  2699.   }
  2700.   default: {
  2701. #ifdef EVENT_DEBUG
  2702.     ndbout_c("NdbDictInterface::execSUB_START_CONF wrong data");
  2703. #endif
  2704.     m_error.code = 1;
  2705.     break;
  2706.   }
  2707.   }
  2708.   m_waiter.signal(NO_WAIT);
  2709. }
  2711. void
  2712. NdbDictInterface::execSUB_START_REF(NdbApiSignal * signal,
  2713.     LinearSectionPtr ptr[3])
  2714. {
  2715. #ifdef EVENT_DEBUG
  2716.     ndbout << "Got GSN_SUB_START_REF" << endl;
  2717. #endif
  2718.   m_error.code = 1;
  2719.   m_waiter.signal(NO_WAIT);  
  2720. }
  2721. void
  2722. NdbDictInterface::execSUB_GCP_COMPLETE_REP(NdbApiSignal * signal,
  2723.    LinearSectionPtr ptr[3])
  2724. {
  2725.   const SubGcpCompleteRep * const rep = CAST_CONSTPTR(SubGcpCompleteRep, signal->getDataPtr());
  2727.   const Uint32 gci            = rep->gci;
  2728.   //  const Uint32 senderRef      = rep->senderRef;
  2729.   const Uint32 subscriberData = rep->subscriberData;
  2731.   const Uint32 bufferId = subscriberData;
  2733.   const Uint32 ref = signal->theSendersBlockRef;
  2735.   NdbApiSignal tSignal(m_reference);
  2736.   SubGcpCompleteAcc * acc = CAST_PTR(SubGcpCompleteAcc, tSignal.getDataPtrSend());
  2738.   acc->rep = *rep;
  2740.   tSignal.theReceiversBlockNumber = refToBlock(ref);
  2741.   tSignal.theVerId_signalNumber   = GSN_SUB_GCP_COMPLETE_ACC;
  2742.   tSignal.theLength = SubGcpCompleteAcc::SignalLength;
  2744.   Uint32 aNodeId = refToNode(ref);
  2746.   //  m_transporter->lock_mutex();
  2747.   int r;
  2748.   r = m_transporter->sendSignal(&tSignal, aNodeId);
  2749.   //  m_transporter->unlock_mutex();
  2751.   NdbGlobalEventBufferHandle::latestGCI(bufferId, gci);
  2752. }
  2754. void
  2755. NdbDictInterface::execSUB_TABLE_DATA(NdbApiSignal * signal,
  2756.      LinearSectionPtr ptr[3])
  2757. {
  2758. #ifdef EVENT_DEBUG
  2759.   const char * FNAME = "NdbDictInterface::execSUB_TABLE_DATA";
  2760. #endif
  2761.   //TODO
  2762.   const SubTableData * const sdata = CAST_CONSTPTR(SubTableData, signal->getDataPtr());
  2764.   //  const Uint32 gci            = sdata->gci;
  2765.   //  const Uint32 operation      = sdata->operation;
  2766.   //  const Uint32 tableId        = sdata->tableId;
  2767.   //  const Uint32 noOfAttrs      = sdata->noOfAttributes;
  2768.   //  const Uint32 dataLen        = sdata->dataSize;
  2769.   const Uint32 subscriberData = sdata->subscriberData;
  2770.   //  const Uint32 logType        = sdata->logType;
  2772.   for (int i=signal->m_noOfSections;i < 3; i++) {
  2773.     ptr[i].p = NULL;
  2774.     ptr[i].sz = 0;
  2775.   }
  2776. #ifdef EVENT_DEBUG
  2777.   ndbout_c("%s: senderData %d, gci %d, operation %d, tableId %d, noOfAttrs %d, dataLen %d",
  2778.    FNAME, subscriberData, gci, operation, tableId, noOfAttrs, dataLen);
  2779.   ndbout_c("ptr[0] %u %u ptr[1] %u %u ptr[2] %u %un",
  2780.    ptr[0].p,ptr[0].sz,ptr[1].p,ptr[1].sz,ptr[2].p,ptr[2].sz);
  2781. #endif
  2782.   const Uint32 bufferId = subscriberData;
  2784.   NdbGlobalEventBufferHandle::insertDataL(bufferId,
  2785.   sdata, ptr);
  2786. }
  2788. /*****************************************************************
  2789.  * Drop event
  2790.  */
  2791. int 
  2792. NdbDictionaryImpl::dropEvent(const char * eventName)
  2793. {
  2794.   NdbEventImpl *ev =  new NdbEventImpl();
  2795.   ev->setName(eventName);
  2796.   int ret = m_receiver.dropEvent(*ev);
  2797.   delete ev;  
  2799.   //  printf("__________________RET %un", ret);
  2800.   return ret;
  2801. }
  2803. int
  2804. NdbDictInterface::dropEvent(const NdbEventImpl &evnt)
  2805. {
  2806.   NdbApiSignal tSignal(m_reference);
  2807.   tSignal.theReceiversBlockNumber = DBDICT;
  2808.   tSignal.theVerId_signalNumber   = GSN_DROP_EVNT_REQ;
  2809.   tSignal.theLength = DropEvntReq::SignalLength;
  2810.   
  2811.   DropEvntReq * const req = CAST_PTR(DropEvntReq, tSignal.getDataPtrSend());
  2813.   req->setUserRef(m_reference);
  2814.   req->setUserData(0);
  2816.   UtilBufferWriter w(m_buffer);
  2818.   w.add(SimpleProperties::StringValue, evnt.m_externalName.c_str());
  2820.   LinearSectionPtr ptr[1];
  2821.   ptr[0].p = (Uint32*)m_buffer.get_data();
  2822.   ptr[0].sz = (m_buffer.length()+3) >> 2;
  2824.   return dropEvent(&tSignal, ptr, 1);
  2825. }
  2827. int
  2828. NdbDictInterface::dropEvent(NdbApiSignal* signal,
  2829.     LinearSectionPtr ptr[3], int noLSP)
  2830. {
  2831.   //TODO
  2832.   const int noErrCodes = 1;
  2833.   int errCodes[noErrCodes] = {DropEvntRef::Busy};
  2834.   return dictSignal(signal,ptr,noLSP,
  2835.     1 /*use masternode id*/,
  2836.     100,
  2837.     WAIT_CREATE_INDX_REQ /*WAIT_CREATE_EVNT_REQ*/,
  2838.     -1,
  2839.     errCodes,noErrCodes, DropEvntRef::Temporary);
  2840. }
  2841. void
  2842. NdbDictInterface::execDROP_EVNT_CONF(NdbApiSignal * signal,
  2843.      LinearSectionPtr ptr[3])
  2844. {
  2845. #ifdef EVENT_DEBUG
  2846.   ndbout << "NdbDictionaryImpl.cpp: execDROP_EVNT_CONF" << endl;
  2847. #endif
  2849.   m_waiter.signal(NO_WAIT);  
  2850. }
  2852. void
  2853. NdbDictInterface::execDROP_EVNT_REF(NdbApiSignal * signal,
  2854.     LinearSectionPtr ptr[3])
  2855. {
  2856. #ifdef EVENT_DEBUG
  2857.   ndbout << "NdbDictionaryImpl.cpp: execDROP_EVNT_REF" << endl;
  2858. #endif
  2859.   const DropEvntRef* const ref = CAST_CONSTPTR(DropEvntRef, signal->getDataPtr());
  2860.   m_error.code = ref->getErrorCode();
  2862. #if 0
  2863.   ndbout_c("execDROP_EVNT_REF");
  2864.   ndbout_c("ErrorCode %u", ref->getErrorCode());
  2865.   ndbout_c("Errorline %u", ref->getErrorLine());
  2866.   ndbout_c("ErrorNode %u", ref->getErrorNode());
  2867. #endif
  2869.   m_waiter.signal(NO_WAIT);  
  2870. }
  2872. /*****************************************************************
  2873.  * List objects or indexes
  2874.  */
  2875. int
  2876. NdbDictionaryImpl::listObjects(List& list, NdbDictionary::Object::Type type)
  2877. {
  2878.   ListTablesReq req;
  2879.   req.requestData = 0;
  2880.   req.setTableType(getKernelConstant(type, objectTypeMapping, 0));
  2881.   req.setListNames(true);
  2882.   return m_receiver.listObjects(list, req.requestData, m_ndb.usingFullyQualifiedNames());
  2883. }
  2885. int
  2886. NdbDictionaryImpl::listIndexes(List& list, Uint32 indexId)
  2887. {
  2888.   ListTablesReq req;
  2889.   req.requestData = 0;
  2890.   req.setTableId(indexId);
  2891.   req.setListNames(true);
  2892.   req.setListIndexes(true);
  2893.   return m_receiver.listObjects(list, req.requestData, m_ndb.usingFullyQualifiedNames());
  2894. }
  2896. int
  2897. NdbDictInterface::listObjects(NdbDictionary::Dictionary::List& list,
  2898.       Uint32 requestData, bool fullyQualifiedNames)
  2899. {
  2900.   NdbApiSignal tSignal(m_reference);
  2901.   ListTablesReq* const req = CAST_PTR(ListTablesReq, tSignal.getDataPtrSend());
  2902.   req->senderRef = m_reference;
  2903.   req->senderData = 0;
  2904.   req->requestData = requestData;
  2905.   tSignal.theReceiversBlockNumber = DBDICT;
  2906.   tSignal.theVerId_signalNumber = GSN_LIST_TABLES_REQ;
  2907.   tSignal.theLength = ListTablesReq::SignalLength;
  2908.   if (listObjects(&tSignal) != 0)
  2909.     return -1;
  2910.   // count
  2911.   const Uint32* data = (const Uint32*)m_buffer.get_data();
  2912.   const unsigned length = m_buffer.length() / 4;
  2913.   list.count = 0;
  2914.   bool ok = true;
  2915.   unsigned pos, count;
  2916.   pos = count = 0;
  2917.   while (pos < length) {
  2918.     // table id - name length - name
  2919.     pos++;
  2920.     if (pos >= length) {
  2921.       ok = false;
  2922.       break;
  2923.     }
  2924.     Uint32 n = (data[pos++] + 3) >> 2;
  2925.     pos += n;
  2926.     if (pos > length) {
  2927.       ok = false;
  2928.       break;
  2929.     }
  2930.     count++;
  2931.   }
  2932.   if (! ok) {
  2933.     // bad signal data
  2934.     m_error.code = 4213;
  2935.     return -1;
  2936.   }
  2937.   list.count = count;
  2938.   list.elements = new NdbDictionary::Dictionary::List::Element[count];
  2939.   pos = count = 0;
  2940.   while (pos < length) {
  2941.     NdbDictionary::Dictionary::List::Element& element = list.elements[count];
  2942.     Uint32 d = data[pos++];
  2943.     element.id = ListTablesConf::getTableId(d);
  2944.     element.type = (NdbDictionary::Object::Type)
  2945.       getApiConstant(ListTablesConf::getTableType(d), objectTypeMapping, 0);
  2946.     element.state = (NdbDictionary::Object::State)
  2947.       getApiConstant(ListTablesConf::getTableState(d), objectStateMapping, 0);
  2948.     element.store = (NdbDictionary::Object::Store)
  2949.       getApiConstant(ListTablesConf::getTableStore(d), objectStoreMapping, 0);
  2950.     // table or index name
  2951.     Uint32 n = (data[pos++] + 3) >> 2;
  2952.     BaseString databaseName;
  2953.     BaseString schemaName;
  2954.     BaseString objectName;
  2955.     if ((element.type == NdbDictionary::Object::UniqueHashIndex) ||
  2956. (element.type == NdbDictionary::Object::HashIndex) ||
  2957. (element.type == NdbDictionary::Object::UniqueOrderedIndex) ||
  2958. (element.type == NdbDictionary::Object::OrderedIndex)) {
  2959.       char * indexName = new char[n << 2];
  2960.       memcpy(indexName, &data[pos], n << 2);
  2961.       databaseName = Ndb::getDatabaseFromInternalName(indexName);
  2962.       schemaName = Ndb::getSchemaFromInternalName(indexName);
  2963.       objectName = BaseString(Ndb::externalizeIndexName(indexName, fullyQualifiedNames));
  2964.       delete [] indexName;
  2965.     } else if ((element.type == NdbDictionary::Object::SystemTable) || 
  2966.        (element.type == NdbDictionary::Object::UserTable)) {
  2967.       char * tableName = new char[n << 2];
  2968.       memcpy(tableName, &data[pos], n << 2);
  2969.       databaseName = Ndb::getDatabaseFromInternalName(tableName);
  2970.       schemaName = Ndb::getSchemaFromInternalName(tableName);
  2971.       objectName = BaseString(Ndb::externalizeTableName(tableName, fullyQualifiedNames));
  2972.       delete [] tableName;
  2973.     }
  2974.     else {
  2975.       char * otherName = new char[n << 2];
  2976.       memcpy(otherName, &data[pos], n << 2);
  2977.       objectName = BaseString(otherName);
  2978.       delete [] otherName;
  2979.     }
  2980.     element.database = new char[databaseName.length() + 1]; 
  2981.     strcpy(element.database, databaseName.c_str());
  2982.     element.schema = new char[schemaName.length() + 1]; 
  2983.     strcpy(element.schema, schemaName.c_str());
  2984.     element.name = new char[objectName.length() + 1]; 
  2985.     strcpy(element.name, objectName.c_str());
  2986.     pos += n;
  2987.     count++;
  2988.   }
  2989.   return 0;
  2990. }
  2992. int
  2993. NdbDictInterface::listObjects(NdbApiSignal* signal)
  2994. {
  2995.   const Uint32 RETRIES = 100;
  2996.   for (Uint32 i = 0; i < RETRIES; i++) {
  2997.     m_buffer.clear();
  2998.     // begin protected
  2999.     m_transporter->lock_mutex();
  3000.     Uint16 aNodeId = m_transporter->get_an_alive_node();
  3001.     if (aNodeId == 0) {
  3002.       m_error.code = 4009;
  3003.       m_transporter->unlock_mutex();
  3004.       return -1;
  3005.     }
  3006.     if (m_transporter->sendSignal(signal, aNodeId) != 0) {
  3007.       m_transporter->unlock_mutex();
  3008.       continue;
  3009.     }
  3010.     m_error.code = 0;
  3011.     m_waiter.m_node = aNodeId;
  3012.     m_waiter.m_state = WAIT_LIST_TABLES_CONF;
  3013.     m_waiter.wait(WAITFOR_RESPONSE_TIMEOUT);
  3014.     m_transporter->unlock_mutex();    
  3015.     // end protected
  3016.     if (m_waiter.m_state == NO_WAIT && m_error.code == 0)
  3017.       return 0;
  3018.     if (m_waiter.m_state == WAIT_NODE_FAILURE)
  3019.       continue;
  3020.     return -1;
  3021.   }
  3022.   return -1;
  3023. }
  3025. void
  3026. NdbDictInterface::execLIST_TABLES_CONF(NdbApiSignal* signal,
  3027.        LinearSectionPtr ptr[3])
  3028. {
  3029.   const unsigned off = ListTablesConf::HeaderLength;
  3030.   const unsigned len = (signal->getLength() - off);
  3031.   m_buffer.append(signal->getDataPtr() + off, len << 2);
  3032.   if (signal->getLength() < ListTablesConf::SignalLength) {
  3033.     // last signal has less than full length
  3034.     m_waiter.signal(NO_WAIT);
  3035.   }
  3036. }
  3038. template class Vector<int>;
  3039. template class Vector<Uint32>;
  3040. template class Vector<Vector<Uint32> >;
  3041. template class Vector<NdbTableImpl*>;
  3042. template class Vector<NdbColumnImpl*>;