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

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

数据库系统

开发平台：

Unix_Linux

statement.c：源码内容
  2. /* Module:          statement.c
  3.  *
  4.  * Description:     This module contains functions related to creating
  5.  *                  and manipulating a statement.
  6.  *
  7.  * Classes:         StatementClass (Functions prefix: "SC_")
  8.  *
  9.  * API functions:   SQLAllocStmt, SQLFreeStmt
  10.  *
  11.  * Comments:        See "notice.txt" for copyright and license information.
  12.  *
  13.  */
  15. #ifdef HAVE_CONFIG_H
  16. #include "config.h"
  17. #endif
  19. #include "statement.h"
  20. #include "bind.h"
  21. #include "connection.h"
  22. #include "qresult.h"
  23. #include "convert.h"
  24. #include "environ.h"
  25. #include <stdio.h>
  26. #include <string.h>
  28. #ifndef WIN32
  29. #include "iodbc.h"
  30. #include "isql.h"
  31. #else
  32. #include <windows.h>
  33. #include <sql.h>
  34. #endif
  36. extern GLOBAL_VALUES globals;
  38. #ifndef WIN32
  39. #ifndef HAVE_STRICMP
  40. #define stricmp(s1,s2)  strcasecmp(s1,s2)
  41. #define strnicmp(s1,s2,n) strncasecmp(s1,s2,n)
  42. #endif
  43. #endif
  45. /* Map sql commands to statement types */
  46. static struct {
  47. int  type;
  48. char *s;
  49. } Statement_Type[] = {
  50. { STMT_TYPE_SELECT, "SELECT" },
  51. { STMT_TYPE_INSERT, "INSERT" },
  52. { STMT_TYPE_UPDATE, "UPDATE" },
  53. { STMT_TYPE_DELETE, "DELETE" },
  54. { STMT_TYPE_CREATE, "CREATE" },
  55. { STMT_TYPE_ALTER,  "ALTER"  },
  56. { STMT_TYPE_DROP,   "DROP"   },
  57. { STMT_TYPE_GRANT,  "GRANT"  },
  58. { STMT_TYPE_REVOKE, "REVOKE" },
  59. {      0,            NULL    }
  60. };
  63. RETCODE SQL_API SQLAllocStmt(HDBC      hdbc,
  64.                              HSTMT FAR *phstmt)
  65. {
  66. static char *func="SQLAllocStmt";
  67. ConnectionClass *conn = (ConnectionClass *) hdbc;
  68. StatementClass *stmt;
  70. mylog("%s: entering...n", func);
  72. if( ! conn) {
  73. CC_log_error(func, "", NULL);
  74. return SQL_INVALID_HANDLE;
  75. }
  77. stmt = SC_Constructor();
  79. mylog("**** SQLAllocStmt: hdbc = %u, stmt = %un", hdbc, stmt);
  81. if ( ! stmt) {
  82. conn->errornumber = CONN_STMT_ALLOC_ERROR;
  83. conn->errormsg = "No more memory to allocate a further SQL-statement";
  84. *phstmt = SQL_NULL_HSTMT;
  85. CC_log_error(func, "", conn);
  86. return SQL_ERROR;
  87. }
  89.     if ( ! CC_add_statement(conn, stmt)) {
  90.         conn->errormsg = "Maximum number of connections exceeded.";
  91.         conn->errornumber = CONN_STMT_ALLOC_ERROR;
  92. CC_log_error(func, "", conn);
  93.         SC_Destructor(stmt);
  94. *phstmt = SQL_NULL_HSTMT;
  95.         return SQL_ERROR;
  96.     }
  98. *phstmt = (HSTMT) stmt;
  100. /* Copy default statement options based from Connection options
  101. */
  102. stmt->options = conn->stmtOptions;
  105. /* Save the handle for later */
  106. stmt->phstmt = phstmt;
  108.     return SQL_SUCCESS;
  109. }
  112. RETCODE SQL_API SQLFreeStmt(HSTMT     hstmt,
  113.                             UWORD     fOption)
  114. {
  115. static char *func="SQLFreeStmt";
  116. StatementClass *stmt = (StatementClass *) hstmt;
  118. mylog("%s: entering...hstmt=%u, fOption=%dn", func, hstmt, fOption);
  120. if ( ! stmt) {
  121. SC_log_error(func, "", NULL);
  122. return SQL_INVALID_HANDLE;
  123. }
  125. if (fOption == SQL_DROP) {
  126. ConnectionClass *conn = stmt->hdbc;
  128. /* Remove the statement from the connection's statement list */
  129. if ( conn) {
  130. if ( ! CC_remove_statement(conn, stmt)) {
  131. stmt->errornumber = STMT_SEQUENCE_ERROR;
  132. stmt->errormsg = "Statement is currently executing a transaction.";
  133. SC_log_error(func, "", stmt);
  134. return SQL_ERROR;  /* stmt may be executing a transaction */
  135. }
  137. /* Free any cursors and discard any result info */
  138. if (stmt->result) {
  139. QR_Destructor(stmt->result);
  140. stmt->result = NULL;
  141. }
  142. }
  144. /* Destroy the statement and free any results, cursors, etc. */
  145. SC_Destructor(stmt);
  147.     } else if (fOption == SQL_UNBIND) {
  148. SC_unbind_cols(stmt);
  150.     } else if (fOption == SQL_CLOSE) {
  151. /* this should discard all the results, but leave the statement */
  152. /* itself in place (it can be executed again) */
  153.         if (!SC_recycle_statement(stmt)) {
  154. // errormsg passed in above
  155. SC_log_error(func, "", stmt);
  156.             return SQL_ERROR;
  157. }
  159.     } else if(fOption == SQL_RESET_PARAMS) {
  160. SC_free_params(stmt, STMT_FREE_PARAMS_ALL);
  162.     } else {
  163.         stmt->errormsg = "Invalid option passed to SQLFreeStmt.";
  164.         stmt->errornumber = STMT_OPTION_OUT_OF_RANGE_ERROR;
  165. SC_log_error(func, "", stmt);
  166.         return SQL_ERROR;
  167.     }
  168.     
  169.     return SQL_SUCCESS;
  170. }
  174. /**********************************************************************
  175.  * StatementClass implementation
  176.  */
  177. void
  178. InitializeStatementOptions(StatementOptions *opt)
  179. {
  180. opt->maxRows = 0; // driver returns all rows
  181. opt->maxLength = 0; // driver returns all data for char/binary
  182. opt->rowset_size = 1;
  183. opt->keyset_size = 0; // fully keyset driven is the default
  184. opt->scroll_concurrency = SQL_CONCUR_READ_ONLY;
  185. opt->cursor_type = SQL_CURSOR_FORWARD_ONLY;
  186. opt->bind_size = 0; /* default is to bind by column */
  187. opt->retrieve_data = SQL_RD_ON;
  188. opt->use_bookmarks = SQL_UB_OFF;
  189. }
  191. StatementClass *
  192. SC_Constructor(void)
  193. {
  194. StatementClass *rv;
  196. rv = (StatementClass *) malloc(sizeof(StatementClass));
  197. if (rv) {
  198. rv->hdbc = NULL;       /* no connection associated yet */
  199. rv->phstmt = NULL;
  200. rv->result = NULL;
  201. rv->manual_result = FALSE;
  202. rv->prepare = FALSE;
  203. rv->status = STMT_ALLOCATED;
  204. rv->internal = FALSE;
  206. rv->errormsg = NULL;
  207. rv->errornumber = 0;
  208. rv->errormsg_created = FALSE;
  210. rv->statement = NULL;
  211. rv->stmt_with_params[0] = '';
  212. rv->statement_type = STMT_TYPE_UNKNOWN;
  214. rv->bindings = NULL;
  215. rv->bindings_allocated = 0;
  217. rv->bookmark.buffer = NULL;
  218. rv->bookmark.used = NULL;
  220. rv->parameters_allocated = 0;
  221. rv->parameters = 0;
  223. rv->currTuple = -1;
  224. rv->rowset_start = -1;
  225. rv->current_col = -1;
  226. rv->bind_row = 0;
  227. rv->last_fetch_count = 0;
  228. rv->save_rowset_size = -1;
  230. rv->data_at_exec = -1;
  231. rv->current_exec_param = -1;
  232. rv->put_data = FALSE;
  234. rv->lobj_fd = -1;
  235. rv->cursor_name[0] = '';
  237. /* Parse Stuff */
  238. rv->ti = NULL;
  239. rv->fi = NULL;
  240. rv->ntab = 0;
  241. rv->nfld = 0;
  242. rv->parse_status = STMT_PARSE_NONE;
  245. /*  Clear Statement Options -- defaults will be set in AllocStmt */
  246. memset(&rv->options, 0, sizeof(StatementOptions));
  247. }
  248. return rv;
  249. }
  251. char
  252. SC_Destructor(StatementClass *self)
  253. {
  255. mylog("SC_Destructor: self=%u, self->result=%u, self->hdbc=%un", self, self->result, self->hdbc);
  256. if (STMT_EXECUTING == self->status) {
  257. self->errornumber = STMT_SEQUENCE_ERROR;
  258. self->errormsg = "Statement is currently executing a transaction.";
  259. return FALSE;
  260. }
  262. if (self->result) {
  263. if ( ! self->hdbc)
  264. self->result->conn = NULL;  /* prevent any dbase activity */
  266. QR_Destructor(self->result);
  267. }
  269. if (self->statement)
  270. free(self->statement);
  272. SC_free_params(self, STMT_FREE_PARAMS_ALL);
  274. /* the memory pointed to by the bindings is not deallocated by the driver */
  275. /* by by the application that uses that driver, so we don't have to care  */
  276. /* about that here. */
  277. if (self->bindings)
  278. free(self->bindings);
  281. /* Free the parsed table information */
  282. if (self->ti) {
  283. int i;
  284. for (i = 0; i < self->ntab; i++) {
  285. free(self->ti[i]);
  286. }
  288. free(self->ti);
  289. }
  291. /* Free the parsed field information */
  292. if (self->fi) {
  293. int i;
  294. for (i = 0; i < self->nfld; i++) {
  295. free(self->fi[i]);
  296. }
  297. free(self->fi);
  298. }
  301. free(self);
  303. mylog("SC_Destructor: EXITn");
  305. return TRUE;
  306. }
  308. /* Free parameters and free the memory from the 
  309. data-at-execution parameters that was allocated in SQLPutData.
  310. */
  311. void
  312. SC_free_params(StatementClass *self, char option)
  313. {
  314. int i;
  316. mylog("SC_free_params:  ENTER, self=%dn", self);
  318. if( ! self->parameters)
  319. return;
  321. for (i = 0; i < self->parameters_allocated; i++) {
  322. if (self->parameters[i].data_at_exec == TRUE) {
  324. if (self->parameters[i].EXEC_used) {
  325. free(self->parameters[i].EXEC_used);
  326. self->parameters[i].EXEC_used = NULL;
  327. }
  329. if (self->parameters[i].EXEC_buffer) {
  330. free(self->parameters[i].EXEC_buffer);
  331. self->parameters[i].EXEC_buffer = NULL;
  332. }
  333. }
  334. }
  335. self->data_at_exec = -1;
  336. self->current_exec_param = -1;
  337. self->put_data = FALSE;
  339. if (option == STMT_FREE_PARAMS_ALL) {
  340. free(self->parameters);
  341. self->parameters = NULL;
  342. self->parameters_allocated = 0;
  343. }
  345. mylog("SC_free_params:  EXITn");
  346. }
  349. int 
  350. statement_type(char *statement)
  351. {
  352. int i;
  354. for (i = 0; Statement_Type[i].s; i++)
  355. if ( ! strnicmp(statement, Statement_Type[i].s, strlen(Statement_Type[i].s)))
  356. return Statement_Type[i].type;
  358. return STMT_TYPE_OTHER;
  359. }
  362. /* Called from SQLPrepare if STMT_PREMATURE, or
  363. from SQLExecute if STMT_FINISHED, or
  364. from SQLFreeStmt(SQL_CLOSE)
  365.  */
  366. char 
  367. SC_recycle_statement(StatementClass *self)
  368. {
  369. ConnectionClass *conn;
  371. mylog("recycle statement: self= %un", self);
  373. /* This would not happen */    
  374. if (self->status == STMT_EXECUTING) {
  375. self->errornumber = STMT_SEQUENCE_ERROR;
  376. self->errormsg = "Statement is currently executing a transaction.";
  377. return FALSE;
  378. }
  380. self->errormsg = NULL;
  381. self->errornumber = 0;
  382. self->errormsg_created = FALSE;
  384. switch (self->status) {
  385. case STMT_ALLOCATED:
  386. /* this statement does not need to be recycled */
  387. return TRUE;
  389. case STMT_READY:
  390. break;
  392. case STMT_PREMATURE:
  393. /* Premature execution of the statement might have caused the start of a transaction.
  394. If so, we have to rollback that transaction.
  395. */
  396. conn = SC_get_conn(self);
  397. if ( ! CC_is_in_autocommit(conn) && CC_is_in_trans(conn)) {             
  399. CC_send_query(conn, "ABORT", NULL);
  400. CC_set_no_trans(conn);
  401. }
  402. break;
  404. case STMT_FINISHED:
  405. break;
  407. default:
  408. self->errormsg = "An internal error occured while recycling statements";
  409. self->errornumber = STMT_INTERNAL_ERROR;
  410. return FALSE;
  411. }
  413. /* Free the parsed table information */
  414. if (self->ti) {
  415. int i;
  416. for (i = 0; i < self->ntab; i++) {
  417. free(self->ti[i]);
  418. }
  420. free(self->ti);
  421. self->ti = NULL;
  422. self->ntab = 0;
  423. }
  425. /* Free the parsed field information */
  426. if (self->fi) {
  427. int i;
  428. for (i = 0; i < self->nfld; i++) {
  429. free(self->fi[i]);
  430. }
  431. free(self->fi);
  432. self->fi = NULL;
  433. self->nfld = 0;
  434. }
  435. self->parse_status = STMT_PARSE_NONE;
  437. /* Free any cursors */
  438. if (self->result) {
  439. QR_Destructor(self->result);
  440. self->result = NULL;
  441. }
  443. /****************************************************************/
  444. /* Reset only parameters that have anything to do with results */
  445. /****************************************************************/
  447. self->status = STMT_READY;
  448. self->manual_result = FALSE; // very important
  450. self->currTuple = -1;
  451. self->rowset_start = -1;
  452. self->current_col = -1;
  453. self->bind_row = 0;
  454. self->last_fetch_count = 0;
  456. self->errormsg = NULL;
  457. self->errornumber = 0;
  458. self->errormsg_created = FALSE;
  460. self->lobj_fd = -1;
  462. // Free any data at exec params before the statement is executed
  463. // again.  If not, then there will be a memory leak when
  464. // the next SQLParamData/SQLPutData is called.
  465. SC_free_params(self, STMT_FREE_PARAMS_DATA_AT_EXEC_ONLY);
  467. return TRUE;
  468. }
  470. /* Pre-execute a statement (SQLPrepare/SQLDescribeCol) */
  471. void 
  472. SC_pre_execute(StatementClass *self)
  473. {
  475. mylog("SC_pre_execute: status = %dn", self->status);
  477. if (self->status == STMT_READY) {
  478. mylog("              preprocess: status = READYn");
  480. SQLExecute(self);
  482. if (self->status == STMT_FINISHED) {
  483. mylog("              preprocess: after status = FINISHED, so set PREMATUREn");
  484. self->status = STMT_PREMATURE;
  485. }
  486. }  
  487. }
  489. /* This is only called from SQLFreeStmt(SQL_UNBIND) */
  490. char 
  491. SC_unbind_cols(StatementClass *self)
  492. {
  493. Int2 lf;
  495. for(lf = 0; lf < self->bindings_allocated; lf++) {
  496. self->bindings[lf].data_left = -1;
  497. self->bindings[lf].buflen = 0;
  498. self->bindings[lf].buffer = NULL;
  499. self->bindings[lf].used = NULL;
  500. self->bindings[lf].returntype = SQL_C_CHAR;
  501. }
  503. self->bookmark.buffer = NULL;
  504. self->bookmark.used = NULL;
  506.     return 1;
  507. }
  509. void 
  510. SC_clear_error(StatementClass *self)
  511. {
  512. self->errornumber = 0;
  513. self->errormsg = NULL;
  514. self->errormsg_created = FALSE;
  515. }
  518. // This function creates an error msg which is the concatenation
  519. // of the result, statement, connection, and socket messages.
  520. char *
  521. SC_create_errormsg(StatementClass *self)
  522. {
  523. QResultClass *res = self->result;
  524. ConnectionClass *conn = self->hdbc;
  525. int pos;
  526. static char msg[4096];
  528. msg[0] = '';
  530. if (res && res->message)
  531. strcpy(msg, res->message);
  533. else if (self->errormsg)
  534. strcpy(msg, self->errormsg);
  536. if (conn) {
  537. SocketClass *sock = conn->sock;
  539. if (conn->errormsg && conn->errormsg[0] != '') {
  540. pos = strlen(msg);
  541. sprintf(&msg[pos], ";n%s", conn->errormsg);
  542. }
  544. if (sock && sock->errormsg && sock->errormsg[0] != '') {
  545. pos = strlen(msg);
  546. sprintf(&msg[pos], ";n%s", sock->errormsg);
  547. }
  548. }
  550. return msg;
  551. }
  553. char 
  554. SC_get_error(StatementClass *self, int *number, char **message)
  555. {
  556. char rv;
  558. // Create a very informative errormsg if it hasn't been done yet.
  559. if ( ! self->errormsg_created) {
  560. self->errormsg = SC_create_errormsg(self);
  561. self->errormsg_created = TRUE;
  562. }
  564. if ( self->errornumber) {
  565. *number = self->errornumber;
  566. *message = self->errormsg;
  567. self->errormsg = NULL;
  568. }
  570. rv = (self->errornumber != 0);
  571. self->errornumber = 0;
  573. return rv;
  574. }
  576. /* Currently, the driver offers very simple bookmark support -- it is
  577. just the current row number.  But it could be more sophisticated 
  578. someday, such as mapping a key to a 32 bit value
  579. */
  580. unsigned long
  581. SC_get_bookmark(StatementClass *self)
  582. {
  583. return (self->currTuple + 1);
  584. }
  586. RETCODE
  587. SC_fetch(StatementClass *self)
  588. {
  589. static char *func = "SC_fetch";
  590. QResultClass *res = self->result;
  591. int retval, result;
  592. Int2 num_cols, lf;
  593. Oid type;
  594. char *value;
  595. ColumnInfoClass *ci;
  596. // TupleField *tupleField;
  598. self->last_fetch_count = 0;
  599. ci = QR_get_fields(res); /* the column info */
  601. mylog("manual_result = %d, use_declarefetch = %dn", self->manual_result, globals.use_declarefetch);
  602.  
  603. if ( self->manual_result || ! globals.use_declarefetch) {
  605. if (self->currTuple >= QR_get_num_tuples(res) -1 || 
  606. (self->options.maxRows > 0 && self->currTuple == self->options.maxRows - 1)) {
  608. /* if at the end of the tuples, return "no data found" 
  609. and set the cursor past the end of the result set 
  610. */
  611. self->currTuple = QR_get_num_tuples(res);
  612. return SQL_NO_DATA_FOUND;
  613. }
  614.  
  615. mylog("**** SQLFetch: manual_resultn");
  616. (self->currTuple)++;
  617. }
  618. else {
  620. // read from the cache or the physical next tuple
  621. retval = QR_next_tuple(res);
  622. if (retval < 0) {
  623. mylog("**** SQLFetch: end_tuplesn");
  624. return SQL_NO_DATA_FOUND;
  625. }
  626. else if (retval > 0)
  627. (self->currTuple)++; // all is well
  629. else {
  630. mylog("SQLFetch: errorn");
  631. self->errornumber = STMT_EXEC_ERROR;
  632. self->errormsg = "Error fetching next row";
  633. SC_log_error(func, "", self);
  634. return SQL_ERROR;
  635. }
  636. }
  638. num_cols = QR_NumResultCols(res);
  640. result = SQL_SUCCESS;
  641. self->last_fetch_count = 1;
  643. /* If the bookmark column was bound then return a bookmark.
  644. Since this is used with SQLExtendedFetch, and the rowset size 
  645. may be greater than 1, and an application can use row or column wise
  646. binding, use the code in copy_and_convert_field() to handle that.
  647. */
  648. if (self->bookmark.buffer) {
  649. char buf[32];
  651. sprintf(buf, "%ld", SC_get_bookmark(self));
  652. result = copy_and_convert_field(self, 0, buf, 
  653. SQL_C_ULONG, self->bookmark.buffer, 0, self->bookmark.used);
  654. }
  656. for (lf=0; lf < num_cols; lf++) {
  658. mylog("fetch: cols=%d, lf=%d, self = %u, self->bindings = %u, buffer[] = %un", num_cols, lf, self, self->bindings, self->bindings[lf].buffer);
  660. /* reset for SQLGetData */
  661. self->bindings[lf].data_left = -1;
  663. if (self->bindings[lf].buffer != NULL) {
  664.             // this column has a binding
  666.             // type = QR_get_field_type(res, lf);
  667. type = CI_get_oid(ci, lf); /* speed things up */
  669. mylog("type = %dn", type);
  671. if (self->manual_result) {
  672. value = QR_get_value_manual(res, self->currTuple, lf);
  673. mylog("manual_resultn");
  674. }
  675. else if (globals.use_declarefetch)
  676. value = QR_get_value_backend(res, lf);
  677. else {
  678. value = QR_get_value_backend_row(res, self->currTuple, lf);
  679. }
  681. mylog("value = '%s'n",  (value==NULL)?"<NULL>":value);
  683. retval = copy_and_convert_field_bindinfo(self, type, value, lf);
  685. mylog("copy_and_convert: retval = %dn", retval);
  687. switch(retval) {
  688. case COPY_OK:
  689. break; /* OK, do next bound column */
  691. case COPY_UNSUPPORTED_TYPE:
  692. self->errormsg = "Received an unsupported type from Postgres.";
  693. self->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
  694. SC_log_error(func, "", self);
  695. result = SQL_ERROR;
  696. break;
  698. case COPY_UNSUPPORTED_CONVERSION:
  699. self->errormsg = "Couldn't handle the necessary data type conversion.";
  700. self->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
  701. SC_log_error(func, "", self);
  702. result = SQL_ERROR;
  703. break;
  705. case COPY_RESULT_TRUNCATED:
  706. self->errornumber = STMT_TRUNCATED;
  707. self->errormsg = "The buffer was too small for the result.";
  708. result = SQL_SUCCESS_WITH_INFO;
  709. break;
  711. case COPY_GENERAL_ERROR: /* error msg already filled in */
  712. SC_log_error(func, "", self);
  713. result = SQL_ERROR;
  714. break;
  716. /*  This would not be meaningful in SQLFetch. */
  717. case COPY_NO_DATA_FOUND:
  718. break;
  720. default:
  721. self->errormsg = "Unrecognized return value from copy_and_convert_field.";
  722. self->errornumber = STMT_INTERNAL_ERROR;
  723. SC_log_error(func, "", self);
  724. result = SQL_ERROR;
  725. break;
  726. }
  727. }
  728. }
  730. return result;
  731. }
  734. RETCODE SC_execute(StatementClass *self)
  735. {
  736. static char *func="SC_execute";
  737. ConnectionClass *conn;
  738. QResultClass *res;
  739. char ok, was_ok, was_nonfatal;
  740. Int2 oldstatus, numcols;
  741. QueryInfo qi;
  744. conn = SC_get_conn(self);
  746. /* Begin a transaction if one is not already in progress */
  747. /* The reason is because we can't use declare/fetch cursors without
  748. starting a transaction first.
  749. */
  750. if ( ! self->internal && ! CC_is_in_trans(conn) && (globals.use_declarefetch || STMT_UPDATE(self))) {
  752. mylog("   about to begin a transaction on statement = %un", self);
  753. res = CC_send_query(conn, "BEGIN", NULL);
  754. if ( ! res) {
  755. self->errormsg = "Could not begin a transaction";
  756. self->errornumber = STMT_EXEC_ERROR;
  757. SC_log_error(func, "", self);
  758. return SQL_ERROR;
  759. }
  761. ok = QR_command_successful(res);   
  763. mylog("SQLExecute: ok = %d, status = %dn", ok, QR_get_status(res));
  765. QR_Destructor(res);
  767. if (!ok) {
  768. self->errormsg = "Could not begin a transaction";
  769. self->errornumber = STMT_EXEC_ERROR;
  770. SC_log_error(func, "", self);
  771. return SQL_ERROR;
  772. }
  773. else
  774. CC_set_in_trans(conn);
  775. }
  779. oldstatus = conn->status;
  780. conn->status = CONN_EXECUTING;
  781. self->status = STMT_EXECUTING;
  784. // If its a SELECT statement, use a cursor.
  785. // Note that the declare cursor has already been prepended to the statement
  786. // in copy_statement...
  787. if (self->statement_type == STMT_TYPE_SELECT) {
  789. char fetch[128];
  791. mylog("       Sending SELECT statement on stmt=%u, cursor_name='%s'n", self, self->cursor_name);
  794. /* send the declare/select */
  795. self->result = CC_send_query(conn, self->stmt_with_params, NULL);
  797. if (globals.use_declarefetch && self->result != NULL) {
  799. QR_Destructor(self->result);
  801. /* That worked, so now send the fetch to start getting data back */
  802. qi.result_in = NULL;
  803. qi.cursor = self->cursor_name;
  804. qi.row_size = globals.fetch_max;
  806. /* Most likely the rowset size will not be set by the application until 
  807. after the statement is executed, so might as well use the cache size.  
  808. The qr_next_tuple() function will correct for any discrepancies in 
  809. sizes and adjust the cache accordingly.
  810. */
  812. sprintf(fetch, "fetch %d in %s", qi.row_size, self->cursor_name);
  814. self->result = CC_send_query( conn, fetch, &qi);
  815. }
  817. mylog("     done sending the query:n");
  821. }
  822. else  { // not a SELECT statement so don't use a cursor   
  823. mylog("      its NOT a select statement: stmt=%un", self);
  824. self->result = CC_send_query(conn, self->stmt_with_params, NULL);
  826. // If we are in autocommit, we must send the commit.
  827. if ( ! self->internal && CC_is_in_autocommit(conn) && STMT_UPDATE(self)) {
  828. CC_send_query(conn, "COMMIT", NULL);
  829. CC_set_no_trans(conn);
  830. }
  832. }
  834. conn->status = oldstatus;
  835. self->status = STMT_FINISHED;
  837. /* Check the status of the result */
  838. if (self->result) {
  840. was_ok = QR_command_successful(self->result);
  841. was_nonfatal = QR_command_nonfatal(self->result);
  843. if ( was_ok)
  844. self->errornumber = STMT_OK;
  845. else
  846. self->errornumber = was_nonfatal ? STMT_INFO_ONLY : STMT_ERROR_TAKEN_FROM_BACKEND;
  848. self->currTuple = -1; /* set cursor before the first tuple in the list */
  849. self->current_col = -1;
  850. self->rowset_start = -1;
  852. /* see if the query did return any result columns */
  853. numcols = QR_NumResultCols(self->result);
  855. /* now allocate the array to hold the binding info */
  856. if (numcols > 0) {
  857. extend_bindings(self, numcols);
  858. if (self->bindings == NULL) {
  859. self->errornumber = STMT_NO_MEMORY_ERROR;
  860. self->errormsg = "Could not get enough free memory to store the binding information";
  861. SC_log_error(func, "", self);
  862. return SQL_ERROR;
  863. }
  864. }
  866. } else { /* Bad Error -- The error message will be in the Connection */
  868. if (self->statement_type == STMT_TYPE_CREATE) {
  869. self->errornumber = STMT_CREATE_TABLE_ERROR;
  870. self->errormsg = "Error creating the table";
  871. /* This would allow the table to already exists, thus appending
  872. rows to it.  BUT, if the table didn't have the same attributes,
  873. it would fail.
  874. return SQL_SUCCESS_WITH_INFO;
  875. */
  876. }
  877. else {
  878. self->errornumber = STMT_EXEC_ERROR;
  879. self->errormsg = "Error while executing the query";
  880. }
  882. if ( ! self->internal)
  883. CC_abort(conn);
  884. }
  886. if (self->errornumber == STMT_OK)
  887. return SQL_SUCCESS;
  889. else if (self->errornumber == STMT_INFO_ONLY)
  890. return SQL_SUCCESS_WITH_INFO;
  892. else {
  893. SC_log_error(func, "", self);
  894. return SQL_ERROR;
  895. }
  896. }
  898. void
  899. SC_log_error(char *func, char *desc, StatementClass *self)
  900. {
  901. if (self) {
  902. qlog("STATEMENT ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'n", func, desc, self->errornumber, self->errormsg);
  903. mylog("STATEMENT ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'n", func, desc, self->errornumber, self->errormsg);
  904. qlog("                 ------------------------------------------------------------n");
  905. qlog("                 hdbc=%u, stmt=%u, result=%un", self->hdbc, self, self->result);
  906. qlog("                 manual_result=%d, prepare=%d, internal=%dn", self->manual_result, self->prepare, self->internal);
  907. qlog("                 bindings=%u, bindings_allocated=%dn", self->bindings, self->bindings_allocated);
  908. qlog("                 parameters=%u, parameters_allocated=%dn", self->parameters, self->parameters_allocated);
  909. qlog("                 statement_type=%d, statement='%s'n", self->statement_type, self->statement);
  910. qlog("                 stmt_with_params='%s'n", self->stmt_with_params);
  911. qlog("                 data_at_exec=%d, current_exec_param=%d, put_data=%dn", self->data_at_exec, self->current_exec_param, self->put_data);
  912. qlog("                 currTuple=%d, current_col=%d, lobj_fd=%dn", self->currTuple, self->current_col, self->lobj_fd);
  913. qlog("                 maxRows=%d, rowset_size=%d, keyset_size=%d, cursor_type=%d, scroll_concurrency=%dn", self->options.maxRows, self->options.rowset_size, self->options.keyset_size, self->options.cursor_type, self->options.scroll_concurrency);
  914. qlog("                 cursor_name='%s'n", self->cursor_name);
  916. qlog("                 ----------------QResult Info -------------------------------n");
  918. if (self->result) {
  919. QResultClass *res = self->result;
  920. qlog("                 fields=%u, manual_tuples=%u, backend_tuples=%u, tupleField=%d, conn=%un", res->fields, res->manual_tuples, res->backend_tuples, res->tupleField, res->conn);
  921. qlog("                 fetch_count=%d, fcount=%d, num_fields=%d, cursor='%s'n", res->fetch_count, res->fcount, res->num_fields, res->cursor);
  922. qlog("                 message='%s', command='%s', notice='%s'n", res->message, res->command, res->notice);
  923. qlog("                 status=%d, inTuples=%dn", res->status, res->inTuples);
  924. }
  926. // Log the connection error if there is one
  927. CC_log_error(func, desc, self->hdbc);
  928. }
  929. else
  930. qlog("INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'n", func, desc);
  931. }