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

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

MySQL数据库

开发平台：

Visual C++

HandleStmt.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 <common/OdbcData.hpp>
  18. #include <codegen/CodeGen.hpp>
  19. #include "HandleRoot.hpp"
  20. #include "HandleDbc.hpp"
  21. #include "HandleStmt.hpp"
  22. #include "HandleDesc.hpp"
  24. HandleStmt::HandleStmt(HandleDbc* pDbc) :
  25.     StmtArea(*pDbc),
  26.     m_dbc(pDbc),
  27.     m_attrArea(m_attrSpec)
  28. {
  29.     m_attrArea.setHandle(this);
  30.     for (unsigned i = 0; i <= 1; i++) {
  31. for (unsigned u = 0; u <= 4; u++) {
  32.     m_handleDesc[i][u] = 0;
  33. }
  34.     }
  35. }
  37. HandleStmt::~HandleStmt()
  38. {
  39. }
  41. void
  42. HandleStmt::ctor(Ctx& ctx)
  43. {
  44.     for (unsigned u = 1; u <= 4; u++) {
  45. HandleDesc** ppDesc = &m_handleDesc[0][u];
  46. m_dbc->sqlAllocDesc(ctx, ppDesc);
  47. if (! ctx.ok())
  48.     return;
  49. m_descArea[u] = &(*ppDesc)->descArea();
  50. m_descArea[u]->setAlloc(Desc_alloc_auto);
  51. m_descArea[u]->setUsage((DescUsage)u);
  52.     }
  53. }
  55. void
  56. HandleStmt::dtor(Ctx& ctx)
  57. {
  58.     free(ctx);
  59.     for (unsigned u = 1; u <= 4; u++) {
  60. HandleDesc** ppDesc = &m_handleDesc[0][u];
  61. if (*ppDesc != 0)
  62.     m_dbc->sqlFreeDesc(ctx, *ppDesc);
  63. *ppDesc = 0;
  64.     }
  65. }
  67. // descriptor handles
  69. HandleDesc*
  70. HandleStmt::getHandleDesc(Ctx& ctx, DescUsage u) const
  71. {
  72.     ctx_assert(1 <= u && u <= 4);
  73.     if (m_handleDesc[1][u] != 0)
  74. return m_handleDesc[1][u];
  75.     return m_handleDesc[0][u];
  76. }
  78. void
  79. HandleStmt::setHandleDesc(Ctx& ctx, DescUsage u, SQLPOINTER handle)
  80. {
  81.     ctx_assert(1 <= u && u <= 4);
  82.     if (handle == SQL_NULL_HDESC) {
  83. m_handleDesc[1][u] = 0; // revert to implicit
  84. m_descArea[u] = &m_handleDesc[0][u]->descArea();
  85. return;
  86.     }
  87.     HandleDesc* pDesc = getRoot()->findDesc(handle);
  88.     if (pDesc == 0) {
  89. ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "cannot set %s handle to invalid descriptor handle %x", DescArea::nameUsage(u), (unsigned)handle);
  90. return;
  91.     }
  92.     if (pDesc == m_handleDesc[0][u]) {
  93. m_handleDesc[1][u] = 0; // revert to implicit
  94. m_descArea[u] = &m_handleDesc[0][u]->descArea();
  95. return;
  96.     }
  97.     // XXX should check implicit handles on all statements
  98.     for (unsigned v = 1; v <= 4; v++) {
  99. if (pDesc == m_handleDesc[0][v]) {
  100.     ctx.pushStatus(Sqlstate::_HY024, Error::Gen, "cannot set %s handle to implicitly allocated %s handle", DescArea::nameUsage(u), DescArea::nameUsage((DescUsage)v));
  101.     return;
  102. }
  103.     }
  104.     m_handleDesc[1][u] = pDesc;
  105.     m_descArea[u] = &m_handleDesc[1][u]->descArea();
  106. }
  108. // allocate and free handles (no valid case)
  110. void
  111. HandleStmt::sqlAllocHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase** ppChild)
  112. {
  113.     ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type");
  114. }
  116. void
  117. HandleStmt::sqlFreeHandle(Ctx& ctx, SQLSMALLINT childType, HandleBase* ppChild)
  118. {
  119.     ctx.pushStatus(Sqlstate::_HY092, Error::Gen, "inappropriate handle type");
  120. }
  122. // attributes and info
  124. static bool
  125. ignore_attr(Ctx& ctx, SQLINTEGER attribute)
  126. {
  127.     switch (attribute) {
  128.     case 1211:
  129.     case 1227:
  130.     case 1228:
  131. ctx_log2(("ignore unknown ADO.NET stmt attribute %d", (int)attribute));
  132. return true;
  133.     }
  134.     return false;
  135. }
  137. void
  138. HandleStmt::sqlSetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER stringLength)
  139. {
  140.     if (ignore_attr(ctx, attribute))
  141. return;
  142.     baseSetHandleAttr(ctx, m_attrArea, attribute, value, stringLength);
  143. }
  145. void
  146. HandleStmt::sqlGetStmtAttr(Ctx& ctx, SQLINTEGER attribute, SQLPOINTER value, SQLINTEGER bufferLength, SQLINTEGER* stringLength)
  147. {
  148.     if (ignore_attr(ctx, attribute))
  149. return;
  150.     baseGetHandleAttr(ctx, m_attrArea, attribute, value, bufferLength, stringLength);
  151. }
  153. void
  154. HandleStmt::sqlSetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLUINTEGER value)
  155. {
  156.     if (ignore_attr(ctx, option))
  157. return;
  158.     baseSetHandleOption(ctx, m_attrArea, option, value);
  159. }
  161. void
  162. HandleStmt::sqlGetStmtOption(Ctx& ctx, SQLUSMALLINT option, SQLPOINTER value)
  163. {
  164.     if (ignore_attr(ctx, option))
  165. return;
  166.     baseGetHandleOption(ctx, m_attrArea, option, value);
  167. }
  169. void
  170. HandleStmt::sqlGetTypeInfo(Ctx& ctx, SQLSMALLINT dataType)
  171. {
  172.     BaseString text;
  173.     // odbc$typeinfo is a (possible unordered) view matching SQLGetTypeInfo result set
  174.     text.append("SELECT * FROM odbc$typeinfo");
  175.     if (dataType != SQL_ALL_TYPES) {
  176. switch (dataType) {
  177. case SQL_CHAR:
  178. case SQL_VARCHAR:
  179. case SQL_BINARY:
  180. case SQL_VARBINARY:
  181. case SQL_SMALLINT:
  182. case SQL_INTEGER:
  183. case SQL_BIGINT:
  184. case SQL_REAL:
  185. case SQL_DOUBLE:
  186.     break;
  187. default:
  188.     // XXX unsupported vs illegal
  189.     ctx_log1(("sqlGetTypeInfo: unknown data type %d", (int)dataType));
  190.     break;
  191. }
  192. text.appfmt(" WHERE data_type = %d", (int)dataType);
  193.     }
  194.     // sort signed before unsigned
  195.     text.append(" ORDER BY data_type, unsigned_attribute, type_name");
  196.     sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length());
  197. }
  199. void
  200. HandleStmt::sqlTables(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* tableType, SQLSMALLINT nameLength4)
  201. {
  202.     BaseString text;
  203.     // odbc$tables is a (possibly unordered) view matching SQLTables result set
  204.     text.append("SELECT * FROM odbc$tables");
  205.     SQLUINTEGER metadata_id = SQL_FALSE;
  206.     sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0);
  207.     if (! ctx.ok())
  208. return;
  209.     unsigned count = 0;
  210.     if (catalogName != 0) {
  211. OdbcData data;
  212. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)catalogName, nameLength1);
  213. if (! ctx.ok())
  214.     return;
  215. text.append(++count == 1 ? " WHERE" : " AND");
  216. if (getOdbcVersion(ctx) == 2)
  217.     text.appfmt(" table_cat = '%s'", data.sqlchar());
  218. else if (metadata_id == SQL_TRUE)
  219.     text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER
  220. else
  221.     text.appfmt(" table_cat LIKE '%s'", data.sqlchar());
  222.     }
  223.     if (schemaName != 0) {
  224. OdbcData data;
  225. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)schemaName, nameLength2);
  226. if (! ctx.ok())
  227.     return;
  228. text.append(++count == 1 ? " WHERE" : " AND");
  229. if (metadata_id == SQL_TRUE)
  230.     text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER
  231. else
  232.     text.appfmt(" table_schem LIKE '%s'", data.sqlchar());
  233.     }
  234.     if (tableName != 0) {
  235. OdbcData data;
  236. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableName, nameLength3);
  237. if (! ctx.ok())
  238.     return;
  239. text.append(++count == 1 ? " WHERE" : " AND");
  240. if (metadata_id == SQL_TRUE)
  241.     text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER
  242. else
  243.     text.appfmt(" table_name LIKE '%s'", data.sqlchar());
  244.     }
  245.     if (tableType != 0) {
  246. OdbcData data;
  247. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableType, nameLength4);
  248. if (! ctx.ok())
  249.     return;
  250. text.append(++count == 1 ? " WHERE" : " AND");
  251. text.appfmt(" table_type IN (%s)", data.sqlchar()); // XXX UPPER, quotes
  252.     }
  253.     text.append(" ORDER BY table_type, table_cat, table_schem, table_name");
  254.     sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length());
  255. }
  257. void
  258. HandleStmt::sqlColumns(Ctx& ctx, SQLCHAR* catalogName, SQLSMALLINT nameLength1, SQLCHAR* schemaName, SQLSMALLINT nameLength2, SQLCHAR* tableName, SQLSMALLINT nameLength3, SQLCHAR* columnName, SQLSMALLINT nameLength4)
  259. {
  260.     BaseString text;
  261.     // odbc$columns is a (possibly unordered) view matching SQLColumns result set
  262.     text.append("SELECT * FROM odbc$columns");
  263.     SQLUINTEGER metadata_id = SQL_FALSE;
  264.     sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0);
  265.     if (! ctx.ok())
  266. return;
  267.     unsigned count = 0;
  268.     if (catalogName != 0) {
  269. OdbcData data;
  270. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)catalogName, nameLength1);
  271. if (! ctx.ok())
  272.     return;
  273. text.append(++count == 1 ? " WHERE" : " AND");
  274. if (getOdbcVersion(ctx) == 2)
  275.     text.appfmt(" table_cat = '%s'", data.sqlchar());
  276. else if (metadata_id == SQL_TRUE)
  277.     text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER
  278. else
  279.     text.appfmt(" table_cat LIKE '%s'", data.sqlchar());
  280.     }
  281.     if (schemaName != 0) {
  282. OdbcData data;
  283. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)schemaName, nameLength2);
  284. if (! ctx.ok())
  285.     return;
  286. text.append(++count == 1 ? " WHERE" : " AND");
  287. if (metadata_id == SQL_TRUE)
  288.     text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER
  289. else
  290.     text.appfmt(" table_schem LIKE '%s'", data.sqlchar());
  291.     }
  292.     if (tableName != 0) {
  293. OdbcData data;
  294. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)tableName, nameLength3);
  295. if (! ctx.ok())
  296.     return;
  297. text.append(++count == 1 ? " WHERE" : " AND");
  298. if (metadata_id == SQL_TRUE)
  299.     text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER
  300. else
  301.     text.appfmt(" table_name LIKE '%s'", data.sqlchar());
  302.     }
  303.     if (columnName != 0) {
  304. OdbcData data;
  305. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)columnName, nameLength4);
  306. if (! ctx.ok())
  307.     return;
  308. text.append(++count == 1 ? " WHERE" : " AND");
  309. if (metadata_id == SQL_TRUE)
  310.     text.appfmt(" column_name = '%s'", data.sqlchar()); // XXX UPPER
  311. else
  312.     text.appfmt(" column_name LIKE '%s'", data.sqlchar());
  313.     }
  314.     text.append(" ORDER BY table_cat, table_schem, table_name, ordinal_position");
  315.     sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length());
  316. }
  318. void
  319. HandleStmt::sqlPrimaryKeys(Ctx& ctx, SQLCHAR* szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR* szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR* szTableName, SQLSMALLINT cbTableName)
  320. {
  321.     BaseString text;
  322.     // odbc$primarykeys is a (possible unordered) view matching SQLPrimaryKeys result set
  323.     text.append("SELECT * FROM odbc$primarykeys");
  324.     SQLUINTEGER metadata_id = SQL_FALSE;
  325.     sqlGetStmtAttr(ctx, SQL_ATTR_METADATA_ID, (SQLPOINTER)&metadata_id, SQL_IS_POINTER, 0);
  326.     if (! ctx.ok())
  327. return;
  328.     unsigned count = 0;
  329.     if (szCatalogName != 0) {
  330. OdbcData data;
  331. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szCatalogName, cbCatalogName);
  332. if (! ctx.ok())
  333.     return;
  334. text.append(++count == 1 ? " WHERE" : " AND");
  335. if (getOdbcVersion(ctx) == 2)
  336.     text.appfmt(" table_cat = '%s'", data.sqlchar());
  337. else if (metadata_id == SQL_TRUE)
  338.     text.appfmt(" table_cat = '%s'", data.sqlchar()); // XXX UPPER
  339. else
  340.     text.appfmt(" table_cat = '%s'", data.sqlchar()); // no pattern
  341.     }
  342.     if (szSchemaName != 0) {
  343. OdbcData data;
  344. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szSchemaName, cbSchemaName);
  345. if (! ctx.ok())
  346.     return;
  347. text.append(++count == 1 ? " WHERE" : " AND");
  348. if (metadata_id == SQL_TRUE)
  349.     text.appfmt(" table_schem = '%s'", data.sqlchar()); // XXX UPPER
  350. else
  351.     text.appfmt(" table_schem = '%s'", data.sqlchar()); // no pattern
  352.     }
  353.     if (szTableName != 0) {
  354. OdbcData data;
  355. data.copyin(ctx, OdbcData::Sqlchar, (SQLPOINTER)szTableName, cbTableName);
  356. if (! ctx.ok())
  357.     return;
  358. text.append(++count == 1 ? " WHERE" : " AND");
  359. if (metadata_id == SQL_TRUE)
  360.     text.appfmt(" table_name = '%s'", data.sqlchar()); // XXX UPPER
  361. else
  362.     text.appfmt(" table_name = '%s'", data.sqlchar()); // no pattern
  363.     } else { // no null
  364. ctx.pushStatus(Sqlstate::_HY009, Error::Gen, "null table name");
  365. return;
  366.     }
  367.     text.append(" ORDER BY table_cat, table_schem, table_name, key_seq");
  368.     sqlExecDirect(ctx, (SQLCHAR*)text.c_str(), text.length());
  369. }
  371. int
  372. HandleStmt::getOdbcVersion(Ctx& ctx)
  373. {
  374.     return m_dbc->getOdbcVersion(ctx);
  375. }
  377. // prepare and execute
  379. void
  380. HandleStmt::sqlPrepare(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength)
  381. {
  382.     if (m_state == Open) {
  383. ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is open");
  384. return;
  385.     }
  386.     free(ctx);
  387.     const char* text = reinterpret_cast<char*>(statementText);
  388.     if (textLength == SQL_NTS) {
  389. m_sqlText.assign(text);
  390.     } else if (textLength >= 0) {
  391. m_sqlText.assign(text, textLength);
  392.     } else {
  393. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "missing SQL text");
  394. return;
  395.     }
  396.     if (! useSchemaCon(ctx, true))
  397. return;
  398.     CodeGen codegen(*this);
  399.     codegen.prepare(ctx);
  400.     useSchemaCon(ctx, false);
  401.     if (! ctx.ok()) {
  402. free(ctx);
  403. return;
  404.     }
  405.     ctx_log2(("prepared %s statement", m_stmtInfo.getDesc()));
  406.     m_state = Prepared;
  407. }
  409. void
  410. HandleStmt::sqlExecute(Ctx& ctx)
  411. {
  412.     if (m_state == Open) {
  413. ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is open");
  414. return;
  415.     }
  416.     StmtType stmtType = m_stmtInfo.getType();
  417.     switch (stmtType) {
  418.     case Stmt_type_DDL:
  419. if (! useSchemaCon(ctx, true))
  420.     return;
  421. break;
  422.     case Stmt_type_query:
  423.     case Stmt_type_DML:
  424. if (! useConnection(ctx, true))
  425.     return;
  426. break;
  427.     default:
  428. ctx_assert(false);
  429. break;
  430.     }
  431.     CodeGen codegen(*this);
  432.     codegen.execute(ctx);
  433.     // valid only after execute says M$  XXX create this diag only on demand
  434.     setFunction(ctx);
  435.     if (ctx.getCode() == SQL_NEED_DATA) {
  436. m_state = NeedData;
  437. return;
  438.     }
  439.     ctx_log2(("execute: fetched %u tuples from NDB", (unsigned)m_tuplesFetched));
  440.     switch (stmtType) {
  441.     case Stmt_type_DDL:
  442. codegen.close(ctx);
  443. useSchemaCon(ctx, false);
  444. m_state = Prepared;
  445. break;
  446.     case Stmt_type_query:
  447. if (! ctx.ok()) {
  448.     codegen.close(ctx);
  449.     useConnection(ctx, false);
  450.     m_state = Prepared;
  451. } else {
  452.     m_state = Open;
  453. }
  454. break;
  455.     case Stmt_type_DML:
  456. codegen.close(ctx);
  457. if (m_dbc->autocommit()) {
  458.     // even if error
  459.     m_dbc->sqlEndTran(ctx, SQL_COMMIT);
  460. } else {
  461.     m_dbc->uncommitted(true); // uncommitted changes possible
  462. }
  463. useConnection(ctx, false);
  464. m_state = Prepared;
  465. break;
  466.     default:
  467. ctx_assert(false);
  468. break;
  469.     }
  470. }
  472. void
  473. HandleStmt::sqlExecDirect(Ctx& ctx, SQLCHAR* statementText, SQLINTEGER textLength)
  474. {
  475.     sqlPrepare(ctx, statementText, textLength);
  476.     if (! ctx.ok())
  477. return;
  478.     sqlExecute(ctx);
  479. }
  481. void
  482. HandleStmt::sqlFetch(Ctx& ctx)
  483. {
  484.     if (m_state != Open) {
  485. ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open");
  486. return;
  487.     }
  488.     StmtType stmtType = m_stmtInfo.getType();
  489.     switch (stmtType) {
  490.     case Stmt_type_query: {
  491. CodeGen codegen(*this);
  492. codegen.fetch(ctx);
  493. if (! ctx.ok()) {
  494.     codegen.close(ctx);
  495.     useConnection(ctx, false);
  496. }
  497. break;
  498. }
  499.     default:
  500. ctx_assert(false);
  501. break;
  502.     }
  503. }
  505. void
  506. HandleStmt::sqlRowCount(Ctx& ctx, SQLINTEGER* rowCount)
  507. {
  508.     *rowCount = m_rowCount;
  509. }
  511. void
  512. HandleStmt::sqlMoreResults(Ctx& ctx)
  513. {
  514.     if (m_state == Open) {
  515. sqlCloseCursor(ctx);
  516. if (! ctx.ok())
  517.     return;
  518.     }
  519.     ctx.setCode(SQL_NO_DATA);
  520. }
  522. void
  523. HandleStmt::sqlCancel(Ctx& ctx)
  524. {
  525.     if (m_state == NeedData) {
  526. CodeGen codegen(*this);
  527. codegen.close(ctx);
  528. m_state = Prepared;
  529.     }
  530. }
  532. void
  533. HandleStmt::sqlCloseCursor(Ctx& ctx)
  534. {
  535.     if (m_state != Open) {
  536. ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open");
  537. return;
  538.     }
  539.     ctx_log2(("execute: fetched %u tuples from NDB", (unsigned)m_tuplesFetched));
  540.     StmtType stmtType = m_stmtInfo.getType();
  541.     switch (stmtType) {
  542.     case Stmt_type_query: {
  543. CodeGen codegen(*this);
  544. codegen.close(ctx);
  545. useConnection(ctx, false);
  546. m_state = Prepared;
  547. m_rowCount = 0;
  548. m_tuplesFetched = 0;
  549. break;
  550. }
  551.     default:
  552. ctx_assert(false);
  553. break;
  554.     }
  555. }
  557. void
  558. HandleStmt::sqlGetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength)
  559. {
  560.     OdbcData name("SQL_CUR_DUMMY");
  561.     name.copyout(ctx, cursorName, bufferLength, 0, nameLength);
  562. }
  564. void
  565. HandleStmt::sqlSetCursorName(Ctx& ctx, SQLCHAR* cursorName, SQLSMALLINT nameLength)
  566. {
  567. }
  569. // special data access
  571. void
  572. HandleStmt::sqlGetData(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind)
  573. {
  574.     if (m_state != Open) {
  575. ctx.pushStatus(Sqlstate::_24000, Error::Gen, "cursor is not open");
  576. return;
  577.     }
  578.     if (bufferLength < 0) {
  579. ctx.pushStatus(Sqlstate::_HY090, Error::Gen, "invalid buffer length %d", (int)bufferLength);
  580. return;
  581.     }
  582.     CodeGen codegen(*this);
  583.     codegen.sqlGetData(ctx, columnNumber, targetType, targetValue, bufferLength, strlen_or_Ind);
  584. }
  586. void
  587. HandleStmt::sqlParamData(Ctx& ctx, SQLPOINTER* value)
  588. {
  589.     if (m_state != NeedData) {
  590. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not expecting data-at-exec");
  591. return;
  592.     }
  593.     CodeGen codegen(*this);
  594.     codegen.sqlParamData(ctx, value);
  595.     if (! ctx.ok())
  596. return;
  597.     sqlExecute(ctx);
  598. }
  600. void
  601. HandleStmt::sqlPutData(Ctx& ctx, SQLPOINTER data, SQLINTEGER strlen_or_Ind)
  602. {
  603.     if (m_state != NeedData) {
  604. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "not expecting data-at-exec");
  605. return;
  606.     }
  607.     CodeGen codegen(*this);
  608.     codegen.sqlPutData(ctx, data, strlen_or_Ind);
  609. }
  611. // describe statement
  613. void
  614. HandleStmt::sqlNumParams(Ctx& ctx, SQLSMALLINT* parameterCountPtr)
  615. {
  616.     if (m_state == Free) {
  617. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared");
  618. return;
  619.     }
  620.     HandleDesc* ipd = getHandleDesc(ctx, Desc_usage_IPD);
  621.     ipd->sqlGetDescField(ctx, 0, SQL_DESC_COUNT, static_cast<SQLPOINTER>(parameterCountPtr), -1, 0);
  622. }
  624. void
  625. HandleStmt::sqlDescribeParam(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT* pfSqlType, SQLUINTEGER* pcbParamDef, SQLSMALLINT* pibScale, SQLSMALLINT* pfNullable)
  626. {
  627.     if (m_state == Free) {
  628. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared");
  629. return;
  630.     }
  631.     HandleDesc* ipd = getHandleDesc(ctx, Desc_usage_IPD);
  632.     ipd->sqlGetDescField(ctx, ipar, SQL_DESC_CONCISE_TYPE, static_cast<SQLPOINTER>(pfSqlType), -1, 0);
  633.     { // XXX fix it
  634. OdbcData data((SQLUINTEGER)0);
  635. data.copyout(ctx, (SQLPOINTER)pcbParamDef, -1, 0);
  636.     }
  637.     { // XXX fix it
  638. OdbcData data((SQLSMALLINT)0);
  639. data.copyout(ctx, (SQLPOINTER)pibScale, -1, 0);
  640.     }
  641.     ipd->sqlGetDescField(ctx, ipar, SQL_DESC_NULLABLE, static_cast<SQLPOINTER>(pfNullable), -1, 0);
  642. }
  644. void
  645. HandleStmt::sqlNumResultCols(Ctx& ctx, SQLSMALLINT* columnCount)
  646. {
  647.     if (m_state == Free) {
  648. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared");
  649. return;
  650.     }
  651.     HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD);
  652.     ird->sqlGetDescField(ctx, 0, SQL_DESC_COUNT, static_cast<SQLPOINTER>(columnCount), -1, 0);
  653.     setFunction(ctx); // unixODBC workaround
  654. }
  656. void
  657. HandleStmt::sqlDescribeCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLCHAR* columnName, SQLSMALLINT bufferLength, SQLSMALLINT* nameLength, SQLSMALLINT* dataType, SQLUINTEGER* columnSize, SQLSMALLINT* decimalDigits, SQLSMALLINT* nullable)
  658. {
  659.     if (m_state == Free) {
  660. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared");
  661. return;
  662.     }
  663.     HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD);
  664.     ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_NAME, static_cast<SQLPOINTER>(columnName), bufferLength, 0, nameLength);
  665.     ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_CONCISE_TYPE, static_cast<SQLPOINTER>(dataType), -1, 0);
  666.     if (! ctx.ok())
  667. return;
  668.     if (columnSize != 0) {
  669. switch (*dataType) {
  670. case SQL_CHAR:
  671. case SQL_VARCHAR:
  672. case SQL_BINARY:
  673. case SQL_VARBINARY:
  674.     ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_LENGTH, static_cast<SQLPOINTER>(columnSize), -1, 0);
  675.     break;
  676. case SQL_SMALLINT:
  677.     *columnSize = 5;
  678.     break;
  679. case SQL_INTEGER:
  680.     *columnSize = 10;
  681.     break;
  682. case SQL_BIGINT:
  683.     *columnSize = 20; // XXX 19 for signed
  684.     break;
  685. case SQL_REAL:
  686.     *columnSize = 7;
  687.     break;
  688. case SQL_DOUBLE:
  689.     *columnSize = 15;
  690.     break;
  691. case SQL_TYPE_TIMESTAMP:
  692.     *columnSize = 30;
  693.     break;
  694. default:
  695.     *columnSize = 0;
  696.     break;
  697. }
  698.     }
  699.     if (decimalDigits != 0) {
  700. switch (*dataType) {
  701. case SQL_SMALLINT:
  702. case SQL_INTEGER:
  703. case SQL_BIGINT:
  704.     *decimalDigits = 0;
  705.     break;
  706. case SQL_TYPE_TIMESTAMP:
  707.     *decimalDigits = 10;
  708.     break;
  709. default:
  710.     *decimalDigits = 0;
  711.     break;
  712. }
  713.     }
  714.     ird->sqlGetDescField(ctx, columnNumber, SQL_DESC_NULLABLE, static_cast<SQLPOINTER>(nullable), -1, 0);
  715. }
  717. void
  718. HandleStmt::sqlColAttribute(Ctx& ctx, SQLUSMALLINT columnNumber, SQLUSMALLINT fieldIdentifier, SQLPOINTER characterAttribute, SQLSMALLINT bufferLength, SQLSMALLINT* stringLength, SQLPOINTER numericAttribute)
  719. {
  720.     if (m_state == Free) {
  721. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is not prepared");
  722. return;
  723.     }
  724.     HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD);
  725.     ird->sqlColAttribute(ctx, columnNumber, fieldIdentifier, characterAttribute, bufferLength, stringLength, numericAttribute);
  726. }
  728. void
  729. HandleStmt::sqlColAttributes(Ctx& ctx, SQLUSMALLINT icol, SQLUSMALLINT fdescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT* pcbDesc, SQLINTEGER* pfDesc)
  730. {
  731.     if (m_state == Free) {
  732. ctx.pushStatus(Sqlstate::_HY010, Error::Gen, "statement is nor prepared");
  733. return;
  734.     }
  735.     HandleDesc* const ird = getHandleDesc(ctx, Desc_usage_IRD);
  736.     ird->sqlColAttributes(ctx, icol, fdescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
  737. }
  739. // descriptor manipulation
  741. void
  742. HandleStmt::sqlBindCol(Ctx& ctx, SQLUSMALLINT columnNumber, SQLSMALLINT targetType, SQLPOINTER targetValue, SQLINTEGER bufferLength, SQLINTEGER* strlen_or_Ind)
  743. {
  744.     HandleDesc* const ard = getHandleDesc(ctx, Desc_usage_ARD);
  745.     DescArea& desc = ard->descArea();
  746.     if (desc.getCount() < columnNumber) {
  747. desc.setCount(ctx, columnNumber);
  748.     }
  749.     DescRec& rec = desc.getRecord(columnNumber);
  750.     rec.setField(ctx, SQL_DESC_TYPE, targetType);
  751.     rec.setField(ctx, SQL_DESC_CONCISE_TYPE, targetType);
  752.     rec.setField(ctx, SQL_DESC_DATA_PTR, targetValue);
  753.     rec.setField(ctx, SQL_DESC_OCTET_LENGTH, bufferLength);
  754.     rec.setField(ctx, SQL_DESC_OCTET_LENGTH_PTR, strlen_or_Ind);
  755.     rec.setField(ctx, SQL_DESC_INDICATOR_PTR, strlen_or_Ind);
  756. }
  758. void
  759. HandleStmt::sqlBindParameter(Ctx& ctx, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLUINTEGER cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLINTEGER cbValueMax, SQLINTEGER* pcbValue)
  760. {
  761.     HandleDesc* const ipd = getHandleDesc(ctx, Desc_usage_IPD);
  762.     HandleDesc* const apd = getHandleDesc(ctx, Desc_usage_APD);
  763.     DescArea& descIPD = ipd->descArea();
  764.     DescArea& descAPD = apd->descArea();
  765.     if (ipar < 1) {
  766. ctx.pushStatus(Sqlstate::_07009, Error::Gen, "invalid parameter index %u", (unsigned)ipar);
  767. return;
  768.     }
  769.     if (descIPD.getCount() < ipar) {
  770. descIPD.setCount(ctx, ipar);
  771.     }
  772.     if (descAPD.getCount() < ipar) {
  773. descAPD.setCount(ctx, ipar);
  774.     }
  775.     DescRec& recIPD = descIPD.getRecord(ipar);
  776.     DescRec& recAPD = descAPD.getRecord(ipar);
  777.     recIPD.setField(ctx, SQL_DESC_PARAMETER_TYPE, fParamType);
  778.     recAPD.setField(ctx, SQL_DESC_TYPE, fCType);
  779.     recAPD.setField(ctx, SQL_DESC_CONCISE_TYPE, fCType);
  780.     recIPD.setField(ctx, SQL_DESC_TYPE, fSqlType);
  781.     recIPD.setField(ctx, SQL_DESC_CONCISE_TYPE, fSqlType);
  782.     switch (fSqlType) {
  783.     case SQL_CHAR: // XXX not complete
  784.     case SQL_VARCHAR:
  785.     case SQL_BINARY:
  786.     case SQL_VARBINARY:
  787. recIPD.setField(ctx, SQL_DESC_LENGTH, cbColDef);
  788. break;
  789.     case SQL_DECIMAL:
  790.     case SQL_NUMERIC:
  791.     case SQL_FLOAT:
  792.     case SQL_REAL:
  793.     case SQL_DOUBLE:
  794. recIPD.setField(ctx, SQL_DESC_PRECISION, cbColDef);
  795. break;
  796.     }
  797.     switch (fSqlType) {
  798.     case SQL_TYPE_TIME: // XXX not complete
  799.     case SQL_TYPE_TIMESTAMP:
  800. recIPD.setField(ctx, SQL_DESC_PRECISION, ibScale);
  801. break;
  802.     case SQL_NUMERIC:
  803.     case SQL_DECIMAL:
  804. recIPD.setField(ctx, SQL_DESC_SCALE, ibScale);
  805. break;
  806.     }
  807.     recAPD.setField(ctx, SQL_DESC_DATA_PTR, rgbValue);
  808.     recAPD.setField(ctx, SQL_DESC_OCTET_LENGTH, cbValueMax);
  809.     recAPD.setField(ctx, SQL_DESC_OCTET_LENGTH_PTR, pcbValue);
  810.     recAPD.setField(ctx, SQL_DESC_INDICATOR_PTR, pcbValue);
  811. }
  813. void
  814. HandleStmt::sqlBindParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind)
  815. {
  816.     sqlBindParameter(ctx, parameterNumber, SQL_PARAM_INPUT_OUTPUT, valueType, parameterType, lengthPrecision, parameterScale, parameterValue, SQL_SETPARAM_VALUE_MAX, strLen_or_Ind);
  817. }
  819. void
  820. HandleStmt::sqlSetParam(Ctx& ctx, SQLUSMALLINT parameterNumber, SQLSMALLINT valueType, SQLSMALLINT parameterType, SQLUINTEGER lengthPrecision, SQLSMALLINT parameterScale, SQLPOINTER parameterValue, SQLINTEGER* strLen_or_Ind)
  821. {
  822.     sqlBindParameter(ctx, parameterNumber, SQL_PARAM_INPUT_OUTPUT, valueType, parameterType, lengthPrecision, parameterScale, parameterValue, SQL_SETPARAM_VALUE_MAX, strLen_or_Ind);
  823. }