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

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

数据库系统

开发平台：

Unix_Linux

results.c：源码内容
  2. /* Module:          results.c
  3.  *
  4.  * Description:     This module contains functions related to 
  5.  *                  retrieving result information through the ODBC API.
  6.  *
  7.  * Classes:         n/a
  8.  *
  9.  * API functions:   SQLRowCount, SQLNumResultCols, SQLDescribeCol, SQLColAttributes,
  10.  *                  SQLGetData, SQLFetch, SQLExtendedFetch, 
  11.  *                  SQLMoreResults(NI), SQLSetPos, SQLSetScrollOptions(NI),
  12.  *                  SQLSetCursorName, SQLGetCursorName
  13.  *
  14.  * Comments:        See "notice.txt" for copyright and license information.
  15.  *
  16.  */
  18. #ifdef HAVE_CONFIG_H
  19. #include "config.h"
  20. #endif
  22. #include <string.h>
  23. #include "psqlodbc.h"
  24. #include "dlg_specific.h"
  25. #include "environ.h"
  26. #include "connection.h"
  27. #include "statement.h"
  28. #include "bind.h"
  29. #include "qresult.h"
  30. #include "convert.h"
  31. #include "pgtypes.h" 
  33. #include <stdio.h>
  35. #ifndef WIN32
  36. #include "iodbc.h"
  37. #include "isqlext.h"
  38. #else
  39. #include <windows.h>
  40. #include <sqlext.h>
  41. #endif
  43. extern GLOBAL_VALUES globals;
  47. RETCODE SQL_API SQLRowCount(
  48.         HSTMT      hstmt,
  49.         SDWORD FAR *pcrow)
  50. {
  51. static char *func="SQLRowCount";
  52. StatementClass *stmt = (StatementClass *) hstmt;
  53. QResultClass *res;
  54. char *msg, *ptr;
  56. if ( ! stmt) {
  57. SC_log_error(func, "", NULL);
  58. return SQL_INVALID_HANDLE;
  59. }
  60. if (stmt->manual_result) {
  61. if (pcrow)
  62. *pcrow = -1;
  63. return SQL_SUCCESS;
  64. }
  66. if(stmt->statement_type == STMT_TYPE_SELECT) {
  67. if (stmt->status == STMT_FINISHED) {
  68. res = SC_get_Result(stmt);
  70. if(res && pcrow) {
  71. *pcrow = globals.use_declarefetch ? -1 : QR_get_num_tuples(res);
  72. return SQL_SUCCESS;
  73. }
  74. }
  75. } else {
  77. res = SC_get_Result(stmt);
  78. if (res && pcrow) {
  79. msg = QR_get_command(res);
  80. mylog("*** msg = '%s'n", msg);
  81. trim(msg); // get rid of trailing spaces
  82. ptr = strrchr(msg, ' ');
  83. if (ptr) {
  84. *pcrow = atoi(ptr+1);
  85. mylog("**** SQLRowCount(): THE ROWS: *pcrow = %dn", *pcrow);
  86. }
  87. else {
  88. *pcrow = -1;
  90. mylog("**** SQLRowCount(): NO ROWS: *pcrow = %dn", *pcrow);
  91. }
  93. return SQL_SUCCESS;
  94. }
  95. }
  97. SC_log_error(func, "Bad return value", stmt);
  98. return SQL_ERROR;     
  99. }
  102. //      This returns the number of columns associated with the database
  103. //      attached to "hstmt".
  106. RETCODE SQL_API SQLNumResultCols(
  107.         HSTMT     hstmt,
  108.         SWORD FAR *pccol)
  109. {       
  110. static char *func="SQLNumResultCols";
  111. StatementClass *stmt = (StatementClass *) hstmt;
  112. QResultClass *result;
  113. char parse_ok;
  115. if ( ! stmt) {
  116. SC_log_error(func, "", NULL);
  117. return SQL_INVALID_HANDLE;
  118. }
  120. SC_clear_error(stmt);    
  122. parse_ok = FALSE;
  123. if (globals.parse && stmt->statement_type == STMT_TYPE_SELECT) {
  125. if (stmt->parse_status == STMT_PARSE_NONE) {
  126. mylog("SQLNumResultCols: calling parse_statement on stmt=%un", stmt);
  127. parse_statement(stmt);
  128. }
  130. if (stmt->parse_status != STMT_PARSE_FATAL) {
  131. parse_ok = TRUE;
  132. *pccol = stmt->nfld;
  133. mylog("PARSE: SQLNumResultCols: *pccol = %dn", *pccol);
  134. }
  135. }
  137. if ( ! parse_ok) {
  139. SC_pre_execute(stmt);       
  140. result = SC_get_Result(stmt);
  142. mylog("SQLNumResultCols: result = %u, status = %d, numcols = %dn", result, stmt->status, result != NULL ? QR_NumResultCols(result) : -1);
  143. if (( ! result) || ((stmt->status != STMT_FINISHED) && (stmt->status != STMT_PREMATURE)) ) {
  144. /* no query has been executed on this statement */
  145. stmt->errornumber = STMT_SEQUENCE_ERROR;
  146. stmt->errormsg = "No query has been executed with that handle";
  147. SC_log_error(func, "", stmt);
  148. return SQL_ERROR;
  149. }
  151. *pccol = QR_NumResultCols(result);
  152. }
  154. return SQL_SUCCESS;
  155. }
  158. //      -       -       -       -       -       -       -       -       -
  162. //      Return information about the database column the user wants
  163. //      information about.
  164. RETCODE SQL_API SQLDescribeCol(
  165.         HSTMT      hstmt,
  166.         UWORD      icol,
  167.         UCHAR  FAR *szColName,
  168.         SWORD      cbColNameMax,
  169.         SWORD  FAR *pcbColName,
  170.         SWORD  FAR *pfSqlType,
  171.         UDWORD FAR *pcbColDef,
  172.         SWORD  FAR *pibScale,
  173.         SWORD  FAR *pfNullable)
  174. {
  175. static char *func="SQLDescribeCol";
  176.     /* gets all the information about a specific column */
  177. StatementClass *stmt = (StatementClass *) hstmt;
  178. QResultClass *res;
  179. char *col_name = NULL;
  180. Int4 fieldtype = 0;
  181. int precision = 0;
  182. ConnInfo *ci;
  183. char parse_ok;
  184. char buf[255];
  185. int len = 0;
  186. RETCODE result;
  189. mylog("%s: entering...n", func);
  191.     if ( ! stmt) {
  192. SC_log_error(func, "", NULL);
  193.         return SQL_INVALID_HANDLE;
  194. }
  196. ci = &(stmt->hdbc->connInfo);
  198.     SC_clear_error(stmt);
  200. /* Dont check for bookmark column.  This is the responsibility
  201. of the driver manager.  
  202. */
  204. icol--; /* use zero based column numbers */
  207. parse_ok = FALSE;
  208. if (globals.parse && stmt->statement_type == STMT_TYPE_SELECT) {
  210. if (stmt->parse_status == STMT_PARSE_NONE) {
  211. mylog("SQLDescribeCol: calling parse_statement on stmt=%un", stmt);
  212. parse_statement(stmt);
  213. }
  216. mylog("PARSE: DescribeCol: icol=%d, stmt=%u, stmt->nfld=%d, stmt->fi=%un", icol, stmt, stmt->nfld, stmt->fi);
  218. if (stmt->parse_status != STMT_PARSE_FATAL && stmt->fi && stmt->fi[icol]) {
  220. if (icol >= stmt->nfld) {
  221. stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
  222. stmt->errormsg = "Invalid column number in DescribeCol.";
  223. SC_log_error(func, "", stmt);
  224. return SQL_ERROR;
  225. }
  226. mylog("DescribeCol: getting info for icol=%dn", icol);
  228. fieldtype = stmt->fi[icol]->type;
  229. col_name = stmt->fi[icol]->name;
  230. precision = stmt->fi[icol]->precision;
  232. mylog("PARSE: fieldtype=%d, col_name='%s', precision=%dn", fieldtype, col_name, precision);
  233. if (fieldtype > 0)
  234. parse_ok = TRUE;
  235. }
  236. }
  239. /* If couldn't parse it OR the field being described was not parsed (i.e., because
  240. it was a function or expression, etc, then do it the old fashioned way.
  241. */
  242. if ( ! parse_ok) {
  243. SC_pre_execute(stmt);
  245. res = SC_get_Result(stmt);
  247. mylog("**** SQLDescribeCol: res = %u, stmt->status = %d, !finished=%d, !premature=%dn", res, stmt->status, stmt->status != STMT_FINISHED, stmt->status != STMT_PREMATURE);
  248. if ( (NULL == res) || ((stmt->status != STMT_FINISHED) && (stmt->status != STMT_PREMATURE))) {
  249. /* no query has been executed on this statement */
  250. stmt->errornumber = STMT_SEQUENCE_ERROR;
  251. stmt->errormsg = "No query has been assigned to this statement.";
  252. SC_log_error(func, "", stmt);
  253. return SQL_ERROR;
  254. }
  256. if (icol >= QR_NumResultCols(res)) {
  257. stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
  258. stmt->errormsg = "Invalid column number in DescribeCol.";
  259. sprintf(buf, "Col#=%d, #Cols=%d", icol, QR_NumResultCols(res));
  260. SC_log_error(func, buf, stmt);
  261. return SQL_ERROR;
  262. }
  264. col_name = QR_get_fieldname(res, icol);
  265.         fieldtype = QR_get_field_type(res, icol);
  267. precision = pgtype_precision(stmt, fieldtype, icol, globals.unknown_sizes);  // atoi(ci->unknown_sizes)
  268. }
  270. mylog("describeCol: col %d fieldname = '%s'n", icol, col_name);
  271. mylog("describeCol: col %d fieldtype = %dn", icol, fieldtype);
  272. mylog("describeCol: col %d precision = %dn", icol, precision);
  275. result = SQL_SUCCESS;
  277. /************************/
  278. /* COLUMN NAME     */
  279. /************************/
  280. len = strlen(col_name);
  282. if (pcbColName)
  283. *pcbColName = len;
  285. if (szColName) {
  286. strncpy_null(szColName, col_name, cbColNameMax);
  288. if (len >= cbColNameMax)  {
  289. result = SQL_SUCCESS_WITH_INFO;
  290. stmt->errornumber = STMT_TRUNCATED;
  291. stmt->errormsg = "The buffer was too small for the result.";
  292. }
  293.     }
  296. /************************/
  297. /* SQL TYPE        */
  298. /************************/
  299.     if (pfSqlType) {
  300.         *pfSqlType = pgtype_to_sqltype(stmt, fieldtype);
  302. mylog("describeCol: col %d *pfSqlType = %dn", icol, *pfSqlType);
  303. }
  305. /************************/
  306. /* PRECISION       */
  307. /************************/
  308.     if (pcbColDef) {
  310. if ( precision < 0)
  311. precision = 0; // "I dont know"
  313. *pcbColDef = precision;
  315. mylog("describeCol: col %d  *pcbColDef = %dn", icol, *pcbColDef);
  316. }
  318. /************************/
  319. /* SCALE           */
  320. /************************/
  321.     if (pibScale) {
  322.         Int2 scale;
  323.         scale = pgtype_scale(stmt, fieldtype);
  324.         if(scale == -1) { scale = 0; }
  325.         
  326.         *pibScale = scale;
  327. mylog("describeCol: col %d  *pibScale = %dn", icol, *pibScale);
  328.     }
  330. /************************/
  331. /* NULLABILITY     */
  332. /************************/
  333.     if (pfNullable) {
  334. *pfNullable = (parse_ok) ? stmt->fi[icol]->nullable : pgtype_nullable(stmt, fieldtype);
  336. mylog("describeCol: col %d  *pfNullable = %dn", icol, *pfNullable);
  337.     }
  339.     return result;
  340. }
  342. //      Returns result column descriptor information for a result set.
  344. RETCODE SQL_API SQLColAttributes(
  345.         HSTMT      hstmt,
  346.         UWORD      icol,
  347.         UWORD      fDescType,
  348.         PTR        rgbDesc,
  349.         SWORD      cbDescMax,
  350.         SWORD  FAR *pcbDesc,
  351.         SDWORD FAR *pfDesc)
  352. {
  353. static char *func = "SQLColAttributes";
  354. StatementClass *stmt = (StatementClass *) hstmt;
  355. Int4 field_type = 0;
  356. ConnInfo *ci;
  357. int unknown_sizes;
  358. int cols = 0;
  359. char parse_ok;
  360. RETCODE result;
  361. char *p = NULL;
  362. int len = 0, value = 0;
  364. mylog("%s: entering...n", func);
  366. if( ! stmt) {
  367. SC_log_error(func, "", NULL);
  368. return SQL_INVALID_HANDLE;
  369. }
  371. ci = &(stmt->hdbc->connInfo);
  373. /* Dont check for bookmark column.  This is the responsibility
  374. of the driver manager.  For certain types of arguments, the column
  375. number is ignored anyway, so it may be 0.
  376. */
  378. icol--;
  380. unknown_sizes = globals.unknown_sizes;          // atoi(ci->unknown_sizes);
  381. if (unknown_sizes == UNKNOWNS_AS_DONTKNOW) // not appropriate for SQLColAttributes()
  382. unknown_sizes = UNKNOWNS_AS_MAX;
  384. parse_ok = FALSE;
  385. if (globals.parse && stmt->statement_type == STMT_TYPE_SELECT) {
  387. if (stmt->parse_status == STMT_PARSE_NONE) {
  388. mylog("SQLColAttributes: calling parse_statementn");
  389. parse_statement(stmt);
  390. }
  392. cols = stmt->nfld;
  394. /* Column Count is a special case.  The Column number is ignored
  395. in this case.
  396. */
  397. if (fDescType == SQL_COLUMN_COUNT) {
  398. if (pfDesc)
  399. *pfDesc = cols;
  401. return SQL_SUCCESS;
  402. }
  404. if (stmt->parse_status != STMT_PARSE_FATAL && stmt->fi && stmt->fi[icol]) {
  406. if (icol >= cols) {
  407. stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
  408. stmt->errormsg = "Invalid column number in DescribeCol.";
  409. SC_log_error(func, "", stmt);
  410. return SQL_ERROR;
  411. }
  413. field_type = stmt->fi[icol]->type;
  414. if (field_type > 0)
  415. parse_ok = TRUE;
  416. }
  417. }
  419. if ( ! parse_ok) {
  420. SC_pre_execute(stmt);       
  422. mylog("**** SQLColAtt: result = %u, status = %d, numcols = %dn", stmt->result, stmt->status, stmt->result != NULL ? QR_NumResultCols(stmt->result) : -1);
  424. if ( (NULL == stmt->result) || ((stmt->status != STMT_FINISHED) && (stmt->status != STMT_PREMATURE)) ) {
  425. stmt->errormsg = "Can't get column attributes: no result found.";
  426. stmt->errornumber = STMT_SEQUENCE_ERROR;
  427. SC_log_error(func, "", stmt);
  428. return SQL_ERROR;
  429. }
  431. cols = QR_NumResultCols(stmt->result);
  433. /* Column Count is a special case.  The Column number is ignored
  434. in this case.
  435. */
  436. if (fDescType == SQL_COLUMN_COUNT) {
  437. if (pfDesc)
  438. *pfDesc = cols;
  440. return SQL_SUCCESS;
  441. }
  443. if (icol >= cols) {
  444. stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
  445. stmt->errormsg = "Invalid column number in DescribeCol.";
  446. SC_log_error(func, "", stmt);
  447. return SQL_ERROR;
  448. }
  450. field_type = QR_get_field_type(stmt->result, icol);
  451. }
  453. mylog("colAttr: col %d field_type = %dn", icol, field_type);
  455. switch(fDescType) {
  456. case SQL_COLUMN_AUTO_INCREMENT:
  457. value  = pgtype_auto_increment(stmt, field_type);
  458. if (value == -1)  /*  non-numeric becomes FALSE (ODBC Doc) */
  459. value = FALSE;
  461. break;
  463. case SQL_COLUMN_CASE_SENSITIVE:
  464. value = pgtype_case_sensitive(stmt, field_type);
  465. break;
  467. /*  This special case is handled above.
  469. case SQL_COLUMN_COUNT: 
  470. */
  472.     case SQL_COLUMN_DISPLAY_SIZE:
  473. value = (parse_ok) ? stmt->fi[icol]->display_size : pgtype_display_size(stmt, field_type, icol, unknown_sizes);
  475. mylog("SQLColAttributes: col %d, display_size= %dn", icol, value);
  477.         break;
  479. case SQL_COLUMN_LABEL:
  480. if (parse_ok && stmt->fi[icol]->alias[0] != '') {
  481. p = stmt->fi[icol]->alias;
  483. mylog("SQLColAttr: COLUMN_LABEL = '%s'n", p);
  484. break;
  486. } // otherwise same as column name -- FALL THROUGH!!!
  488. case SQL_COLUMN_NAME:
  490. p = (parse_ok) ? stmt->fi[icol]->name : QR_get_fieldname(stmt->result, icol);
  492. mylog("SQLColAttr: COLUMN_NAME = '%s'n", p);
  493. break;
  495. case SQL_COLUMN_LENGTH:
  496. value = (parse_ok) ? stmt->fi[icol]->length :  pgtype_length(stmt, field_type, icol, unknown_sizes); 
  498. mylog("SQLColAttributes: col %d, length = %dn", icol, value);
  499.         break;
  501. case SQL_COLUMN_MONEY:
  502. value = pgtype_money(stmt, field_type);
  503. break;
  505. case SQL_COLUMN_NULLABLE:
  506. value = (parse_ok) ? stmt->fi[icol]->nullable : pgtype_nullable(stmt, field_type);
  507. break;
  509. case SQL_COLUMN_OWNER_NAME:
  510. p = "";
  511. break;
  513. case SQL_COLUMN_PRECISION:
  514. value = (parse_ok) ? stmt->fi[icol]->precision : pgtype_precision(stmt, field_type, icol, unknown_sizes);
  516. mylog("SQLColAttributes: col %d, precision = %dn", icol, value);
  517.         break;
  519. case SQL_COLUMN_QUALIFIER_NAME:
  520. p = "";
  521. break;
  523. case SQL_COLUMN_SCALE:
  524. value = pgtype_scale(stmt, field_type);
  525. break;
  527. case SQL_COLUMN_SEARCHABLE:
  528. value = pgtype_searchable(stmt, field_type);
  529. break;
  531.     case SQL_COLUMN_TABLE_NAME:
  533. p = (parse_ok && stmt->fi[icol]->ti) ? stmt->fi[icol]->ti->name : "";
  535. mylog("SQLColAttr: TABLE_NAME = '%s'n", p);
  536.         break;
  538. case SQL_COLUMN_TYPE:
  539. value = pgtype_to_sqltype(stmt, field_type);
  540. break;
  542. case SQL_COLUMN_TYPE_NAME:
  543. p = pgtype_to_name(stmt, field_type);
  544. break;
  546. case SQL_COLUMN_UNSIGNED:
  547. value = pgtype_unsigned(stmt, field_type);
  548. if(value == -1) /* non-numeric becomes TRUE (ODBC Doc) */
  549. value = TRUE;
  551. break;
  553. case SQL_COLUMN_UPDATABLE:
  554. /* Neither Access or Borland care about this.
  556. if (field_type == PG_TYPE_OID)
  557. *pfDesc = SQL_ATTR_READONLY;
  558. else
  559. */
  561. value = SQL_ATTR_WRITE;
  563. mylog("SQLColAttr: UPDATEABLE = %dn", value);
  564. break;
  565.     }
  567. result = SQL_SUCCESS;
  569. if (p) {  /* char/binary data */
  570. len = strlen(p);
  572. if (rgbDesc) {
  573. strncpy_null((char *)rgbDesc, p, (size_t)cbDescMax);
  575. if (len >= cbDescMax)  {
  576. result = SQL_SUCCESS_WITH_INFO;
  577. stmt->errornumber = STMT_TRUNCATED;
  578. stmt->errormsg = "The buffer was too small for the result.";
  579. }
  580. }
  582. if (pcbDesc) 
  583. *pcbDesc = len;
  584. }
  585. else { /* numeric data */
  587. if (pfDesc)
  588. *pfDesc = value;
  590. }
  593.     return result;
  594. }
  596. //      Returns result data for a single column in the current row.
  598. RETCODE SQL_API SQLGetData(
  599.         HSTMT      hstmt,
  600.         UWORD      icol,
  601.         SWORD      fCType,
  602.         PTR        rgbValue,
  603.         SDWORD     cbValueMax,
  604.         SDWORD FAR *pcbValue)
  605. {
  606. static char *func="SQLGetData";
  607. QResultClass *res;
  608. StatementClass *stmt = (StatementClass *) hstmt;
  609. int num_cols, num_rows;
  610. Int4 field_type;
  611. void *value;
  612. int result;
  613. char get_bookmark = FALSE;
  615. mylog("SQLGetData: enter, stmt=%un", stmt);
  617.     if( ! stmt) {
  618. SC_log_error(func, "", NULL);
  619.         return SQL_INVALID_HANDLE;
  620.     }
  621. res = stmt->result;
  623.     if (STMT_EXECUTING == stmt->status) {
  624.         stmt->errormsg = "Can't get data while statement is still executing.";
  625.         stmt->errornumber = STMT_SEQUENCE_ERROR;
  626. SC_log_error(func, "", stmt);
  627.         return SQL_ERROR;
  628.     }
  630.     if (stmt->status != STMT_FINISHED) {
  631.         stmt->errornumber = STMT_STATUS_ERROR;
  632.         stmt->errormsg = "GetData can only be called after the successful execution on a SQL statement";
  633. SC_log_error(func, "", stmt);
  634.         return SQL_ERROR;
  635.     }
  637.     if (icol == 0) {
  639. if (stmt->options.use_bookmarks == SQL_UB_OFF) {
  640. stmt->errornumber = STMT_COLNUM_ERROR;
  641. stmt->errormsg = "Attempt to retrieve bookmark with bookmark usage disabled";
  642. SC_log_error(func, "", stmt);
  643. return SQL_ERROR;
  644. }
  646. /* Make sure it is the bookmark data type */
  647. if (fCType != SQL_C_BOOKMARK) {
  648. stmt->errormsg = "Column 0 is not of type SQL_C_BOOKMARK";
  649. stmt->errornumber = STMT_PROGRAM_TYPE_OUT_OF_RANGE;
  650. SC_log_error(func, "", stmt);
  651. return SQL_ERROR;
  652. }
  654. get_bookmark = TRUE;
  656.     }
  658. else {
  660. // use zero-based column numbers
  661. icol--;
  663. // make sure the column number is valid
  664. num_cols = QR_NumResultCols(res);
  665. if (icol >= num_cols) {
  666. stmt->errormsg = "Invalid column number.";
  667. stmt->errornumber = STMT_INVALID_COLUMN_NUMBER_ERROR;
  668. SC_log_error(func, "", stmt);
  669. return SQL_ERROR;
  670. }
  671. }
  673. if ( stmt->manual_result || ! globals.use_declarefetch) {
  674. // make sure we're positioned on a valid row
  675. num_rows = QR_get_num_tuples(res);
  676. if((stmt->currTuple < 0) ||
  677.    (stmt->currTuple >= num_rows)) {
  678. stmt->errormsg = "Not positioned on a valid row for GetData.";
  679. stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
  680. SC_log_error(func, "", stmt);
  681. return SQL_ERROR;
  682. }
  683. mylog("     num_rows = %dn", num_rows);
  685. if ( ! get_bookmark) {
  686. if ( stmt->manual_result) {
  687. value = QR_get_value_manual(res, stmt->currTuple, icol);
  688. }
  689. else {
  690. value = QR_get_value_backend_row(res, stmt->currTuple, icol);
  691. }
  692. mylog("     value = '%s'n", value);
  693. }
  694. }
  695. else { /* its a SOCKET result (backend data) */
  696. if (stmt->currTuple == -1 || ! res || ! res->tupleField) {
  697. stmt->errormsg = "Not positioned on a valid row for GetData.";
  698. stmt->errornumber = STMT_INVALID_CURSOR_STATE_ERROR;
  699. SC_log_error(func, "", stmt);
  700. return SQL_ERROR;
  701. }
  703. if ( ! get_bookmark)
  704. value = QR_get_value_backend(res, icol);
  706. mylog("  socket: value = '%s'n", value);
  707. }
  709. if ( get_bookmark) {
  710. *((UDWORD *) rgbValue) = SC_get_bookmark(stmt);
  712. if (pcbValue)
  713. *pcbValue = 4;
  715. return SQL_SUCCESS;
  716. }
  718. field_type = QR_get_field_type(res, icol);
  720. mylog("**** SQLGetData: icol = %d, fCType = %d, field_type = %d, value = '%s'n", icol, fCType, field_type, value);
  722. stmt->current_col = icol;
  724.     result = copy_and_convert_field(stmt, field_type, value, 
  725.                                     fCType, rgbValue, cbValueMax, pcbValue);
  727. stmt->current_col = -1;
  729. switch(result) {
  730. case COPY_OK:
  731. return SQL_SUCCESS;
  733. case COPY_UNSUPPORTED_TYPE:
  734. stmt->errormsg = "Received an unsupported type from Postgres.";
  735. stmt->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
  736. SC_log_error(func, "", stmt);
  737. return SQL_ERROR;
  739. case COPY_UNSUPPORTED_CONVERSION:
  740. stmt->errormsg = "Couldn't handle the necessary data type conversion.";
  741. stmt->errornumber = STMT_RESTRICTED_DATA_TYPE_ERROR;
  742. SC_log_error(func, "", stmt);
  743. return SQL_ERROR;
  745. case COPY_RESULT_TRUNCATED:
  746. stmt->errornumber = STMT_TRUNCATED;
  747. stmt->errormsg = "The buffer was too small for the result.";
  748. return SQL_SUCCESS_WITH_INFO;
  750. case COPY_GENERAL_ERROR: /* error msg already filled in */
  751. SC_log_error(func, "", stmt);
  752. return SQL_ERROR;
  754. case COPY_NO_DATA_FOUND:
  755. /* SC_log_error(func, "no data found", stmt); */
  756. return SQL_NO_DATA_FOUND;
  758.     default:
  759.         stmt->errormsg = "Unrecognized return value from copy_and_convert_field.";
  760.         stmt->errornumber = STMT_INTERNAL_ERROR;
  761. SC_log_error(func, "", stmt);
  762.         return SQL_ERROR;
  763.     }
  764. }
  768. //      Returns data for bound columns in the current row ("hstmt->iCursor"),
  769. //      advances the cursor.
  771. RETCODE SQL_API SQLFetch(
  772.         HSTMT   hstmt)
  773. {
  774. static char *func = "SQLFetch";
  775. StatementClass *stmt = (StatementClass *) hstmt;   
  776. QResultClass *res;
  778. mylog("SQLFetch: stmt = %u, stmt->result= %un", stmt, stmt->result);
  780. if ( ! stmt) {
  781. SC_log_error(func, "", NULL);
  782. return SQL_INVALID_HANDLE;
  783. }
  785. SC_clear_error(stmt);
  787. if ( ! (res = stmt->result)) {
  788. stmt->errormsg = "Null statement result in SQLFetch.";
  789. stmt->errornumber = STMT_SEQUENCE_ERROR;
  790. SC_log_error(func, "", stmt);
  791. return SQL_ERROR;
  792. }
  794. /* Not allowed to bind a bookmark column when using SQLFetch. */
  795. if ( stmt->bookmark.buffer) {
  796. stmt->errornumber = STMT_COLNUM_ERROR;
  797. stmt->errormsg = "Not allowed to bind a bookmark column when using SQLFetch";
  798. SC_log_error(func, "", stmt);
  799. return SQL_ERROR;
  800. }
  802. if (stmt->status == STMT_EXECUTING) {
  803. stmt->errormsg = "Can't fetch while statement is still executing.";
  804. stmt->errornumber = STMT_SEQUENCE_ERROR;
  805. SC_log_error(func, "", stmt);
  806. return SQL_ERROR;
  807. }
  810. if (stmt->status != STMT_FINISHED) {
  811. stmt->errornumber = STMT_STATUS_ERROR;
  812. stmt->errormsg = "Fetch can only be called after the successful execution on a SQL statement";
  813. SC_log_error(func, "", stmt);
  814. return SQL_ERROR;
  815. }
  817. if (stmt->bindings == NULL) {
  818. // just to avoid a crash if the user insists on calling this
  819. // function even if SQL_ExecDirect has reported an Error
  820. stmt->errormsg = "Bindings were not allocated properly.";
  821. stmt->errornumber = STMT_SEQUENCE_ERROR;
  822. SC_log_error(func, "", stmt);
  823. return SQL_ERROR;
  824. }
  826. QR_set_rowset_size(res, 1);
  827. QR_inc_base(res, stmt->last_fetch_count);
  829. return SC_fetch(stmt);
  830. }
  832. //      This fetchs a block of data (rowset).
  834. RETCODE SQL_API SQLExtendedFetch(
  835.         HSTMT      hstmt,
  836.         UWORD      fFetchType,
  837.         SDWORD     irow,
  838.         UDWORD FAR *pcrow,
  839.         UWORD  FAR *rgfRowStatus)
  840. {
  841. static char *func = "SQLExtendedFetch";
  842. StatementClass *stmt = (StatementClass *) hstmt;
  843. QResultClass *res;
  844. int num_tuples, i, save_rowset_size;
  845. RETCODE result;
  846. char truncated, error;
  848. mylog("SQLExtendedFetch: stmt=%un", stmt);
  850. if ( ! stmt) {
  851. SC_log_error(func, "", NULL);
  852. return SQL_INVALID_HANDLE;
  853. }
  855. if ( globals.use_declarefetch && ! stmt->manual_result) {
  856. if ( fFetchType != SQL_FETCH_NEXT) {
  857. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  858. stmt->errormsg = "Unsupported fetch type for SQLExtendedFetch with UseDeclareFetch option.";
  859. return SQL_ERROR;
  860. }
  861. }
  863. SC_clear_error(stmt);
  865. if ( ! (res = stmt->result)) {
  866. stmt->errormsg = "Null statement result in SQLExtendedFetch.";
  867. stmt->errornumber = STMT_SEQUENCE_ERROR;
  868. SC_log_error(func, "", stmt);
  869. return SQL_ERROR;
  870. }
  872. /* If a bookmark colunmn is bound but bookmark usage is off, then error */
  873. if (stmt->bookmark.buffer && stmt->options.use_bookmarks == SQL_UB_OFF) {
  874. stmt->errornumber = STMT_COLNUM_ERROR;
  875. stmt->errormsg = "Attempt to retrieve bookmark with bookmark usage disabled";
  876. SC_log_error(func, "", stmt);
  877. return SQL_ERROR;
  878. }
  880. if (stmt->status == STMT_EXECUTING) {
  881. stmt->errormsg = "Can't fetch while statement is still executing.";
  882. stmt->errornumber = STMT_SEQUENCE_ERROR;
  883. SC_log_error(func, "", stmt);
  884. return SQL_ERROR;
  885. }
  887. if (stmt->status != STMT_FINISHED) {
  888. stmt->errornumber = STMT_STATUS_ERROR;
  889. stmt->errormsg = "ExtendedFetch can only be called after the successful execution on a SQL statement";
  890. SC_log_error(func, "", stmt);
  891. return SQL_ERROR;
  892. }
  894. if (stmt->bindings == NULL) {
  895. // just to avoid a crash if the user insists on calling this
  896. // function even if SQL_ExecDirect has reported an Error
  897. stmt->errormsg = "Bindings were not allocated properly.";
  898. stmt->errornumber = STMT_SEQUENCE_ERROR;
  899. SC_log_error(func, "", stmt);
  900. return SQL_ERROR;
  901. }
  903. /* Initialize to no rows fetched */
  904. if (rgfRowStatus)
  905. for (i = 0; i < stmt->options.rowset_size; i++)
  906. *(rgfRowStatus + i) = SQL_ROW_NOROW;
  908. if (pcrow)
  909. *pcrow = 0;
  911. num_tuples = QR_get_num_tuples(res);
  913. /* Save and discard the saved rowset size */
  914. save_rowset_size = stmt->save_rowset_size;
  915. stmt->save_rowset_size = -1;
  917. switch (fFetchType)  {
  918. case SQL_FETCH_NEXT:
  920. /* From the odbc spec... If positioned before the start of the RESULT SET,
  921. then this should be equivalent to SQL_FETCH_FIRST.
  922. */
  924. if (stmt->rowset_start < 0)
  925. stmt->rowset_start = 0;
  927. else {
  929. stmt->rowset_start += (save_rowset_size > 0 ? save_rowset_size : stmt->options.rowset_size);
  930. }
  932. mylog("SQL_FETCH_NEXT: num_tuples=%d, currtuple=%dn", num_tuples, stmt->currTuple);
  933. break;
  935. case SQL_FETCH_PRIOR:
  936. mylog("SQL_FETCH_PRIOR: num_tuples=%d, currtuple=%dn", num_tuples, stmt->currTuple);
  939. /* From the odbc spec... If positioned after the end of the RESULT SET,
  940. then this should be equivalent to SQL_FETCH_LAST.
  941. */
  943. if (stmt->rowset_start >= num_tuples) {
  944. stmt->rowset_start = num_tuples <= 0 ? 0 : (num_tuples - stmt->options.rowset_size);
  946. }
  947. else {
  949. stmt->rowset_start -= stmt->options.rowset_size;
  951. }
  953. break;
  955. case SQL_FETCH_FIRST:
  956. mylog("SQL_FETCH_FIRST: num_tuples=%d, currtuple=%dn", num_tuples, stmt->currTuple);
  958. stmt->rowset_start = 0;
  959. break;
  961. case SQL_FETCH_LAST:
  962. mylog("SQL_FETCH_LAST: num_tuples=%d, currtuple=%dn", num_tuples, stmt->currTuple);
  964. stmt->rowset_start = num_tuples <= 0 ? 0 : (num_tuples - stmt->options.rowset_size) ;
  965. break;
  967. case SQL_FETCH_ABSOLUTE:
  968. mylog("SQL_FETCH_ABSOLUTE: num_tuples=%d, currtuple=%d, irow=%dn", num_tuples, stmt->currTuple, irow);
  970. /* Position before result set, but dont fetch anything */
  971. if (irow == 0) {
  972. stmt->rowset_start = -1;
  973. stmt->currTuple = -1;
  974. return SQL_NO_DATA_FOUND;
  975. }
  976. /* Position before the desired row */
  977. else if (irow > 0) {
  978. stmt->rowset_start = irow - 1;
  979. }
  980. /* Position with respect to the end of the result set */
  981. else {
  982. stmt->rowset_start = num_tuples + irow;
  983. }    
  985. break;
  987. case SQL_FETCH_RELATIVE:
  989. /* Refresh the current rowset -- not currently implemented, but lie anyway */
  990. if (irow == 0) {
  991. break;
  992. }
  994. stmt->rowset_start += irow;
  997. break;
  999. case SQL_FETCH_BOOKMARK:
  1001. stmt->rowset_start = irow - 1;
  1002. break;
  1004. default:
  1005. SC_log_error(func, "Unsupported SQLExtendedFetch Direction", stmt);
  1006. return SQL_ERROR;   
  1008. }           
  1011. /***********************************/
  1012. /* CHECK FOR PROPER CURSOR STATE  */
  1013. /***********************************/
  1014. /* Handle Declare Fetch style specially because the end is not really the end... */
  1015. if ( globals.use_declarefetch && ! stmt->manual_result) {
  1016. if (QR_end_tuples(res)) {
  1017. return SQL_NO_DATA_FOUND;
  1018. }
  1019. }
  1020. else {
  1021. /* If *new* rowset is after the result_set, return no data found */
  1022. if (stmt->rowset_start >= num_tuples) {
  1023. stmt->rowset_start = num_tuples;
  1024. return SQL_NO_DATA_FOUND;
  1025. }
  1026. }
  1028. /* If *new* rowset is prior to result_set, return no data found */
  1029. if (stmt->rowset_start < 0) {
  1030. if (stmt->rowset_start + stmt->options.rowset_size <= 0) {
  1031. stmt->rowset_start = -1;
  1032. return SQL_NO_DATA_FOUND;
  1033. }
  1034. else { /* overlap with beginning of result set, so get first rowset */
  1035. stmt->rowset_start = 0;
  1036. }
  1037. }
  1039. /* currTuple is always 1 row prior to the rowset */
  1040. stmt->currTuple = stmt->rowset_start - 1;
  1042. /* increment the base row in the tuple cache */
  1043. QR_set_rowset_size(res, stmt->options.rowset_size);
  1044. QR_inc_base(res, stmt->last_fetch_count);
  1046. /* Physical Row advancement occurs for each row fetched below */
  1048. mylog("SQLExtendedFetch: new currTuple = %dn", stmt->currTuple);
  1050. truncated = error = FALSE;
  1051. for (i = 0; i < stmt->options.rowset_size; i++) {
  1053. stmt->bind_row = i; // set the binding location
  1054. result = SC_fetch(stmt);
  1056. /* Determine Function status */
  1057. if (result == SQL_NO_DATA_FOUND)
  1058. break;
  1059. else if (result == SQL_SUCCESS_WITH_INFO)
  1060. truncated = TRUE;
  1061. else if (result == SQL_ERROR)
  1062. error = TRUE;
  1064. /* Determine Row Status */
  1065. if (rgfRowStatus) {
  1066. if (result == SQL_ERROR) 
  1067. *(rgfRowStatus + i) = SQL_ROW_ERROR;
  1068. else
  1069. *(rgfRowStatus + i)= SQL_ROW_SUCCESS;
  1070. }
  1071. }
  1073. /* Save the fetch count for SQLSetPos */
  1074. stmt->last_fetch_count= i;
  1076. /* Reset next binding row */
  1077. stmt->bind_row = 0;
  1079. /* Move the cursor position to the first row in the result set. */
  1080. stmt->currTuple = stmt->rowset_start;
  1082. /* For declare/fetch, need to reset cursor to beginning of rowset */
  1083. if (globals.use_declarefetch && ! stmt->manual_result) {
  1084. QR_set_position(res, 0);
  1085. }
  1087. /* Set the number of rows retrieved */
  1088. if (pcrow)
  1089. *pcrow = i;
  1091. if (i == 0)
  1092. return SQL_NO_DATA_FOUND; /* Only DeclareFetch should wind up here */
  1093. else if (error)
  1094. return SQL_ERROR;
  1095. else if (truncated)
  1096. return SQL_SUCCESS_WITH_INFO;
  1097. else
  1098. return SQL_SUCCESS;
  1100. }
  1103. //      This determines whether there are more results sets available for
  1104. //      the "hstmt".
  1106. /* CC: return SQL_NO_DATA_FOUND since we do not support multiple result sets */
  1107. RETCODE SQL_API SQLMoreResults(
  1108.         HSTMT   hstmt)
  1109. {
  1110. return SQL_NO_DATA_FOUND;
  1111. }
  1113. //     This positions the cursor within a rowset, that was positioned using SQLExtendedFetch.
  1114. //    This will be useful (so far) only when using SQLGetData after SQLExtendedFetch.
  1115. RETCODE SQL_API SQLSetPos(
  1116.         HSTMT   hstmt,
  1117.         UWORD   irow,
  1118.         UWORD   fOption,
  1119.         UWORD   fLock)
  1120. {
  1121. static char *func = "SQLSetPos";
  1122. StatementClass *stmt = (StatementClass *) hstmt;
  1123. QResultClass *res;
  1124. int num_cols, i;
  1125. BindInfoClass *bindings = stmt->bindings;
  1127. if ( ! stmt) {
  1128. SC_log_error(func, "", NULL);
  1129. return SQL_INVALID_HANDLE;
  1130. }
  1132. if (fOption != SQL_POSITION && fOption != SQL_REFRESH) {
  1133. stmt->errornumber = STMT_NOT_IMPLEMENTED_ERROR;
  1134. stmt->errormsg = "Only SQL_POSITION/REFRESH is supported for SQLSetPos";
  1135. SC_log_error(func, "", stmt);
  1136. return SQL_ERROR;
  1137. }
  1139. if ( ! (res = stmt->result)) {
  1140. stmt->errormsg = "Null statement result in SQLSetPos.";
  1141. stmt->errornumber = STMT_SEQUENCE_ERROR;
  1142. SC_log_error(func, "", stmt);
  1143. return SQL_ERROR;
  1144. }
  1145. num_cols = QR_NumResultCols(res);
  1147. if (irow == 0) {
  1148. stmt->errornumber = STMT_ROW_OUT_OF_RANGE;
  1149. stmt->errormsg = "Driver does not support Bulk operations.";
  1150. SC_log_error(func, "", stmt);
  1151. return SQL_ERROR;
  1152. }
  1154. if (irow > stmt->last_fetch_count) {
  1155. stmt->errornumber = STMT_ROW_OUT_OF_RANGE;
  1156. stmt->errormsg = "Row value out of range";
  1157. SC_log_error(func, "", stmt);
  1158. return SQL_ERROR;
  1159. }
  1161. irow--;
  1163. /* Reset for SQLGetData */
  1164. for (i = 0; i < num_cols; i++)
  1165. bindings[i].data_left = -1;
  1167. QR_set_position(res, irow);
  1169. stmt->currTuple = stmt->rowset_start + irow;
  1171. return SQL_SUCCESS;
  1173. }
  1175. //      Sets options that control the behavior of cursors.
  1177. RETCODE SQL_API SQLSetScrollOptions(
  1178.         HSTMT      hstmt,
  1179.         UWORD      fConcurrency,
  1180.         SDWORD  crowKeyset,
  1181.         UWORD      crowRowset)
  1182. {
  1183. static char *func = "SQLSetScrollOptions";
  1185. SC_log_error(func, "Function not implemented", (StatementClass *) hstmt);
  1186. return SQL_ERROR;
  1187. }
  1190. //      Set the cursor name on a statement handle
  1192. RETCODE SQL_API SQLSetCursorName(
  1193.         HSTMT     hstmt,
  1194.         UCHAR FAR *szCursor,
  1195.         SWORD     cbCursor)
  1196. {
  1197. static char *func="SQLSetCursorName";
  1198. StatementClass *stmt = (StatementClass *) hstmt;
  1199. int len;
  1201. mylog("SQLSetCursorName: hstmt=%u, szCursor=%u, cbCursorMax=%dn", hstmt, szCursor, cbCursor);
  1203. if ( ! stmt) {
  1204. SC_log_error(func, "", NULL);
  1205. return SQL_INVALID_HANDLE;
  1206. }
  1208. len = (cbCursor == SQL_NTS) ? strlen(szCursor) : cbCursor;
  1210. if (len <= 0 || len > sizeof(stmt->cursor_name) - 1) {
  1211. stmt->errornumber = STMT_INVALID_CURSOR_NAME;
  1212. stmt->errormsg = "Invalid Cursor Name";
  1213. SC_log_error(func, "", stmt);
  1214. return SQL_ERROR;
  1215. }
  1217. strncpy_null(stmt->cursor_name, szCursor, len+1);
  1218. return SQL_SUCCESS;
  1219. }
  1221. //      Return the cursor name for a statement handle
  1223. RETCODE SQL_API SQLGetCursorName(
  1224.         HSTMT     hstmt,
  1225.         UCHAR FAR *szCursor,
  1226.         SWORD     cbCursorMax,
  1227.         SWORD FAR *pcbCursor)
  1228. {
  1229. static char *func="SQLGetCursorName";
  1230. StatementClass *stmt = (StatementClass *) hstmt;
  1231. int len = 0;
  1232. RETCODE result;
  1234. mylog("SQLGetCursorName: hstmt=%u, szCursor=%u, cbCursorMax=%d, pcbCursor=%un", hstmt, szCursor, cbCursorMax, pcbCursor);
  1236. if ( ! stmt) {
  1237. SC_log_error(func, "", NULL);
  1238. return SQL_INVALID_HANDLE;
  1239. }
  1241. if ( stmt->cursor_name[0] == '') {
  1242. stmt->errornumber = STMT_NO_CURSOR_NAME;
  1243. stmt->errormsg = "No Cursor name available";
  1244. SC_log_error(func, "", stmt);
  1245. return SQL_ERROR;
  1246. }
  1248. result = SQL_SUCCESS;
  1249. len = strlen(stmt->cursor_name);
  1251. if (szCursor) {
  1252. strncpy_null(szCursor, stmt->cursor_name, cbCursorMax);
  1254. if (len >= cbCursorMax)  {
  1255. result = SQL_SUCCESS_WITH_INFO;
  1256. stmt->errornumber = STMT_TRUNCATED;
  1257. stmt->errormsg = "The buffer was too small for the result.";
  1258. }
  1259. }
  1261. if (pcbCursor)
  1262. *pcbCursor = len;
  1264. return result;
  1265. }