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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
odbc0odbc.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：16k
源码类别：

MySQL数据库

开发平台：

Visual C++

odbc0odbc.c：源码内容
  1. /******************************************************
  2. Innobase ODBC client library
  4. (c) 1998 Innobase Oy
  6. Created 2/22/1998 Heikki Tuuri
  7. *******************************************************/
  9. #include "odbc0odbc.h"
  11. #include "mem0mem.h"
  12. #include "com0com.h"
  13. #include "usr0sess.h"
  15. #define ODBC_STAT_INITIAL 1
  16. #define ODBC_STAT_PREPARED 2
  17. #define ODBC_STAT_EXECUTED 3
  20. typedef struct odbc_conn_struct odbc_conn_t;
  21. typedef struct odbc_env_struct odbc_env_t;
  23. /* ODBC parameter description struct */
  25. typedef struct odbc_param_struct odbc_param_t;
  26. struct odbc_param_struct{
  27. ulint data_type; /* SQL_CHAR, ... */
  28. ibool is_input; /* TRUE if an input parameter of a stored
  29. procedure, FALSE if an output parameter */
  30. byte* buf; /* buffer where the value is stored before
  31. SQLExecute, or where it comes after SQLExecute
  32. in the case of an output parameter */
  33. lint* data_len; /* pointer to where the data len or the value
  34. SQL_NULL_DATA is stored */
  35. ulint buf_len; /* buffer size */
  36. };
  38. /* ODBC statement data structure */
  40. typedef struct odbc_stat_struct odbc_stat_t;
  41. struct odbc_stat_struct{
  42. ulint state; /* ODBC_STAT_INITIAL,
  43. ODBC_STAT_PREPARED,
  44. ODBC_STAT_EXECUTED */
  45. ulint id; /* statement id */
  46. ulint n_params; /* number of parameters */
  47. odbc_param_t* params; /* pointer to an array describing
  48. the parameters, if any */
  49. ulint n_params_bound; /* number of parameters that have
  50. been bound: the statement cannot be
  51. executed before n_params_bound
  52. == n_params */
  53. byte* error_msg; /* possible error message, or NULL;
  54. allocated separately from dynamic
  55. memory */
  56. ulint error_msg_len; /* error mesage length if it is
  57. non-NULL */
  58. odbc_conn_t* conn; /* connection */
  59. UT_LIST_NODE_T(odbc_stat_t)
  60. stat_list; /* list of the statements of the
  61. connection */
  62. };
  64. /* ODBC connection data structure */
  66. struct odbc_conn_struct{
  67. ibool connected; /* TRUE if connected */
  68. char* server_name; /* server name where connected
  69. (= server address) */
  70. ulint server_name_len;/* length of the server name */
  71. com_endpoint_t* com_endpoint; /* connection endpoint for this client
  72. connection */
  73. dulint out_msg_count; /* count of outgoing messages */
  74. byte* out_datagram_buf;/* buffer for outgoing datagrams to
  75. the server */
  76. byte* in_datagram_buf;/* buffer for incoming datagrams from
  77. the server */
  78. byte* addr_buf; /* buffer for the address from which
  79. an incoming datagram came; in practice,
  80. this will be the server address */
  81. dulint sess_id; /* user session id, once the
  82. connection to the server is
  83. established */
  84. odbc_env_t* env; /* environment */
  85. UT_LIST_BASE_NODE_T(odbc_stat_t)
  86. stat_list; /* list of the statements of the
  87. connection */
  88. UT_LIST_NODE_T(odbc_conn_t)
  89. conn_list; /* list of the connections of the
  90. environment */
  91. };
  93. /* ODBC environment data structure */
  95. struct odbc_env_struct{
  96. UT_LIST_BASE_NODE_T(odbc_conn_t) conn_list;
  97. /* list of the connections of the
  98. environment */
  99. };
  101. /**************************************************************************
  102. Gets the nth parameter description struct for a statement. */
  103. UNIV_INLINE
  104. odbc_param_t*
  105. stat_get_nth_param(
  106. /*===============*/
  107. /* out: nth parameter */
  108. odbc_stat_t* stat, /* in: pointer to statement handle */
  109. ulint i) /* in: parameter index */
  110. {
  111. ut_ad(stat->n_params > i);
  113. return(stat->params + i);
  114. }
  116. /**************************************************************************
  117. Allocates an SQL environment. */
  119. RETCODE
  120. SQLAllocEnv(
  121. /*========*/
  122. /* out: SQL_SUCCESS */
  123. HENV* phenv) /* out: pointer to an environment handle */
  124. {
  125. odbc_env_t* env;
  127. if (!sync_initialized) {
  128. sync_init();
  129. mem_init(2000000);
  130. }
  132. env = mem_alloc(sizeof(odbc_env_t));
  134. UT_LIST_INIT(env->conn_list);
  136. *phenv = env;
  138. return(SQL_SUCCESS);
  139. }
  141. /**************************************************************************
  142. Allocates an SQL connection. */
  144. RETCODE
  145. SQLAllocConnect(
  146. /*============*/
  147. /* out: SQL_SUCCESS */
  148. HENV henv, /* in: pointer to an environment handle */
  149. HDBC* phdbc) /* out: pointer to a connection handle */
  150. {
  151. odbc_conn_t* conn;
  152. odbc_env_t* env;
  154. ut_a(henv);
  156. env = henv;
  157. conn = mem_alloc(sizeof(odbc_conn_t));
  159. conn->connected = FALSE;
  160. conn->env = env;
  162. UT_LIST_INIT(conn->stat_list);
  164. UT_LIST_ADD_LAST(conn_list, env->conn_list, conn);
  166. *phdbc = conn;
  168. return(SQL_SUCCESS);
  169. }
  171. /**************************************************************************
  172. Allocates an SQL statement. */
  174. RETCODE
  175. SQLAllocStmt(
  176. /*=========*/
  177. HDBC hdbc, /* in: SQL connection */
  178. HSTMT* phstmt) /* out: pointer to a statement handle */
  179. {
  180. odbc_conn_t* conn;
  181. odbc_stat_t* stat;
  183. ut_a(hdbc);
  185. conn = hdbc;
  187. stat = mem_alloc(sizeof(odbc_stat_t));
  189. stat->state = ODBC_STAT_INITIAL;
  190. stat->error_msg = NULL;
  191. stat->conn = conn;
  193. UT_LIST_ADD_LAST(stat_list, conn->stat_list, stat);
  195. *phstmt = stat;
  197. return(SQL_SUCCESS);
  198. }
  200. /**************************************************************************
  201. Sends the message in datagram_buf to the server. */
  202. static
  203. void
  204. odbc_send_cli_msg(
  205. /*==============*/
  206. odbc_conn_t* conn, /* in: connection, does not have to be
  207. connected yet */
  208. ulint  len) /* in: message length (excluding the standard
  209. header of size SESS_CLI_MSG_DATA) */
  210. {
  211. ulint ret;
  212. ulint fold;
  213. byte* msg;
  215. ut_a(len + SESS_CLI_MSG_DATA <= ODBC_DATAGRAM_SIZE);
  217. msg = conn->out_datagram_buf;
  219. mach_write_to_8(msg + SESS_CLI_MSG_NO, conn->out_msg_count);
  221. UT_DULINT_INC(conn->out_msg_count);
  223. fold = ut_fold_binary(msg + 4, len + SESS_CLI_MSG_DATA - 4);
  225.   ut_ad(SESS_CLI_MSG_CHECKSUM == 0);
  227. mach_write_to_4(msg + SESS_CLI_MSG_CHECKSUM, fold);
  229. ret = com_sendto(conn->com_endpoint, msg, SESS_CLI_MSG_DATA + len,
  230. conn->server_name, conn->server_name_len);
  231. ut_a(ret == 0);
  232. }
  234. /**************************************************************************
  235. Receives a message in datagram_buf from the server. */
  236. static
  237. void
  238. odbc_recv_srv_msg(
  239. /*==============*/
  240. odbc_conn_t* conn, /* in: connection, does not have to be
  241. connected yet */
  242. ulint*  len) /* out: received message length (excluding the
  243. standard header of size SESS_SRV_MSG_DATA) */
  244. {
  245. ulint total_len;
  246. ulint addr_len;
  247. ulint ret;
  249. ret = com_recvfrom(conn->com_endpoint, conn->in_datagram_buf,
  250. ODBC_DATAGRAM_SIZE, &total_len, (char*)conn->addr_buf,
  251. ODBC_ADDRESS_SIZE, &addr_len);
  252. ut_a(ret == 0);
  253. ut_a(total_len >= SESS_SRV_MSG_DATA);
  255. *len = total_len - SESS_SRV_MSG_DATA;
  256. }
  258. /**************************************************************************
  259. Connects to a database server process (establishes a connection and a
  260. session). */
  262. RETCODE
  263. SQLConnect(
  264. /*=======*/
  265. /* out: SQL_SUCCESS */
  266. HDBC hdbc, /* in: SQL connection handle */
  267. UCHAR* szDSN, /* in: data source name (server name) */
  268. SWORD cbDSN, /* in: data source name length */
  269. UCHAR* szUID, /* in: user name */
  270. SWORD cbUID, /* in: user name length */
  271. UCHAR* szAuthStr, /* in: password */
  272. SWORD cbAuthStr) /* in: password length */
  273. {
  274. com_endpoint_t* ep;
  275. odbc_conn_t* conn;
  276. ulint err;
  277. ulint size;
  278. byte* msg;
  279. ulint len;
  280. UCHAR catenated_name[100];
  282. ut_a(hdbc && szDSN);
  284. UT_NOT_USED(szUID);
  285. UT_NOT_USED(cbUID);
  286. UT_NOT_USED(szAuthStr);
  287. UT_NOT_USED(cbAuthStr);
  289. conn = hdbc;
  291. ut_a(!conn->connected);
  293. conn->server_name = mem_alloc(cbDSN);
  294. ut_memcpy(conn->server_name, szDSN, cbDSN);
  296. conn->server_name_len = cbDSN;
  298. ep = com_endpoint_create(COM_SHM);
  300. ut_a(ep);
  302. conn->com_endpoint = ep;
  304. conn->out_msg_count = ut_dulint_zero;
  306. size = ODBC_DATAGRAM_SIZE;
  308. err = com_endpoint_set_option(ep, COM_OPT_MAX_DGRAM_SIZE,
  309. (byte*)&size, 4);
  310. ut_a(err == 0);
  312. /* Make the data source name catenated to user name as the
  313. address of the communications endpoint */
  315. ut_a((ulint)cbDSN + (ulint)cbUID < 100);
  317. ut_memcpy(catenated_name, szDSN, (ulint)cbDSN);
  318. ut_memcpy(catenated_name + (ulint)cbDSN, szUID, (ulint)cbUID);
  320. err = com_bind(ep, (char*)catenated_name, (ulint)cbDSN
  321. + (ulint)cbUID);
  322. ut_a(err == 0);
  324. conn->in_datagram_buf = mem_alloc(ODBC_DATAGRAM_SIZE);
  326. msg = mem_alloc(ODBC_DATAGRAM_SIZE);
  328. conn->out_datagram_buf = msg;
  329. conn->addr_buf = mem_alloc(ODBC_ADDRESS_SIZE);
  331. /* Set the session id to dulint 0 as we are not yet connected */
  333. sess_cli_msg_set_sess(msg, ut_dulint_zero);
  334. sess_cli_msg_set_type(msg, SESS_CLI_CONNECT);
  336. /*------------------------------------------*/
  338. odbc_send_cli_msg(conn, 0);
  340. odbc_recv_srv_msg(conn, &len);
  342. /*------------------------------------------*/
  344. ut_a(len == 0);
  345. ut_a(sess_srv_msg_get_type(conn->in_datagram_buf)
  346. == SESS_SRV_ACCEPT_CONNECT);
  348. conn->sess_id = mach_read_from_8(conn->in_datagram_buf
  349. + SESS_SRV_MSG_SESS_ID);
  351. /* Write the session id to out_datagram_buf: it will not be rewritten
  352. until the connection is closed, as the session id will stay the same */
  354. sess_cli_msg_set_sess(msg, conn->sess_id);
  356. /* We currently only send single part messages: the following will
  357. stay 0 during the connection */
  359. mach_write_to_4(msg + SESS_CLI_MSG_CONTINUE, 0);
  360. mach_write_to_4(msg + SESS_CLI_MSG_CONT_SIZE, 0);
  362. conn->connected = TRUE;
  364. return(SQL_SUCCESS);
  365. }
  367. /**************************************************************************
  368. Stores an error message to a statement handle, so that it can be later
  369. queried with SQLError. */
  370. static
  371. void
  372. odbc_stat_store_error_msg(
  373. /*======================*/
  374. odbc_stat_t* stat, /* in: statement handle */
  375. byte* msg, /* in: error message sent by the server */
  376. ulint len) /* in: length of msg */
  377. {
  378. if (stat->error_msg) {
  379. mem_free(stat->error_msg);
  380. }
  382. stat->error_msg_len = len;
  384. len += SESS_SRV_MSG_DATA;
  386. stat->error_msg = mem_alloc(len);
  387. ut_memcpy(stat->error_msg, msg, len);
  388. }
  390. /**************************************************************************
  391. Queries an error message. */
  393. RETCODE
  394. SQLError(
  395. /*=====*/
  396. /* out: SQL_SUCCESS or SQL_NO_DATA_FOUND */
  397. HENV henv, /* in: SQL_NULL_HENV */
  398. HDBC hdbc, /* in: SQL_NULL_HDBC */
  399. HSTMT hstmt, /* in: statement handle */
  400. UCHAR* szSqlState, /* in/out: SQLSTATE as a null-terminated string,
  401. (currently, always == "S1000") */
  402. SDWORD* pfNativeError, /* out: native error code */
  403. UCHAR* szErrorMsg, /* in/out: buffer for an error message as a
  404. null-terminated string */
  405. SWORD cbErrorMsgMax, /* in: buffer size for szErrorMsg */
  406. SWORD* pcbErrorMsg) /* out: error message length */
  407. {
  408. odbc_stat_t* stat;
  409. ulint len;
  411. ut_a(henv == SQL_NULL_HENV);
  412. ut_a(hdbc == SQL_NULL_HDBC);
  413. ut_a(hstmt);
  414. ut_a(cbErrorMsgMax > 1);
  416. stat = hstmt;
  418. if (stat->error_msg == NULL) {
  420. return(SQL_NO_DATA_FOUND);
  421. }
  423. *pfNativeError = 0;
  424. ut_memcpy(szSqlState, "S1000", 6);
  426. len = (ulint)cbErrorMsgMax - 1;
  428. if (stat->error_msg_len < len) {
  429. len = stat->error_msg_len;
  430. }
  432. ut_memcpy(szErrorMsg, stat->error_msg + SESS_SRV_MSG_DATA, len);
  434. *(szErrorMsg + len) = '';
  436. *pcbErrorMsg = (SWORD)len;
  438. if (stat->error_msg) {
  439. mem_free(stat->error_msg);
  440. stat->error_msg = NULL;
  441. }
  443. return(SQL_SUCCESS);
  444. }
  446. /**************************************************************************
  447. Makes the server to parse and optimize an SQL string. */
  449. RETCODE
  450. SQLPrepare(
  451. /*=======*/
  452. /* out: SQL_SUCCESS or SQL_ERROR */
  453. HSTMT hstmt, /* in: statement handle */
  454. UCHAR* szSqlStr, /* in: SQL string */
  455. SDWORD cbSqlStr) /* in: SQL string length */
  456. {
  457. odbc_stat_t* stat;
  458. odbc_conn_t* conn;
  459. odbc_param_t* param;
  460. ulint len;
  461. byte* msg;
  462. ulint i;
  464. stat = hstmt;
  465. conn = stat->conn;
  467. if (stat->error_msg) {
  468. mem_free(stat->error_msg);
  469. stat->error_msg = NULL;
  470. }
  472. ut_memcpy(conn->out_datagram_buf + SESS_CLI_MSG_DATA, szSqlStr,
  473. 1 + (ulint)cbSqlStr);
  475. sess_cli_msg_set_type(conn->out_datagram_buf, SESS_CLI_PREPARE);
  477. /* The client message will be decoded in sess_receive_prepare */
  479. /*------------------------------------------*/
  481. odbc_send_cli_msg(conn, 1 + (ulint)cbSqlStr);
  483. odbc_recv_srv_msg(conn, &len);
  485. /*------------------------------------------*/
  487. /* The server message was coded in sess_receive_prepare */
  489. ut_a(len >= 8);
  491. msg = conn->in_datagram_buf;
  493. if (sess_srv_msg_get_type(msg) != SESS_SRV_SUCCESS) {
  495. ut_a(sess_srv_msg_get_type(msg) == SESS_SRV_ERROR);
  497. odbc_stat_store_error_msg(stat, msg, len);
  499. return(SQL_ERROR);
  500. }
  502. stat->id = mach_read_from_4(msg + SESS_SRV_MSG_DATA);
  504. stat->n_params = mach_read_from_4(msg + SESS_SRV_MSG_DATA + 4);
  506. stat->n_params_bound = 0;
  508. ut_a(len == 8 + stat->n_params);
  510. if (stat->n_params > 0) {
  512. stat->params = mem_alloc(stat->n_params
  513. * sizeof(odbc_param_t));
  514. for (i = 0; i < stat->n_params; i++) {
  515. param = stat_get_nth_param(stat, i);
  517. param->is_input = mach_read_from_1(
  518.     msg + SESS_SRV_MSG_DATA + 8 + i);
  519. /* Set buf to NULL so that we know when the parameter
  520. has been bound */
  522. param->buf = NULL;
  523. }
  524. }
  526. stat->state = ODBC_STAT_PREPARED;
  528. return(SQL_SUCCESS);
  529. }
  531. /**************************************************************************
  532. Binds a parameter in a prepared statement. */
  534. RETCODE
  535. SQLBindParameter(
  536. /*=============*/
  537. /* out: SQL_SUCCESS */
  538. HSTMT hstmt, /* in: statement handle */
  539. UWORD ipar, /* in: parameter index, starting from 1 */
  540. SWORD fParamType, /* in: SQL_PARAM_INPUT or SQL_PARAM_OUTPUT */
  541. SWORD fCType, /* in: SQL_C_CHAR, ... */
  542. SWORD fSqlType, /* in: SQL_CHAR, ... */
  543. UDWORD cbColDef, /* in: precision: ignored */
  544. SWORD ibScale, /* in: scale: ignored */
  545. PTR rgbValue, /* in: pointer to a buffer for the data */
  546. SDWORD cbValueMax, /* in: buffer size */
  547. SDWORD* pcbValue) /* in: pointer to a buffer for the data
  548. length or SQL_NULL_DATA */
  549. {
  550. odbc_stat_t* stat;
  551. odbc_param_t* param;
  553. stat = hstmt;
  555. ut_a(stat->state != ODBC_STAT_INITIAL);
  556. ut_a(rgbValue);
  557. ut_a(ipar <= stat->n_params);
  558. ut_a(ipar > 0);
  559. ut_a(cbValueMax >= 0);
  560. ut_a(pcbValue);
  562. UT_NOT_USED(ibScale);
  563. UT_NOT_USED(fCType);
  564. UT_NOT_USED(cbColDef);
  566. if (stat->error_msg) {
  567. mem_free(stat->error_msg);
  568. stat->error_msg = NULL;
  569. }
  571. param = stat_get_nth_param(stat, ipar - 1);
  573. if (param->buf == NULL) {
  574. stat->n_params_bound++;
  575. }
  577. param->data_type = fSqlType;
  579. ut_a((fParamType != SQL_PARAM_INPUT) || param->is_input);
  580. ut_a((fParamType == SQL_PARAM_INPUT) || !param->is_input);
  582. param->buf = rgbValue;
  583. param->buf_len = cbValueMax;
  584. param->data_len = pcbValue;
  586. return(SQL_SUCCESS);
  587. }
  589. /**************************************************************************
  590. Executes a prepared statement where all parameters have been bound. */
  592. RETCODE
  593. SQLExecute(
  594. /*=======*/
  595. /* out: SQL_SUCCESS or SQL_ERROR */
  596. HSTMT hstmt) /* in: statement handle */
  597. {
  598. odbc_stat_t* stat;
  599. odbc_conn_t* conn;
  600. odbc_param_t* param;
  601. lint len;
  602. ulint msg_len;
  603. byte* msg;
  604. byte* ptr;
  605. lint int_val;
  606. ulint i;
  608. stat = hstmt;
  610. ut_a(stat->state != ODBC_STAT_INITIAL);
  611. ut_a(stat->n_params == stat->n_params_bound);
  613. if (stat->error_msg) {
  614. mem_free(stat->error_msg);
  615. stat->error_msg = NULL;
  616. }
  618. conn = stat->conn;
  619. msg = conn->out_datagram_buf;
  621. sess_cli_msg_set_type(msg, SESS_CLI_EXECUTE);
  623. ptr = msg + SESS_CLI_MSG_DATA;
  625. mach_write_to_4(ptr, stat->id);
  627. ptr += 4;
  629. for (i = 0; i < stat->n_params; i++) {
  631. param = stat_get_nth_param(stat, i);
  633. if (param->is_input) {
  634. /* Copy its length and data to the message buffer */
  636. len = *(param->data_len);
  638. mach_write_to_4(ptr, (ulint)len);
  640. ptr += 4;
  642. if (len != SQL_NULL_DATA) {
  643. if (param->data_type == SQL_INTEGER) {
  644. ut_ad(len == 4);
  645. int_val = *((lint*)(param->buf));
  647. mach_write_to_4(ptr, (ulint)int_val);
  648. } else {
  649. ut_memcpy(ptr, param->buf, len);
  650. }
  652. ptr += len;
  653. }
  654. }
  655. }
  657. /* The client message will be decoded in sess_receive_command */
  659. /*------------------------------------------*/
  661. odbc_send_cli_msg(conn, ptr - (msg + SESS_CLI_MSG_DATA));
  663. odbc_recv_srv_msg(conn, &msg_len);
  665. /*------------------------------------------*/
  667. /* The server message was coded in sess_command_completed_message */
  669. msg = conn->in_datagram_buf;
  671. if (sess_srv_msg_get_type(msg) != SESS_SRV_SUCCESS) {
  673. ut_a(sess_srv_msg_get_type(msg) == SESS_SRV_ERROR);
  675. odbc_stat_store_error_msg(stat, msg, msg_len);
  677. return(SQL_ERROR);
  678. }
  680. ptr = msg + SESS_SRV_MSG_DATA;
  682. for (i = 0; i < stat->n_params; i++) {
  684. param = stat_get_nth_param(stat, i);
  686. if (!param->is_input) {
  687. /* Copy its length and data from the message buffer */
  689. len = (lint)mach_read_from_4(ptr);
  691. ptr += 4;
  693. *(param->data_len) = len;
  695. if (len != SQL_NULL_DATA) {
  696. if (param->data_type == SQL_INTEGER) {
  697. ut_ad(len == 4);
  699. int_val = (lint)mach_read_from_4(ptr);
  701. *((lint*)(param->buf)) = int_val;
  702. } else {
  703. ut_memcpy(param->buf, ptr, (ulint)len);
  704. }
  706. ptr += len;
  707. }
  708. }
  709. }
  711. ut_ad(msg + SESS_SRV_MSG_DATA + msg_len == ptr);
  713. return(SQL_SUCCESS);
  714. }