src/iodbc/fetch.c

/*
 *  fetch.c
 *
 *  $Id$
 *
 *  Fetch query result
 *
 *  The iODBC driver manager.
 *
 *  Copyright (C) 1995 by Ke Jin <kejin@empress.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include	"config.h"

#include	"isql.h"
#include	"isqlext.h"

#include        "dlproc.h"

#include	"herr.h"
#include	"henv.h"
#include	"hdbc.h"
#include	"hstmt.h"

#include	"itrace.h"

RETCODE SQL_API
SQLFetch (HSTMT hstmt)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  /* check state */
  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	 case en_stmt_xfetched:
	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   PUSHSQLERR (pstmt->herr, en_S1010);
	   return SQL_ERROR;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != en_Fetch)
    {
      PUSHSQLERR (pstmt->herr, en_S1010);
      return SQL_ERROR;
    }

  hproc = _iodbcdm_getproc (pstmt->hdbc, en_Fetch);

  if (hproc == SQL_NULL_HPROC)
    {
      PUSHSQLERR (pstmt->herr, en_IM001);

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Fetch,
    (pstmt->dhstmt))

  /* state transition */
  if (pstmt->asyn_on == en_Fetch)
    {
      switch (retcode)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_NO_DATA_FOUND:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return retcode;
	 }
    }

  switch (pstmt->state)
     {
     case en_stmt_cursoropen:
     case en_stmt_fetched:
       switch (retcode)
	  {
	  case SQL_SUCCESS:
	  case SQL_SUCCESS_WITH_INFO:
	    pstmt->state = en_stmt_fetched;
	    pstmt->cursor_state = en_stmt_cursor_fetched;
	    break;

	  case SQL_NO_DATA_FOUND:
	    if (pstmt->prep_state)
	      {
		pstmt->state = en_stmt_prepared;
	      }
	    else
	      {

		pstmt->state = en_stmt_allocated;
	      }
	    pstmt->cursor_state = en_stmt_cursor_no;
	    break;

	  case SQL_STILL_EXECUTING:
	    pstmt->asyn_on = en_Fetch;
	    break;

	  default:
	    break;
	  }
       break;

     default:
       break;
     }

  return retcode;
}


RETCODE SQL_API
SQLExtendedFetch (
    HSTMT hstmt,
    UWORD fFetchType,
    SDWORD irow,
    UDWORD FAR * pcrow,
    UWORD FAR * rgfRowStatus)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  /* check fetch type */
  if (fFetchType < SQL_FETCH_NEXT || fFetchType > SQL_FETCH_BOOKMARK)
    {
      /* Unlike MS driver manager(i.e. DM),
       * we don't check driver's ODBC version
       * against SQL_FETCH_RESUME (only 1.0)
       * and SQL_FETCH_BOOKMARK (only 2.0).
       */
      PUSHSQLERR (pstmt->herr, en_S1106);

      return SQL_ERROR;
    }

  /* check state */
  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	 case en_stmt_fetched:
	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   PUSHSQLERR (pstmt->herr, en_S1010);
	   return SQL_ERROR;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != en_ExtendedFetch)
    {
      PUSHSQLERR (pstmt->herr, en_S1010);
      return SQL_ERROR;
    }

  hproc = _iodbcdm_getproc (pstmt->hdbc, en_ExtendedFetch);

  if (hproc == SQL_NULL_HPROC)
    {
      PUSHSQLERR (pstmt->herr, en_IM001);

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ExtendedFetch,
    (pstmt->dhstmt, fFetchType, irow, pcrow, rgfRowStatus))

  /* state transition */
  if (pstmt->asyn_on == en_ExtendedFetch)
    {
      switch (retcode)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_NO_DATA_FOUND:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return retcode;
	 }
    }

  switch (pstmt->state)
     {
     case en_stmt_cursoropen:
     case en_stmt_xfetched:
       switch (retcode)
	  {
	  case SQL_SUCCESS:
	  case SQL_SUCCESS_WITH_INFO:
	  case SQL_NO_DATA_FOUND:
	    pstmt->state = en_stmt_xfetched;
	    pstmt->cursor_state = en_stmt_cursor_xfetched;
	    break;

	  case SQL_STILL_EXECUTING:
	    pstmt->asyn_on = en_ExtendedFetch;
	    break;

	  default:
	    break;
	  }
       break;

     default:
       break;
     }

  return retcode;
}


RETCODE SQL_API
SQLGetData (
    HSTMT hstmt,
    UWORD icol,
    SWORD fCType,
    PTR rgbValue,
    SDWORD cbValueMax,
    SDWORD FAR * pcbValue)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  /* check argument */
  if (rgbValue == NULL)
    {
      sqlstat = en_S1009;
    }
  else if (cbValueMax < 0)
    {
      sqlstat = en_S1090;
    }
  else
    {
      switch (fCType)
	 {
	 case SQL_C_DEFAULT:
	 case SQL_C_CHAR:
	 case SQL_C_BINARY:
	 case SQL_C_BIT:
	 case SQL_C_TINYINT:
	 case SQL_C_STINYINT:
	 case SQL_C_UTINYINT:
	 case SQL_C_SHORT:
	 case SQL_C_SSHORT:
	 case SQL_C_USHORT:
	 case SQL_C_LONG:
	 case SQL_C_SLONG:
	 case SQL_C_ULONG:
	 case SQL_C_FLOAT:
	 case SQL_C_DOUBLE:
	 case SQL_C_DATE:
	 case SQL_C_TIME:
	 case SQL_C_TIMESTAMP:
	   break;

	 default:
	   sqlstat = en_S1003;
	   break;
	 }
    }

  if (sqlstat != en_00000)
    {
      PUSHSQLERR (pstmt->herr, sqlstat);

      return SQL_ERROR;
    }

  /* check state */
  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   sqlstat = en_S1010;
	   break;

	 case en_stmt_executed:
	 case en_stmt_cursoropen:
	   sqlstat = en_24000;
	   break;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != en_GetData)
    {
      sqlstat = en_S1010;
    }

  if (sqlstat != en_00000)
    {
      PUSHSQLERR (pstmt->herr, sqlstat);

      return SQL_ERROR;
    }

  /* call driver */
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetData);

  if (hproc == SQL_NULL_HPROC)
    {
      PUSHSQLERR (pstmt->herr, en_IM001);

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_GetData,
    (pstmt->dhstmt, icol, fCType, rgbValue, cbValueMax, pcbValue))

  /* state transition */
  if (pstmt->asyn_on == en_GetData)
    {
      switch (retcode)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_NO_DATA_FOUND:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return retcode;
	 }
    }

  switch (pstmt->state)
     {
     case en_stmt_fetched:
     case en_stmt_xfetched:
       if (retcode == SQL_STILL_EXECUTING)
	 {
	   pstmt->asyn_on = en_GetData;
	   break;
	 }
       break;

     default:
       break;
     }

  return retcode;
}


RETCODE SQL_API
SQLMoreResults (HSTMT hstmt)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc;
  RETCODE retcode;

  if (hstmt == SQL_NULL_HSTMT
      || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  /* check state */
  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	   return SQL_NO_DATA_FOUND;

	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   PUSHSQLERR (pstmt->herr, en_S1010);
	   return SQL_ERROR;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != en_MoreResults)
    {
      PUSHSQLERR (pstmt->herr, en_S1010);

      return SQL_ERROR;
    }

  /* call driver */
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_MoreResults);

  if (hproc == SQL_NULL_HPROC)
    {
      PUSHSQLERR (pstmt->herr, en_IM001);

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_MoreResults,
    (pstmt->dhstmt))

  /* state transition */
  if (pstmt->asyn_on == en_MoreResults)
    {
      switch (retcode)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_NO_DATA_FOUND:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return retcode;
	 }
    }

  switch (pstmt->state)
     {
     case en_stmt_allocated:
     case en_stmt_prepared:
       /* driver should return SQL_NO_DATA_FOUND */
       break;

     case en_stmt_executed:
       if (retcode == SQL_NO_DATA_FOUND)
	 {
	   if (pstmt->prep_state)
	     {
	       pstmt->state = en_stmt_prepared;
	     }
	   else
	     {
	       pstmt->state = en_stmt_allocated;
	     }
	 }
       else if (retcode == SQL_STILL_EXECUTING)
	 {
	   pstmt->asyn_on = en_MoreResults;
	 }
       break;

     case en_stmt_cursoropen:
     case en_stmt_fetched:
     case en_stmt_xfetched:
       if (retcode == SQL_SUCCESS)
	 {
	   break;
	 }
       else if (retcode == SQL_NO_DATA_FOUND)
	 {
	   if (pstmt->prep_state)
	     {
	       pstmt->state = en_stmt_prepared;
	     }
	   else
	     {
	       pstmt->state = en_stmt_allocated;
	     }
	 }
       else if (retcode == SQL_STILL_EXECUTING)
	 {
	   pstmt->asyn_on = en_MoreResults;
	 }
       break;

     default:
       break;
     }

  return retcode;
}


RETCODE SQL_API
SQLSetPos (
    HSTMT hstmt,
    UWORD irow,
    UWORD fOption,
    UWORD fLock)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  /* check argument value */
  if (fOption > SQL_ADD || fLock > SQL_LOCK_UNLOCK)
    {
      PUSHSQLERR (pstmt->herr, en_S1009);
    }

  /* check state */
  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	 case en_stmt_fetched:
	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   sqlstat = en_S1010;
	   break;

	 case en_stmt_executed:
	 case en_stmt_cursoropen:
	   sqlstat = en_24000;
	   break;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != en_SetPos)
    {
      sqlstat = en_S1010;
    }

  if (sqlstat != en_00000)
    {
      PUSHSQLERR (pstmt->herr, sqlstat);

      return SQL_ERROR;
    }

  /* call driver */
  hproc = _iodbcdm_getproc (pstmt->hdbc, en_SetPos);

  if (hproc == SQL_NULL_HPROC)
    {
      PUSHSQLERR (pstmt->herr, en_IM001);

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SetPos,
    (pstmt->dhstmt, irow, fOption, fLock))

  /* state transition */
  if (pstmt->asyn_on == en_SetPos)
    {
      switch (retcode)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_NEED_DATA:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return retcode;
	 }
    }

  /* now, the only possible init state is 'xfetched' */
  switch (retcode)
     {
     case SQL_SUCCESS:
     case SQL_SUCCESS_WITH_INFO:
       break;

     case SQL_NEED_DATA:
       pstmt->state = en_stmt_needdata;
       pstmt->need_on = en_SetPos;
       break;

     case SQL_STILL_EXECUTING:
       pstmt->asyn_on = en_SetPos;
       break;

     default:
       break;
     }

  return retcode;
}
Commit	Line	Data
	1	/*
	2	* fetch.c
	3	*
	4	* $Id$
	5	*
	6	* Fetch query result
	7	*
	8	* The iODBC driver manager.
	9	*
	10	* Copyright (C) 1995 by Ke Jin <kejin@empress.com>
	11	*
	12	* This library is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU Library General Public
	14	* License as published by the Free Software Foundation; either
	15	* version 2 of the License, or (at your option) any later version.
	16	*
	17	* This library is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* Library General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU Library General Public
	23	* License along with this library; if not, write to the Free
	24	* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	25	*/
	26
	27	#include "config.h"
	28
	29	#include "isql.h"
	30	#include "isqlext.h"
	31
	32	#include "dlproc.h"
	33
	34	#include "herr.h"
	35	#include "henv.h"
	36	#include "hdbc.h"
	37	#include "hstmt.h"
	38
	39	#include "itrace.h"
	40
	41	RETCODE SQL_API
	42	SQLFetch (HSTMT hstmt)
	43	{
	44	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	45	HPROC hproc = SQL_NULL_HPROC;
	46	RETCODE retcode;
	47
	48	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	49	{
	50	return SQL_INVALID_HANDLE;
	51	}
	52
	53	/* check state */
	54	if (pstmt->asyn_on == en_NullProc)
	55	{
	56	switch (pstmt->state)
	57	{
	58	case en_stmt_allocated:
	59	case en_stmt_prepared:
	60	case en_stmt_xfetched:
	61	case en_stmt_needdata:
	62	case en_stmt_mustput:
	63	case en_stmt_canput:
	64	PUSHSQLERR (pstmt->herr, en_S1010);
	65	return SQL_ERROR;
	66
	67	default:
	68	break;
	69	}
	70	}
	71	else if (pstmt->asyn_on != en_Fetch)
	72	{
	73	PUSHSQLERR (pstmt->herr, en_S1010);
	74	return SQL_ERROR;
	75	}
	76
	77	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Fetch);
	78
	79	if (hproc == SQL_NULL_HPROC)
	80	{
	81	PUSHSQLERR (pstmt->herr, en_IM001);
	82
	83	return SQL_ERROR;
	84	}
	85
	86	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Fetch,
	87	(pstmt->dhstmt))
	88
	89	/* state transition */
	90	if (pstmt->asyn_on == en_Fetch)
	91	{
	92	switch (retcode)
	93	{
	94	case SQL_SUCCESS:
	95	case SQL_SUCCESS_WITH_INFO:
	96	case SQL_NO_DATA_FOUND:
	97	case SQL_ERROR:
	98	pstmt->asyn_on = en_NullProc;
	99	break;
	100
	101	case SQL_STILL_EXECUTING:
	102	default:
	103	return retcode;
	104	}
	105	}
	106
	107	switch (pstmt->state)
	108	{
	109	case en_stmt_cursoropen:
	110	case en_stmt_fetched:
	111	switch (retcode)
	112	{
	113	case SQL_SUCCESS:
	114	case SQL_SUCCESS_WITH_INFO:
	115	pstmt->state = en_stmt_fetched;
	116	pstmt->cursor_state = en_stmt_cursor_fetched;
	117	break;
	118
	119	case SQL_NO_DATA_FOUND:
	120	if (pstmt->prep_state)
	121	{
	122	pstmt->state = en_stmt_prepared;
	123	}
	124	else
	125	{
	126
	127	pstmt->state = en_stmt_allocated;
	128	}
	129	pstmt->cursor_state = en_stmt_cursor_no;
	130	break;
	131
	132	case SQL_STILL_EXECUTING:
	133	pstmt->asyn_on = en_Fetch;
	134	break;
	135
	136	default:
	137	break;
	138	}
	139	break;
	140
	141	default:
	142	break;
	143	}
	144
	145	return retcode;
	146	}
	147
	148
	149	RETCODE SQL_API
	150	SQLExtendedFetch (
	151	HSTMT hstmt,
	152	UWORD fFetchType,
	153	SDWORD irow,
	154	UDWORD FAR * pcrow,
	155	UWORD FAR * rgfRowStatus)
	156	{
	157	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	158	HPROC hproc = SQL_NULL_HPROC;
	159	RETCODE retcode;
	160
	161	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	162	{
	163	return SQL_INVALID_HANDLE;
	164	}
	165
	166	/* check fetch type */
	167	if (fFetchType < SQL_FETCH_NEXT \|\| fFetchType > SQL_FETCH_BOOKMARK)
	168	{
	169	/* Unlike MS driver manager(i.e. DM),
	170	* we don't check driver's ODBC version
	171	* against SQL_FETCH_RESUME (only 1.0)
	172	* and SQL_FETCH_BOOKMARK (only 2.0).
	173	*/
	174	PUSHSQLERR (pstmt->herr, en_S1106);
	175
	176	return SQL_ERROR;
	177	}
	178
	179	/* check state */
	180	if (pstmt->asyn_on == en_NullProc)
	181	{
	182	switch (pstmt->state)
	183	{
	184	case en_stmt_allocated:
	185	case en_stmt_prepared:
	186	case en_stmt_fetched:
	187	case en_stmt_needdata:
	188	case en_stmt_mustput:
	189	case en_stmt_canput:
	190	PUSHSQLERR (pstmt->herr, en_S1010);
	191	return SQL_ERROR;
	192
	193	default:
	194	break;
	195	}
	196	}
	197	else if (pstmt->asyn_on != en_ExtendedFetch)
	198	{
	199	PUSHSQLERR (pstmt->herr, en_S1010);
	200	return SQL_ERROR;
	201	}
	202
	203	hproc = _iodbcdm_getproc (pstmt->hdbc, en_ExtendedFetch);
	204
	205	if (hproc == SQL_NULL_HPROC)
	206	{
	207	PUSHSQLERR (pstmt->herr, en_IM001);
	208
	209	return SQL_ERROR;
	210	}
	211
	212	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ExtendedFetch,
	213	(pstmt->dhstmt, fFetchType, irow, pcrow, rgfRowStatus))
	214
	215	/* state transition */
	216	if (pstmt->asyn_on == en_ExtendedFetch)
	217	{
	218	switch (retcode)
	219	{
	220	case SQL_SUCCESS:
	221	case SQL_SUCCESS_WITH_INFO:
	222	case SQL_NO_DATA_FOUND:
	223	case SQL_ERROR:
	224	pstmt->asyn_on = en_NullProc;
	225	break;
	226
	227	case SQL_STILL_EXECUTING:
	228	default:
	229	return retcode;
	230	}
	231	}
	232
	233	switch (pstmt->state)
	234	{
	235	case en_stmt_cursoropen:
	236	case en_stmt_xfetched:
	237	switch (retcode)
	238	{
	239	case SQL_SUCCESS:
	240	case SQL_SUCCESS_WITH_INFO:
	241	case SQL_NO_DATA_FOUND:
	242	pstmt->state = en_stmt_xfetched;
	243	pstmt->cursor_state = en_stmt_cursor_xfetched;
	244	break;
	245
	246	case SQL_STILL_EXECUTING:
	247	pstmt->asyn_on = en_ExtendedFetch;
	248	break;
	249
	250	default:
	251	break;
	252	}
	253	break;
	254
	255	default:
	256	break;
	257	}
	258
	259	return retcode;
	260	}
	261
	262
	263	RETCODE SQL_API
	264	SQLGetData (
	265	HSTMT hstmt,
	266	UWORD icol,
	267	SWORD fCType,
	268	PTR rgbValue,
	269	SDWORD cbValueMax,
	270	SDWORD FAR * pcbValue)
	271	{
	272	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	273	HPROC hproc;
	274	RETCODE retcode;
	275	int sqlstat = en_00000;
	276
	277	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	278	{
	279	return SQL_INVALID_HANDLE;
	280	}
	281
	282	/* check argument */
	283	if (rgbValue == NULL)
	284	{
	285	sqlstat = en_S1009;
	286	}
	287	else if (cbValueMax < 0)
	288	{
	289	sqlstat = en_S1090;
	290	}
	291	else
	292	{
	293	switch (fCType)
	294	{
	295	case SQL_C_DEFAULT:
	296	case SQL_C_CHAR:
	297	case SQL_C_BINARY:
	298	case SQL_C_BIT:
	299	case SQL_C_TINYINT:
	300	case SQL_C_STINYINT:
	301	case SQL_C_UTINYINT:
	302	case SQL_C_SHORT:
	303	case SQL_C_SSHORT:
	304	case SQL_C_USHORT:
	305	case SQL_C_LONG:
	306	case SQL_C_SLONG:
	307	case SQL_C_ULONG:
	308	case SQL_C_FLOAT:
	309	case SQL_C_DOUBLE:
	310	case SQL_C_DATE:
	311	case SQL_C_TIME:
	312	case SQL_C_TIMESTAMP:
	313	break;
	314
	315	default:
	316	sqlstat = en_S1003;
	317	break;
	318	}
	319	}
	320
	321	if (sqlstat != en_00000)
	322	{
	323	PUSHSQLERR (pstmt->herr, sqlstat);
	324
	325	return SQL_ERROR;
	326	}
	327
	328	/* check state */
	329	if (pstmt->asyn_on == en_NullProc)
	330	{
	331	switch (pstmt->state)
	332	{
	333	case en_stmt_allocated:
	334	case en_stmt_prepared:
	335	case en_stmt_needdata:
	336	case en_stmt_mustput:
	337	case en_stmt_canput:
	338	sqlstat = en_S1010;
	339	break;
	340
	341	case en_stmt_executed:
	342	case en_stmt_cursoropen:
	343	sqlstat = en_24000;
	344	break;
	345
	346	default:
	347	break;
	348	}
	349	}
	350	else if (pstmt->asyn_on != en_GetData)
	351	{
	352	sqlstat = en_S1010;
	353	}
	354
	355	if (sqlstat != en_00000)
	356	{
	357	PUSHSQLERR (pstmt->herr, sqlstat);
	358
	359	return SQL_ERROR;
	360	}
	361
	362	/* call driver */
	363	hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetData);
	364
	365	if (hproc == SQL_NULL_HPROC)
	366	{
	367	PUSHSQLERR (pstmt->herr, en_IM001);
	368
	369	return SQL_ERROR;
	370	}
	371
	372	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_GetData,
	373	(pstmt->dhstmt, icol, fCType, rgbValue, cbValueMax, pcbValue))
	374
	375	/* state transition */
	376	if (pstmt->asyn_on == en_GetData)
	377	{
	378	switch (retcode)
	379	{
	380	case SQL_SUCCESS:
	381	case SQL_SUCCESS_WITH_INFO:
	382	case SQL_NO_DATA_FOUND:
	383	case SQL_ERROR:
	384	pstmt->asyn_on = en_NullProc;
	385	break;
	386
	387	case SQL_STILL_EXECUTING:
	388	default:
	389	return retcode;
	390	}
	391	}
	392
	393	switch (pstmt->state)
	394	{
	395	case en_stmt_fetched:
	396	case en_stmt_xfetched:
	397	if (retcode == SQL_STILL_EXECUTING)
	398	{
	399	pstmt->asyn_on = en_GetData;
	400	break;
	401	}
	402	break;
	403
	404	default:
	405	break;
	406	}
	407
	408	return retcode;
	409	}
	410
	411
	412	RETCODE SQL_API
	413	SQLMoreResults (HSTMT hstmt)
	414	{
	415	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	416	HPROC hproc;
	417	RETCODE retcode;
	418
	419	if (hstmt == SQL_NULL_HSTMT
	420	\|\| pstmt->hdbc == SQL_NULL_HDBC)
	421	{
	422	return SQL_INVALID_HANDLE;
	423	}
	424
	425	/* check state */
	426	if (pstmt->asyn_on == en_NullProc)
	427	{
	428	switch (pstmt->state)
	429	{
	430	case en_stmt_allocated:
	431	case en_stmt_prepared:
	432	return SQL_NO_DATA_FOUND;
	433
	434	case en_stmt_needdata:
	435	case en_stmt_mustput:
	436	case en_stmt_canput:
	437	PUSHSQLERR (pstmt->herr, en_S1010);
	438	return SQL_ERROR;
	439
	440	default:
	441	break;
	442	}
	443	}
	444	else if (pstmt->asyn_on != en_MoreResults)
	445	{
	446	PUSHSQLERR (pstmt->herr, en_S1010);
	447
	448	return SQL_ERROR;
	449	}
	450
	451	/* call driver */
	452	hproc = _iodbcdm_getproc (pstmt->hdbc, en_MoreResults);
	453
	454	if (hproc == SQL_NULL_HPROC)
	455	{
	456	PUSHSQLERR (pstmt->herr, en_IM001);
	457
	458	return SQL_ERROR;
	459	}
	460
	461	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_MoreResults,
	462	(pstmt->dhstmt))
	463
	464	/* state transition */
	465	if (pstmt->asyn_on == en_MoreResults)
	466	{
	467	switch (retcode)
	468	{
	469	case SQL_SUCCESS:
	470	case SQL_SUCCESS_WITH_INFO:
	471	case SQL_NO_DATA_FOUND:
	472	case SQL_ERROR:
	473	pstmt->asyn_on = en_NullProc;
	474	break;
	475
	476	case SQL_STILL_EXECUTING:
	477	default:
	478	return retcode;
	479	}
	480	}
	481
	482	switch (pstmt->state)
	483	{
	484	case en_stmt_allocated:
	485	case en_stmt_prepared:
	486	/* driver should return SQL_NO_DATA_FOUND */
	487	break;
	488
	489	case en_stmt_executed:
	490	if (retcode == SQL_NO_DATA_FOUND)
	491	{
	492	if (pstmt->prep_state)
	493	{
	494	pstmt->state = en_stmt_prepared;
	495	}
	496	else
	497	{
	498	pstmt->state = en_stmt_allocated;
	499	}
	500	}
	501	else if (retcode == SQL_STILL_EXECUTING)
	502	{
	503	pstmt->asyn_on = en_MoreResults;
	504	}
	505	break;
	506
	507	case en_stmt_cursoropen:
	508	case en_stmt_fetched:
	509	case en_stmt_xfetched:
	510	if (retcode == SQL_SUCCESS)
	511	{
	512	break;
	513	}
	514	else if (retcode == SQL_NO_DATA_FOUND)
	515	{
	516	if (pstmt->prep_state)
	517	{
	518	pstmt->state = en_stmt_prepared;
	519	}
	520	else
	521	{
	522	pstmt->state = en_stmt_allocated;
	523	}
	524	}
	525	else if (retcode == SQL_STILL_EXECUTING)
	526	{
	527	pstmt->asyn_on = en_MoreResults;
	528	}
	529	break;
	530
	531	default:
	532	break;
	533	}
	534
	535	return retcode;
	536	}
	537
	538
	539	RETCODE SQL_API
	540	SQLSetPos (
	541	HSTMT hstmt,
	542	UWORD irow,
	543	UWORD fOption,
	544	UWORD fLock)
	545	{
	546	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	547	HPROC hproc;
	548	RETCODE retcode;
	549	int sqlstat = en_00000;
	550
	551	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	552	{
	553	return SQL_INVALID_HANDLE;
	554	}
	555
	556	/* check argument value */
	557	if (fOption > SQL_ADD \|\| fLock > SQL_LOCK_UNLOCK)
	558	{
	559	PUSHSQLERR (pstmt->herr, en_S1009);
	560	}
	561
	562	/* check state */
	563	if (pstmt->asyn_on == en_NullProc)
	564	{
	565	switch (pstmt->state)
	566	{
	567	case en_stmt_allocated:
	568	case en_stmt_prepared:
	569	case en_stmt_fetched:
	570	case en_stmt_needdata:
	571	case en_stmt_mustput:
	572	case en_stmt_canput:
	573	sqlstat = en_S1010;
	574	break;
	575
	576	case en_stmt_executed:
	577	case en_stmt_cursoropen:
	578	sqlstat = en_24000;
	579	break;
	580
	581	default:
	582	break;
	583	}
	584	}
	585	else if (pstmt->asyn_on != en_SetPos)
	586	{
	587	sqlstat = en_S1010;
	588	}
	589
	590	if (sqlstat != en_00000)
	591	{
	592	PUSHSQLERR (pstmt->herr, sqlstat);
	593
	594	return SQL_ERROR;
	595	}
	596
	597	/* call driver */
	598	hproc = _iodbcdm_getproc (pstmt->hdbc, en_SetPos);
	599
	600	if (hproc == SQL_NULL_HPROC)
	601	{
	602	PUSHSQLERR (pstmt->herr, en_IM001);
	603
	604	return SQL_ERROR;
	605	}
	606
	607	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SetPos,
	608	(pstmt->dhstmt, irow, fOption, fLock))
	609
	610	/* state transition */
	611	if (pstmt->asyn_on == en_SetPos)
	612	{
	613	switch (retcode)
	614	{
	615	case SQL_SUCCESS:
	616	case SQL_SUCCESS_WITH_INFO:
	617	case SQL_NEED_DATA:
	618	case SQL_ERROR:
	619	pstmt->asyn_on = en_NullProc;
	620	break;
	621
	622	case SQL_STILL_EXECUTING:
	623	default:
	624	return retcode;
	625	}
	626	}
	627
	628	/* now, the only possible init state is 'xfetched' */
	629	switch (retcode)
	630	{
	631	case SQL_SUCCESS:
	632	case SQL_SUCCESS_WITH_INFO:
	633	break;
	634
	635	case SQL_NEED_DATA:
	636	pstmt->state = en_stmt_needdata;
	637	pstmt->need_on = en_SetPos;
	638	break;
	639
	640	case SQL_STILL_EXECUTING:
	641	pstmt->asyn_on = en_SetPos;
	642	break;
	643
	644	default:
	645	break;
	646	}
	647
	648	return retcode;
	649	}