[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 RR	1	/** Query statement object management functions
	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 SQLAllocStmt (
	31	HDBC hdbc,
	32	HSTMT FAR* phstmt )
	33	{
	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;
	38
	39	#if (ODBCVER >= 0x0300)
	40	if( hdbc == SQL_NULL_HDBC
	41	\|\| pdbc->type != SQL_HANDLE_DBC )
	42	#else
	43	if( hdbc == SQL_NULL_HDBC )
	44	#endif
	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	}
82
83	#if (ODBCVER >= 0x0300)
84	pstmt->type = SQL_HANDLE_STMT;
85	#endif
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 */
96	#if (ODBCVER >= 0x0300)
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
108	#endif
109	{
110	hproc = _iodbcdm_getproc( hdbc, en_AllocStmt );
111
112	if( hproc == SQL_NULL_HPROC )
113	{
114	PUSHSQLERR ( pstmt->herr, en_IM001 );
115	*phstmt = SQL_NULL_HSTMT;
116	MEM_FREE ( pstmt );
117
118	return SQL_ERROR;
119	}
120
121	CALL_DRIVER ( hdbc, retcode, hproc, en_AllocStmt, (
122	pdbc->dhdbc, &(pstmt->dhstmt) ) )
123	}
124
125	if( retcode != SQL_SUCCESS
126	&& retcode != SQL_SUCCESS_WITH_INFO )
127	{
128	*phstmt = SQL_NULL_HSTMT;
129	MEM_FREE ( pstmt );
130
131	return retcode;
132	}
133
134	/* insert into list */
135	pstmt->next = pdbc->hstmt;
136	pdbc->hstmt = pstmt;
137
138	*phstmt = (HSTMT)pstmt;
139
140	/* state transition */
141	pdbc->state = en_dbc_hstmt;
142
143	return SQL_SUCCESS;
144	}
145
146	RETCODE _iodbcdm_dropstmt( HSTMT hstmt )
147	{
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;
185	}
186
0d73e5a1	187	RETCODE SQL_API SQLFreeStmt (
1a6944fd RR	188	HSTMT hstmt,
	189	UWORD fOption )
	190	{
	191	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
e3e65dac	192	/* STMT_t FAR* tpstmt; */
1a6944fd RR	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;
	230
	231	#if (ODBCVER >= 0x0300)
	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	}
	242	#endif
	243
	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;
314	}
315
316	RETCODE SQL_API SQLSetStmtOption (
317	HSTMT hstmt,
318	UWORD fOption,
319	UDWORD vParam )
320	{
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 ) )
418
419	#if 0
420	retcode = hproc ( pstmt->dhstmt, fOption, vParam );
421	#endif
422
423	return retcode;
424	}
425
426	RETCODE SQL_API SQLGetStmtOption (
427	HSTMT hstmt,
428	UWORD fOption,
429	PTR pvParam )
430	{
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 ) )
494
495	#if 0
496	retcode = hproc ( pstmt->dhstmt, fOption, pvParam );
497	#endif
498
499	return retcode;
500	}
501
502	RETCODE SQL_API SQLCancel ( HSTMT hstmt )
503	{
504	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
505	HPROC hproc;
506	RETCODE retcode;
507
508	if( hstmt == SQL_NULL_HSTMT
509	\|\| pstmt->hdbc == SQL_NULL_HDBC )
510	{
511	return SQL_INVALID_HANDLE;
512	}
513
514	/* check argument */
515	/* check state */
516
517	/* call driver */
518	hproc = _iodbcdm_getproc( pstmt->hdbc, en_Cancel );
519
520	if( hproc == SQL_NULL_HPROC )
521	{
522	PUSHSQLERR ( pstmt->herr, en_IM001 );
523
524	return SQL_ERROR;
525	}
526
527	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_Cancel, (pstmt->dhstmt) )
528
529	#if 0
530	retcode = hproc ( pstmt->dhstmt );
531	#endif
532
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;
598	}