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

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

MySQL数据库

开发平台：

Visual C++

NdbDictionary.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 <NdbDictionary.hpp>
  18. #include "NdbDictionaryImpl.hpp"
  19. #include <NdbOut.hpp>
  21. /*****************************************************************
  22.  * Column facade
  23.  */
  24. NdbDictionary::Column::Column(const char * name) 
  25.   : m_impl(* new NdbColumnImpl(* this))
  26. {
  27.   setName(name);
  28. }
  30. NdbDictionary::Column::Column(const NdbDictionary::Column & org)
  31.   : m_impl(* new NdbColumnImpl(* this))
  32. {
  33.   m_impl = org.m_impl;
  34. }
  36. NdbDictionary::Column::Column(NdbColumnImpl& impl)
  37.   : m_impl(impl)
  38. {
  39. }
  41. NdbDictionary::Column::~Column(){
  42.   NdbColumnImpl * tmp = &m_impl;  
  43.   if(this != tmp){
  44.     delete tmp;
  45.   }
  46. }
  48. NdbDictionary::Column&
  49. NdbDictionary::Column::operator=(const NdbDictionary::Column& column)
  50. {
  51.   m_impl = column.m_impl;
  52.   
  53.   return *this;
  54. }
  56. void 
  57. NdbDictionary::Column::setName(const char * name){
  58.   m_impl.m_name.assign(name);
  59. }
  61. const char* 
  62. NdbDictionary::Column::getName() const {
  63.   return m_impl.m_name.c_str();
  64. }
  66. void
  67. NdbDictionary::Column::setType(Type t){
  68.   m_impl.init(t);
  69. }
  71. NdbDictionary::Column::Type 
  72. NdbDictionary::Column::getType() const {
  73.   return m_impl.m_type;
  74. }
  76. void 
  77. NdbDictionary::Column::setPrecision(int val){
  78.   m_impl.m_precision = val;
  79. }
  81. int 
  82. NdbDictionary::Column::getPrecision() const {
  83.   return m_impl.m_precision;
  84. }
  86. void 
  87. NdbDictionary::Column::setScale(int val){
  88.   m_impl.m_scale = val;
  89. }
  91. int 
  92. NdbDictionary::Column::getScale() const{
  93.   return m_impl.m_scale;
  94. }
  96. void
  97. NdbDictionary::Column::setLength(int length){
  98.   m_impl.m_length = length;
  99. }
  101. int 
  102. NdbDictionary::Column::getLength() const{
  103.   return m_impl.m_length;
  104. }
  106. void
  107. NdbDictionary::Column::setInlineSize(int size)
  108. {
  109.   m_impl.m_precision = size;
  110. }
  112. void
  113. NdbDictionary::Column::setCharset(CHARSET_INFO* cs)
  114. {
  115.   m_impl.m_cs = cs;
  116. }
  118. CHARSET_INFO*
  119. NdbDictionary::Column::getCharset() const
  120. {
  121.   return m_impl.m_cs;
  122. }
  124. int
  125. NdbDictionary::Column::getInlineSize() const
  126. {
  127.   return m_impl.m_precision;
  128. }
  130. void
  131. NdbDictionary::Column::setPartSize(int size)
  132. {
  133.   m_impl.m_scale = size;
  134. }
  136. int
  137. NdbDictionary::Column::getPartSize() const
  138. {
  139.   return m_impl.m_scale;
  140. }
  142. void
  143. NdbDictionary::Column::setStripeSize(int size)
  144. {
  145.   m_impl.m_length = size;
  146. }
  148. int
  149. NdbDictionary::Column::getStripeSize() const
  150. {
  151.   return m_impl.m_length;
  152. }
  154. int 
  155. NdbDictionary::Column::getSize() const{
  156.   return m_impl.m_attrSize;
  157. }
  159. void 
  160. NdbDictionary::Column::setNullable(bool val){
  161.   m_impl.m_nullable = val;
  162. }
  164. bool 
  165. NdbDictionary::Column::getNullable() const {
  166.   return m_impl.m_nullable;
  167. }
  169. void 
  170. NdbDictionary::Column::setPrimaryKey(bool val){
  171.   m_impl.m_pk = val;
  172. }
  174. bool 
  175. NdbDictionary::Column::getPrimaryKey() const {
  176.   return m_impl.m_pk;
  177. }
  179. void
  180. NdbDictionary::Column::setTupleKey(bool val){
  181.   m_impl.m_tupleKey = val;
  182. }
  184. bool 
  185. NdbDictionary::Column::getTupleKey() const {
  186.   return m_impl.m_tupleKey;
  187. }
  189. void 
  190. NdbDictionary::Column::setDistributionKey(bool val){
  191.   m_impl.m_distributionKey = val;
  192. }
  194. bool 
  195. NdbDictionary::Column::getDistributionKey() const{
  196.   return m_impl.m_distributionKey;
  197. }
  199. void
  200. NdbDictionary::Column::setDistributionGroup(bool val, int bits){
  201.   m_impl.m_distributionGroup = val;
  202.   m_impl.m_distributionGroupBits = bits;
  203. }
  205. bool 
  206. NdbDictionary::Column::getDistributionGroup() const {
  207.   return m_impl.m_distributionGroup;
  208. }
  210. int 
  211. NdbDictionary::Column::getDistributionGroupBits() const{
  212.   return m_impl.m_distributionGroupBits;
  213. }
  215. void 
  216. NdbDictionary::Column::setIndexOnlyStorage(bool val){
  217.   m_impl.m_indexOnly = val;
  218. }
  220. bool 
  221. NdbDictionary::Column::getIndexOnlyStorage() const {
  222.   return m_impl.m_indexOnly;
  223. }
  225. const NdbDictionary::Table * 
  226. NdbDictionary::Column::getBlobTable() const {
  227.   NdbTableImpl * t = m_impl.m_blobTable;
  228.   if (t)
  229.     return t->m_facade;
  230.   return 0;
  231. }
  233. void 
  234. NdbDictionary::Column::setAutoIncrement(bool val){
  235.   m_impl.m_autoIncrement = val;
  236. }
  238. bool 
  239. NdbDictionary::Column::getAutoIncrement() const {
  240.   return m_impl.m_autoIncrement;
  241. }
  243. void
  244. NdbDictionary::Column::setAutoIncrementInitialValue(Uint64 val){
  245.   m_impl.m_autoIncrementInitialValue = val;
  246. }
  248. void
  249. NdbDictionary::Column::setDefaultValue(const char* defaultValue)
  250. {
  251.   m_impl.m_defaultValue.assign(defaultValue);
  252. }
  254. const char*
  255. NdbDictionary::Column::getDefaultValue() const
  256. {
  257.   return m_impl.m_defaultValue.c_str();
  258. }
  260. int
  261. NdbDictionary::Column::getColumnNo() const {
  262.   return m_impl.m_attrId;
  263. }
  265. bool
  266. NdbDictionary::Column::equal(const NdbDictionary::Column & col) const {
  267.   return m_impl.equal(col.m_impl);
  268. }
  270. /*****************************************************************
  271.  * Table facade
  272.  */
  273. NdbDictionary::Table::Table(const char * name)
  274.   : m_impl(* new NdbTableImpl(* this)) 
  275. {
  276.   setName(name);
  277. }
  279. NdbDictionary::Table::Table(const NdbDictionary::Table & org)
  280.   : NdbDictionary::Object(),
  281.     m_impl(* new NdbTableImpl(* this))
  282. {
  283.   m_impl.assign(org.m_impl);
  284. }
  286. NdbDictionary::Table::Table(NdbTableImpl & impl)
  287.   : m_impl(impl)
  288. {
  289. }
  291. NdbDictionary::Table::~Table(){
  292.   NdbTableImpl * tmp = &m_impl;  
  293.   if(this != tmp){
  294.     delete tmp;
  295.   }
  296. }
  298. NdbDictionary::Table&
  299. NdbDictionary::Table::operator=(const NdbDictionary::Table& table)
  300. {
  301.   m_impl.assign(table.m_impl);
  302.   
  303.   m_impl.m_facade = this;
  304.   return *this;
  305. }
  307. void 
  308. NdbDictionary::Table::setName(const char * name){
  309.   m_impl.setName(name);
  310. }
  312. const char * 
  313. NdbDictionary::Table::getName() const {
  314.   return m_impl.getName();
  315. }
  317. int
  318. NdbDictionary::Table::getTableId() const {
  319.   return m_impl.m_tableId;
  320. }
  322. void 
  323. NdbDictionary::Table::addColumn(const Column & c){
  324.   NdbColumnImpl* col = new NdbColumnImpl;
  325.   (* col) = NdbColumnImpl::getImpl(c);
  326.   m_impl.m_columns.push_back(col);
  327.   if(c.getPrimaryKey()){
  328.     m_impl.m_noOfKeys++;
  329.   }
  330.   if (col->getBlobType()) {
  331.     m_impl.m_noOfBlobs++;
  332.   }
  333.   m_impl.buildColumnHash();
  334. }
  336. const NdbDictionary::Column*
  337. NdbDictionary::Table::getColumn(const char * name) const {
  338.   return m_impl.getColumn(name);
  339. }
  341. const NdbDictionary::Column* 
  342. NdbDictionary::Table::getColumn(const int attrId) const {
  343.   return m_impl.getColumn(attrId);
  344. }
  346. NdbDictionary::Column*
  347. NdbDictionary::Table::getColumn(const char * name) 
  348. {
  349.   return m_impl.getColumn(name);
  350. }
  352. NdbDictionary::Column* 
  353. NdbDictionary::Table::getColumn(const int attrId)
  354. {
  355.   return m_impl.getColumn(attrId);
  356. }
  358. void
  359. NdbDictionary::Table::setLogging(bool val){
  360.   m_impl.m_logging = val;
  361. }
  363. bool 
  364. NdbDictionary::Table::getLogging() const {
  365.   return m_impl.m_logging;
  366. }
  368. void
  369. NdbDictionary::Table::setFragmentType(FragmentType ft){
  370.   m_impl.m_fragmentType = ft;
  371. }
  373. NdbDictionary::Object::FragmentType 
  374. NdbDictionary::Table::getFragmentType() const {
  375.   return m_impl.m_fragmentType;
  376. }
  378. void 
  379. NdbDictionary::Table::setKValue(int kValue){
  380.   m_impl.m_kvalue = kValue;
  381. }
  383. int
  384. NdbDictionary::Table::getKValue() const {
  385.   return m_impl.m_kvalue;
  386. }
  388. void 
  389. NdbDictionary::Table::setMinLoadFactor(int lf){
  390.   m_impl.m_minLoadFactor = lf;
  391. }
  393. int 
  394. NdbDictionary::Table::getMinLoadFactor() const {
  395.   return m_impl.m_minLoadFactor;
  396. }
  398. void 
  399. NdbDictionary::Table::setMaxLoadFactor(int lf){
  400.   m_impl.m_maxLoadFactor = lf;  
  401. }
  403. int 
  404. NdbDictionary::Table::getMaxLoadFactor() const {
  405.   return m_impl.m_maxLoadFactor;
  406. }
  408. int
  409. NdbDictionary::Table::getNoOfColumns() const {
  410.   return m_impl.m_columns.size();
  411. }
  413. int
  414. NdbDictionary::Table::getNoOfPrimaryKeys() const {
  415.   return m_impl.m_noOfKeys;
  416. }
  418. const char*
  419. NdbDictionary::Table::getPrimaryKey(int no) const {
  420.   int count = 0;
  421.   for (unsigned i = 0; i < m_impl.m_columns.size(); i++) {
  422.     if (m_impl.m_columns[i]->m_pk) {
  423.       if (count++ == no)
  424.         return m_impl.m_columns[i]->m_name.c_str();
  425.     }
  426.   }
  427.   return 0;
  428. }
  430. const void* 
  431. NdbDictionary::Table::getFrmData() const {
  432.   return m_impl.m_frm.get_data();
  433. }
  435. Uint32
  436. NdbDictionary::Table::getFrmLength() const {
  437.   return m_impl.m_frm.length();
  438. }
  440. void
  441. NdbDictionary::Table::setFrm(const void* data, Uint32 len){
  442.   m_impl.m_frm.assign(data, len);
  443. }
  445. NdbDictionary::Object::Status
  446. NdbDictionary::Table::getObjectStatus() const {
  447.   return m_impl.m_status;
  448. }
  450. int 
  451. NdbDictionary::Table::getObjectVersion() const {
  452.   return m_impl.m_version;
  453. }
  455. bool
  456. NdbDictionary::Table::equal(const NdbDictionary::Table & col) const {
  457.   return m_impl.equal(col.m_impl);
  458. }
  460. int
  461. NdbDictionary::Table::getRowSizeInBytes() const {  
  462.   int sz = 0;
  463.   for(int i = 0; i<getNoOfColumns(); i++){
  464.     const NdbDictionary::Column * c = getColumn(i);
  465.     const NdbColumnImpl & col = NdbColumnImpl::getImpl(* c);
  466.     sz += (((col.m_attrSize * col.m_arraySize) + 3) / 4);
  467.   }
  468.   return sz * 4;
  469. }
  471. int
  472. NdbDictionary::Table::createTableInDb(Ndb* pNdb, bool equalOk) const {  
  473.   const NdbDictionary::Table * pTab = 
  474.     pNdb->getDictionary()->getTable(getName());
  475.   if(pTab != 0 && equal(* pTab))
  476.     return 0;
  477.   if(pTab != 0 && !equal(* pTab))
  478.     return -1;
  479.   return pNdb->getDictionary()->createTable(* this);
  480. }
  482. /*****************************************************************
  483.  * Index facade
  484.  */
  485. NdbDictionary::Index::Index(const char * name)
  486.   : m_impl(* new NdbIndexImpl(* this))
  487. {
  488.   setName(name);
  489. }
  491. NdbDictionary::Index::Index(NdbIndexImpl & impl)
  492.   : m_impl(impl) 
  493. {
  494. }
  496. NdbDictionary::Index::~Index(){
  497.   NdbIndexImpl * tmp = &m_impl;  
  498.   if(this != tmp){
  499.     delete tmp;
  500.   }
  501. }
  503. void 
  504. NdbDictionary::Index::setName(const char * name){
  505.   m_impl.setName(name);
  506. }
  508. const char * 
  509. NdbDictionary::Index::getName() const {
  510.   return m_impl.getName();
  511. }
  513. void 
  514. NdbDictionary::Index::setTable(const char * table){
  515.   m_impl.setTable(table);
  516. }
  518. const char * 
  519. NdbDictionary::Index::getTable() const {
  520.   return m_impl.getTable();
  521. }
  523. unsigned
  524. NdbDictionary::Index::getNoOfColumns() const {
  525.   return m_impl.m_columns.size();
  526. }
  528. int
  529. NdbDictionary::Index::getNoOfIndexColumns() const {
  530.   return m_impl.m_columns.size();
  531. }
  533. const NdbDictionary::Column *
  534. NdbDictionary::Index::getColumn(unsigned no) const {
  535.   if(no < m_impl.m_columns.size())
  536.     return m_impl.m_columns[no];
  537.   return NULL;
  538. }
  540. const char *
  541. NdbDictionary::Index::getIndexColumn(int no) const {
  542.   const NdbDictionary::Column* col = getColumn(no);
  544.   if (col)
  545.     return col->getName();
  546.   else
  547.     return NULL;
  548. }
  550. void
  551. NdbDictionary::Index::addColumn(const Column & c){
  552.   NdbColumnImpl* col = new NdbColumnImpl;
  553.   (* col) = NdbColumnImpl::getImpl(c);
  554.   m_impl.m_columns.push_back(col);
  555. }
  557. void
  558. NdbDictionary::Index::addColumnName(const char * name){
  559.   const Column c(name);
  560.   addColumn(c);
  561. }
  563. void
  564. NdbDictionary::Index::addIndexColumn(const char * name){
  565.   const Column c(name);
  566.   addColumn(c);
  567. }
  569. void
  570. NdbDictionary::Index::addColumnNames(unsigned noOfNames, const char ** names){
  571.   for(unsigned i = 0; i < noOfNames; i++) {
  572.     const Column c(names[i]);
  573.     addColumn(c);
  574.   }
  575. }
  577. void
  578. NdbDictionary::Index::addIndexColumns(int noOfNames, const char ** names){
  579.   for(int i = 0; i < noOfNames; i++) {
  580.     const Column c(names[i]);
  581.     addColumn(c);
  582.   }
  583. }
  585. void
  586. NdbDictionary::Index::setType(NdbDictionary::Index::Type t){
  587.   m_impl.m_type = t;
  588. }
  590. NdbDictionary::Index::Type
  591. NdbDictionary::Index::getType() const {
  592.   return m_impl.m_type;
  593. }
  595. void
  596. NdbDictionary::Index::setLogging(bool val){
  597.   m_impl.m_logging = val;
  598. }
  600. bool 
  601. NdbDictionary::Index::getLogging() const {
  602.   return m_impl.m_logging;
  603. }
  605. NdbDictionary::Object::Status
  606. NdbDictionary::Index::getObjectStatus() const {
  607.   return m_impl.m_status;
  608. }
  610. int 
  611. NdbDictionary::Index::getObjectVersion() const {
  612.   return m_impl.m_version;
  613. }
  615. /*****************************************************************
  616.  * Event facade
  617.  */
  618. NdbDictionary::Event::Event(const char * name)
  619.   : m_impl(* new NdbEventImpl(* this))
  620. {
  621.   setName(name);
  622. }
  624. NdbDictionary::Event::Event(NdbEventImpl & impl)
  625.   : m_impl(impl) 
  626. {
  627. }
  629. NdbDictionary::Event::~Event()
  630. {
  631.   NdbEventImpl * tmp = &m_impl;
  632.   if(this != tmp){
  633.     delete tmp;
  634.   }
  635. }
  637. void 
  638. NdbDictionary::Event::setName(const char * name)
  639. {
  640.   m_impl.setName(name);
  641. }
  643. void 
  644. NdbDictionary::Event::setTable(const char * table)
  645. {
  646.   m_impl.setTable(table);
  647. }
  649. void
  650. NdbDictionary::Event::addTableEvent(const TableEvent t)
  651. {
  652.   m_impl.addTableEvent(t);
  653. }
  655. void
  656. NdbDictionary::Event::setDurability(const EventDurability d)
  657. {
  658.   m_impl.setDurability(d);
  659. }
  661. void
  662. NdbDictionary::Event::addColumn(const Column & c){
  663.   NdbColumnImpl* col = new NdbColumnImpl;
  664.   (* col) = NdbColumnImpl::getImpl(c);
  665.   m_impl.m_columns.push_back(col);
  666. }
  668. void
  669. NdbDictionary::Event::addEventColumn(unsigned attrId)
  670. {
  671.   m_impl.m_attrIds.push_back(attrId);
  672. }
  674. void
  675. NdbDictionary::Event::addEventColumn(const char * name)
  676. {
  677.   const Column c(name);
  678.   addColumn(c);
  679. }
  681. void
  682. NdbDictionary::Event::addEventColumns(int n, const char ** names)
  683. {
  684.   for (int i = 0; i < n; i++)
  685.     addEventColumn(names[i]);
  686. }
  688. NdbDictionary::Object::Status
  689. NdbDictionary::Event::getObjectStatus() const
  690. {
  691.   return m_impl.m_status;
  692. }
  694. int 
  695. NdbDictionary::Event::getObjectVersion() const
  696. {
  697.   return m_impl.m_version;
  698. }
  700. void NdbDictionary::Event::print()
  701. {
  702.   m_impl.print();
  703. }
  705. /*****************************************************************
  706.  * Dictionary facade
  707.  */
  708. NdbDictionary::Dictionary::Dictionary(Ndb & ndb)
  709.   : m_impl(* new NdbDictionaryImpl(ndb, *this))
  710. {
  711. }
  713. NdbDictionary::Dictionary::Dictionary(NdbDictionaryImpl & impl)
  714.   : m_impl(impl) 
  715. {
  716. }
  717. NdbDictionary::Dictionary::~Dictionary(){
  718.   NdbDictionaryImpl * tmp = &m_impl;  
  719.   if(this != tmp){
  720.     delete tmp;
  721.   }
  722. }
  724. int 
  725. NdbDictionary::Dictionary::createTable(const Table & t){
  726.   return m_impl.createTable(NdbTableImpl::getImpl(t));
  727. }
  729. int
  730. NdbDictionary::Dictionary::dropTable(Table & t){
  731.   return m_impl.dropTable(NdbTableImpl::getImpl(t));
  732. }
  734. int
  735. NdbDictionary::Dictionary::dropTable(const char * name){
  736.   return m_impl.dropTable(name);
  737. }
  739. int
  740. NdbDictionary::Dictionary::alterTable(const Table & t){
  741.   return m_impl.alterTable(NdbTableImpl::getImpl(t));
  742. }
  744. const NdbDictionary::Table * 
  745. NdbDictionary::Dictionary::getTable(const char * name, void **data){
  746.   NdbTableImpl * t = m_impl.getTable(name, data);
  747.   if(t)
  748.     return t->m_facade;
  749.   return 0;
  750. }
  752. void NdbDictionary::Dictionary::set_local_table_data_size(unsigned sz)
  753. {
  754.   m_impl.m_local_table_data_size= sz;
  755. }
  757. const NdbDictionary::Table * 
  758. NdbDictionary::Dictionary::getTable(const char * name){
  759.   return getTable(name, 0);
  760. }
  762. void
  763. NdbDictionary::Dictionary::invalidateTable(const char * name){
  764.   NdbTableImpl * t = m_impl.getTable(name);
  765.   if(t)
  766.     m_impl.invalidateObject(* t);
  767. }
  769. void
  770. NdbDictionary::Dictionary::removeCachedTable(const char * name){
  771.   NdbTableImpl * t = m_impl.getTable(name);
  772.   if(t)
  773.     m_impl.removeCachedObject(* t);
  774. }
  776. int
  777. NdbDictionary::Dictionary::createIndex(const Index & ind)
  778. {
  779.   return m_impl.createIndex(NdbIndexImpl::getImpl(ind));
  780. }
  782. int 
  783. NdbDictionary::Dictionary::dropIndex(const char * indexName,
  784.      const char * tableName)
  785. {
  786.   return m_impl.dropIndex(indexName, tableName);
  787. }
  789. const NdbDictionary::Index * 
  790. NdbDictionary::Dictionary::getIndex(const char * indexName,
  791.     const char * tableName)
  792. {
  793.   NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
  794.   if(i)
  795.     return i->m_facade;
  796.   return 0;
  797. }
  799. void
  800. NdbDictionary::Dictionary::invalidateIndex(const char * indexName,
  801.                                            const char * tableName){
  802.   NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
  803.   if(i) {
  804.     assert(i->m_table != 0);
  805.     m_impl.invalidateObject(* i->m_table);
  806.   }
  807. }
  809. void
  810. NdbDictionary::Dictionary::removeCachedIndex(const char * indexName,
  811.      const char * tableName){
  812.   NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
  813.   if(i) {
  814.     assert(i->m_table != 0);
  815.     m_impl.removeCachedObject(* i->m_table);
  816.   }
  817. }
  819. const NdbDictionary::Table *
  820. NdbDictionary::Dictionary::getIndexTable(const char * indexName, 
  821.  const char * tableName)
  822. {
  823.   NdbIndexImpl * i = m_impl.getIndex(indexName, tableName);
  824.   NdbTableImpl * t = m_impl.getTable(tableName);
  825.   if(i && t) {
  826.     NdbTableImpl * it = m_impl.getIndexTable(i, t);
  827.     return it->m_facade;
  828.   }
  829.   return 0;
  830. }
  833. int
  834. NdbDictionary::Dictionary::createEvent(const Event & ev)
  835. {
  836.   return m_impl.createEvent(NdbEventImpl::getImpl(ev));
  837. }
  839. int 
  840. NdbDictionary::Dictionary::dropEvent(const char * eventName)
  841. {
  842.   return m_impl.dropEvent(eventName);
  843. }
  845. const NdbDictionary::Event *
  846. NdbDictionary::Dictionary::getEvent(const char * eventName)
  847. {
  848.   NdbEventImpl * t = m_impl.getEvent(eventName);
  849.   if(t)
  850.     return t->m_facade;
  851.   return 0;
  852. }
  854. int
  855. NdbDictionary::Dictionary::listObjects(List& list, Object::Type type)
  856. {
  857.   return m_impl.listObjects(list, type);
  858. }
  860. int
  861. NdbDictionary::Dictionary::listIndexes(List& list, const char * tableName)
  862. {
  863.   const NdbDictionary::Table* tab= getTable(tableName);
  864.   if(tab == 0)
  865.   {
  866.     return -1;
  867.   }
  868.   return m_impl.listIndexes(list, tab->getTableId());
  869. }
  871. const struct NdbError & 
  872. NdbDictionary::Dictionary::getNdbError() const {
  873.   return m_impl.getNdbError();
  874. }
  876. // printers
  878. NdbOut&
  879. operator<<(NdbOut& out, const NdbDictionary::Column& col)
  880. {
  881.   const CHARSET_INFO *cs = col.getCharset();
  882.   const char *csname = cs ? cs->name : "?";
  883.   out << col.getName() << " ";
  884.   switch (col.getType()) {
  885.   case NdbDictionary::Column::Tinyint:
  886.     out << "Tinyint";
  887.     break;
  888.   case NdbDictionary::Column::Tinyunsigned:
  889.     out << "Tinyunsigned";
  890.     break;
  891.   case NdbDictionary::Column::Smallint:
  892.     out << "Smallint";
  893.     break;
  894.   case NdbDictionary::Column::Smallunsigned:
  895.     out << "Smallunsigned";
  896.     break;
  897.   case NdbDictionary::Column::Mediumint:
  898.     out << "Mediumint";
  899.     break;
  900.   case NdbDictionary::Column::Mediumunsigned:
  901.     out << "Mediumunsigned";
  902.     break;
  903.   case NdbDictionary::Column::Int:
  904.     out << "Int";
  905.     break;
  906.   case NdbDictionary::Column::Unsigned:
  907.     out << "Unsigned";
  908.     break;
  909.   case NdbDictionary::Column::Bigint:
  910.     out << "Bigint";
  911.     break;
  912.   case NdbDictionary::Column::Bigunsigned:
  913.     out << "Bigunsigned";
  914.     break;
  915.   case NdbDictionary::Column::Float:
  916.     out << "Float";
  917.     break;
  918.   case NdbDictionary::Column::Double:
  919.     out << "Double";
  920.     break;
  921.   case NdbDictionary::Column::Olddecimal:
  922.     out << "Olddecimal(" << col.getPrecision() << "," << col.getScale() << ")";
  923.     break;
  924.   case NdbDictionary::Column::Olddecimalunsigned:
  925.     out << "Olddecimalunsigned(" << col.getPrecision() << "," << col.getScale() << ")";
  926.     break;
  927.   case NdbDictionary::Column::Char:
  928.     out << "Char(" << col.getLength() << ";" << csname << ")";
  929.     break;
  930.   case NdbDictionary::Column::Varchar:
  931.     out << "Varchar(" << col.getLength() << ";" << csname << ")";
  932.     break;
  933.   case NdbDictionary::Column::Binary:
  934.     out << "Binary(" << col.getLength() << ")";
  935.     break;
  936.   case NdbDictionary::Column::Varbinary:
  937.     out << "Varbinary(" << col.getLength() << ")";
  938.     break;
  939.   case NdbDictionary::Column::Datetime:
  940.     out << "Datetime";
  941.     break;
  942.   case NdbDictionary::Column::Date:
  943.     out << "Date";
  944.     break;
  945.   case NdbDictionary::Column::Blob:
  946.     out << "Blob(" << col.getInlineSize() << "," << col.getPartSize()
  947.         << ";" << col.getStripeSize() << ")";
  948.     break;
  949.   case NdbDictionary::Column::Text:
  950.     out << "Text(" << col.getInlineSize() << "," << col.getPartSize()
  951.         << ";" << col.getStripeSize() << ";" << csname << ")";
  952.     break;
  953.   case NdbDictionary::Column::Time:
  954.     out << "Time";
  955.     break;
  956.   case NdbDictionary::Column::Year:
  957.     out << "Year";
  958.     break;
  959.   case NdbDictionary::Column::Timestamp:
  960.     out << "Timestamp";
  961.     break;
  962.   case NdbDictionary::Column::Undefined:
  963.     out << "Undefined";
  964.     break;
  965.   default:
  966.     out << "Type" << (Uint32)col.getType();
  967.     break;
  968.   }
  969.   if (col.getPrimaryKey())
  970.     out << " PRIMARY KEY";
  971.   else if (! col.getNullable())
  972.     out << " NOT NULL";
  973.   else
  974.     out << " NULL";
  976.   if (col.getDistributionKey())
  977.     out << " DISTRIBUTION KEY";
  978.   
  979.   return out;
  980. }
  982. const NdbDictionary::Column * NdbDictionary::Column::FRAGMENT = 0;
  983. const NdbDictionary::Column * NdbDictionary::Column::ROW_COUNT = 0;
  984. const NdbDictionary::Column * NdbDictionary::Column::COMMIT_COUNT = 0;