DataType.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef ODBC_COMMON_DataType_hpp
  14. #define ODBC_COMMON_DataType_hpp
  15. #include <map>
  16. #include <ndb_types.h>
  17. #include <AttrType.hpp>
  18. #include <NdbDictionary.hpp>
  19. #include <common/common.hpp>
  20. /**
  21.  * Sql data exists in several formats:
  22.  *
  23.  * - as NDB data at the bottom
  24.  * - as SQL data during intermediary processing
  25.  * - as external data in user input and output buffers
  26.  * - as lexical constants in SQL statement text
  27.  *
  28.  * Each data format has specific types (e.g. number) and each
  29.  * type has specific attributes (e.g. precision).
  30.  */
  31. enum DataFormat {
  32.     Undef_format = 0,
  33.     Ndb_format = 1, // not used in NDB version >= v2.10
  34.     Sql_format = 2,
  35.     Ext_format = 3,
  36.     Lex_format = 4
  37. };
  38. #define UndefDataType 990
  39. #define NullDataType 991
  40. #define UnboundDataType 992
  41. class SqlType;
  42. class ExtType;
  43. class LexType;
  44. /**
  45.  * @class SqlType
  46.  * @brief Sql data type
  47.  */
  48. class SqlType {
  49. public:
  50.     enum Type {
  51. Undef = UndefDataType,
  52. Char = SQL_CHAR,
  53. Varchar = SQL_VARCHAR,
  54. Longvarchar = SQL_LONGVARCHAR,
  55. Binary = SQL_BINARY,
  56. Varbinary = SQL_VARBINARY,
  57. Longvarbinary = SQL_LONGVARBINARY,
  58. Decimal = SQL_DECIMAL,
  59. Tinyint = SQL_TINYINT,
  60. Smallint = SQL_SMALLINT,
  61. Integer = SQL_INTEGER,
  62. Bigint = SQL_BIGINT,
  63. Real = SQL_REAL,
  64. Double = SQL_DOUBLE,
  65. Date = SQL_DATE,
  66. Datetime = SQL_TYPE_TIMESTAMP,
  67. Blob = SQL_BLOB,
  68. Clob = SQL_CLOB,
  69. Null = NullDataType, // not an ODBC SQL type
  70. Unbound = UnboundDataType // special for placeholders
  71.     };
  72.     SqlType();
  73.     SqlType(Type type, bool nullable = true);
  74.     SqlType(Type type, unsigned length, bool nullable = true);
  75.     SqlType(Type type, unsigned precision, unsigned scale, bool nullable = true);
  76.     SqlType(Ctx& ctx, Type type, bool nullable = true);
  77.     SqlType(Ctx& ctx, Type type, unsigned length, bool nullable = true);
  78.     SqlType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable = true);
  79.     SqlType(Ctx& ctx, const NdbDictionary::Column* ndbColumn);
  80.     Type type() const;
  81.     void setType(Ctx& ctx, Type type, bool nullable = true);
  82.     void setType(Ctx& ctx, Type type, unsigned length, bool nullable = true);
  83.     void setType(Ctx& ctx, Type type, unsigned precision, unsigned scale, bool nullable = true);
  84.     void setType(Ctx& ctx, const NdbDictionary::Column* ndbColumn);
  85.     bool equal(const SqlType& sqlType) const;
  86.     unsigned size() const;
  87.     unsigned displaySize() const;
  88.     const char* typeName() const;
  89.     unsigned length() const;
  90.     bool nullable() const;
  91.     void nullable(bool value);
  92.     bool unSigned() const;
  93.     void unSigned(bool value);
  94.     // forwards compatible
  95.     void getType(Ctx& ctx, NdbDictionary::Column* ndbColumn) const;
  96.     // type conversion
  97.     SQLSMALLINT sqlcdefault(Ctx& ctx) const;
  98.     // print for debugging
  99.     void print(char* buf, unsigned size) const;
  100. private:
  101.     friend class LexType;
  102.     Type m_type;
  103.     unsigned m_precision;
  104.     unsigned m_scale;
  105.     unsigned m_length;
  106.     bool m_nullable;
  107.     bool m_unSigned; // qualifier instead of separate types
  108. };
  109. inline SqlType::Type
  110. SqlType::type() const
  111. {
  112.     return m_type;
  113. }
  114. inline unsigned
  115. SqlType::length() const
  116. {
  117.     return m_length;
  118. }
  119. inline bool
  120. SqlType::nullable() const
  121. {
  122.     return m_nullable;
  123. }
  124. inline void
  125. SqlType::nullable(bool value)
  126. {
  127.     m_nullable = value;
  128. }
  129. inline bool
  130. SqlType::unSigned() const
  131. {
  132.     return m_unSigned;
  133. }
  134. inline void
  135. SqlType::unSigned(bool value)
  136. {
  137.     ctx_assert(m_type == Smallint || m_type == Integer || m_type == Bigint);
  138.     m_unSigned = value;
  139. }
  140. /**
  141.  * Actual SQL datatypes.
  142.  */
  143. typedef unsigned char SqlChar; // Char and Varchar via pointer
  144. typedef Int16 SqlSmallint;
  145. typedef Int32 SqlInteger;
  146. typedef Int64 SqlBigint;
  147. typedef Uint16 SqlUsmallint;
  148. typedef Uint32 SqlUinteger;
  149. typedef Uint64 SqlUbigint;
  150. typedef float SqlReal;
  151. typedef double SqlDouble;
  152. // datetime cc yy mm dd HH MM SS 00 ff ff ff ff stored as String(12)
  153. struct SqlDatetime {
  154.     int cc() const { return *(signed char*)&m_data[0]; }
  155.     void cc(int x) { *(signed char*)&m_data[0] = x; }
  156.     unsigned yy() const { return *(unsigned char*)&m_data[1]; }
  157.     void yy(unsigned x) { *(unsigned char*)&m_data[1] = x; }
  158.     unsigned mm() const { return *(unsigned char*)&m_data[2]; }
  159.     void mm(unsigned x) { *(unsigned char*)&m_data[2] = x; }
  160.     unsigned dd() const { return *(unsigned char*)&m_data[3]; }
  161.     void dd(unsigned x) { *(unsigned char*)&m_data[3] = x; }
  162.     unsigned HH() const { return *(unsigned char*)&m_data[4]; }
  163.     void HH(unsigned x) { *(unsigned char*)&m_data[4] = x; }
  164.     unsigned MM() const { return *(unsigned char*)&m_data[5]; }
  165.     void MM(unsigned x) { *(unsigned char*)&m_data[5] = x; }
  166.     unsigned SS() const { return *(unsigned char*)&m_data[6]; }
  167.     void SS(unsigned x) { *(unsigned char*)&m_data[6] = x; }
  168.     unsigned ff() const {
  169. const unsigned char* p = (unsigned char*)&m_data[8];
  170. unsigned x = 0;
  171. x += *p++ << 24;
  172. x += *p++ << 16;
  173. x += *p++ << 8;
  174. x += *p++;
  175. return x;
  176.     }
  177.     void ff(unsigned x) {
  178. unsigned char* p = (unsigned char*)&m_data[8];
  179. *p++ = (x >> 24) & 0xff;
  180. *p++ = (x >> 16) & 0xff;
  181. *p++ = (x >> 8) & 0xff;
  182. *p++ = x & 0xff;
  183.     }
  184.     bool valid() { return true; } // XXX later
  185.     bool less(const SqlDatetime t) const {
  186. if (cc() != t.cc())
  187.     return cc() < t.cc();
  188. if (yy() != t.yy())
  189.     return yy() < t.yy();
  190. if (mm() != t.mm())
  191.     return mm() < t.mm();
  192. if (dd() != t.dd())
  193.     return dd() < t.dd();
  194. if (HH() != t.HH())
  195.     return HH() < t.HH();
  196. if (MM() != t.MM())
  197.     return MM() < t.MM();
  198. if (SS() != t.SS())
  199.     return SS() < t.SS();
  200. if (ff() != t.ff())
  201.     return ff() < t.ff();
  202. return false;
  203.     }
  204. private:
  205.     char m_data[12]; // use array to avoid gaps
  206. };
  207. /**
  208.  * @class ExtType
  209.  * @brief External data type
  210.  */
  211. class ExtType {
  212. public:
  213.     enum Type {
  214. Undef = UndefDataType,
  215. Char = SQL_C_CHAR,
  216. Short = SQL_C_SHORT,
  217. Sshort = SQL_C_SSHORT,
  218. Ushort = SQL_C_USHORT,
  219. Long = SQL_C_LONG, // for sun.jdbc.odbc
  220. Slong = SQL_C_SLONG,
  221. Ulong = SQL_C_ULONG,
  222. Sbigint = SQL_C_SBIGINT,
  223. Ubigint = SQL_C_UBIGINT,
  224. Float = SQL_C_FLOAT,
  225. Double = SQL_C_DOUBLE,
  226. Timestamp = SQL_C_TYPE_TIMESTAMP,
  227. Binary = SQL_C_BINARY, // XXX BLOB hack
  228. Unbound = UnboundDataType
  229.     };
  230.     ExtType();
  231.     ExtType(Type type);
  232.     ExtType(Ctx& ctx, Type type);
  233.     Type type() const;
  234.     void setType(Ctx& ctx, Type type);
  235.     unsigned size() const;
  236. private:
  237.     Type m_type;
  238. };
  239. inline ExtType::Type
  240. ExtType::type() const
  241. {
  242.     return m_type;
  243. }
  244. /**
  245.  * @class LexType
  246.  * @class Lexical data type
  247.  */
  248. class LexType {
  249. public:
  250.     enum Type {
  251. Undef = UndefDataType,
  252. Char = 1,
  253. Integer = 2,
  254. Float = 3,
  255. Null = 4
  256.     };
  257.     LexType();
  258.     LexType(Type type);
  259.     LexType(Ctx& ctx, Type type);
  260.     Type type() const;
  261.     void setType(Ctx& ctx, Type type);
  262.     void convert(Ctx& ctx, SqlType& out, unsigned length = 0) const;
  263. private:
  264.     Type m_type;
  265. };
  266. inline LexType::Type
  267. LexType::type() const
  268. {
  269.     return m_type;
  270. }
  271. #endif