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

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

MySQL数据库

开发平台：

Visual C++

DataType.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 "DataType.hpp"
  19. // SqlType
  21. SqlType::SqlType() :
  22.     m_type(Undef)
  23. {
  24. }
  26. SqlType::SqlType(Type type, bool nullable)
  27. {
  28.     Ctx ctx;
  29.     setType(ctx, type, nullable);
  30.     ctx_assert(ctx.ok());
  31. }
  33. SqlType::SqlType(Type type, unsigned length, bool nullable)
  34. {
  35.     Ctx ctx;
  36.     setType(ctx, type, length, nullable);
  37.     ctx_assert(ctx.ok());
  38. }
  40. SqlType::SqlType(Type type, unsigned precision, unsigned scale, bool nullable)
  41. {
  42.     Ctx ctx;
  43.     setType(ctx, type, precision, scale, nullable);
  44.     ctx_assert(ctx.ok());
  45. }
  47. SqlType::SqlType(Ctx& ctx, Type type, bool nullable)
  48. {
  49.     setType(ctx, type, nullable);
  50. }
  52. SqlType::SqlType(Ctx& ctx, Type type, unsigned length, bool nullable)
  53. {
  54.     setType(ctx, type, length, nullable);
  55. }
  57. SqlType::SqlType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable)
  58. {
  59.     setType(ctx, type, precision, scale, nullable);
  60. }
  62. SqlType::SqlType(Ctx& ctx, const NdbDictionary::Column* ndbColumn)
  63. {
  64.     setType(ctx, ndbColumn);
  65. }
  67. void
  68. SqlType::setType(Ctx& ctx, Type type, bool nullable)
  69. {
  70.     switch (type) {
  71.     case Smallint:
  72.     case Integer:
  73.     case Bigint:
  74.     case Real:
  75.     case Double:
  76.     case Datetime:
  77. break;
  78.     case Blob:
  79. setType(ctx, Varbinary, FAKE_BLOB_SIZE, nullable); // XXX BLOB hack
  80. return;
  81.     case Clob:
  82. setType(ctx, Varchar, FAKE_BLOB_SIZE, nullable); // XXX BLOB hack
  83. return;
  84.     case Null:
  85.     case Unbound:
  86. break;
  87.     default:
  88. ctx_assert(false);
  89. break;
  90.     }
  91.     m_type = type;
  92.     m_precision = 0;
  93.     m_scale = 0;
  94.     m_length = 0;
  95.     m_nullable = nullable;
  96.     m_unSigned = false;
  97. }
  99. void
  100. SqlType::setType(Ctx& ctx, Type type, unsigned length, bool nullable)
  101. {
  102.     switch (type) {
  103.     case Char:
  104.     case Varchar:
  105.     case Binary:
  106.     case Varbinary:
  107. break;
  108.     default:
  109. ctx_assert(false);
  110. break;
  111.     }
  112.     m_type = type;
  113.     m_precision = 0;
  114.     m_scale = 0;
  115.     m_length = length;
  116.     m_nullable = nullable;
  117.     m_unSigned = false;
  118. }
  120. void
  121. SqlType::setType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable)
  122. {
  123.     ctx_assert(false); // not yet
  124. }
  126. void
  127. SqlType::setType(Ctx& ctx, const NdbDictionary::Column* ndbColumn)
  128. {
  129.     NdbDictionary::Column::Type type = ndbColumn->getType();
  130.     unsigned length = ndbColumn->getLength();
  131.     unsigned precision = ndbColumn->getPrecision();
  132.     unsigned scale = ndbColumn->getScale();
  133.     bool nullable = ndbColumn->getNullable();
  134.     switch (type) {
  135.     case NdbDictionary::Column::Undefined:
  136. break;
  137.     case NdbDictionary::Column::Int:
  138. if (length == 1)
  139.     setType(ctx, Integer, nullable);
  140. else
  141.     setType(ctx, Binary, length * sizeof(SqlInteger), nullable);
  142. return;
  143.     case NdbDictionary::Column::Unsigned:
  144. if (length == 1) {
  145.     setType(ctx, Integer, nullable);
  146.     unSigned(true);
  147. } else
  148.     setType(ctx, Binary, length * sizeof(SqlUinteger), nullable);
  149. return;
  150.     case NdbDictionary::Column::Bigint:
  151. if (length == 1)
  152.     setType(ctx, Bigint, nullable);
  153. else
  154.     setType(ctx, Binary, length * sizeof(SqlBigint), nullable);
  155. return;
  156.     case NdbDictionary::Column::Bigunsigned:
  157. if (length == 1) {
  158.     setType(ctx, Bigint, nullable);
  159.     unSigned(true);
  160. } else
  161.     setType(ctx, Binary, length * sizeof(SqlBigint), nullable);
  162. return;
  163.     case NdbDictionary::Column::Float:
  164. if (length == 1)
  165.     setType(ctx, Real, nullable);
  166. else
  167.     setType(ctx, Binary, length * sizeof(SqlReal), nullable);
  168. return;
  169.     case NdbDictionary::Column::Double:
  170. if (length == 1)
  171.     setType(ctx, Double, nullable);
  172. else
  173.     setType(ctx, Binary, length * sizeof(SqlDouble), nullable);
  174. return;
  175.     case NdbDictionary::Column::Decimal:
  176. setType(ctx, Decimal, precision, scale, nullable);
  177. return;
  178.     case NdbDictionary::Column::Char:
  179. setType(ctx, Char, length, nullable);
  180. return;
  181.     case NdbDictionary::Column::Varchar:
  182. setType(ctx, Varchar, length, nullable);
  183. return;
  184.     case NdbDictionary::Column::Binary:
  185. setType(ctx, Binary, length, nullable);
  186. return;
  187.     case NdbDictionary::Column::Varbinary:
  188. setType(ctx, Varbinary, length, nullable);
  189. return;
  190.     case NdbDictionary::Column::Datetime:
  191. // XXX not yet
  192. break;
  193.     case NdbDictionary::Column::Timespec:
  194. setType(ctx, Datetime, nullable);
  195. return;
  196.     case NdbDictionary::Column::Blob:
  197. setType(ctx, Blob, nullable);
  198. return;
  199.     case NdbDictionary::Column::Clob:
  200. setType(ctx, Clob, nullable);
  201. return;
  202.     default:
  203. break;
  204.     }
  205.     ctx.pushStatus(Error::Gen, "unsupported NDB type %d", (signed)type);
  206. }
  208. bool
  209. SqlType::equal(const SqlType& sqlType) const
  210. {
  211.     return
  212. m_type == sqlType.m_type &&
  213. m_precision == sqlType.m_precision &&
  214. m_scale == sqlType.m_scale &&
  215. m_length == sqlType.m_length;
  216. }
  218. unsigned
  219. SqlType::size() const
  220. {
  221.     switch (m_type) {
  222.     case Char:
  223.     case Varchar:
  224.     case Binary:
  225.     case Varbinary:
  226. return m_length;
  227.     case Smallint:
  228. return sizeof(SqlSmallint);
  229.     case Integer:
  230. return sizeof(SqlInteger);
  231.     case Bigint:
  232. return sizeof(SqlBigint);
  233.     case Real:
  234. return sizeof(SqlReal);
  235.     case Double:
  236. return sizeof(SqlDouble);
  237.     case Datetime:
  238. return sizeof(SqlDatetime);
  239.     case Null:
  240. return 0;
  241.     default:
  242. break;
  243.     }
  244.     ctx_assert(false);
  245.     return 0;
  246. }
  248. unsigned
  249. SqlType::displaySize() const
  250. {
  251.     switch (m_type) {
  252.     case Char:
  253.     case Varchar:
  254. return m_length;
  255.     case Binary:
  256.     case Varbinary:
  257. return m_length;
  258.     case Smallint:
  259. return m_unSigned ? 5 : 6;
  260.     case Integer:
  261. return m_unSigned ? 10 : 11;
  262.     case Bigint:
  263. return m_unSigned ? 20 : 21;
  264.     case Real:
  265. return 10;
  266.     case Double:
  267. return 20;
  268.     case Datetime:
  269. return 30;
  270.     case Null:
  271. return 0;
  272.     default:
  273. break;
  274.     }
  275.     ctx_assert(false);
  276.     return 0;
  277. }
  279. void
  280. SqlType::getType(Ctx& ctx, NdbDictionary::Column* ndbColumn) const
  281. {
  282.     switch (m_type) {
  283.     case Char:
  284. ndbColumn->setType(NdbDictionary::Column::Char);
  285. ndbColumn->setLength(m_length);
  286. break;
  287.     case Varchar:
  288. ndbColumn->setType(NdbDictionary::Column::Varchar);
  289. ndbColumn->setLength(m_length);
  290. break;
  291.     case Binary:
  292. ndbColumn->setType(NdbDictionary::Column::Binary);
  293. ndbColumn->setLength(m_length);
  294. break;
  295.     case Varbinary:
  296. ndbColumn->setType(NdbDictionary::Column::Varbinary);
  297. ndbColumn->setLength(m_length);
  298. break;
  299.     case Smallint:
  300. break; // XXX
  301.     case Integer:
  302. if (! m_unSigned)
  303.     ndbColumn->setType(NdbDictionary::Column::Int);
  304. else
  305.     ndbColumn->setType(NdbDictionary::Column::Unsigned);
  306. ndbColumn->setLength(1);
  307. break;
  308.     case Bigint:
  309. if (! m_unSigned)
  310.     ndbColumn->setType(NdbDictionary::Column::Bigint);
  311. else
  312.     ndbColumn->setType(NdbDictionary::Column::Bigunsigned);
  313. ndbColumn->setLength(1);
  314. break;
  315.     case Real:
  316. ndbColumn->setType(NdbDictionary::Column::Float);
  317. ndbColumn->setLength(1);
  318. break;
  319.     case Double:
  320. ndbColumn->setType(NdbDictionary::Column::Double);
  321. ndbColumn->setLength(1);
  322. break;
  323.     case Datetime:
  324. ndbColumn->setType(NdbDictionary::Column::Timespec);
  325. ndbColumn->setLength(1);
  326. break;
  327.     default:
  328. ctx_assert(false);
  329. break;
  330.     }
  331.     ndbColumn->setNullable(m_nullable);
  332. }
  334. const char*
  335. SqlType::typeName() const
  336. {
  337.     switch (m_type) {
  338.     case Char:
  339. return "CHAR";
  340.     case Varchar:
  341. return "VARCHAR";
  342.     case Binary:
  343. return "BINARY";
  344.     case Varbinary:
  345. return "VARBINARY";
  346.     case Smallint:
  347. return "SMALLINT";
  348.     case Integer:
  349. return "INTEGER";
  350.     case Bigint:
  351. return "BIGINT";
  352.     case Real:
  353. return "REAL";
  354.     case Double:
  355. return "FLOAT";
  356.     case Datetime:
  357. return "DATETIME";
  358.     default:
  359. break;
  360.     }
  361.     return "UNKNOWN";
  362. }
  364. void
  365. SqlType::print(char* buf, unsigned size) const
  366. {
  367.     switch (m_type) {
  368.     case Char:
  369. snprintf(buf, size, "char(%d)", m_length);
  370. break;
  371.     case Varchar:
  372. snprintf(buf, size, "varchar(%d)", m_length);
  373. break;
  374.     case Binary:
  375. snprintf(buf, size, "binary(%d)", m_length);
  376. break;
  377.     case Varbinary:
  378. snprintf(buf, size, "varbinary(%d)", m_length);
  379. break;
  380.     case Smallint:
  381. snprintf(buf, size, "smallint%s", m_unSigned ? " unsigned" : "");
  382. break;
  383.     case Integer:
  384. snprintf(buf, size, "integer%s", m_unSigned ? " unsigned" : "");
  385. break;
  386.     case Bigint:
  387. snprintf(buf, size, "bigint%s", m_unSigned ? " unsigned" : "");
  388. break;
  389.     case Real:
  390. snprintf(buf, size, "real");
  391. break;
  392.     case Double:
  393. snprintf(buf, size, "double");
  394. break;
  395.     case Datetime:
  396. snprintf(buf, size, "datetime");
  397. break;
  398.     case Null:
  399. snprintf(buf, size, "null");
  400. break;
  401.     case Unbound:
  402. snprintf(buf, size, "unbound");
  403. break;
  404.     default:
  405. snprintf(buf, size, "sqltype(%d)", (int)m_type);
  406. break;
  407.     }
  408. }
  410. // ExtType
  412. ExtType::ExtType() :
  413.     m_type(Undef)
  414. {
  415. }
  417. ExtType::ExtType(Type type)
  418. {
  419.     Ctx ctx;
  420.     setType(ctx, type);
  421.     ctx_assert(ctx.ok());
  422. }
  424. ExtType::ExtType(Ctx& ctx, Type type)
  425. {
  426.     setType(ctx, type);
  427. }
  429. void
  430. ExtType::setType(Ctx& ctx, Type type)
  431. {
  432.     switch (type) {
  433.     case Char:
  434.     case Short:
  435.     case Sshort:
  436.     case Ushort:
  437.     case Long:
  438.     case Slong:
  439.     case Ulong:
  440.     case Sbigint:
  441.     case Ubigint:
  442.     case Float:
  443.     case Double:
  444.     case Timestamp:
  445.     case Binary: // XXX BLOB hack
  446.     case Unbound:
  447. break;
  448.     default:
  449. ctx.pushStatus(Error::Gen, "unsupported external type %d", (int)type);
  450. return;
  451.     }
  452.     m_type = type;
  453. }
  455. unsigned
  456. ExtType::size() const
  457. {
  458.     ctx_assert(false);
  459.     return 0;
  460. }
  462. // LexType
  464. LexType::LexType() :
  465.     m_type(Undef)
  466. {
  467. }
  469. LexType::LexType(Type type)
  470. {
  471.     Ctx ctx;
  472.     setType(ctx, type);
  473.     ctx_assert(ctx.ok());
  474. }
  476. LexType::LexType(Ctx& ctx, Type type)
  477. {
  478.     setType(ctx, type);
  479. }
  481. void
  482. LexType::setType(Ctx& ctx, Type type)
  483. {
  484.     switch (type) {
  485.     case Char:
  486.     case Integer:
  487.     case Float:
  488.     case Null:
  489. break;
  490.     default:
  491. ctx_assert(false);
  492. break;
  493.     }
  494.     m_type = type;
  495. }
  497. // convert types
  499. SQLSMALLINT
  500. SqlType::sqlcdefault(Ctx& ctx) const
  501. {
  502.     switch (m_type) {
  503.     case Char:
  504. return SQL_C_CHAR;
  505.     case Varchar:
  506. return SQL_C_CHAR;
  507.     case Binary:
  508. return SQL_C_BINARY;
  509.     case Varbinary:
  510. return SQL_C_BINARY;
  511.     case Smallint:
  512. return m_unSigned ? SQL_C_USHORT : SQL_C_SSHORT;
  513.     case Integer:
  514. return m_unSigned ? SQL_C_ULONG : SQL_C_SLONG;
  515.     case Bigint:
  516. return SQL_C_CHAR;
  517. // or maybe this
  518. return m_unSigned ? SQL_C_UBIGINT : SQL_C_SBIGINT;
  519.     case Real:
  520. return SQL_C_FLOAT;
  521.     case Double:
  522. return SQL_C_DOUBLE;
  523.     case Datetime:
  524. return SQL_C_TYPE_TIMESTAMP;
  525.     default:
  526. break;
  527.     }
  528.     return SQL_C_DEFAULT; // no default
  529. }
  531. void
  532. LexType::convert(Ctx& ctx, SqlType& out, unsigned length) const
  533. {
  534.     switch (m_type) {
  535.     case Char:
  536. out.setType(ctx, SqlType::Char, length, true);
  537. return;
  538.     case Integer:
  539. out.setType(ctx, SqlType::Bigint, false);
  540. return;
  541.     case Float:
  542. out.setType(ctx, SqlType::Double, false);
  543. return;
  544.     case Null:
  545. out.setType(ctx, SqlType::Null, true);
  546. return;
  547.     default:
  548. break;
  549.     }
  550.     ctx.pushStatus(Error::Gen, "unsupported lexical to SQL type conversion");
  551. }