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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
options.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：15k
源码类别：

数据库系统

开发平台：

Unix_Linux

options.c：源码内容
  2. /* Module:          options.c
  3.  *
  4.  * Description:     This module contains routines for getting/setting
  5.  *                  connection and statement options.
  6.  *
  7.  * Classes:         n/a
  8.  *
  9.  * API functions:   SQLSetConnectOption, SQLSetStmtOption, SQLGetConnectOption,
  10.  *                  SQLGetStmtOption
  11.  *
  12.  * Comments:        See "notice.txt" for copyright and license information.
  13.  *
  14.  */
  16. #ifdef HAVE_CONFIG_H
  17. #include "config.h"
  18. #endif
  20. #include "psqlodbc.h"
  22. #ifndef WIN32
  23. #include "iodbc.h"
  24. #include "isql.h"
  25. #include "isqlext.h"
  26. #else
  27. #include <windows.h>
  28. #include <sql.h>
  29. #include <sqlext.h>
  30. #endif
  32. #include "environ.h"
  33. #include "connection.h"
  34. #include "statement.h"
  35. #include "qresult.h"
  38. extern GLOBAL_VALUES globals;
  40. RETCODE set_statement_option(ConnectionClass *conn, 
  41.  StatementClass *stmt, 
  42.  UWORD   fOption,
  43.  UDWORD  vParam);
  47. RETCODE set_statement_option(ConnectionClass *conn, 
  48.  StatementClass *stmt, 
  49.  UWORD   fOption,
  50.  UDWORD  vParam)
  51. {
  52. static char *func="set_statement_option";
  53. char changed = FALSE;
  56. switch(fOption) {
  57. case SQL_ASYNC_ENABLE:/* ignored */
  58. break;
  60. case SQL_BIND_TYPE:
  61. /* now support multi-column and multi-row binding */
  62. if (conn) conn->stmtOptions.bind_size = vParam;
  63. if (stmt) stmt->options.bind_size = vParam;
  64. break;
  66. case SQL_CONCURRENCY:
  67. /* positioned update isn't supported so cursor concurrency is read-only */
  69. if (conn) conn->stmtOptions.scroll_concurrency = vParam;
  70. if (stmt) stmt->options.scroll_concurrency = vParam;
  71. break;
  73. /*
  74. if (globals.lie) {
  75. if (conn) conn->stmtOptions.scroll_concurrency = vParam;
  76. if (stmt) stmt->options.scroll_concurrency = vParam;
  77. }
  78. else {
  80. if (conn) conn->stmtOptions.scroll_concurrency = SQL_CONCUR_READ_ONLY;
  81. if (stmt) stmt->options.scroll_concurrency = SQL_CONCUR_READ_ONLY;
  83. if (vParam != SQL_CONCUR_READ_ONLY)
  84. changed = TRUE;
  85. }
  86. break;
  87. */
  89. case SQL_CURSOR_TYPE:
  90. /* if declare/fetch, then type can only be forward.
  91. otherwise, it can only be forward or static.
  92. */
  93. mylog("SetStmtOption(): SQL_CURSOR_TYPE = %dn", vParam);
  95. if (globals.lie) {
  97. if (conn) conn->stmtOptions.cursor_type = vParam;
  98. if (stmt) stmt->options.cursor_type = vParam;
  100. }
  101. else {
  102. if (globals.use_declarefetch) {
  104. if (conn) conn->stmtOptions.cursor_type = SQL_CURSOR_FORWARD_ONLY;
  105. if (stmt) stmt->options.cursor_type = SQL_CURSOR_FORWARD_ONLY;
  107. if (vParam != SQL_CURSOR_FORWARD_ONLY) 
  108. changed = TRUE;
  109. }
  110. else {
  111. if (vParam == SQL_CURSOR_FORWARD_ONLY || vParam == SQL_CURSOR_STATIC) {
  113. if (conn) conn->stmtOptions.cursor_type = vParam; // valid type
  114. if (stmt) stmt->options.cursor_type = vParam; // valid type
  115. }
  116. else {
  118. if (conn) conn->stmtOptions.cursor_type = SQL_CURSOR_STATIC;
  119. if (stmt) stmt->options.cursor_type = SQL_CURSOR_STATIC;
  121. changed = TRUE;
  122. }
  123. }
  124. }
  125. break;
  127. case SQL_KEYSET_SIZE: /* ignored, but saved and returned  */
  128. mylog("SetStmtOption(): SQL_KEYSET_SIZE, vParam = %dn", vParam);
  130. if (conn) conn->stmtOptions.keyset_size = vParam;
  131. if (stmt) stmt->options.keyset_size = vParam;
  133. break;
  135. /*
  136. if (globals.lie)
  137. stmt->keyset_size = vParam;
  138. else {
  139. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  140. stmt->errormsg = "Driver does not support keyset size option";
  141. SC_log_error(func, "", stmt);
  142. return SQL_ERROR;
  143. }
  144. */
  146. case SQL_MAX_LENGTH:/* ignored, but saved */
  147. mylog("SetStmtOption(): SQL_MAX_LENGTH, vParam = %dn", vParam);
  148. if (conn) conn->stmtOptions.maxLength = vParam;
  149. if (stmt) stmt->options.maxLength = vParam;
  150. break;
  152. case SQL_MAX_ROWS: /* ignored, but saved */
  153. mylog("SetStmtOption(): SQL_MAX_ROWS, vParam = %dn", vParam);
  154. if (conn) conn->stmtOptions.maxRows = vParam;
  155. if (stmt) stmt->options.maxRows = vParam;
  156. break;
  158. case SQL_NOSCAN: /* ignored */
  159. mylog("SetStmtOption: SQL_NOSCAN, vParam = %dn", vParam);
  160. break;
  162. case SQL_QUERY_TIMEOUT: /* ignored */
  163. mylog("SetStmtOption: SQL_QUERY_TIMEOUT, vParam = %dn", vParam);
  164. // "0" returned in SQLGetStmtOption
  165. break;
  167. case SQL_RETRIEVE_DATA: /* ignored, but saved */
  168. mylog("SetStmtOption(): SQL_RETRIEVE_DATA, vParam = %dn", vParam);
  169. if (conn) conn->stmtOptions.retrieve_data = vParam;
  170. if (stmt) stmt->options.retrieve_data = vParam;
  171. break;
  173. case SQL_ROWSET_SIZE:
  174. mylog("SetStmtOption(): SQL_ROWSET_SIZE, vParam = %dn", vParam);
  177. /* Save old rowset size for SQLExtendedFetch purposes 
  178. If the rowset_size is being changed since the last call
  179. to fetch rows.
  180. */
  182. if (stmt && stmt->save_rowset_size <= 0 && stmt->last_fetch_count > 0 )
  183. stmt->save_rowset_size = stmt->options.rowset_size;
  185. if (vParam < 1) {
  186. vParam = 1;
  187. changed = TRUE;
  188. }
  190. if (conn) conn->stmtOptions.rowset_size = vParam;
  191. if (stmt) stmt->options.rowset_size = vParam;
  193. break;
  195. case SQL_SIMULATE_CURSOR: /* NOT SUPPORTED */
  196. if (stmt) {
  197. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  198. stmt->errormsg = "Simulated positioned update/delete not supported.  Use the cursor library.";
  199. SC_log_error(func, "", stmt);
  200. }
  201. if (conn) {
  202. conn->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  203. conn->errormsg = "Simulated positioned update/delete not supported.  Use the cursor library.";
  204. CC_log_error(func, "", conn);
  205. }
  206. return SQL_ERROR;
  208. case SQL_USE_BOOKMARKS:
  210. if (stmt) stmt->options.use_bookmarks = vParam;
  211. if (conn) conn->stmtOptions.use_bookmarks = vParam;
  212. break;
  214.     default:
  215. {
  216. char option[64];
  218. if (stmt) {
  219. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  220. stmt->errormsg = "Unknown statement option (Set)";
  221. sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
  222. SC_log_error(func, option, stmt);
  223. }
  224. if (conn) {
  225. conn->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  226. conn->errormsg = "Unknown statement option (Set)";
  227. sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
  228. CC_log_error(func, option, conn);
  229. }
  231.         return SQL_ERROR;
  232. }
  233.     }
  235. if (changed) {
  236. if (stmt) {
  237. stmt->errormsg = "Requested value changed.";
  238. stmt->errornumber = STMT_OPTION_VALUE_CHANGED;
  239. }
  240. if (conn) {
  241. conn->errormsg = "Requested value changed.";
  242. conn->errornumber = STMT_OPTION_VALUE_CHANGED;
  243. }
  244. return SQL_SUCCESS_WITH_INFO;
  245. }
  246. else
  247. return SQL_SUCCESS;
  248. }
  252. /* Implements only SQL_AUTOCOMMIT */
  253. RETCODE SQL_API SQLSetConnectOption(
  254.         HDBC    hdbc,
  255.         UWORD   fOption,
  256.         UDWORD  vParam)
  257. {
  258. static char *func="SQLSetConnectOption";
  259. ConnectionClass *conn = (ConnectionClass *) hdbc;
  260. char changed = FALSE;
  261. RETCODE retval;
  262. int i;
  264. mylog("%s: entering...n", func);
  266. if ( ! conn)  {
  267. CC_log_error(func, "", NULL);
  268. return SQL_INVALID_HANDLE;
  269. }
  272. switch (fOption) {
  273. /* Statement Options 
  274.    (apply to all stmts on the connection and become defaults for new stmts)
  275. */
  276. case SQL_ASYNC_ENABLE:
  277. case SQL_BIND_TYPE:
  278. case SQL_CONCURRENCY:
  279. case SQL_CURSOR_TYPE:
  280. case SQL_KEYSET_SIZE: 
  281. case SQL_MAX_LENGTH:
  282. case SQL_MAX_ROWS:
  283. case SQL_NOSCAN: 
  284. case SQL_QUERY_TIMEOUT:
  285. case SQL_RETRIEVE_DATA:
  286. case SQL_ROWSET_SIZE:
  287. case SQL_SIMULATE_CURSOR:
  288. case SQL_USE_BOOKMARKS:
  290. /* Affect all current Statements */
  291. for (i = 0; i < conn->num_stmts; i++) {
  292. if ( conn->stmts[i]) {
  293. set_statement_option(NULL, conn->stmts[i], fOption, vParam);
  294. }
  295. }
  297. /* Become the default for all future statements on this connection */
  298. retval = set_statement_option(conn, NULL, fOption, vParam);
  300. if (retval == SQL_SUCCESS_WITH_INFO)
  301. changed = TRUE;
  302. else if (retval == SQL_ERROR)
  303. return SQL_ERROR;
  305. break;
  307. /**********************************/
  308. /***** Connection Options  *******/
  309. /**********************************/
  311. case SQL_ACCESS_MODE: /* ignored */
  312. break;
  314. case SQL_AUTOCOMMIT:
  316. /*  Since we are almost always in a transaction, this is now ok.
  317. Even if we were, the logic will handle it by sending a commit
  318. after the statement.
  320. if (CC_is_in_trans(conn)) {
  321. conn->errormsg = "Cannot switch commit mode while a transaction is in progres";
  322. conn->errornumber = CONN_TRANSACT_IN_PROGRES;
  323. CC_log_error(func, "", conn);
  324. return SQL_ERROR;
  325. }
  326. */
  328. mylog("SQLSetConnectOption: AUTOCOMMIT: transact_status=%d, vparam=%dn", conn->transact_status, vParam);
  330. switch(vParam) {
  331. case SQL_AUTOCOMMIT_OFF:
  332. CC_set_autocommit_off(conn);
  333. break;
  335. case SQL_AUTOCOMMIT_ON:
  336. CC_set_autocommit_on(conn);
  337. break;
  339. default:
  340. conn->errormsg = "Illegal parameter value for SQL_AUTOCOMMIT";
  341. conn->errornumber = CONN_INVALID_ARGUMENT_NO;
  342. CC_log_error(func, "", conn);
  343. return SQL_ERROR;
  344. }
  346. break;
  348. case SQL_CURRENT_QUALIFIER: /* ignored */
  349. break;
  351. case SQL_LOGIN_TIMEOUT: /* ignored */
  352. break;
  354. case SQL_PACKET_SIZE: /* ignored */
  355. break;
  357. case SQL_QUIET_MODE: /* ignored */
  358. break;
  360. case SQL_TXN_ISOLATION: /* ignored */
  361. break;
  363. /* These options should be handled by driver manager */
  364. case SQL_ODBC_CURSORS:
  365. case SQL_OPT_TRACE:
  366. case SQL_OPT_TRACEFILE:
  367. case SQL_TRANSLATE_DLL:
  368. case SQL_TRANSLATE_OPTION:
  369. CC_log_error(func, "This connect option (Set) is only used by the Driver Manager", conn);
  370. break;
  372. default:
  373. { 
  374. char option[64];
  375. conn->errormsg = "Unknown connect option (Set)";
  376. conn->errornumber = CONN_UNSUPPORTED_OPTION;
  377. sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
  378. CC_log_error(func, option, conn);
  379. return SQL_ERROR;
  380. }
  382. }    
  384. if (changed) {
  385. conn->errornumber = CONN_OPTION_VALUE_CHANGED;
  386. conn->errormsg = "Requested value changed.";
  387. return SQL_SUCCESS_WITH_INFO;
  388. }
  389. else
  390. return SQL_SUCCESS;
  391. }
  393. //      -       -       -       -       -       -       -       -       -
  395. /* This function just can tell you whether you are in Autcommit mode or not */
  396. RETCODE SQL_API SQLGetConnectOption(
  397.         HDBC    hdbc,
  398.         UWORD   fOption,
  399.         PTR     pvParam)
  400. {
  401. static char *func="SQLGetConnectOption";
  402. ConnectionClass *conn = (ConnectionClass *) hdbc;
  404. mylog("%s: entering...n", func);
  406. if (! conn)  {
  407. CC_log_error(func, "", NULL);
  408. return SQL_INVALID_HANDLE;
  409. }
  411. switch (fOption) {
  412. case SQL_ACCESS_MODE:/* NOT SUPPORTED */
  413. *((UDWORD *) pvParam) = SQL_MODE_READ_WRITE;
  414. break;
  416. case SQL_AUTOCOMMIT:
  417. *((UDWORD *)pvParam) = (UDWORD)( CC_is_in_autocommit(conn) ?
  418. SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
  419. break;
  421. case SQL_CURRENT_QUALIFIER: /* don't use qualifiers */
  422. if(pvParam)
  423. strcpy(pvParam, "");
  425. break;
  427. case SQL_LOGIN_TIMEOUT: /* NOT SUPPORTED */
  428. *((UDWORD *) pvParam) = 0;
  429. break;
  431. case SQL_PACKET_SIZE: /* NOT SUPPORTED */
  432. *((UDWORD *) pvParam) = globals.socket_buffersize;
  433. break;
  435. case SQL_QUIET_MODE:/* NOT SUPPORTED */
  436. *((UDWORD *) pvParam) = (UDWORD) NULL;
  437. break;
  439. case SQL_TXN_ISOLATION:/* NOT SUPPORTED */
  440. *((UDWORD *) pvParam) = SQL_TXN_SERIALIZABLE;
  441. break;
  443. /* These options should be handled by driver manager */
  444. case SQL_ODBC_CURSORS:
  445. case SQL_OPT_TRACE:
  446. case SQL_OPT_TRACEFILE:
  447. case SQL_TRANSLATE_DLL:
  448. case SQL_TRANSLATE_OPTION:
  449. CC_log_error(func, "This connect option (Get) is only used by the Driver Manager", conn);
  450. break;
  452. default:
  453. {
  454. char option[64];
  455. conn->errormsg = "Unknown connect option (Get)";
  456. conn->errornumber = CONN_UNSUPPORTED_OPTION;
  457. sprintf(option, "fOption=%d", fOption);
  458. CC_log_error(func, option, conn);
  459. return SQL_ERROR;
  460. break;
  461. }
  463. }    
  465. return SQL_SUCCESS;
  466. }
  468. //      -       -       -       -       -       -       -       -       -
  470. RETCODE SQL_API SQLSetStmtOption(
  471.         HSTMT   hstmt,
  472.         UWORD   fOption,
  473.         UDWORD  vParam)
  474. {
  475. static char *func="SQLSetStmtOption";
  476. StatementClass *stmt = (StatementClass *) hstmt;
  477. char changed = FALSE;
  479. mylog("%s: entering...n", func);
  481.     // thought we could fake Access out by just returning SQL_SUCCESS
  482.     // all the time, but it tries to set a huge value for SQL_MAX_LENGTH
  483.     // and expects the driver to reduce it to the real value
  485. if( ! stmt) {
  486. SC_log_error(func, "", NULL);
  487. return SQL_INVALID_HANDLE;
  488. }
  490. return set_statement_option(NULL, stmt, fOption, vParam);
  491. }
  494. //      -       -       -       -       -       -       -       -       -
  496. RETCODE SQL_API SQLGetStmtOption(
  497.         HSTMT   hstmt,
  498.         UWORD   fOption,
  499.         PTR     pvParam)
  500. {
  501. static char *func="SQLGetStmtOption";
  502. StatementClass *stmt = (StatementClass *) hstmt;
  503. QResultClass *res;
  505. mylog("%s: entering...n", func);
  507.     // thought we could fake Access out by just returning SQL_SUCCESS
  508.     // all the time, but it tries to set a huge value for SQL_MAX_LENGTH
  509.     // and expects the driver to reduce it to the real value
  511. if( ! stmt) {
  512. SC_log_error(func, "", NULL);
  513. return SQL_INVALID_HANDLE;
  514. }
  516. switch(fOption) {
  517. case SQL_GET_BOOKMARK:
  518. case SQL_ROW_NUMBER:
  520. res = stmt->result;
  522. if ( stmt->manual_result || ! globals.use_declarefetch) {
  523. // make sure we're positioned on a valid row
  524. if((stmt->currTuple < 0) ||
  525.    (stmt->currTuple >= QR_get_num_tuples(res))) {
  526. stmt->errormsg = "Not positioned on a valid row.";
  527. stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
  528. SC_log_error(func, "", stmt);
  529. return SQL_ERROR;
  530. }
  531. }
  532. else {
  533. if (stmt->currTuple == -1 || ! res || ! res->tupleField) {
  534. stmt->errormsg = "Not positioned on a valid row.";
  535. stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
  536. SC_log_error(func, "", stmt);
  537. return SQL_ERROR;
  538. }
  539. }
  541. if (fOption == SQL_GET_BOOKMARK && stmt->options.use_bookmarks == SQL_UB_OFF) {
  542. stmt->errormsg = "Operation invalid because use bookmarks not enabled.";
  543. stmt->errornumber = STMT_OPERATION_INVALID;
  544. SC_log_error(func, "", stmt);
  545. return SQL_ERROR;
  546. }
  548. *((UDWORD *) pvParam) = SC_get_bookmark(stmt);
  550. break;
  552. case SQL_ASYNC_ENABLE: /* NOT SUPPORTED */
  553. *((SDWORD *) pvParam) = SQL_ASYNC_ENABLE_OFF;
  554. break;
  556. case SQL_BIND_TYPE:
  557. *((SDWORD *) pvParam) = stmt->options.bind_size;
  558. break;
  560. case SQL_CONCURRENCY: /* NOT REALLY SUPPORTED */
  561. mylog("GetStmtOption(): SQL_CONCURRENCYn");
  562. *((SDWORD *)pvParam) = stmt->options.scroll_concurrency;
  563. break;
  565. case SQL_CURSOR_TYPE: /* PARTIAL SUPPORT */
  566. mylog("GetStmtOption(): SQL_CURSOR_TYPEn");
  567. *((SDWORD *)pvParam) = stmt->options.cursor_type;
  568. break;
  570. case SQL_KEYSET_SIZE: /* NOT SUPPORTED, but saved */
  571. mylog("GetStmtOption(): SQL_KEYSET_SIZEn");
  572. *((SDWORD *)pvParam) = stmt->options.keyset_size;
  573. break;
  575. case SQL_MAX_LENGTH: /* NOT SUPPORTED, but saved */
  576. *((SDWORD *)pvParam) = stmt->options.maxLength;
  577. break;
  579. case SQL_MAX_ROWS: /* NOT SUPPORTED, but saved */
  580. *((SDWORD *)pvParam) = stmt->options.maxRows;
  581. mylog("GetSmtOption: MAX_ROWS, returning %dn", stmt->options.maxRows);
  582. break;
  584. case SQL_NOSCAN:/* NOT SUPPORTED */
  585. *((SDWORD *) pvParam) = SQL_NOSCAN_ON;
  586. break;
  588. case SQL_QUERY_TIMEOUT: /* NOT SUPPORTED */
  589. *((SDWORD *) pvParam) = 0;
  590. break;
  592. case SQL_RETRIEVE_DATA: /* NOT SUPPORTED, but saved */
  593. *((SDWORD *) pvParam) = stmt->options.retrieve_data;
  594. break;
  596. case SQL_ROWSET_SIZE:
  597. *((SDWORD *) pvParam) = stmt->options.rowset_size;
  598. break;
  600. case SQL_SIMULATE_CURSOR:/* NOT SUPPORTED */
  601. *((SDWORD *) pvParam) = SQL_SC_NON_UNIQUE;
  602. break;
  604. case SQL_USE_BOOKMARKS:
  605. *((SDWORD *) pvParam) = stmt->options.use_bookmarks;
  606. break;
  608. default:
  609. {
  610. char option[64];
  611. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  612. stmt->errormsg = "Unknown statement option (Get)";
  613. sprintf(option, "fOption=%d", fOption);
  614. SC_log_error(func, option, stmt);
  615. return SQL_ERROR;
  616. }
  617. }
  619. return SQL_SUCCESS;
  620. }
  622. //      -       -       -       -       -       -       -       -       -