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

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

MySQL数据库

开发平台：

Visual C++

AttrStmt.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"
  18. #include "HandleStmt.hpp"
  19. #include "HandleDesc.hpp"
  21. static void
  22. callback_SQL_ATTR_APP_PARAM_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  23. {
  24.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  25.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer);
  26.     pStmt->setHandleDesc(ctx, Desc_usage_APD, data.pointer());
  27. }
  29. static void
  30. callback_SQL_ATTR_APP_PARAM_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  31. {
  32.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  33.     ctx_assert(pStmt != 0);
  34.     HandleDesc* apd = pStmt->getHandleDesc(ctx, Desc_usage_APD);
  35.     OdbcData value(reinterpret_cast<SQLPOINTER>(apd));
  36.     data.setValue(value);
  37. }
  39. static void
  40. callback_SQL_ATTR_APP_ROW_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  41. {
  42.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  43.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer);
  44.     pStmt->setHandleDesc(ctx, Desc_usage_ARD, data.pointer());
  45. }
  47. static void
  48. callback_SQL_ATTR_APP_ROW_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  49. {
  50.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  51.     ctx_assert(pStmt != 0);
  52.     HandleDesc* ard = pStmt->getHandleDesc(ctx, Desc_usage_ARD);
  53.     OdbcData value(reinterpret_cast<SQLPOINTER>(ard));
  54.     data.setValue(value);
  55. }
  57. static void
  58. callback_SQL_ATTR_ASYNC_ENABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  59. {
  60.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  61.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  62.     SQLUINTEGER value = data.uinteger();
  63.     switch (value) {
  64.     case SQL_ASYNC_ENABLE_OFF:
  65. break;
  66.     case SQL_ASYNC_ENABLE_ON:
  67. // ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "async enable ON not supported");
  68. break;
  69.     default:
  70. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid async enable value %u", (unsigned)value);
  71. break;
  72.     }
  73. }
  75. static void
  76. callback_SQL_ATTR_ASYNC_ENABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  77. {
  78.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  79.     ctx_assert(pStmt != 0);
  80.     SQLUINTEGER value = SQL_ASYNC_ENABLE_OFF;
  81.     data.setValue(value);
  82. }
  84. static void
  85. callback_SQL_ATTR_CONCURRENCY_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  86. {
  87.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  88.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  89.     SQLUINTEGER value = data.uinteger();
  90.     switch (value) {
  91.     case SQL_CONCUR_READ_ONLY:
  92. break;
  93.     case SQL_CONCUR_LOCK:
  94. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur lock not supported");
  95. break;
  96.     case SQL_CONCUR_ROWVER:
  97. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur rowver not supported");
  98. break;
  99.     case SQL_CONCUR_VALUES:
  100. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "concur values not supported");
  101. break;
  102.     default:
  103. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid concurrency value %u", (unsigned)value);
  104. break;
  105.     }
  106. }
  108. static void
  109. callback_SQL_ATTR_CONCURRENCY_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  110. {
  111.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  112.     ctx_assert(pStmt != 0);
  113.     SQLUINTEGER value = SQL_CONCUR_READ_ONLY;
  114.     data.setValue(value);
  115. }
  117. static void
  118. callback_SQL_ATTR_CURSOR_SCROLLABLE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  119. {
  120.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  121.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  122.     SQLUINTEGER value = data.uinteger();
  123.     switch (value) {
  124.     case SQL_NONSCROLLABLE:
  125. break;
  126.     case SQL_SCROLLABLE:
  127. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor scrollable not supported");
  128. break;
  129.     default:
  130. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid concurrency value %u", (unsigned)value);
  131. break;
  132.     }
  133. }
  135. static void
  136. callback_SQL_ATTR_CURSOR_SCROLLABLE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  137. {
  138.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  139.     ctx_assert(pStmt != 0);
  140.     SQLUINTEGER value = SQL_NONSCROLLABLE;
  141.     data.setValue(value);
  142. }
  144. static void
  145. callback_SQL_ATTR_CURSOR_SENSITIVITY_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  146. {
  147.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  148.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  149.     SQLUINTEGER value = data.uinteger();
  150.     switch (value) {
  151.     case SQL_UNSPECIFIED:
  152.     case SQL_INSENSITIVE:
  153. break;
  154.     case SQL_SENSITIVE:
  155. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor sensitive not supported");
  156. break;
  157.     default:
  158. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cursor sensitivity value %u", (unsigned)value);
  159. break;
  160.     }
  161. }
  163. static void
  164. callback_SQL_ATTR_CURSOR_SENSITIVITY_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  165. {
  166.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  167.     ctx_assert(pStmt != 0);
  168.     SQLUINTEGER value = SQL_INSENSITIVE;
  169.     data.setValue(value);
  170. }
  172. static void
  173. callback_SQL_ATTR_CURSOR_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  174. {
  175.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  176.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  177.     SQLUINTEGER value = data.uinteger();
  178.     switch (value) {
  179.     case SQL_CURSOR_FORWARD_ONLY:
  180. break;
  181.     case SQL_CURSOR_STATIC:
  182. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor static not supported");
  183. break;
  184.     case SQL_CURSOR_KEYSET_DRIVEN:
  185. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor keyset driven not supported");
  186. break;
  187.     case SQL_CURSOR_DYNAMIC:
  188. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "cursor dynamic not supported");
  189. break;
  190.     default:
  191. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid cursor type value %u", (unsigned)value);
  192. break;
  193.     }
  194. }
  196. static void
  197. callback_SQL_ATTR_CURSOR_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  198. {
  199.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  200.     ctx_assert(pStmt != 0);
  201.     SQLUINTEGER value = SQL_CURSOR_FORWARD_ONLY;
  202.     data.setValue(value);
  203. }
  205. static void
  206. callback_SQL_ATTR_ENABLE_AUTO_IPD_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  207. {
  208.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  209.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  210.     SQLUINTEGER value = data.uinteger();
  211.     switch (value) {
  212.     case SQL_FALSE:
  213. break;
  214.     case SQL_TRUE:
  215. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "enable auto IPD not supported");
  216. break;
  217.     default:
  218. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid enable auto IPD value %u", (unsigned)value);
  219. break;
  220.     }
  221. }
  223. static void
  224. callback_SQL_ATTR_ENABLE_AUTO_IPD_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  225. {
  226.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  227.     ctx_assert(pStmt != 0);
  228.     SQLUINTEGER value = SQL_FALSE;
  229.     data.setValue(value);
  230. }
  232. static void
  233. callback_SQL_ATTR_FETCH_BOOKMARK_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  234. {
  235.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  236.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer);
  237.     SQLPOINTER value = data.pointer();
  238.     if (value != 0) {
  239. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "fetch bookmark ptr not supported");
  240. return;
  241.     }
  242. }
  244. static void
  245. callback_SQL_ATTR_FETCH_BOOKMARK_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  246. {
  247.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  248.     ctx_assert(pStmt != 0);
  249.     SQLPOINTER value = 0;
  250.     data.setValue(value);
  251. }
  253. static void
  254. callback_SQL_ATTR_IMP_PARAM_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  255. {
  256.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  257.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer);
  258.     ctx_assert(false); // read-only
  259. }
  261. static void
  262. callback_SQL_ATTR_IMP_PARAM_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  263. {
  264.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  265.     ctx_assert(pStmt != 0);
  266.     HandleDesc* ipd = pStmt->getHandleDesc(ctx, Desc_usage_IPD);
  267.     OdbcData value(reinterpret_cast<SQLPOINTER>(ipd));
  268.     data.setValue(value);
  269. }
  271. static void
  272. callback_SQL_ATTR_IMP_ROW_DESC_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  273. {
  274.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  275.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Pointer);
  276.     ctx_assert(false); // read-only
  277. }
  279. static void
  280. callback_SQL_ATTR_IMP_ROW_DESC_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  281. {
  282.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  283.     ctx_assert(pStmt != 0);
  284.     HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD);
  285.     OdbcData value(reinterpret_cast<SQLPOINTER>(ird));
  286.     data.setValue(value);
  287. }
  289. static void
  290. callback_SQL_ATTR_KEYSET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  291. {
  292.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  293.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  294.     SQLUINTEGER value = data.uinteger();
  295.     if (value != 0) {
  296. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "keyset size not supported");
  297. return;
  298.     }
  299. }
  301. static void
  302. callback_SQL_ATTR_KEYSET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  303. {
  304.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  305.     ctx_assert(pStmt != 0);
  306.     SQLUINTEGER value = 0;
  307.     data.setValue(value);
  308. }
  310. static void
  311. callback_SQL_ATTR_MAX_LENGTH_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  312. {
  313.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  314.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  315.     SQLUINTEGER value = data.uinteger();
  316.     if (value != 0) {
  317. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "max length not supported");
  318. return;
  319.     }
  320. }
  322. static void
  323. callback_SQL_ATTR_MAX_LENGTH_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  324. {
  325.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  326.     ctx_assert(pStmt != 0);
  327.     SQLUINTEGER value = 0;
  328.     data.setValue(value);
  329. }
  331. static void
  332. callback_SQL_ATTR_MAX_ROWS_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  333. {
  334.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  335.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  336.     SQLUINTEGER value = data.uinteger();
  337.     if (value != 0) {
  338. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "max rows not supported");
  339. return;
  340.     }
  341. }
  343. static void
  344. callback_SQL_ATTR_MAX_ROWS_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  345. {
  346.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  347.     ctx_assert(pStmt != 0);
  348.     SQLUINTEGER value = 0;
  349.     data.setValue(value);
  350. }
  352. static void
  353. callback_SQL_ATTR_METADATA_ID_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  354. {
  355.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  356.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  357.     SQLUINTEGER value = data.uinteger();
  358.     switch (value) {
  359.     case SQL_FALSE:
  360. break;
  361.     case SQL_TRUE:
  362. break;
  363.     default:
  364. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid metadata id value %u", (unsigned)value);
  365. break;
  366.     }
  367. }
  369. static void
  370. callback_SQL_ATTR_METADATA_ID_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  371. {
  372.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  373.     ctx_assert(pStmt != 0);
  374.     SQLUINTEGER value = SQL_FALSE;
  375.     data.setValue(value);
  376. }
  378. static void
  379. callback_SQL_ATTR_NOSCAN_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  380. {
  381.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  382.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  383.     SQLUINTEGER value = data.uinteger();
  384.     switch (value) {
  385.     case SQL_NOSCAN_OFF:
  386. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "noscan OFF not supported");
  387. break;
  388.     case SQL_NOSCAN_ON:
  389. break;
  390.     default:
  391. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid no scan value %u", (unsigned)value);
  392. break;
  393.     }
  394. }
  396. static void
  397. callback_SQL_ATTR_NOSCAN_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  398. {
  399.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  400.     ctx_assert(pStmt != 0);
  401.     SQLUINTEGER value = SQL_NOSCAN_ON;
  402.     data.setValue(value);
  403. }
  405. static void
  406. callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  407. {
  408.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  409.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr);
  410.     SQLUINTEGER* value = data.uintegerPtr();
  411.     if (value != 0) {
  412. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param bind offset ptr not supported");
  413. return;
  414.     }
  415. }
  417. static void
  418. callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  419. {
  420.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  421.     ctx_assert(pStmt != 0);
  422.     SQLUINTEGER* value = 0;
  423.     data.setValue(value);
  424. }
  426. static void
  427. callback_SQL_ATTR_PARAM_BIND_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  428. {
  429.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  430.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  431.     SQLUINTEGER value = data.uinteger();
  432.     if (value != SQL_PARAM_BIND_BY_COLUMN) {
  433. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row-wise param binding not supported");
  434. return;
  435.     }
  436. }
  438. static void
  439. callback_SQL_ATTR_PARAM_BIND_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  440. {
  441.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  442.     ctx_assert(pStmt != 0);
  443.     SQLUINTEGER value = SQL_PARAM_BIND_BY_COLUMN;
  444.     data.setValue(value);
  445. }
  447. static void
  448. callback_SQL_ATTR_PARAM_OPERATION_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  449. {
  450.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  451.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr);
  452.     SQLUSMALLINT* value = data.usmallintPtr();
  453.     if (value != 0) {
  454. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param operation ptr not supported");
  455. return;
  456.     }
  457. }
  459. static void
  460. callback_SQL_ATTR_PARAM_OPERATION_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  461. {
  462.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  463.     ctx_assert(pStmt != 0);
  464.     SQLUSMALLINT* value = 0;
  465.     data.setValue(value);
  466. }
  468. static void
  469. callback_SQL_ATTR_PARAM_STATUS_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  470. {
  471.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  472.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr);
  473.     SQLUSMALLINT* value = data.usmallintPtr();
  474.     if (value != 0) {
  475. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "param status ptr not supported");
  476. return;
  477.     }
  478. }
  480. static void
  481. callback_SQL_ATTR_PARAM_STATUS_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  482. {
  483.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  484.     ctx_assert(pStmt != 0);
  485.     SQLUSMALLINT* value = 0;
  486.     data.setValue(value);
  487. }
  489. static void
  490. callback_SQL_ATTR_PARAMS_PROCESSED_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  491. {
  492.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  493.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr);
  494.     SQLUINTEGER* value = data.uintegerPtr();
  495.     if (value != 0) {
  496. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "params processed ptr not supported");
  497. return;
  498.     }
  499. }
  501. static void
  502. callback_SQL_ATTR_PARAMS_PROCESSED_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  503. {
  504.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  505.     ctx_assert(pStmt != 0);
  506.     SQLUINTEGER* value = 0;
  507.     data.setValue(value);
  508. }
  510. static void
  511. callback_SQL_ATTR_PARAMSET_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  512. {
  513.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  514.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  515.     SQLUINTEGER value = data.uinteger();
  516.     if (value != 1) {
  517. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "paramset size %u not supported", (unsigned)value);
  518. return;
  519.     }
  520. }
  522. static void
  523. callback_SQL_ATTR_PARAMSET_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  524. {
  525.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  526.     ctx_assert(pStmt != 0);
  527.     SQLUINTEGER value = 1;
  528.     data.setValue(value);
  529. }
  531. static void
  532. callback_SQL_ATTR_QUERY_TIMEOUT_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  533. {
  534.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  535.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  536.     SQLUINTEGER value = data.uinteger();
  537.     if (value != 0) {
  538. ctx.pushStatus(Sqlstate::_01S02, Error::Gen, "query timeout %u replaced by 0", (unsigned)value);
  539. return;
  540.     }
  541. }
  543. static void
  544. callback_SQL_ATTR_QUERY_TIMEOUT_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  545. {
  546.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  547.     ctx_assert(pStmt != 0);
  548.     SQLUINTEGER value = 0;
  549.     data.setValue(value);
  550. }
  552. static void
  553. callback_SQL_ATTR_RETRIEVE_DATA_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  554. {
  555.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  556.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  557.     SQLUINTEGER value = data.uinteger();
  558.     switch (value) {
  559.     case SQL_RD_ON:
  560. break;
  561.     case SQL_RD_OFF:
  562. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "retrieve data OFF not supported");
  563. break;
  564.     default:
  565. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid retrieve data value %u", (unsigned)value);
  566. break;
  567.     }
  568. }
  570. static void
  571. callback_SQL_ATTR_RETRIEVE_DATA_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  572. {
  573.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  574.     ctx_assert(pStmt != 0);
  575.     SQLUINTEGER value = SQL_RD_ON;
  576.     data.setValue(value);
  577. }
  579. static void
  580. callback_SQL_ATTR_ROW_ARRAY_SIZE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  581. {
  582.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  583.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  584.     SQLUINTEGER value = data.uinteger();
  585.     if (value != 1) {
  586. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row array size %u != 1 not supported", (unsigned)value);
  587. return;
  588.     }
  589. }
  591. static void
  592. callback_SQL_ATTR_ROW_ARRAY_SIZE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  593. {
  594.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  595.     ctx_assert(pStmt != 0);
  596.     SQLUINTEGER value = 1;
  597.     data.setValue(value);
  598. }
  600. static void
  601. callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  602. {
  603.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  604.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr);
  605.     SQLUINTEGER* value = data.uintegerPtr();
  606.     if (value != 0) {
  607. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row bind offset ptr != 0 not supported");
  608. return;
  609.     }
  610. }
  612. static void
  613. callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  614. {
  615.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  616.     ctx_assert(pStmt != 0);
  617.     SQLUINTEGER* value = 0;
  618.     data.setValue(value);
  619. }
  621. static void
  622. callback_SQL_ATTR_ROW_BIND_TYPE_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  623. {
  624.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  625.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  626.     SQLUINTEGER value = data.uinteger();
  627.     if (value != SQL_BIND_BY_COLUMN) {
  628. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row-wise binding not supported");
  629. return;
  630.     }
  631. }
  633. static void
  634. callback_SQL_ATTR_ROW_BIND_TYPE_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  635. {
  636.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  637.     ctx_assert(pStmt != 0);
  638.     SQLUINTEGER value = SQL_BIND_BY_COLUMN;
  639.     data.setValue(value);
  640. }
  642. static void
  643. callback_SQL_ATTR_ROW_NUMBER_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  644. {
  645.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  646.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  647.     ctx_assert(false); // read-only
  648. }
  650. static void
  651. callback_SQL_ATTR_ROW_NUMBER_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  652. {
  653.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  654.     ctx_assert(pStmt != 0);
  655.     SQLUINTEGER value = pStmt->getRowCount();
  656.     data.setValue(value);
  657. }
  659. static void
  660. callback_SQL_ATTR_ROW_OPERATION_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  661. {
  662.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  663.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr);
  664.     SQLUSMALLINT* value = data.usmallintPtr();
  665.     if (value != 0) {
  666. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row operation ptr not supported");
  667. return;
  668.     }
  669. }
  671. static void
  672. callback_SQL_ATTR_ROW_OPERATION_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  673. {
  674.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  675.     ctx_assert(pStmt != 0);
  676.     SQLUSMALLINT* value = 0;
  677.     data.setValue(value);
  678. }
  680. static void
  681. callback_SQL_ATTR_ROW_STATUS_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  682. {
  683.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  684.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UsmallintPtr);
  685.     SQLUSMALLINT* value = data.usmallintPtr();
  686.     if (value != 0) {
  687. ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "row status ptr not supported");
  688. return;
  689.     }
  690. }
  692. static void
  693. callback_SQL_ATTR_ROW_STATUS_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  694. {
  695.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  696.     ctx_assert(pStmt != 0);
  697.     SQLUSMALLINT* value = 0;
  698.     data.setValue(value);
  699. }
  701. static void
  702. callback_SQL_ATTR_ROWS_FETCHED_PTR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  703. {
  704.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  705.     ctx_assert(pStmt != 0 && data.type() == OdbcData::UintegerPtr);
  706.     SQLUINTEGER* value = data.uintegerPtr();
  707.     HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD);
  708.     ird->sqlSetDescField(ctx, 0, SQL_DESC_ROWS_PROCESSED_PTR, static_cast<SQLPOINTER>(value), SQL_IS_POINTER);
  709. }
  711. static void
  712. callback_SQL_ATTR_ROWS_FETCHED_PTR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  713. {
  714.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  715.     ctx_assert(pStmt != 0);
  716.     SQLUINTEGER* value = 0;
  717.     HandleDesc* ird = pStmt->getHandleDesc(ctx, Desc_usage_IRD);
  718.     ird->sqlGetDescField(ctx, 0, SQL_DESC_ROWS_PROCESSED_PTR, &value, SQL_IS_POINTER, 0);
  719.     data.setValue(value);
  720. }
  722. static void
  723. callback_SQL_ATTR_SIMULATE_CURSOR_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  724. {
  725.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  726.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  727.     SQLUINTEGER value = data.uinteger();
  728.     switch (value) {
  729.     case SQL_SC_NON_UNIQUE:
  730. break;
  731.     case SQL_SC_TRY_UNIQUE:
  732. break;
  733.     case SQL_SC_UNIQUE:
  734. break;
  735.     default:
  736. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "invalid simulate cursor value %u", (unsigned)value);
  737. break;
  738.     }
  739. }
  741. static void
  742. callback_SQL_ATTR_SIMULATE_CURSOR_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  743. {
  744.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  745.     ctx_assert(pStmt != 0);
  746.     SQLUINTEGER value = SQL_SC_UNIQUE; // XXX if we did
  747.     data.setValue(value);
  748. }
  750. static void
  751. callback_SQL_ATTR_USE_BOOKMARKS_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  752. {
  753.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  754.     SQLUINTEGER value = data.uinteger();
  755.     switch (value) {
  756.     case SQL_UB_OFF:
  757. break;
  758.     case SQL_UB_VARIABLE:
  759.     case SQL_UB_FIXED:
  760.  ctx.pushStatus(Sqlstate::_HYC00, Error::Gen, "bookmarks not supported");
  761.  return;
  762.     }
  763. }
  765. static void
  766. callback_SQL_ATTR_USE_BOOKMARKS_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  767. {
  768.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  769.     ctx_assert(pStmt != 0);
  770.     SQLUINTEGER value = SQL_UB_OFF;
  771.     data.setValue(value);
  772. }
  774. // driver specific
  776. static void
  777. callback_SQL_ATTR_NDB_TUPLES_FETCHED_set(Ctx& ctx, HandleBase* self, const OdbcData& data)
  778. {
  779.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  780.     ctx_assert(pStmt != 0 && data.type() == OdbcData::Uinteger);
  781.     ctx_assert(false); // read-only
  782. }
  784. static void
  785. callback_SQL_ATTR_NDB_TUPLES_FETCHED_default(Ctx& ctx, HandleBase* self, OdbcData& data)
  786. {
  787.     HandleStmt* pStmt = static_cast<HandleStmt*>(self);
  788.     ctx_assert(pStmt != 0);
  789.     SQLUINTEGER value = pStmt->getTuplesFetched();
  790.     data.setValue(value);
  791. }
  793. AttrSpec HandleStmt::m_attrSpec[] = {
  794.     {   SQL_ATTR_APP_PARAM_DESC,
  795.         OdbcData::Pointer,
  796.         Attr_mode_readwrite,
  797.         callback_SQL_ATTR_APP_PARAM_DESC_set,
  798.         callback_SQL_ATTR_APP_PARAM_DESC_default,
  799.     },
  800.     {   SQL_ATTR_APP_ROW_DESC,
  801.         OdbcData::Pointer,
  802.         Attr_mode_readwrite,
  803.         callback_SQL_ATTR_APP_ROW_DESC_set,
  804.         callback_SQL_ATTR_APP_ROW_DESC_default,
  805.     },
  806.     {   SQL_ATTR_ASYNC_ENABLE,
  807.         OdbcData::Uinteger,
  808.         Attr_mode_readwrite,
  809.         callback_SQL_ATTR_ASYNC_ENABLE_set,
  810.         callback_SQL_ATTR_ASYNC_ENABLE_default,
  811.     },
  812.     {   SQL_ATTR_CONCURRENCY,
  813.         OdbcData::Uinteger,
  814.         Attr_mode_readwrite,
  815.         callback_SQL_ATTR_CONCURRENCY_set,
  816.         callback_SQL_ATTR_CONCURRENCY_default,
  817.     },
  818.     {   SQL_ATTR_CURSOR_SCROLLABLE,
  819.         OdbcData::Uinteger,
  820.         Attr_mode_readwrite,
  821.         callback_SQL_ATTR_CURSOR_SCROLLABLE_set,
  822.         callback_SQL_ATTR_CURSOR_SCROLLABLE_default,
  823.     },
  824.     {   SQL_ATTR_CURSOR_SENSITIVITY,
  825.         OdbcData::Uinteger,
  826.         Attr_mode_readwrite,
  827.         callback_SQL_ATTR_CURSOR_SENSITIVITY_set,
  828.         callback_SQL_ATTR_CURSOR_SENSITIVITY_default,
  829.     },
  830.     {   SQL_ATTR_CURSOR_TYPE,
  831.         OdbcData::Uinteger,
  832.         Attr_mode_readwrite,
  833.         callback_SQL_ATTR_CURSOR_TYPE_set,
  834.         callback_SQL_ATTR_CURSOR_TYPE_default,
  835.     },
  836.     {   SQL_ATTR_ENABLE_AUTO_IPD,
  837.         OdbcData::Uinteger,
  838.         Attr_mode_readwrite,
  839.         callback_SQL_ATTR_ENABLE_AUTO_IPD_set,
  840.         callback_SQL_ATTR_ENABLE_AUTO_IPD_default,
  841.     },
  842.     {   SQL_ATTR_FETCH_BOOKMARK_PTR,
  843.         OdbcData::Pointer,
  844.         Attr_mode_readwrite,
  845.         callback_SQL_ATTR_FETCH_BOOKMARK_PTR_set,
  846.         callback_SQL_ATTR_FETCH_BOOKMARK_PTR_default,
  847.     },
  848.     {   SQL_ATTR_IMP_PARAM_DESC,
  849.         OdbcData::Pointer,
  850.         Attr_mode_readonly,
  851.         callback_SQL_ATTR_IMP_PARAM_DESC_set,
  852.         callback_SQL_ATTR_IMP_PARAM_DESC_default,
  853.     },
  854.     {   SQL_ATTR_IMP_ROW_DESC,
  855.         OdbcData::Pointer,
  856.         Attr_mode_readonly,
  857.         callback_SQL_ATTR_IMP_ROW_DESC_set,
  858.         callback_SQL_ATTR_IMP_ROW_DESC_default,
  859.     },
  860.     {   SQL_ATTR_KEYSET_SIZE,
  861.         OdbcData::Uinteger,
  862.         Attr_mode_readwrite,
  863.         callback_SQL_ATTR_KEYSET_SIZE_set,
  864.         callback_SQL_ATTR_KEYSET_SIZE_default,
  865.     },
  866.     {   SQL_ATTR_MAX_LENGTH,
  867.         OdbcData::Uinteger,
  868.         Attr_mode_readwrite,
  869.         callback_SQL_ATTR_MAX_LENGTH_set,
  870.         callback_SQL_ATTR_MAX_LENGTH_default,
  871.     },
  872.     {   SQL_ATTR_MAX_ROWS,
  873.         OdbcData::Uinteger,
  874.         Attr_mode_readwrite,
  875.         callback_SQL_ATTR_MAX_ROWS_set,
  876.         callback_SQL_ATTR_MAX_ROWS_default,
  877.     },
  878.     {   SQL_ATTR_METADATA_ID,
  879.         OdbcData::Uinteger,
  880.         Attr_mode_readwrite,
  881.         callback_SQL_ATTR_METADATA_ID_set,
  882.         callback_SQL_ATTR_METADATA_ID_default,
  883.     },
  884.     {   SQL_ATTR_NOSCAN,
  885.         OdbcData::Uinteger,
  886.         Attr_mode_readwrite,
  887.         callback_SQL_ATTR_NOSCAN_set,
  888.         callback_SQL_ATTR_NOSCAN_default,
  889.     },
  890.     {   SQL_ATTR_PARAM_BIND_OFFSET_PTR,
  891.         OdbcData::UintegerPtr,
  892.         Attr_mode_readwrite,
  893.         callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_set,
  894.         callback_SQL_ATTR_PARAM_BIND_OFFSET_PTR_default,
  895.     },
  896.     {   SQL_ATTR_PARAM_BIND_TYPE,
  897.         OdbcData::Uinteger,
  898.         Attr_mode_readwrite,
  899.         callback_SQL_ATTR_PARAM_BIND_TYPE_set,
  900.         callback_SQL_ATTR_PARAM_BIND_TYPE_default,
  901.     },
  902.     {   SQL_ATTR_PARAM_OPERATION_PTR,
  903.         OdbcData::UsmallintPtr,
  904.         Attr_mode_readwrite,
  905.         callback_SQL_ATTR_PARAM_OPERATION_PTR_set,
  906.         callback_SQL_ATTR_PARAM_OPERATION_PTR_default,
  907.     },
  908.     {   SQL_ATTR_PARAM_STATUS_PTR,
  909.         OdbcData::UsmallintPtr,
  910.         Attr_mode_readwrite,
  911.         callback_SQL_ATTR_PARAM_STATUS_PTR_set,
  912.         callback_SQL_ATTR_PARAM_STATUS_PTR_default,
  913.     },
  914.     {   SQL_ATTR_PARAMS_PROCESSED_PTR,
  915.         OdbcData::UintegerPtr,
  916.         Attr_mode_readwrite,
  917.         callback_SQL_ATTR_PARAMS_PROCESSED_PTR_set,
  918.         callback_SQL_ATTR_PARAMS_PROCESSED_PTR_default,
  919.     },
  920.     {   SQL_ATTR_PARAMSET_SIZE,
  921.         OdbcData::Uinteger,
  922.         Attr_mode_readwrite,
  923.         callback_SQL_ATTR_PARAMSET_SIZE_set,
  924.         callback_SQL_ATTR_PARAMSET_SIZE_default,
  925.     },
  926.     {   SQL_ATTR_QUERY_TIMEOUT,
  927.         OdbcData::Uinteger,
  928.         Attr_mode_readwrite,
  929.         callback_SQL_ATTR_QUERY_TIMEOUT_set,
  930.         callback_SQL_ATTR_QUERY_TIMEOUT_default,
  931.     },
  932.     {   SQL_ATTR_RETRIEVE_DATA,
  933.         OdbcData::Uinteger,
  934.         Attr_mode_readwrite,
  935.         callback_SQL_ATTR_RETRIEVE_DATA_set,
  936.         callback_SQL_ATTR_RETRIEVE_DATA_default,
  937.     },
  938.     {   SQL_ATTR_ROW_ARRAY_SIZE,
  939.         OdbcData::Uinteger,
  940.         Attr_mode_readwrite,
  941.         callback_SQL_ATTR_ROW_ARRAY_SIZE_set,
  942.         callback_SQL_ATTR_ROW_ARRAY_SIZE_default,
  943.     },
  944.     {   SQL_ATTR_ROW_BIND_OFFSET_PTR,
  945.         OdbcData::UintegerPtr,
  946.         Attr_mode_readwrite,
  947.         callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_set,
  948.         callback_SQL_ATTR_ROW_BIND_OFFSET_PTR_default,
  949.     },
  950.     {   SQL_ATTR_ROW_BIND_TYPE,
  951.         OdbcData::Uinteger,
  952.         Attr_mode_readwrite,
  953.         callback_SQL_ATTR_ROW_BIND_TYPE_set,
  954.         callback_SQL_ATTR_ROW_BIND_TYPE_default,
  955.     },
  956.     {   SQL_ATTR_ROW_NUMBER,
  957.         OdbcData::Uinteger,
  958.         Attr_mode_readonly,
  959.         callback_SQL_ATTR_ROW_NUMBER_set,
  960.         callback_SQL_ATTR_ROW_NUMBER_default,
  961.     },
  962.     {   SQL_ATTR_ROW_OPERATION_PTR,
  963.         OdbcData::UsmallintPtr,
  964.         Attr_mode_readwrite,
  965.         callback_SQL_ATTR_ROW_OPERATION_PTR_set,
  966.         callback_SQL_ATTR_ROW_OPERATION_PTR_default,
  967.     },
  968.     {   SQL_ATTR_ROW_STATUS_PTR,
  969.         OdbcData::UsmallintPtr,
  970.         Attr_mode_readwrite,
  971.         callback_SQL_ATTR_ROW_STATUS_PTR_set,
  972.         callback_SQL_ATTR_ROW_STATUS_PTR_default,
  973.     },
  974.     {   SQL_ATTR_ROWS_FETCHED_PTR,
  975.         OdbcData::UintegerPtr,
  976.         Attr_mode_readwrite,
  977.         callback_SQL_ATTR_ROWS_FETCHED_PTR_set,
  978.         callback_SQL_ATTR_ROWS_FETCHED_PTR_default,
  979.     },
  980.     {   SQL_ATTR_SIMULATE_CURSOR,
  981.         OdbcData::Uinteger,
  982.         Attr_mode_readwrite,
  983.         callback_SQL_ATTR_SIMULATE_CURSOR_set,
  984.         callback_SQL_ATTR_SIMULATE_CURSOR_default,
  985.     },
  986.     {   SQL_ATTR_USE_BOOKMARKS,
  987.         OdbcData::Uinteger,
  988.         Attr_mode_readwrite,
  989.         callback_SQL_ATTR_USE_BOOKMARKS_set,
  990.         callback_SQL_ATTR_USE_BOOKMARKS_default,
  991.     },
  992.     // driver specific
  993.     {   SQL_ATTR_NDB_TUPLES_FETCHED,
  994.         OdbcData::Uinteger,
  995.         Attr_mode_readonly,
  996.         callback_SQL_ATTR_NDB_TUPLES_FETCHED_set,
  997.         callback_SQL_ATTR_NDB_TUPLES_FETCHED_default,
  998.     },
  999.     {   0,
  1000.         OdbcData::Undef,
  1001.         Attr_mode_undef,
  1002.         0,
  1003.         0,
  1004.     },
  1005. };