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

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

MySQL数据库

开发平台：

Visual C++

OdbcData.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 "OdbcData.hpp"
  19. OdbcData::OdbcData() :
  20.     m_type(Undef)
  21. {
  22. }
  24. OdbcData::OdbcData(Type type) :
  25.     m_type(type)
  26. {
  27.     switch (m_type) {
  28.     case Smallint:
  29. m_smallint = 0;
  30. break;
  31.     case Usmallint:
  32. m_usmallint = 0;
  33. break;
  34.     case Integer:
  35. m_integer = 0;
  36. break;
  37.     case Uinteger:
  38. m_uinteger = 0;
  39. break;
  40.     case Pointer:
  41. m_pointer = 0;
  42. break;
  43.     case SmallintPtr:
  44. m_smallintPtr = 0;
  45. break;
  46.     case UsmallintPtr:
  47. m_usmallintPtr = 0;
  48. break;
  49.     case IntegerPtr:
  50. m_integerPtr = 0;
  51. break;
  52.     case UintegerPtr:
  53. m_uintegerPtr = 0;
  54. break;
  55.     case PointerPtr:
  56. m_pointerPtr = 0;
  57. break;
  58.     case Sqlchar:
  59. m_sqlchar = 0;
  60. break;
  61.     case Sqlstate:
  62. m_sqlstate = 0;
  63. break;
  64.     default:
  65. ctx_assert(false);
  66. break;
  67.     };
  68. }
  70. OdbcData::OdbcData(const OdbcData& odbcData) :
  71.     m_type(odbcData.m_type)
  72. {
  73.     switch (m_type) {
  74.     case Smallint:
  75. m_smallint = odbcData.m_smallint;
  76. break;
  77.     case Usmallint:
  78. m_usmallint = odbcData.m_usmallint;
  79. break;
  80.     case Integer:
  81. m_integer = odbcData.m_integer;
  82. break;
  83.     case Uinteger:
  84. m_uinteger = odbcData.m_uinteger;
  85. break;
  86.     case Pointer:
  87. m_pointer = odbcData.m_pointer;
  88. break;
  89.     case SmallintPtr:
  90. m_smallintPtr = odbcData.m_smallintPtr;
  91. break;
  92.     case UsmallintPtr:
  93. m_usmallintPtr = odbcData.m_usmallintPtr;
  94. break;
  95.     case IntegerPtr:
  96. m_integerPtr = odbcData.m_integerPtr;
  97. break;
  98.     case UintegerPtr:
  99. m_uintegerPtr = odbcData.m_uintegerPtr;
  100. break;
  101.     case PointerPtr:
  102. m_pointerPtr = odbcData.m_pointerPtr;
  103. break;
  104.     case Sqlchar: {
  105. unsigned n = strlen(odbcData.m_sqlchar);
  106. m_sqlchar = new char[n + 1];
  107. memcpy(m_sqlchar, odbcData.m_sqlchar, n + 1);
  108. break;
  109. }
  110.     case Sqlstate:
  111. m_sqlstate = odbcData.m_sqlstate;
  112. break;
  113.     default:
  114. ctx_assert(false);
  115. break;
  116.     };
  117. }
  119. OdbcData::~OdbcData()
  120. {
  121.     switch (m_type) {
  122.     case Sqlchar:
  123. delete[] m_sqlchar;
  124. break;
  125.     default:
  126. break;
  127.     }
  128. }
  130. void
  131. OdbcData::setValue()
  132. {
  133.     m_type = Undef;
  134. }
  136. void
  137. OdbcData::setValue(Type type)
  138. {
  139.     if (m_type == Sqlchar) {
  140. delete[] m_sqlchar;
  141. m_sqlchar = 0;
  142.     }
  143.     switch (m_type) {
  144.     case Smallint:
  145. m_smallint = 0;
  146. break;
  147.     case Usmallint:
  148. m_usmallint = 0;
  149. break;
  150.     case Integer:
  151. m_integer = 0;
  152. break;
  153.     case Uinteger:
  154. m_uinteger = 0;
  155. break;
  156.     case Pointer:
  157. m_pointer = 0;
  158. break;
  159.     case SmallintPtr:
  160. m_smallintPtr = 0;
  161. break;
  162.     case UsmallintPtr:
  163. m_usmallintPtr = 0;
  164. break;
  165.     case IntegerPtr:
  166. m_integerPtr = 0;
  167. break;
  168.     case UintegerPtr:
  169. m_uintegerPtr = 0;
  170. break;
  171.     case PointerPtr:
  172. m_pointerPtr = 0;
  173. break;
  174.     case Sqlchar:
  175. m_sqlchar = 0;
  176. break;
  177.     case Sqlstate:
  178. m_sqlstate = 0;
  179. break;
  180.     default:
  181. ctx_assert(false);
  182. break;
  183.     };
  184. }
  186. void
  187. OdbcData::setValue(const OdbcData odbcData)
  188. {
  189.     if (m_type == Sqlchar) {
  190. delete[] m_sqlchar;
  191. m_sqlchar = 0;
  192.     }
  193.     m_type = odbcData.m_type;
  194.     switch (m_type) {
  195.     case Smallint:
  196. m_smallint = odbcData.m_smallint;
  197. break;
  198.     case Usmallint:
  199. m_usmallint = odbcData.m_usmallint;
  200. break;
  201.     case Integer:
  202. m_integer = odbcData.m_integer;
  203. break;
  204.     case Uinteger:
  205. m_uinteger = odbcData.m_uinteger;
  206. break;
  207.     case Pointer:
  208. m_pointer = odbcData.m_pointer;
  209. break;
  210.     case SmallintPtr:
  211. m_smallintPtr = odbcData.m_smallintPtr;
  212. break;
  213.     case UsmallintPtr:
  214. m_usmallintPtr = odbcData.m_usmallintPtr;
  215. break;
  216.     case IntegerPtr:
  217. m_integerPtr = odbcData.m_integerPtr;
  218. break;
  219.     case UintegerPtr:
  220. m_uintegerPtr = odbcData.m_uintegerPtr;
  221. break;
  222.     case PointerPtr:
  223. m_pointerPtr = odbcData.m_pointerPtr;
  224. break;
  225.     case Sqlchar: {
  226. unsigned n = strlen(odbcData.m_sqlchar);
  227. m_sqlchar = new char[n + 1];
  228. memcpy(m_sqlchar, odbcData.m_sqlchar, n + 1);
  229. break;
  230. }
  231.     case Sqlstate:
  232. m_sqlstate = odbcData.m_sqlstate;
  233. break;
  234.     default:
  235. ctx_assert(false);
  236. break;
  237.     };
  238. }
  240. // copy in from user buffer
  242. void
  243. OdbcData::copyin(Ctx& ctx, Type type, SQLPOINTER buf, SQLINTEGER length)
  244. {
  245.     if (m_type == Sqlchar) {
  246. delete[] m_sqlchar;
  247. m_sqlchar = 0;
  248.     }
  249.     m_type = type;
  250.     switch (m_type) {
  251.     case Smallint: {
  252. SQLSMALLINT val = 0;
  253. switch (length) {
  254. case 0:
  255. case SQL_IS_SMALLINT:
  256.     val = (SQLSMALLINT)(SQLINTEGER)buf;
  257.     break;
  258. case SQL_IS_USMALLINT:
  259.     val = (SQLUSMALLINT)(SQLUINTEGER)buf;
  260.     break;
  261. case SQL_IS_INTEGER:
  262.     val = (SQLINTEGER)buf;
  263.     break;
  264. case SQL_IS_UINTEGER:
  265.     val = (SQLUINTEGER)buf;
  266.     break;
  267. default:
  268.     ctx.pushStatus(Error::Gen, "smallint input - invalid length %d", (int)length);
  269.     return;
  270. }
  271. m_smallint = val;
  272. break;
  273. }
  274.     case Usmallint: {
  275. SQLUSMALLINT val = 0;
  276. switch (length) {
  277. case SQL_IS_SMALLINT:
  278.     val = (SQLSMALLINT)(SQLINTEGER)buf;
  279.     break;
  280. case 0:
  281. case SQL_IS_USMALLINT:
  282.     val = (SQLUSMALLINT)(SQLUINTEGER)buf;
  283.     break;
  284. case SQL_IS_INTEGER:
  285.     val = (SQLINTEGER)buf;
  286.     break;
  287. case SQL_IS_UINTEGER:
  288.     val = (SQLUINTEGER)buf;
  289.     break;
  290. default:
  291.     ctx.pushStatus(Error::Gen, "unsigned smallint input - invalid length %d", (int)length);
  292.     return;
  293. }
  294. m_usmallint = val;
  295. break;
  296. }
  297.     case Integer: {
  298. SQLINTEGER val = 0;
  299. switch (length) {
  300. case SQL_IS_SMALLINT:
  301.     val = (SQLSMALLINT)(SQLINTEGER)buf;
  302.     break;
  303. case SQL_IS_USMALLINT:
  304.     val = (SQLUSMALLINT)(SQLUINTEGER)buf;
  305.     break;
  306. case 0:
  307. case SQL_IS_INTEGER:
  308.     val = (SQLINTEGER)buf;
  309.     break;
  310. case SQL_IS_UINTEGER:
  311.     val = (SQLUINTEGER)buf;
  312.     break;
  313. default:
  314.     ctx.pushStatus(Error::Gen, "integer input - invalid length %d", (int)length);
  315.     return;
  316. }
  317. m_integer = val;
  318. break;
  319. }
  320.     case Uinteger: {
  321. SQLUINTEGER val = 0;
  322. switch (length) {
  323. case SQL_IS_SMALLINT:
  324.     val = (SQLSMALLINT)(SQLINTEGER)buf;
  325.     break;
  326. case SQL_IS_USMALLINT:
  327.     val = (SQLUSMALLINT)(SQLUINTEGER)buf;
  328.     break;
  329. case SQL_IS_INTEGER:
  330.     val = (SQLINTEGER)buf;
  331.     break;
  332. case 0:
  333. case SQL_IS_UINTEGER:
  334.     val = (SQLUINTEGER)buf;
  335.     break;
  336. default:
  337.     ctx.pushStatus(Error::Gen, "unsigned integer input - invalid length %d", (int)length);
  338.     return;
  339. }
  340. m_uinteger = val;
  341. break;
  342. }
  343.     case Pointer: {
  344. SQLPOINTER val = 0;
  345. switch (length) {
  346. case 0:
  347. case SQL_IS_POINTER:
  348.     val = (SQLPOINTER)buf;
  349.     break;
  350. default:
  351.     ctx.pushStatus(Error::Gen, "pointer input - invalid length %d", (int)length);
  352.     return;
  353. }
  354. m_pointer = val;
  355. break;
  356. }
  357.     case SmallintPtr: {
  358. SQLSMALLINT* val = 0;
  359. switch (length) {
  360. case 0:
  361. case SQL_IS_POINTER:
  362.     val = (SQLSMALLINT*)buf;
  363.     break;
  364. default:
  365.     ctx.pushStatus(Error::Gen, "smallint pointer input - invalid length %d", (int)length);
  366.     return;
  367. }
  368. m_smallintPtr = val;
  369. break;
  370. }
  371.     case UsmallintPtr: {
  372. SQLUSMALLINT* val = 0;
  373. switch (length) {
  374. case 0:
  375. case SQL_IS_POINTER:
  376.     val = (SQLUSMALLINT*)buf;
  377.     break;
  378. default:
  379.     ctx.pushStatus(Error::Gen, "unsigned smallint pointer input - invalid length %d", (int)length);
  380.     return;
  381. }
  382. m_usmallintPtr = val;
  383. break;
  384. }
  385.     case IntegerPtr: {
  386. SQLINTEGER* val = 0;
  387. switch (length) {
  388. case 0:
  389. case SQL_IS_POINTER:
  390.     val = (SQLINTEGER*)buf;
  391.     break;
  392. default:
  393.     ctx.pushStatus(Error::Gen, "integer pointer input - invalid length %d", (int)length);
  394.     return;
  395. }
  396. m_integerPtr = val;
  397. break;
  398. }
  399.     case UintegerPtr: {
  400. SQLUINTEGER* val = 0;
  401. switch (length) {
  402. case 0:
  403. case SQL_IS_POINTER:
  404.     val = (SQLUINTEGER*)buf;
  405.     break;
  406. default:
  407.     ctx.pushStatus(Error::Gen, "unsigned integer pointer input - invalid length %d", (int)length);
  408.     return;
  409. }
  410. m_uintegerPtr = val;
  411. break;
  412. }
  413.     case Sqlchar: {
  414. const char* val = (char*)buf;
  415. if (val == 0) {
  416.     ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "null string input");
  417.     return;
  418. }
  419. if (length < 0 && length != SQL_NTS) {
  420.     ctx.pushStatus(Error::Gen, "string input - invalid length %d", (int)length);
  421.     return;
  422. }
  423. if (length == SQL_NTS) {
  424.     m_sqlchar = strcpy(new char[strlen(val) + 1], val);
  425. } else {
  426.     m_sqlchar = (char*)memcpy(new char[length + 1], val, length);
  427.     m_sqlchar[length] = 0;
  428. }
  429. break;
  430. }
  431.     default:
  432. ctx_assert(false);
  433. break;
  434.     }
  435. }
  437. // copy out to user buffer
  439. void
  440. OdbcData::copyout(Ctx& ctx, SQLPOINTER buf, SQLINTEGER length, SQLINTEGER* total, SQLSMALLINT* total2)
  441. {
  442.     if (buf == 0) {
  443. ctx.setCode(SQL_ERROR);
  444. return;
  445.     }
  446.     switch (m_type) {
  447.     case Smallint: {
  448. SQLSMALLINT* ptr = static_cast<SQLSMALLINT*>(buf);
  449. *ptr = m_smallint;
  450. break;
  451. }
  452.     case Usmallint: {
  453. SQLUSMALLINT* ptr = static_cast<SQLUSMALLINT*>(buf);
  454. *ptr = m_usmallint;
  455. break;
  456. }
  457.     case Integer: {
  458. SQLINTEGER* ptr = static_cast<SQLINTEGER*>(buf);
  459. *ptr = m_integer;
  460. break;
  461. }
  462.     case Uinteger: {
  463. SQLUINTEGER* ptr = static_cast<SQLUINTEGER*>(buf);
  464. *ptr = m_uinteger;
  465. break;
  466. }
  467.     case Pointer: {
  468. SQLPOINTER* ptr = static_cast<SQLPOINTER*>(buf);
  469. *ptr = m_pointer;
  470. break;
  471. }
  472.     case Sqlchar: {
  473. char* ptr = static_cast<char*>(buf);
  474. if (length < 0 && length != SQL_NTS) {
  475.     ctx.setCode(SQL_ERROR);
  476.     return;
  477. }
  478. if (length == SQL_NTS) {
  479.     strcpy(ptr, m_sqlchar);
  480. } else {
  481.     strncpy(ptr, m_sqlchar, length);
  482. }
  483. if (total != 0)
  484.     *total = strlen(m_sqlchar);
  485. if (total2 != 0)
  486.     *total2 = strlen(m_sqlchar);
  487. break;
  488. }
  489.     case Sqlstate: {
  490. char* ptr = static_cast<char*>(buf);
  491. const char* state = m_sqlstate->state();
  492. if (length < 0 && length != SQL_NTS) {
  493.     ctx.setCode(SQL_ERROR);
  494.     return;
  495. }
  496. if (length == SQL_NTS) {
  497.     strcpy(ptr, state);
  498. } else {
  499.     strncpy(ptr, state, length);
  500. }
  501. if (total != 0)
  502.     *total = strlen(state);
  503. if (total2 != 0)
  504.     *total2 = strlen(state);
  505. break;
  506. }
  507.     default:
  508. ctx_assert(false);
  509. break;
  510.     }
  511. }
  513. void
  514. OdbcData::print(char* buf, unsigned size) const
  515. {
  516.     switch (m_type) {
  517.     case Undef:
  518. snprintf(buf, size, "undef");
  519. break;
  520.     case Smallint:
  521. snprintf(buf, size, "%d", (int)m_smallint);
  522. break;
  523.     case Usmallint:
  524. snprintf(buf, size, "%u", (unsigned)m_usmallint);
  525. break;
  526.     case Integer:
  527. snprintf(buf, size, "%ld", (long)m_integer);
  528. break;
  529.     case Uinteger:
  530. snprintf(buf, size, "%lu", (unsigned long)m_uinteger);
  531. break;
  532.     case Pointer:
  533. snprintf(buf, size, "0x%lx", (unsigned long)m_pointer);
  534. break;
  535.     case SmallintPtr:
  536. snprintf(buf, size, "0x%lx", (unsigned long)m_smallintPtr);
  537. break;
  538.     case UsmallintPtr:
  539. snprintf(buf, size, "0x%lx", (unsigned long)m_usmallintPtr);
  540. break;
  541.     case IntegerPtr:
  542. snprintf(buf, size, "0x%lx", (unsigned long)m_integerPtr);
  543. break;
  544.     case UintegerPtr:
  545. snprintf(buf, size, "0x%lx", (unsigned long)m_uintegerPtr);
  546. break;
  547.     case PointerPtr:
  548. snprintf(buf, size, "0x%lx", (unsigned long)m_pointerPtr);
  549. break;
  550.     case Sqlchar:
  551. snprintf(buf, size, "%s", m_sqlchar);
  552. break;
  553.     case Sqlstate:
  554. snprintf(buf, size, "%s", m_sqlstate->state());
  555. break;
  556.     default:
  557. snprintf(buf, size, "data(%d)", (int)m_type);
  558. break;
  559.     };
  560. }