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

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

MySQL数据库

开发平台：

Visual C++

NdbDictionaryImpl.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef NdbDictionaryImpl_H
  18. #define NdbDictionaryImpl_H
  20. #include <ndb_types.h>
  21. #include <kernel_types.h>
  22. #include <ndb_limits.h>
  23. #include <NdbError.hpp>
  24. #include <BaseString.hpp>
  25. #include <Vector.hpp>
  26. #include <UtilBuffer.hpp>
  27. #include <NdbDictionary.hpp>
  28. #include <Bitmask.hpp>
  29. #include <AttributeList.hpp>
  30. #include <Ndb.hpp>
  31. #include "NdbWaiter.hpp"
  32. #include "DictCache.hpp"
  34. class NdbDictObjectImpl {
  35. public:
  36.   Uint32 m_version;
  37.   NdbDictionary::Object::Status m_status;
  38.   
  39.   bool change();
  40. protected:
  41.   NdbDictObjectImpl() :
  42.     m_status(NdbDictionary::Object::New) {
  43.   }
  44. };
  46. /**
  47.  * Column
  48.  */
  49. class NdbColumnImpl : public NdbDictionary::Column {
  50. public:
  51.   NdbColumnImpl();
  52.   NdbColumnImpl(NdbDictionary::Column &); // This is not a copy constructor
  53.   ~NdbColumnImpl();
  54.   NdbColumnImpl& operator=(const NdbColumnImpl&);
  55.   void init(Type t = Unsigned);
  56.   
  57.   int m_attrId;
  58.   BaseString m_name;
  59.   NdbDictionary::Column::Type m_type;
  60.   int m_precision;
  61.   int m_scale;
  62.   int m_length;
  63.   CHARSET_INFO * m_cs;          // not const in MySQL
  64.   
  65.   bool m_pk;
  66.   bool m_tupleKey;
  67.   bool m_distributionKey;
  68.   bool m_distributionGroup;
  69.   int m_distributionGroupBits;
  70.   bool m_nullable;
  71.   bool m_indexOnly;
  72.   bool m_autoIncrement;
  73.   Uint64 m_autoIncrementInitialValue;
  74.   BaseString m_defaultValue;
  75.   NdbTableImpl * m_blobTable;
  77.   /**
  78.    * Internal types and sizes, and aggregates
  79.    */
  80.   Uint32 m_attrType;            // type outsize API and DICT
  81.   Uint32 m_attrSize;            // element size (size when arraySize==1)
  82.   Uint32 m_arraySize;           // length or length+2 for Var* types
  83.   Uint32 m_keyInfoPos;
  84.   Uint32 m_extType;             // used by restore (kernel type in versin v2x)
  85.   bool getInterpretableType() const ;
  86.   bool getCharType() const;
  87.   bool getBlobType() const;
  89.   /**
  90.    * Equality/assign
  91.    */
  92.   bool equal(const NdbColumnImpl&) const;
  94.   static NdbColumnImpl & getImpl(NdbDictionary::Column & t);
  95.   static const NdbColumnImpl & getImpl(const NdbDictionary::Column & t);
  96.   NdbDictionary::Column * m_facade;
  98.   static NdbDictionary::Column * create_psuedo(const char *);
  99. };
  101. class NdbTableImpl : public NdbDictionary::Table, public NdbDictObjectImpl {
  102. public:
  103.   NdbTableImpl();
  104.   NdbTableImpl(NdbDictionary::Table &);
  105.   ~NdbTableImpl();
  106.   
  107.   void init();
  108.   void setName(const char * name);
  109.   const char * getName() const;
  111.   Uint32 m_changeMask;
  112.   Uint32 m_tableId;
  113.   BaseString m_internalName;
  114.   BaseString m_externalName;
  115.   BaseString m_newExternalName; // Used for alter table
  116.   UtilBuffer m_frm; 
  117.   NdbDictionary::Object::FragmentType m_fragmentType;
  119.   /**
  120.    * 
  121.    */
  122.   Uint32 m_columnHashMask;
  123.   Vector<Uint32> m_columnHash;
  124.   Vector<NdbColumnImpl *> m_columns;
  125.   void buildColumnHash(); 
  126.   
  127.   bool m_logging;
  128.   int m_kvalue;
  129.   int m_minLoadFactor;
  130.   int m_maxLoadFactor;
  131.   int m_keyLenInWords;
  132.   int m_fragmentCount;
  134.   NdbDictionaryImpl * m_dictionary;
  135.   NdbIndexImpl * m_index;
  136.   NdbColumnImpl * getColumn(unsigned attrId);
  137.   NdbColumnImpl * getColumn(const char * name);
  138.   const NdbColumnImpl * getColumn(unsigned attrId) const;
  139.   const NdbColumnImpl * getColumn(const char * name) const;
  140.   
  141.   /**
  142.    * Index only stuff
  143.    */
  144.   BaseString m_primaryTable;
  145.   NdbDictionary::Index::Type m_indexType;
  147.   /**
  148.    * Aggregates
  149.    */
  150.   Uint32 m_noOfKeys;
  151.   unsigned short m_sizeOfKeysInWords;
  152.   unsigned short m_noOfBlobs;
  154.   /**
  155.    * Equality/assign
  156.    */
  157.   bool equal(const NdbTableImpl&) const;
  158.   void assign(const NdbTableImpl&);
  159.   void clearNewProperties();
  160.   void copyNewProperties();
  162.   static NdbTableImpl & getImpl(NdbDictionary::Table & t);
  163.   static NdbTableImpl & getImpl(const NdbDictionary::Table & t);
  164.   NdbDictionary::Table * m_facade;
  165. };
  167. class NdbIndexImpl : public NdbDictionary::Index, public NdbDictObjectImpl {
  168. public:
  169.   NdbIndexImpl();
  170.   NdbIndexImpl(NdbDictionary::Index &);
  171.   ~NdbIndexImpl();
  173.   void setName(const char * name);
  174.   const char * getName() const;
  175.   void setTable(const char * table);
  176.   const char * getTable() const;
  177.   const NdbTableImpl * getIndexTable() const;
  179.   Uint32 m_indexId;
  180.   BaseString m_internalName;
  181.   BaseString m_externalName;
  182.   BaseString m_tableName;
  183.   Vector<NdbColumnImpl *> m_columns;
  184.   Vector<int> m_key_ids;
  185.   NdbDictionary::Index::Type m_type;
  187.   bool m_logging;
  188.   
  189.   NdbTableImpl * m_table;
  190.   
  191.   static NdbIndexImpl & getImpl(NdbDictionary::Index & t);
  192.   static NdbIndexImpl & getImpl(const NdbDictionary::Index & t);
  193.   NdbDictionary::Index * m_facade;
  194. };
  196. class NdbEventImpl : public NdbDictionary::Event, public NdbDictObjectImpl {
  197. public:
  198.   NdbEventImpl();
  199.   NdbEventImpl(NdbDictionary::Event &);
  200.   ~NdbEventImpl();
  202.   void setName(const char * name);
  203.   const char * getName() const;
  204.   void setTable(const char * table);
  205.   const char * getTable() const;
  206.   void addTableEvent(const NdbDictionary::Event::TableEvent t);
  207.   void setDurability(const NdbDictionary::Event::EventDurability d);
  208.   void addEventColumn(const NdbColumnImpl &c);
  210.   void print() {
  211.     ndbout_c("NdbEventImpl: id=%d, key=%d",
  212.      m_eventId,
  213.      m_eventKey);
  214.   };
  216.   Uint32 m_eventId;
  217.   Uint32 m_eventKey;
  218.   Uint32 m_tableId;
  219.   AttributeMask m_attrListBitmask;
  220.   //BaseString m_internalName;
  221.   BaseString m_externalName;
  222.   Uint32 mi_type;
  223.   NdbDictionary::Event::EventDurability m_dur;
  226.   NdbTableImpl *m_tableImpl;
  227.   BaseString m_tableName;
  228.   Vector<NdbColumnImpl *> m_columns;
  229.   Vector<unsigned> m_attrIds;
  231.   int m_bufferId;
  233.   NdbEventOperation *eventOp;
  235.   static NdbEventImpl & getImpl(NdbDictionary::Event & t);
  236.   static NdbEventImpl & getImpl(const NdbDictionary::Event & t);
  237.   NdbDictionary::Event * m_facade;
  238. };
  241. class NdbDictInterface {
  242. public:
  243.   NdbDictInterface(NdbError& err) : m_error(err) {
  244.     m_reference = 0;
  245.     m_masterNodeId = 0;
  246.     m_transporter= NULL;
  247.   }
  248.   ~NdbDictInterface();
  249.   
  250.   bool setTransporter(class Ndb * ndb, class TransporterFacade * tf);
  251.   bool setTransporter(class TransporterFacade * tf);
  252.   
  253.   // To abstract the stuff thats made in all create/drop/lists below
  254.   int
  255.   dictSignal(NdbApiSignal* signal, 
  256.      LinearSectionPtr ptr[3], int noLPTR,
  257.      const int useMasterNodeId,
  258.      const Uint32 RETRIES,
  259.      const WaitSignalType wst,
  260.      const int theWait,
  261.      const int *errcodes,
  262.      const int noerrcodes,
  263.      const int temporaryMask = 0);
  265.   int createOrAlterTable(class Ndb & ndb, NdbTableImpl &, bool alter);
  267.   int createTable(class Ndb & ndb, NdbTableImpl &);
  268.   int createTable(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  270.   int alterTable(class Ndb & ndb, NdbTableImpl &);
  271.   int alterTable(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  273.   int createIndex(class Ndb & ndb,
  274.   NdbIndexImpl &, 
  275.   const NdbTableImpl &);
  276.   int createIndex(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  277.   
  278.   int createEvent(class Ndb & ndb, NdbEventImpl &, int getFlag);
  279.   int createEvent(NdbApiSignal* signal, LinearSectionPtr ptr[3], int noLSP);
  280.   
  281.   int dropTable(const NdbTableImpl &);
  282.   int dropTable(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  284.   int dropIndex(const NdbIndexImpl &, const NdbTableImpl &);
  285.   int dropIndex(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  287.   int dropEvent(const NdbEventImpl &);
  288.   int dropEvent(NdbApiSignal* signal, LinearSectionPtr ptr[3], int noLSP);
  290.   int executeSubscribeEvent(class Ndb & ndb, NdbEventImpl &);
  291.   int executeSubscribeEvent(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  292.   
  293.   int stopSubscribeEvent(class Ndb & ndb, NdbEventImpl &);
  294.   int stopSubscribeEvent(NdbApiSignal* signal, LinearSectionPtr ptr[3]);
  295.   
  296.   int listObjects(NdbDictionary::Dictionary::List& list, Uint32 requestData, bool fullyQualifiedNames);
  297.   int listObjects(NdbApiSignal* signal);
  298.   
  299.   NdbTableImpl * getTable(int tableId, bool fullyQualifiedNames);
  300.   NdbTableImpl * getTable(const char * name, bool fullyQualifiedNames);
  301.   NdbTableImpl * getTable(class NdbApiSignal * signal, 
  302.   LinearSectionPtr ptr[3],
  303.   Uint32 noOfSections, bool fullyQualifiedNames);
  305.   static int parseTableInfo(NdbTableImpl ** dst, 
  306.     const Uint32 * data, Uint32 len,
  307.     bool fullyQualifiedNames);
  308.   
  309.   static int create_index_obj_from_table(NdbIndexImpl ** dst, 
  310.  const NdbTableImpl*,
  311.  const NdbTableImpl*);
  312.   
  313.   NdbError & m_error;
  314. private:
  315.   Uint32 m_reference;
  316.   Uint32 m_masterNodeId;
  317.   
  318.   NdbWaiter m_waiter;
  319.   class TransporterFacade * m_transporter;
  320.   
  321.   friend class Ndb;
  322.   static void execSignal(void* dictImpl, 
  323.  class NdbApiSignal* signal, 
  324.  struct LinearSectionPtr ptr[3]);
  325.   
  326.   static void execNodeStatus(void* dictImpl, Uint32, 
  327.      bool alive, bool nfCompleted);  
  328.   
  329.   void execGET_TABINFO_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  330.   void execGET_TABINFO_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  331.   void execCREATE_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  332.   void execCREATE_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  333.   void execALTER_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  334.   void execALTER_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  336.   void execCREATE_INDX_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  337.   void execCREATE_INDX_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  338.   void execDROP_INDX_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  339.   void execDROP_INDX_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  341.   void execCREATE_EVNT_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  342.   void execCREATE_EVNT_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  343.   void execSUB_START_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  344.   void execSUB_START_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  345.   void execSUB_TABLE_DATA(NdbApiSignal *, LinearSectionPtr ptr[3]);
  346.   void execSUB_GCP_COMPLETE_REP(NdbApiSignal *, LinearSectionPtr ptr[3]);
  347.   void execSUB_STOP_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  348.   void execSUB_STOP_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  349.   void execDROP_EVNT_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  350.   void execDROP_EVNT_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  352.   void execDROP_TABLE_REF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  353.   void execDROP_TABLE_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  354.   void execLIST_TABLES_CONF(NdbApiSignal *, LinearSectionPtr ptr[3]);
  356.   Uint32 m_fragmentId;
  357.   UtilBuffer m_buffer;
  358. };
  360. class NdbDictionaryImpl : public NdbDictionary::Dictionary {
  361. public:
  362.   NdbDictionaryImpl(Ndb &ndb);
  363.   NdbDictionaryImpl(Ndb &ndb, NdbDictionary::Dictionary & f);
  364.   ~NdbDictionaryImpl();
  366.   bool setTransporter(class Ndb * ndb, class TransporterFacade * tf);
  367.   bool setTransporter(class TransporterFacade * tf);
  368.   
  369.   int createTable(NdbTableImpl &t);
  370.   int createBlobTables(NdbTableImpl &);
  371.   int addBlobTables(NdbTableImpl &);
  372.   int alterTable(NdbTableImpl &t);
  373.   int dropTable(const char * name);
  374.   int dropTable(NdbTableImpl &);
  375.   int dropBlobTables(NdbTableImpl &);
  376.   int invalidateObject(NdbTableImpl &);
  377.   int removeCachedObject(NdbTableImpl &);
  379.   int createIndex(NdbIndexImpl &ix);
  380.   int dropIndex(const char * indexName, 
  381. const char * tableName);
  382.   int dropIndex(NdbIndexImpl &, const char * tableName);
  383.   NdbTableImpl * getIndexTable(NdbIndexImpl * index, 
  384.        NdbTableImpl * table);
  386.   int createEvent(NdbEventImpl &);
  387.   int dropEvent(const char * eventName);
  389.   int executeSubscribeEvent(NdbEventImpl &);
  390.   int stopSubscribeEvent(NdbEventImpl &);
  392.   int listObjects(List& list, NdbDictionary::Object::Type type);
  393.   int listIndexes(List& list, Uint32 indexId);
  394.   
  395.   NdbTableImpl * getTable(const char * tableName, void **data= 0);
  396.   Ndb_local_table_info * get_local_table_info(const char * internalName,
  397.       bool do_add_blob_tables);
  398.   NdbIndexImpl * getIndex(const char * indexName,
  399.   const char * tableName);
  400.   NdbIndexImpl * getIndexImpl(const char * name, const char * internalName);
  401.   NdbEventImpl * getEvent(const char * eventName);
  402.   NdbEventImpl * getEventImpl(const char * internalName);
  403.   
  404.   const NdbError & getNdbError() const;
  405.   NdbError m_error;
  406.   Uint32 m_local_table_data_size;
  408.   LocalDictCache m_localHash;
  409.   GlobalDictCache * m_globalHash;
  411.   static NdbDictionaryImpl & getImpl(NdbDictionary::Dictionary & t);
  412.   static const NdbDictionaryImpl & getImpl(const NdbDictionary::Dictionary &t);
  413.   NdbDictionary::Dictionary * m_facade;
  415.   NdbDictInterface m_receiver;
  416.   Ndb & m_ndb;
  417. private:
  418.   Ndb_local_table_info * fetchGlobalTableImpl(const char * internalName);
  419. };
  421. inline
  422. NdbEventImpl &
  423. NdbEventImpl::getImpl(const NdbDictionary::Event & t){
  424.   return t.m_impl;
  425. }
  427. inline
  428. NdbEventImpl &
  429. NdbEventImpl::getImpl(NdbDictionary::Event & t){
  430.   return t.m_impl;
  431. }
  433. inline
  434. NdbColumnImpl &
  435. NdbColumnImpl::getImpl(NdbDictionary::Column & t){
  436.   return t.m_impl;
  437. }
  439. inline
  440. const NdbColumnImpl &
  441. NdbColumnImpl::getImpl(const NdbDictionary::Column & t){
  442.   return t.m_impl;
  443. }
  445. inline
  446. bool 
  447. NdbColumnImpl::getInterpretableType() const {
  448.   return (m_type == NdbDictionary::Column::Unsigned ||
  449.   m_type == NdbDictionary::Column::Bigunsigned);
  450. }
  452. inline
  453. bool 
  454. NdbColumnImpl::getCharType() const {
  455.   return (m_type == NdbDictionary::Column::Char ||
  456.           m_type == NdbDictionary::Column::Varchar ||
  457.           m_type == NdbDictionary::Column::Text);
  458. }
  459.    
  460. inline
  461. bool 
  462. NdbColumnImpl::getBlobType() const {
  463.   return (m_type == NdbDictionary::Column::Blob ||
  464.   m_type == NdbDictionary::Column::Text);
  465. }
  467. inline
  468. NdbTableImpl &
  469. NdbTableImpl::getImpl(NdbDictionary::Table & t){
  470.   return t.m_impl;
  471. }
  473. inline
  474. NdbTableImpl &
  475. NdbTableImpl::getImpl(const NdbDictionary::Table & t){
  476.   return t.m_impl;
  477. }
  479. inline
  480. NdbColumnImpl *
  481. NdbTableImpl::getColumn(unsigned attrId){
  482.   if(m_columns.size() > attrId){
  483.     return m_columns[attrId];
  484.   }
  485.   return 0;
  486. }
  488. inline
  489. Uint32
  490. Hash( const char* str ){
  491.   Uint32 h = 0;
  492.   Uint32 len = strlen(str);
  493.   while(len >= 4){
  494.     h = (h << 5) + h + str[0];
  495.     h = (h << 5) + h + str[1];
  496.     h = (h << 5) + h + str[2];
  497.     h = (h << 5) + h + str[3];
  498.     len -= 4;
  499.     str += 4;
  500.   }
  501.   
  502.   switch(len){
  503.   case 3:
  504.     h = (h << 5) + h + *str++;
  505.   case 2:
  506.     h = (h << 5) + h + *str++;
  507.   case 1:
  508.     h = (h << 5) + h + *str++;
  509.   }
  510.   return h + h;
  511. }
  514. inline
  515. NdbColumnImpl *
  516. NdbTableImpl::getColumn(const char * name){
  518.   Uint32 sz = m_columns.size();
  519.   NdbColumnImpl** cols = m_columns.getBase();
  520.   const Uint32 * hashtable = m_columnHash.getBase();
  522.   if(sz > 5 && false){
  523.     Uint32 hashValue = Hash(name) & 0xFFFE;
  524.     Uint32 bucket = hashValue & m_columnHashMask;
  525.     bucket = (bucket < sz ? bucket : bucket - sz);
  526.     hashtable += bucket;
  527.     Uint32 tmp = * hashtable;
  528.     if((tmp & 1) == 1 ){ // No chaining
  529.       sz = 1;
  530.     } else {
  531.       sz = (tmp >> 16);
  532.       hashtable += (tmp & 0xFFFE) >> 1;
  533.       tmp = * hashtable;
  534.     }
  535.     do {
  536.       if(hashValue == (tmp & 0xFFFE)){
  537. NdbColumnImpl* col = cols[tmp >> 16];
  538. if(strcmp(name, col->m_name.c_str()) == 0){
  539.   return col;
  540. }
  541.       }
  542.       hashtable++;
  543.       tmp = * hashtable;
  544.     } while(--sz > 0);
  545. #if 0
  546.     Uint32 dir = m_columnHash[bucket];
  547.     Uint32 pos = bucket + ((dir & 0xFFFE) >> 1); 
  548.     Uint32 cnt = dir >> 16;
  549.     ndbout_c("col: %s hv: %x bucket: %d dir: %x pos: %d cnt: %d tmp: %d -> 0", 
  550.      name, hashValue, bucket, dir, pos, cnt, tmp);
  551. #endif
  552.     return 0;
  553.   } else {
  554.     for(Uint32 i = 0; i<sz; i++){
  555.       NdbColumnImpl* col = * cols++;
  556.       if(col != 0 && strcmp(name, col->m_name.c_str()) == 0)
  557. return col;
  558.     }
  559.   }
  560.   return 0;
  561. }
  563. inline
  564. const NdbColumnImpl *
  565. NdbTableImpl::getColumn(unsigned attrId) const {
  566.   if(m_columns.size() > attrId){
  567.     return m_columns[attrId];
  568.   }
  569.   return 0;
  570. }
  572. inline
  573. const NdbColumnImpl *
  574. NdbTableImpl::getColumn(const char * name) const {
  575.   Uint32 sz = m_columns.size();
  576.   NdbColumnImpl* const * cols = m_columns.getBase();
  577.   for(Uint32 i = 0; i<sz; i++, cols++){
  578.     NdbColumnImpl* col = * cols;
  579.     if(col != 0 && strcmp(name, col->m_name.c_str()) == 0)
  580.       return col;
  581.   }
  582.   return 0;
  583. }
  585. inline
  586. NdbIndexImpl &
  587. NdbIndexImpl::getImpl(NdbDictionary::Index & t){
  588.   return t.m_impl;
  589. }
  591. inline
  592. NdbIndexImpl &
  593. NdbIndexImpl::getImpl(const NdbDictionary::Index & t){
  594.   return t.m_impl;
  595. }
  597. inline
  598. NdbDictionaryImpl &
  599. NdbDictionaryImpl::getImpl(NdbDictionary::Dictionary & t){
  600.   return t.m_impl;
  601. }
  603. inline
  604. const NdbDictionaryImpl &
  605. NdbDictionaryImpl::getImpl(const NdbDictionary::Dictionary & t){
  606.   return t.m_impl;
  607. }
  609. /*****************************************************************
  610.  * Inline:d getters
  611.  */
  613. inline
  614. NdbTableImpl * 
  615. NdbDictionaryImpl::getTable(const char * tableName, void **data)
  616. {
  617.   Ndb_local_table_info *info=
  618.     get_local_table_info(m_ndb.internalizeTableName(tableName), true);
  619.   if (info == 0) {
  620.     return 0;
  621.   }
  622.   if (data) {
  623.     *data= info->m_local_data;
  624.   }
  625.   return info->m_table_impl;
  626. }
  628. inline
  629. Ndb_local_table_info * 
  630. NdbDictionaryImpl::get_local_table_info(const char * internalTableName,
  631. bool do_add_blob_tables)
  632. {
  633.   Ndb_local_table_info *info= m_localHash.get(internalTableName);
  634.   if (info == 0) {
  635.     info= fetchGlobalTableImpl(internalTableName);
  636.     if (info == 0) {
  637.       return 0;
  638.     }
  639.   }
  640.   if (do_add_blob_tables && info->m_table_impl->m_noOfBlobs)
  641.     addBlobTables(*(info->m_table_impl));
  642.   
  643.   return info; // autoincrement already initialized
  644. }
  646. inline
  647. NdbIndexImpl * 
  648. NdbDictionaryImpl::getIndex(const char * indexName,
  649.     const char * tableName)
  650. {
  651.   if (tableName || m_ndb.usingFullyQualifiedNames()) {
  652.     const char * internalIndexName = 0;
  653.     if (tableName) {
  654.       NdbTableImpl * t = getTable(tableName);
  655.       if (t != 0)
  656.         internalIndexName = m_ndb.internalizeIndexName(t, indexName);
  657.     } else {
  658.       internalIndexName =
  659. m_ndb.internalizeTableName(indexName); // Index is also a table
  660.     }
  661.     if (internalIndexName) {
  662.       Ndb_local_table_info * info = get_local_table_info(internalIndexName,
  663.  false);
  664.       if (info) {
  665. NdbTableImpl * tab = info->m_table_impl;
  666.         if (tab->m_index == 0)
  667.           tab->m_index = getIndexImpl(indexName, internalIndexName);
  668.         if (tab->m_index != 0)
  669.           tab->m_index->m_table = tab;
  670.         return tab->m_index;
  671.       }
  672.     }
  673.   }
  675.   m_error.code = 4243;
  676.   return 0;
  677. }
  679. #endif