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

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

MySQL数据库

开发平台：

Visual C++

AttrDbc.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 "HandleDbc.hpp"
  19. static void
  20. callback_SQL_ATTR_ACCESS_MODE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  21. {
  22.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  23.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  24.     SQLUINTEGER value = data.uinteger();
  25.     switch (value) {
  26.     case SQL_MODE_READ_ONLY:
  27. break;
  28.     case SQL_MODE_READ_WRITE:
  29. break;
  30.     default:
  31. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid access mode value %u", (unsigned)value);
  32. break;
  33.     }
  34. }
  36. static void
  37. callback_SQL_ATTR_ACCESS_MODE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  38. {
  39.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  40.     ctx_assert(pDbc != 0);
  41.     SQLUINTEGER value = SQL_MODE_READ_WRITE;
  42.     data.setValue(value);
  43. }
  45. static void
  46. callback_SQL_ATTR_ASYNC_ENABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  47. {
  48.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  49.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  50.     SQLUINTEGER value = data.uinteger();
  51.     switch (value) {
  52.     case SQL_ASYNC_ENABLE_OFF:
  53. break;
  54.     case SQL_ASYNC_ENABLE_ON:
  55. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "async enable on not supported");
  56. break;
  57.     default:
  58. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid async enable value %u", (unsigned)value);
  59. break;
  60.     }
  61. }
  63. static void
  64. callback_SQL_ATTR_ASYNC_ENABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  65. {
  66.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  67.     ctx_assert(pDbc != 0);
  68.     SQLUINTEGER value = SQL_ASYNC_ENABLE_OFF;
  69.     data.setValue(value);
  70. }
  72. static void
  73. callback_SQL_ATTR_AUTO_IPD_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  74. {
  75.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  76.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  77.     ctx_assert(false); // read-only
  78. }
  80. static void
  81. callback_SQL_ATTR_AUTO_IPD_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  82. {
  83.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  84.     ctx_assert(pDbc != 0);
  85.     SQLUINTEGER value = SQL_FALSE;
  86.     data.setValue(value);
  87. }
  89. static void
  90. callback_SQL_ATTR_AUTOCOMMIT_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  91. {
  92.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  93.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  94.     SQLUINTEGER value = data.uinteger();
  95.     switch (value) {
  96.     case SQL_AUTOCOMMIT_OFF:
  97. if (pDbc->autocommit()) {
  98.     pDbc->autocommit(false);
  99.     pDbc->useConnection(ctx, true);
  100. }
  101. break;
  102.     case SQL_AUTOCOMMIT_ON:
  103. if (! pDbc->autocommit()) {
  104.     pDbc->autocommit(true);
  105.     pDbc->sqlEndTran(ctx, SQL_COMMIT);
  106.     pDbc->useConnection(ctx, false);
  107. }
  108. break;
  109.     default:
  110. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid autocommit value %u", (unsigned)value);
  111. break;
  112.     }
  113. }
  115. static void
  116. callback_SQL_ATTR_AUTOCOMMIT_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  117. {
  118.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  119.     ctx_assert(pDbc != 0);
  120.     SQLUINTEGER value = pDbc->autocommit() ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;
  121.     data.setValue(value);
  122. }
  124. static void
  125. callback_SQL_ATTR_CONNECTION_DEAD_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  126. {
  127.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  128.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  129.     ctx_assert(false); // read-only
  130. }
  132. static void
  133. callback_SQL_ATTR_CONNECTION_DEAD_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  134. {
  135.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  136.     ctx_assert(pDbc != 0);
  137.     SQLUINTEGER value = pDbc->getState() == HandleDbc::Free ? SQL_CD_TRUE : SQL_CD_FALSE;
  138.     data.setValue(value);
  139. }
  141. static void
  142. callback_SQL_ATTR_CONNECTION_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  143. {
  144.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  145.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  146. }
  148. static void
  149. callback_SQL_ATTR_CONNECTION_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  150. {
  151.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  152.     ctx_assert(pDbc != 0);
  153.     SQLUINTEGER value = 0;
  154.     data.setValue(value);
  155. }
  157. static void
  158. callback_SQL_ATTR_CURRENT_CATALOG_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  159. {
  160.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  161.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar);
  162. }
  164. static void
  165. callback_SQL_ATTR_CURRENT_CATALOG_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  166. {
  167.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  168.     ctx_assert(pDbc != 0);
  169.     const char* value = "DEFAULT";
  170.     data.setValue(value);
  171. }
  173. static void
  174. callback_SQL_ATTR_LOGIN_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  175. {
  176.     callback_SQL_ATTR_CONNECTION_TIMEOUT_set(ctx, self, data);
  177. }
  179. static void
  180. callback_SQL_ATTR_LOGIN_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  181. {
  182.     callback_SQL_ATTR_CONNECTION_TIMEOUT_default(ctx, self, data);
  183. }
  185. static void
  186. callback_SQL_ATTR_METADATA_ID_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  187. {
  188.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  189.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  190.     SQLUINTEGER value = data.uinteger();
  191.     switch (value) {
  192.     case SQL_FALSE:
  193. break;
  194.     case SQL_TRUE:
  195. break;
  196.     default:
  197. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid metadata id value %u", (unsigned)value);
  198. break;
  199.     }
  200. }
  202. static void
  203. callback_SQL_ATTR_METADATA_ID_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  204. {
  205.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  206.     ctx_assert(pDbc != 0);
  207.     SQLUINTEGER value = SQL_FALSE;
  208.     data.setValue(value);
  209. }
  211. static void
  212. callback_SQL_ATTR_ODBC_CURSORS_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  213. {
  214.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  215.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  216.     SQLUINTEGER value = data.uinteger();
  217.     switch (value) {
  218.     case SQL_CUR_USE_DRIVER:
  219. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cur use driver not supported");
  220. break;
  221.     case SQL_CUR_USE_IF_NEEDED:
  222. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cur use if needed not supported");
  223. break;
  224.     case SQL_CUR_USE_ODBC:
  225. break;
  226.     default:
  227. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid odbc cursors value %u", (unsigned)value);
  228. break;
  229.     }
  230. }
  232. static void
  233. callback_SQL_ATTR_ODBC_CURSORS_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  234. {
  235.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  236.     ctx_assert(pDbc != 0);
  237.     SQLUINTEGER value = SQL_CUR_USE_ODBC;
  238.     data.setValue(value);
  239. }
  241. static void
  242. callback_SQL_ATTR_PACKET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  243. {
  244.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  245.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  246.     SQLUINTEGER value = data.uinteger();
  247.     ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "packet size (%u) not supported", (unsigned)value);
  248. }
  250. static void
  251. callback_SQL_ATTR_PACKET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  252. {
  253.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  254.     ctx_assert(pDbc != 0);
  255.     SQLUINTEGER value = 0;
  256.     data.setValue(value);
  257. }
  259. static void
  260. callback_SQL_ATTR_QUIET_MODE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  261. {
  262.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  263.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Pointer);
  264. }
  266. static void
  267. callback_SQL_ATTR_QUIET_MODE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  268. {
  269.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  270.     ctx_assert(pDbc != 0);
  271.     data.setValue();
  272. }
  274. static void
  275. callback_SQL_ATTR_TRACE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  276. {
  277.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  278.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  279. }
  281. static void
  282. callback_SQL_ATTR_TRACE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  283. {
  284.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  285.     ctx_assert(pDbc != 0);
  286.     data.setValue();
  287. }
  289. static void
  290. callback_SQL_ATTR_TRACEFILE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  291. {
  292.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  293.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar);
  294. }
  296. static void
  297. callback_SQL_ATTR_TRACEFILE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  298. {
  299.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  300.     ctx_assert(pDbc != 0);
  301.     data.setValue();
  302. }
  304. static void
  305. callback_SQL_ATTR_TRANSLATE_LIB_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  306. {
  307.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  308.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Sqlchar);
  309. }
  311. static void
  312. callback_SQL_ATTR_TRANSLATE_LIB_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  313. {
  314.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  315.     ctx_assert(pDbc != 0);
  316.     data.setValue();
  317. }
  319. static void
  320. callback_SQL_ATTR_TRANSLATE_OPTION_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  321. {
  322.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  323.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  324. }
  326. static void
  327. callback_SQL_ATTR_TRANSLATE_OPTION_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  328. {
  329.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  330.     ctx_assert(pDbc != 0);
  331.     data.setValue();
  332. }
  334. static void
  335. callback_SQL_ATTR_TXN_ISOLATION_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  336. {
  337.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  338.     ctx_assert(pDbc != 0 && data.type() == OdbcData::Uinteger);
  339.     if (pDbc->getState() == HandleDbc::Free) {
  340. ctx.pushStatus(Sqlstate::_08003, Error::Gen, "not connected");
  341. return;
  342.     }
  343.     if (pDbc->getState() == HandleDbc::Transacting) {
  344. ctx.pushStatus(Sqlstate::_HY011, Error::Gen, "transaction is open");
  345. return;
  346.     }
  347.     SQLUINTEGER value = data.uinteger();
  348.     SQLUINTEGER mask = SQL_TXN_READ_COMMITTED;
  349.     if (! (value & mask)) {
  350. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "txn isolation level %u not supported", (unsigned)value);
  351. return;
  352.     }
  353. }
  355. static void
  356. callback_SQL_ATTR_TXN_ISOLATION_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  357. {
  358.     HandleDbc* pDbc = static_cast<HandleDbc*>(self);
  359.     ctx_assert(pDbc != 0);
  360.     SQLUINTEGER value = SQL_TXN_READ_COMMITTED;
  361.     data.setValue(value);
  362. }
  364. AttrSpec HandleDbc::m_attrSpec[] = {
  365.     {   SQL_ATTR_ACCESS_MODE,
  366.         OdbcData::Uinteger,
  367.         Attr_mode_readwrite,
  368.         callback_SQL_ATTR_ACCESS_MODE_set,
  369.         callback_SQL_ATTR_ACCESS_MODE_default,
  370.     },
  371.     {   SQL_ATTR_ASYNC_ENABLE,
  372.         OdbcData::Uinteger,
  373.         Attr_mode_readwrite,
  374.         callback_SQL_ATTR_ASYNC_ENABLE_set,
  375.         callback_SQL_ATTR_ASYNC_ENABLE_default,
  376.     },
  377.     {   SQL_ATTR_AUTO_IPD,
  378.         OdbcData::Uinteger,
  379.         Attr_mode_readonly,
  380.         callback_SQL_ATTR_AUTO_IPD_set,
  381.         callback_SQL_ATTR_AUTO_IPD_default,
  382.     },
  383.     {   SQL_ATTR_AUTOCOMMIT,
  384.         OdbcData::Uinteger,
  385.         Attr_mode_readwrite,
  386.         callback_SQL_ATTR_AUTOCOMMIT_set,
  387.         callback_SQL_ATTR_AUTOCOMMIT_default,
  388.     },
  389.     {   SQL_ATTR_CONNECTION_DEAD,
  390.         OdbcData::Uinteger,
  391.         Attr_mode_readonly,
  392.         callback_SQL_ATTR_CONNECTION_DEAD_set,
  393.         callback_SQL_ATTR_CONNECTION_DEAD_default,
  394.     },
  395.     {   SQL_ATTR_CONNECTION_TIMEOUT,
  396.         OdbcData::Uinteger,
  397.         Attr_mode_readwrite,
  398.         callback_SQL_ATTR_CONNECTION_TIMEOUT_set,
  399.         callback_SQL_ATTR_CONNECTION_TIMEOUT_default,
  400.     },
  401.     {   SQL_ATTR_CURRENT_CATALOG,
  402.         OdbcData::Sqlchar,
  403.         Attr_mode_readwrite,
  404.         callback_SQL_ATTR_CURRENT_CATALOG_set,
  405.         callback_SQL_ATTR_CURRENT_CATALOG_default,
  406.     },
  407.     {   SQL_ATTR_LOGIN_TIMEOUT,
  408.         OdbcData::Uinteger,
  409.         Attr_mode_readwrite,
  410.         callback_SQL_ATTR_LOGIN_TIMEOUT_set,
  411.         callback_SQL_ATTR_LOGIN_TIMEOUT_default,
  412.     },
  413.     {   SQL_ATTR_METADATA_ID,
  414.         OdbcData::Uinteger,
  415.         Attr_mode_readwrite,
  416.         callback_SQL_ATTR_METADATA_ID_set,
  417.         callback_SQL_ATTR_METADATA_ID_default,
  418.     },
  419.     {   SQL_ATTR_ODBC_CURSORS,
  420.         OdbcData::Uinteger,
  421.         Attr_mode_readwrite,
  422.         callback_SQL_ATTR_ODBC_CURSORS_set,
  423.         callback_SQL_ATTR_ODBC_CURSORS_default,
  424.     },
  425.     {   SQL_ATTR_PACKET_SIZE,
  426.         OdbcData::Uinteger,
  427.         Attr_mode_readwrite,
  428.         callback_SQL_ATTR_PACKET_SIZE_set,
  429.         callback_SQL_ATTR_PACKET_SIZE_default,
  430.     },
  431.     {   SQL_ATTR_QUIET_MODE,
  432.         OdbcData::Pointer,
  433.         Attr_mode_readwrite,
  434.         callback_SQL_ATTR_QUIET_MODE_set,
  435.         callback_SQL_ATTR_QUIET_MODE_default,
  436.     },
  437.     {   SQL_ATTR_TRACE,
  438.         OdbcData::Uinteger,
  439.         Attr_mode_readwrite,
  440.         callback_SQL_ATTR_TRACE_set,
  441.         callback_SQL_ATTR_TRACE_default,
  442.     },
  443.     {   SQL_ATTR_TRACEFILE,
  444.         OdbcData::Sqlchar,
  445.         Attr_mode_readwrite,
  446.         callback_SQL_ATTR_TRACEFILE_set,
  447.         callback_SQL_ATTR_TRACEFILE_default,
  448.     },
  449.     {   SQL_ATTR_TRANSLATE_LIB,
  450.         OdbcData::Sqlchar,
  451.         Attr_mode_readwrite,
  452.         callback_SQL_ATTR_TRANSLATE_LIB_set,
  453.         callback_SQL_ATTR_TRANSLATE_LIB_default,
  454.     },
  455.     {   SQL_ATTR_TRANSLATE_OPTION,
  456.         OdbcData::Uinteger,
  457.         Attr_mode_readwrite,
  458.         callback_SQL_ATTR_TRANSLATE_OPTION_set,
  459.         callback_SQL_ATTR_TRANSLATE_OPTION_default,
  460.     },
  461.     {   SQL_ATTR_TXN_ISOLATION,
  462.         OdbcData::Uinteger,
  463.         Attr_mode_readwrite,
  464.         callback_SQL_ATTR_TXN_ISOLATION_set,
  465.         callback_SQL_ATTR_TXN_ISOLATION_default,
  466.     },
  467.     {   0,
  468.         OdbcData::Undef,
  469.         Attr_mode_undef,
  470.         0,
  471.         0,
  472.     },
  473. };