src/iodbc/fetch.c

/** Fetch query result

    Copyright (C) 1995 by Ke Jin <kejin@empress.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.
**/

#include	<../iodbc/iodbc.h>

#include	<../iodbc/isql.h>
#include	<../iodbc/isqlext.h>

#include        <../iodbc/dlproc.h>

#include	<../iodbc/herr.h>
#include	<../iodbc/henv.h>
#include	<../iodbc/hdbc.h>
#include	<../iodbc/hstmt.h>

#include	<../iodbc/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) )

#if 0
	retcode = hproc( pstmt->dhstmt );
#endif
	/* 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 ) )

#if 0
	retcode = hproc(pstmt->dhstmt,
			fFetchType,
			irow,
			pcrow,
			rgfRowStatus );
#endif

	/* 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 ) )

#if 0
	retcode = hproc(pstmt->dhstmt,
			icol,
			fCType,
			rgbValue,
			cbValueMax,
			pcbValue );
#endif

	/* 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) )

#if 0
	retcode = hproc( pstmt->dhstmt );
#endif

	/* 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 ) )
#if 0
	retcode = hproc(pstmt->dhstmt,
			irow,
			fOption,
			fLock );
#endif

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