[wxWidgets.git] / src / iodbc / hstmt.c

/** Query statement object management functions

    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 SQLAllocStmt (
                        HDBC            hdbc,
                        HSTMT FAR*      phstmt )
{
        DBC_t  FAR*     pdbc    = (DBC_t FAR*)hdbc;
        STMT_t FAR*     pstmt   = NULL;
        HPROC           hproc   = SQL_NULL_HPROC;
        RETCODE         retcode = SQL_SUCCESS;

#if (ODBCVER >= 0x0300)
        if( hdbc == SQL_NULL_HDBC
         || pdbc->type != SQL_HANDLE_DBC )
#else
        if( hdbc == SQL_NULL_HDBC )
#endif
        {
                return SQL_INVALID_HANDLE;
        }

        if( phstmt == NULL )
        {
                PUSHSQLERR ( pdbc->herr, en_S1009 );

                return SQL_ERROR;
        }

        /* check state */
        switch( pdbc->state )
        {
                case en_dbc_connected:
                case en_dbc_hstmt:
                        break;

                case en_dbc_allocated:
                case en_dbc_needdata:
                        PUSHSQLERR ( pdbc->herr, en_08003 );
                        *phstmt = SQL_NULL_HSTMT;
                        return SQL_ERROR;

                default:
                        return SQL_INVALID_HANDLE;
        }

        pstmt = (STMT_t FAR*)MEM_ALLOC(sizeof(STMT_t));

        if( pstmt == NULL )
        {
                PUSHSQLERR ( pdbc->herr, en_S1001 );
                *phstmt = SQL_NULL_HSTMT;

                return SQL_ERROR;
        }

#if (ODBCVER >= 0x0300)
        pstmt->type = SQL_HANDLE_STMT;
#endif
        /* initiate the object */
        pstmt->herr = SQL_NULL_HERR;
        pstmt->hdbc = hdbc;
        pstmt->state = en_stmt_allocated;
        pstmt->cursor_state = en_stmt_cursor_no;
        pstmt->prep_state = 0;
        pstmt->asyn_on = en_NullProc;
        pstmt->need_on = en_NullProc;

        /* call driver's function */
#if (ODBCVER >= 0x0300)
        hproc = _iodbcdm_getproc( hdbc, en_AllocHandle );

        if( hproc )
        {
                CALL_DRIVER ( pstmt->hdbc, hdbc, retcode, hproc,
                        en_AllocHandle, (
                        SQL_HANDLE_STMT,
                        pdbc->dhdbc,
                        &(pstmt->dhstmt) ) )
        }
        else
#endif
        {
                hproc = _iodbcdm_getproc( hdbc, en_AllocStmt );

                if( hproc == SQL_NULL_HPROC )
                {
                        PUSHSQLERR ( pstmt->herr, en_IM001 );
                        *phstmt = SQL_NULL_HSTMT;
                        MEM_FREE ( pstmt );

                        return SQL_ERROR;
                }

                CALL_DRIVER ( hdbc, retcode, hproc, en_AllocStmt, (
                                pdbc->dhdbc, &(pstmt->dhstmt) ) )
        }

        if( retcode != SQL_SUCCESS
         && retcode != SQL_SUCCESS_WITH_INFO )
        {
                *phstmt = SQL_NULL_HSTMT;
                MEM_FREE ( pstmt );

                return retcode;
        }

        /* insert into list */
        pstmt->next = pdbc->hstmt;
        pdbc->hstmt = pstmt;

        *phstmt = (HSTMT)pstmt;

        /* state transition */
        pdbc->state = en_dbc_hstmt;

        return SQL_SUCCESS;
}

RETCODE _iodbcdm_dropstmt( HSTMT hstmt )
{
        STMT_t FAR*     pstmt = (STMT_t FAR*)hstmt;
        STMT_t FAR*     tpstmt;
        DBC_t  FAR*     pdbc;

        if( hstmt == SQL_NULL_HSTMT )
        {
                return SQL_INVALID_HANDLE;
        }

        pdbc = (DBC_t FAR*)(pstmt->hdbc);

        for(tpstmt  = (STMT_t FAR*)pdbc->hstmt;
            tpstmt != NULL;
            tpstmt  = tpstmt->next )
        {
                if(tpstmt == pstmt)
                {
                        pdbc->hstmt = (HSTMT)pstmt->next;
                        break;
                }

                if(tpstmt->next == pstmt)
                {
                        tpstmt->next = pstmt->next;
                        break;
                }
        }

        if( tpstmt == NULL )
        {
                return SQL_INVALID_HANDLE;
        }

        _iodbcdm_freesqlerrlist(pstmt->herr);
        MEM_FREE(hstmt);

        return SQL_SUCCESS;
}

RETCODE SQL_API SQLFreeStmt (
                        HSTMT   hstmt,
                        UWORD   fOption )
{
        STMT_t FAR*     pstmt = (STMT_t FAR*)hstmt;
        STMT_t FAR*     tpstmt;
        DBC_t  FAR*     pdbc;

        HPROC           hproc = SQL_NULL_HPROC;
        RETCODE         retcode;

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

        pdbc = (DBC_t FAR*)(pstmt->hdbc);

        /* check option */
        switch( fOption )
        {
                case SQL_DROP:
                case SQL_CLOSE:
                case SQL_UNBIND:
                case SQL_RESET_PARAMS:
                        break;

                default:
                        PUSHSQLERR ( pstmt->herr, en_S1092 );
                        return SQL_ERROR;
        }

        /* check state */
        if( pstmt->state >= en_stmt_needdata
         || pstmt->asyn_on != en_NullProc )
        {
                PUSHSQLERR ( pstmt->herr, en_S1010 );

                return SQL_ERROR;
        }

        hproc == SQL_NULL_HPROC;

#if (ODBCVER >= 0x0300)
        if( fOption == SQL_DROP )
        {
                hproc = _iodbcdm_getproc( pstmt->hdbc, en_FreeHandle );

                if( hproc )
                {
                        CALL_DRIVER( pstmt->hdbc, retcode, hproc, en_FreeHandle, (
                                SQL_HANDLE_STMT, pstmt->dhstmt )
                }
        }
#endif

        if( hproc == SQL_NULL_HPROC )
        {
                hproc = _iodbcdm_getproc( pstmt->hdbc, en_FreeStmt);

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

                        return SQL_ERROR;
                }

                CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_FreeStmt, (
                                pstmt->dhstmt, fOption) )
        }

        if( retcode != SQL_SUCCESS
         && retcode != SQL_SUCCESS_WITH_INFO )
        {
                return retcode;
        }

        /* state transition */
        switch( fOption )
        {
                case SQL_DROP:
                        /* delet this object (ignore return) */
                        _iodbcdm_dropstmt( hstmt );
                        break;

                case SQL_CLOSE:
                        pstmt->cursor_state = en_stmt_cursor_no;
                        /* This means cursor name set by
                         * SQLSetCursorName() call will also
                         * be erased.
                         */

                        switch( pstmt->state )
                        {
                                case en_stmt_allocated:
                                case en_stmt_prepared:
                                        break;

                                case en_stmt_executed:
                                case en_stmt_cursoropen:
                                case en_stmt_fetched:
                                case en_stmt_xfetched:
                                        if( pstmt->prep_state )
                                        {
                                                pstmt->state =
                                                en_stmt_prepared;
                                        }
                                        else
                                        {
                                                pstmt->state =
                                                en_stmt_allocated;
                                        }
                                        break;

                                default:
                                        break;
                        }
                        break;

                case SQL_UNBIND:
                case SQL_RESET_PARAMS:
                default:
                        break;
        }

        return retcode;
}

RETCODE SQL_API SQLSetStmtOption (
                        HSTMT   hstmt,
                        UWORD   fOption,
                        UDWORD  vParam )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc;
        int             sqlstat = en_00000;
        RETCODE         retcode;

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

        /* check option */
        if(/* fOption < SQL_STMT_OPT_MIN || */
              fOption > SQL_STMT_OPT_MAX )
        {
                PUSHSQLERR ( pstmt->herr, en_S1092 );

                return SQL_ERROR;
        }

        if( fOption == SQL_CONCURRENCY
         || fOption == SQL_CURSOR_TYPE
         || fOption == SQL_SIMULATE_CURSOR
         || fOption == SQL_USE_BOOKMARKS )
        {
                if( pstmt->asyn_on != en_NullProc )
                {
                        if( pstmt->prep_state )
                        {
                                sqlstat = en_S1011;
                        }
                }
                else
                {
                        switch( pstmt->state )
                        {
                                case en_stmt_prepared:
                                        sqlstat = en_S1011;
                                        break;

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

                                case en_stmt_needdata:
                                case en_stmt_mustput:
                                case en_stmt_canput:
                                        if( pstmt->prep_state )
                                        {
                                                sqlstat = en_S1011;
                                        }
                                        break;

                                default:
                                        break;
                        }
                }
        }
        else
        {
                if( pstmt->asyn_on != en_NullProc )
                {
                        if( ! pstmt->prep_state )
                        {
                                sqlstat = en_S1010;
                        }
                }
                else
                {
                        if( pstmt->state >= en_stmt_needdata )
                        {
                                sqlstat = en_S1010;
                        }
                }
        }

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetStmtOption, (
                        pstmt->dhstmt, fOption, vParam ) )

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

        return retcode;
}

RETCODE SQL_API SQLGetStmtOption (
                        HSTMT   hstmt,
                        UWORD   fOption,
                        PTR     pvParam )
{
        STMT_t FAR*     pstmt   = (STMT_t*)hstmt;
        HPROC           hproc;
        int             sqlstat = en_00000;
        RETCODE         retcode;

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

        /* check option */
        if( /* fOption < SQL_STMT_OPT_MIN || */
               fOption > SQL_STMT_OPT_MAX )
        {
                PUSHSQLERR ( pstmt->herr, en_S1092 );

                return SQL_ERROR;
        }

        /* check state */
        if( pstmt->state >= en_stmt_needdata
         || pstmt->asyn_on != en_NullProc )
        {
                sqlstat = en_S1010;
        }
        else
        {
                switch( pstmt->state )
                {
                        case en_stmt_allocated:
                        case en_stmt_prepared:
                        case en_stmt_executed:
                        case en_stmt_cursoropen:
                                if( fOption == SQL_ROW_NUMBER
                                 || fOption == SQL_GET_BOOKMARK )
                                {
                                        sqlstat = en_24000;
                                }
                                break;

                        default:
                                break;
                }
        }

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

                return SQL_ERROR;
        }

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

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

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetStmtOption, (
                        pstmt->dhstmt, fOption, pvParam ) )

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

        return retcode;
}

RETCODE SQL_API SQLCancel ( 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 argument */
        /* check state */

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

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

                return SQL_ERROR;
        }

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

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

        /* state transition */
        if( retcode != SQL_SUCCESS
         && retcode != SQL_SUCCESS_WITH_INFO )
        {
                return retcode;
        }

        switch( pstmt->state )
        {
                case en_stmt_allocated:
                case en_stmt_prepared:
                        break;

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

                case en_stmt_cursoropen:
                case en_stmt_fetched:
                case en_stmt_xfetched:
                        if( pstmt->prep_state )
                        {
                                pstmt->state = en_stmt_prepared;
                        }
                        else
                        {
                                pstmt->state = en_stmt_allocated;
                        }
                        break;

                case en_stmt_needdata:
                case en_stmt_mustput:
                case en_stmt_canput:
                        switch( pstmt->need_on )
                        {
                                case en_ExecDirect:
                                        pstmt->state = en_stmt_allocated;
                                        break;

                                case en_Execute:
                                        pstmt->state = en_stmt_prepared;
                                        break;

                                case en_SetPos:
                                        pstmt->state = en_stmt_xfetched;
                                        break;

                                default:
                                        break;
                        }
                        pstmt->need_on = en_NullProc;
                        break;

                default:
                        break;
        }

        return retcode;
}
Commit	Line	Data
1a6944fd	1	/** Query statement object management functions
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
	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
7e616b10 RR	30	RETCODE SQL_API SQLAllocStmt (
	31	HDBC hdbc,
	32	HSTMT FAR* phstmt )
1a6944fd	33	{
7e616b10 RR	34	DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
	35	STMT_t FAR* pstmt = NULL;
	36	HPROC hproc = SQL_NULL_HPROC;
	37	RETCODE retcode = SQL_SUCCESS;
1a6944fd RR	38
1a6944fd RR	39	#if (ODBCVER >= 0x0300)
7e616b10 RR	40	if( hdbc == SQL_NULL_HDBC
7e616b10 RR	41	\|\| pdbc->type != SQL_HANDLE_DBC )
1a6944fd	42	#else
7e616b10	43	if( hdbc == SQL_NULL_HDBC )
1a6944fd	44	#endif
7e616b10 RR	45	{
	46	return SQL_INVALID_HANDLE;
	47	}
	48
	49	if( phstmt == NULL )
	50	{
	51	PUSHSQLERR ( pdbc->herr, en_S1009 );
	52
	53	return SQL_ERROR;
	54	}
	55
	56	/* check state */
	57	switch( pdbc->state )
	58	{
	59	case en_dbc_connected:
	60	case en_dbc_hstmt:
	61	break;
	62
	63	case en_dbc_allocated:
	64	case en_dbc_needdata:
	65	PUSHSQLERR ( pdbc->herr, en_08003 );
	66	*phstmt = SQL_NULL_HSTMT;
	67	return SQL_ERROR;
	68
	69	default:
	70	return SQL_INVALID_HANDLE;
	71	}
	72
	73	pstmt = (STMT_t FAR*)MEM_ALLOC(sizeof(STMT_t));
	74
	75	if( pstmt == NULL )
	76	{
	77	PUSHSQLERR ( pdbc->herr, en_S1001 );
	78	*phstmt = SQL_NULL_HSTMT;
	79
	80	return SQL_ERROR;
	81	}
1a6944fd RR	82
1a6944fd RR	83	#if (ODBCVER >= 0x0300)
7e616b10	84	pstmt->type = SQL_HANDLE_STMT;
1a6944fd	85	#endif
7e616b10 RR	86	/* initiate the object */
	87	pstmt->herr = SQL_NULL_HERR;
	88	pstmt->hdbc = hdbc;
	89	pstmt->state = en_stmt_allocated;
	90	pstmt->cursor_state = en_stmt_cursor_no;
	91	pstmt->prep_state = 0;
	92	pstmt->asyn_on = en_NullProc;
	93	pstmt->need_on = en_NullProc;
	94
	95	/* call driver's function */
1a6944fd	96	#if (ODBCVER >= 0x0300)
7e616b10 RR	97	hproc = _iodbcdm_getproc( hdbc, en_AllocHandle );
	98
	99	if( hproc )
	100	{
	101	CALL_DRIVER ( pstmt->hdbc, hdbc, retcode, hproc,
	102	en_AllocHandle, (
	103	SQL_HANDLE_STMT,
	104	pdbc->dhdbc,
	105	&(pstmt->dhstmt) ) )
	106	}
	107	else
1a6944fd	108	#endif
7e616b10 RR	109	{
7e616b10 RR	110	hproc = _iodbcdm_getproc( hdbc, en_AllocStmt );
1a6944fd	111
7e616b10 RR	112	if( hproc == SQL_NULL_HPROC )
	113	{
	114	PUSHSQLERR ( pstmt->herr, en_IM001 );
	115	*phstmt = SQL_NULL_HSTMT;
	116	MEM_FREE ( pstmt );
1a6944fd	117
7e616b10 RR	118	return SQL_ERROR;
7e616b10 RR	119	}
1a6944fd	120
7e616b10 RR	121	CALL_DRIVER ( hdbc, retcode, hproc, en_AllocStmt, (
	122	pdbc->dhdbc, &(pstmt->dhstmt) ) )
	123	}
1a6944fd	124
7e616b10 RR	125	if( retcode != SQL_SUCCESS
	126	&& retcode != SQL_SUCCESS_WITH_INFO )
	127	{
	128	*phstmt = SQL_NULL_HSTMT;
	129	MEM_FREE ( pstmt );
1a6944fd	130
7e616b10 RR	131	return retcode;
7e616b10 RR	132	}
1a6944fd	133
7e616b10 RR	134	/* insert into list */
	135	pstmt->next = pdbc->hstmt;
	136	pdbc->hstmt = pstmt;
1a6944fd	137
7e616b10	138	*phstmt = (HSTMT)pstmt;
1a6944fd	139
7e616b10 RR	140	/* state transition */
7e616b10 RR	141	pdbc->state = en_dbc_hstmt;
1a6944fd	142
7e616b10	143	return SQL_SUCCESS;
1a6944fd RR	144	}
	145
	146	RETCODE _iodbcdm_dropstmt( HSTMT hstmt )
	147	{
7e616b10 RR	148	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	149	STMT_t FAR* tpstmt;
	150	DBC_t FAR* pdbc;
	151
	152	if( hstmt == SQL_NULL_HSTMT )
	153	{
	154	return SQL_INVALID_HANDLE;
	155	}
	156
	157	pdbc = (DBC_t FAR*)(pstmt->hdbc);
	158
	159	for(tpstmt = (STMT_t FAR*)pdbc->hstmt;
	160	tpstmt != NULL;
	161	tpstmt = tpstmt->next )
	162	{
	163	if(tpstmt == pstmt)
	164	{
	165	pdbc->hstmt = (HSTMT)pstmt->next;
	166	break;
	167	}
	168
	169	if(tpstmt->next == pstmt)
	170	{
	171	tpstmt->next = pstmt->next;
	172	break;
	173	}
	174	}
	175
	176	if( tpstmt == NULL )
	177	{
	178	return SQL_INVALID_HANDLE;
	179	}
	180
	181	_iodbcdm_freesqlerrlist(pstmt->herr);
	182	MEM_FREE(hstmt);
	183
	184	return SQL_SUCCESS;
1a6944fd RR	185	}
1a6944fd RR	186
7e616b10 RR	187	RETCODE SQL_API SQLFreeStmt (
	188	HSTMT hstmt,
	189	UWORD fOption )
1a6944fd	190	{
7e616b10 RR	191	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	192	STMT_t FAR* tpstmt;
	193	DBC_t FAR* pdbc;
	194
	195	HPROC hproc = SQL_NULL_HPROC;
	196	RETCODE retcode;
	197
	198	if( hstmt == SQL_NULL_HSTMT
	199	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	200	{
	201	return SQL_INVALID_HANDLE;
	202	}
	203
	204	pdbc = (DBC_t FAR*)(pstmt->hdbc);
	205
	206	/* check option */
	207	switch( fOption )
	208	{
	209	case SQL_DROP:
	210	case SQL_CLOSE:
	211	case SQL_UNBIND:
	212	case SQL_RESET_PARAMS:
	213	break;
	214
	215	default:
	216	PUSHSQLERR ( pstmt->herr, en_S1092 );
	217	return SQL_ERROR;
	218	}
	219
	220	/* check state */
	221	if( pstmt->state >= en_stmt_needdata
	222	\|\| pstmt->asyn_on != en_NullProc )
	223	{
	224	PUSHSQLERR ( pstmt->herr, en_S1010 );
	225
	226	return SQL_ERROR;
	227	}
	228
	229	hproc == SQL_NULL_HPROC;
1a6944fd RR	230
1a6944fd RR	231	#if (ODBCVER >= 0x0300)
7e616b10 RR	232	if( fOption == SQL_DROP )
	233	{
	234	hproc = _iodbcdm_getproc( pstmt->hdbc, en_FreeHandle );
	235
	236	if( hproc )
	237	{
	238	CALL_DRIVER( pstmt->hdbc, retcode, hproc, en_FreeHandle, (
	239	SQL_HANDLE_STMT, pstmt->dhstmt )
	240	}
	241	}
1a6944fd RR	242	#endif
1a6944fd RR	243
7e616b10 RR	244	if( hproc == SQL_NULL_HPROC )
	245	{
	246	hproc = _iodbcdm_getproc( pstmt->hdbc, en_FreeStmt);
	247
	248	if( hproc == SQL_NULL_HPROC )
	249	{
	250	PUSHSQLERR ( pstmt->herr, en_IM001 );
	251
	252	return SQL_ERROR;
	253	}
	254
	255	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_FreeStmt, (
	256	pstmt->dhstmt, fOption) )
	257	}
	258
	259	if( retcode != SQL_SUCCESS
	260	&& retcode != SQL_SUCCESS_WITH_INFO )
	261	{
	262	return retcode;
	263	}
	264
	265	/* state transition */
	266	switch( fOption )
	267	{
	268	case SQL_DROP:
	269	/* delet this object (ignore return) */
	270	_iodbcdm_dropstmt( hstmt );
	271	break;
	272
	273	case SQL_CLOSE:
	274	pstmt->cursor_state = en_stmt_cursor_no;
	275	/* This means cursor name set by
	276	* SQLSetCursorName() call will also
	277	* be erased.
	278	*/
	279
	280	switch( pstmt->state )
	281	{
	282	case en_stmt_allocated:
	283	case en_stmt_prepared:
	284	break;
	285
	286	case en_stmt_executed:
	287	case en_stmt_cursoropen:
	288	case en_stmt_fetched:
	289	case en_stmt_xfetched:
	290	if( pstmt->prep_state )
	291	{
	292	pstmt->state =
	293	en_stmt_prepared;
	294	}
	295	else
	296	{
	297	pstmt->state =
	298	en_stmt_allocated;
	299	}
	300	break;
	301
	302	default:
	303	break;
	304	}
	305	break;
	306
	307	case SQL_UNBIND:
308	case SQL_RESET_PARAMS:
309	default:
310	break;
311	}
312
313	return retcode;
1a6944fd RR	314	}
1a6944fd RR	315
7e616b10 RR	316	RETCODE SQL_API SQLSetStmtOption (
	317	HSTMT hstmt,
	318	UWORD fOption,
	319	UDWORD vParam )
1a6944fd	320	{
7e616b10 RR	321	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	322	HPROC hproc;
	323	int sqlstat = en_00000;
	324	RETCODE retcode;
	325
	326	if( hstmt == SQL_NULL_HSTMT
	327	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	328	{
	329	return SQL_INVALID_HANDLE;
	330	}
	331
	332	/* check option */
	333	if(/* fOption < SQL_STMT_OPT_MIN \|\| */
	334	fOption > SQL_STMT_OPT_MAX )
	335	{
	336	PUSHSQLERR ( pstmt->herr, en_S1092 );
	337
	338	return SQL_ERROR;
	339	}
	340
	341	if( fOption == SQL_CONCURRENCY
	342	\|\| fOption == SQL_CURSOR_TYPE
	343	\|\| fOption == SQL_SIMULATE_CURSOR
	344	\|\| fOption == SQL_USE_BOOKMARKS )
	345	{
	346	if( pstmt->asyn_on != en_NullProc )
	347	{
	348	if( pstmt->prep_state )
	349	{
	350	sqlstat = en_S1011;
	351	}
	352	}
	353	else
	354	{
	355	switch( pstmt->state )
	356	{
	357	case en_stmt_prepared:
	358	sqlstat = en_S1011;
	359	break;
	360
	361	case en_stmt_executed:
	362	case en_stmt_cursoropen:
	363	case en_stmt_fetched:
	364	case en_stmt_xfetched:
	365	sqlstat = en_24000;
	366	break;
	367
	368	case en_stmt_needdata:
	369	case en_stmt_mustput:
	370	case en_stmt_canput:
	371	if( pstmt->prep_state )
	372	{
	373	sqlstat = en_S1011;
	374	}
	375	break;
	376
	377	default:
	378	break;
	379	}
	380	}
	381	}
	382	else
	383	{
	384	if( pstmt->asyn_on != en_NullProc )
385	{
386	if( ! pstmt->prep_state )
387	{
388	sqlstat = en_S1010;
389	}
390	}
391	else
392	{
393	if( pstmt->state >= en_stmt_needdata )
394	{
395	sqlstat = en_S1010;
396	}
397	}
398	}
399
400	if( sqlstat != en_00000 )
401	{
402	PUSHSQLERR ( pstmt->herr, sqlstat );
403
404	return SQL_ERROR;
405	}
406
407	hproc = _iodbcdm_getproc( pstmt->hdbc, en_SetStmtOption );
408
409	if( hproc == SQL_NULL_HPROC )
410	{
411	PUSHSQLERR ( pstmt->herr, en_IM001 );
412
413	return SQL_ERROR;
414	}
415
416	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetStmtOption, (
417	pstmt->dhstmt, fOption, vParam ) )
1a6944fd RR	418
1a6944fd RR	419	#if 0
7e616b10	420	retcode = hproc ( pstmt->dhstmt, fOption, vParam );
1a6944fd RR	421	#endif
1a6944fd RR	422
7e616b10	423	return retcode;
1a6944fd RR	424	}
1a6944fd RR	425
7e616b10 RR	426	RETCODE SQL_API SQLGetStmtOption (
	427	HSTMT hstmt,
	428	UWORD fOption,
	429	PTR pvParam )
1a6944fd	430	{
7e616b10 RR	431	STMT_t FAR* pstmt = (STMT_t*)hstmt;
	432	HPROC hproc;
	433	int sqlstat = en_00000;
	434	RETCODE retcode;
	435
	436	if( hstmt == SQL_NULL_HSTMT
	437	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	438	{
	439	return SQL_INVALID_HANDLE;
	440	}
	441
	442	/* check option */
	443	if( /* fOption < SQL_STMT_OPT_MIN \|\| */
	444	fOption > SQL_STMT_OPT_MAX )
	445	{
	446	PUSHSQLERR ( pstmt->herr, en_S1092 );
	447
	448	return SQL_ERROR;
	449	}
	450
	451	/* check state */
	452	if( pstmt->state >= en_stmt_needdata
	453	\|\| pstmt->asyn_on != en_NullProc )
	454	{
	455	sqlstat = en_S1010;
	456	}
	457	else
	458	{
	459	switch( pstmt->state )
	460	{
	461	case en_stmt_allocated:
	462	case en_stmt_prepared:
	463	case en_stmt_executed:
	464	case en_stmt_cursoropen:
	465	if( fOption == SQL_ROW_NUMBER
	466	\|\| fOption == SQL_GET_BOOKMARK )
	467	{
	468	sqlstat = en_24000;
	469	}
	470	break;
	471
	472	default:
	473	break;
	474	}
	475	}
	476
	477	if( sqlstat != en_00000 )
	478	{
	479	PUSHSQLERR ( pstmt->herr, sqlstat );
	480
	481	return SQL_ERROR;
	482	}
	483
	484	hproc = _iodbcdm_getproc( pstmt->hdbc, en_GetStmtOption);
	485
	486	if( hproc == SQL_NULL_HPROC )
	487	{
	488	PUSHSQLERR ( pstmt->herr, en_IM001 );
	489	return SQL_ERROR;
	490	}
	491
	492	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetStmtOption, (
	493	pstmt->dhstmt, fOption, pvParam ) )
1a6944fd RR	494
1a6944fd RR	495	#if 0
7e616b10	496	retcode = hproc ( pstmt->dhstmt, fOption, pvParam );
1a6944fd	497	#endif
7e616b10 RR	498
7e616b10 RR	499	return retcode;
1a6944fd RR	500	}
1a6944fd RR	501
7e616b10	502	RETCODE SQL_API SQLCancel ( HSTMT hstmt )
1a6944fd	503	{
7e616b10 RR	504	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	505	HPROC hproc;
	506	RETCODE retcode;
1a6944fd	507
7e616b10 RR	508	if( hstmt == SQL_NULL_HSTMT
	509	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	510	{
	511	return SQL_INVALID_HANDLE;
	512	}
1a6944fd	513
7e616b10 RR	514	/* check argument */
7e616b10 RR	515	/* check state */
1a6944fd	516
7e616b10 RR	517	/* call driver */
7e616b10 RR	518	hproc = _iodbcdm_getproc( pstmt->hdbc, en_Cancel );
1a6944fd	519
7e616b10 RR	520	if( hproc == SQL_NULL_HPROC )
	521	{
	522	PUSHSQLERR ( pstmt->herr, en_IM001 );
1a6944fd	523
7e616b10 RR	524	return SQL_ERROR;
7e616b10 RR	525	}
1a6944fd	526
7e616b10	527	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_Cancel, (pstmt->dhstmt) )
1a6944fd RR	528
1a6944fd RR	529	#if 0
7e616b10	530	retcode = hproc ( pstmt->dhstmt );
1a6944fd RR	531	#endif
1a6944fd RR	532
7e616b10 RR	533	/* state transition */
	534	if( retcode != SQL_SUCCESS
	535	&& retcode != SQL_SUCCESS_WITH_INFO )
	536	{
	537	return retcode;
	538	}
	539
	540	switch( pstmt->state )
	541	{
	542	case en_stmt_allocated:
	543	case en_stmt_prepared:
	544	break;
	545
	546	case en_stmt_executed:
	547	if( pstmt->prep_state )
	548	{
	549	pstmt->state = en_stmt_prepared;
	550	}
	551	else
	552	{
	553	pstmt->state = en_stmt_allocated;
	554	}
	555	break;
	556
	557	case en_stmt_cursoropen:
	558	case en_stmt_fetched:
	559	case en_stmt_xfetched:
	560	if( pstmt->prep_state )
	561	{
	562	pstmt->state = en_stmt_prepared;
	563	}
	564	else
	565	{
	566	pstmt->state = en_stmt_allocated;
	567	}
	568	break;
	569
	570	case en_stmt_needdata:
	571	case en_stmt_mustput:
	572	case en_stmt_canput:
	573	switch( pstmt->need_on )
	574	{
	575	case en_ExecDirect:
	576	pstmt->state = en_stmt_allocated;
	577	break;
	578
	579	case en_Execute:
	580	pstmt->state = en_stmt_prepared;
	581	break;
	582
	583	case en_SetPos:
	584	pstmt->state = en_stmt_xfetched;
	585	break;
	586
	587	default:
	588	break;
	589	}
	590	pstmt->need_on = en_NullProc;
	591	break;
	592
	593	default:
	594	break;
	595	}
	596
597	return retcode;
1a6944fd	598	}