[wxWidgets.git] / 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        <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) )

#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
1a6944fd	1	/** Fetch query result
7e616b10 RR	2
7e616b10 RR	3	Copyright (C) 1995 by Ke Jin <kejin@empress.com>
1a6944fd RR	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
7e616b10	16	#include <config.h>
1a6944fd	17
7e616b10 RR	18	#include <isql.h>
7e616b10 RR	19	#include <isqlext.h>
1a6944fd	20
7e616b10	21	#include <dlproc.h>
1a6944fd	22
7e616b10 RR	23	#include <herr.h>
	24	#include <henv.h>
	25	#include <hdbc.h>
	26	#include <hstmt.h>
1a6944fd	27
7e616b10	28	#include <itrace.h>
1a6944fd	29
7e616b10	30	RETCODE SQL_API SQLFetch ( HSTMT hstmt )
1a6944fd	31	{
7e616b10 RR	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) )
1a6944fd RR	76
1a6944fd RR	77	#if 0
7e616b10	78	retcode = hproc( pstmt->dhstmt );
1a6944fd	79	#endif
7e616b10 RR	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;
1a6944fd RR	137	}
1a6944fd RR	138
7e616b10 RR	139	RETCODE SQL_API SQLExtendedFetch (
	140	HSTMT hstmt,
	141	UWORD fFetchType,
	142	SDWORD irow,
	143	UDWORD FAR* pcrow,
	144	UWORD FAR* rgfRowStatus )
1a6944fd	145	{
7e616b10 RR	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 ) )
1a6944fd RR	209
1a6944fd RR	210	#if 0
7e616b10 RR	211	retcode = hproc(pstmt->dhstmt,
	212	fFetchType,
	213	irow,
	214	pcrow,
	215	rgfRowStatus );
1a6944fd RR	216	#endif
1a6944fd RR	217
7e616b10 RR	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;
1a6944fd RR	263	}
1a6944fd RR	264
7e616b10 RR	265	RETCODE SQL_API SQLGetData(
	266	HSTMT hstmt,
	267	UWORD icol,
	268	SWORD fCType,
	269	PTR rgbValue,
	270	SDWORD cbValueMax,
	271	SDWORD FAR* pcbValue )
1a6944fd	272	{
7e616b10 RR	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 ) )
1a6944fd RR	381
1a6944fd RR	382	#if 0
7e616b10 RR	383	retcode = hproc(pstmt->dhstmt,
	384	icol,
	385	fCType,
	386	rgbValue,
	387	cbValueMax,
	388	pcbValue );
1a6944fd RR	389	#endif
1a6944fd RR	390
7e616b10 RR	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;
1a6944fd RR	425	}
1a6944fd RR	426
7e616b10	427	RETCODE SQL_API SQLMoreResults( HSTMT hstmt )
1a6944fd	428	{
7e616b10 RR	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) )
1a6944fd RR	476
1a6944fd RR	477	#if 0
7e616b10	478	retcode = hproc( pstmt->dhstmt );
1a6944fd RR	479	#endif
1a6944fd RR	480
7e616b10 RR	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;
1a6944fd RR	553	}
1a6944fd RR	554
7e616b10 RR	555	RETCODE SQL_API SQLSetPos (
	556	HSTMT hstmt,
	557	UWORD irow,
	558	UWORD fOption,
	559	UWORD fLock )
1a6944fd	560	{
7e616b10 RR	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 ) )
1a6944fd	629	#if 0
7e616b10 RR	630	retcode = hproc(pstmt->dhstmt,
	631	irow,
	632	fOption,
	633	fLock );
1a6944fd RR	634	#endif
1a6944fd RR	635
7e616b10 RR	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;
1a6944fd	675	}