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

/** Invoke a query 
       
    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>

static void	do_cursoropen(STMT_t FAR* pstmt)
{
	RETCODE	retcode;
	SWORD	ncol;

	pstmt->state = en_stmt_executed;

	retcode = SQLNumResultCols( pstmt, &ncol );

	if( retcode == SQL_SUCCESS
	 || retcode == SQL_SUCCESS_WITH_INFO )
	{
		if( ncol )
		{
			pstmt->state = en_stmt_cursoropen;
			pstmt->cursor_state = en_stmt_cursor_opened;
		}
		else
		{
			pstmt->state = en_stmt_executed;
			pstmt->cursor_state = en_stmt_cursor_no;
		}
	}
}

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

	int		sqlstat	= en_00000;

	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:
				sqlstat = en_S1010;
				break;
	
			case en_stmt_executed:
				if( ! pstmt->prep_state )
				{
					sqlstat = en_S1010;
				}
				break;
	
			case en_stmt_cursoropen:
				if( ! pstmt->prep_state )
				{
					sqlstat = en_S1010;
				}
				break;
	
			case en_stmt_fetched:
			case en_stmt_xfetched:
				if( ! pstmt->prep_state )
				{
					sqlstat = en_S1010;
				}
				else
				{
					sqlstat = en_24000;
				}
				break;
					
			case en_stmt_needdata:
			case en_stmt_mustput:
			case en_stmt_canput:
				sqlstat = en_S1010;
				break;
	
			default:
				break;
		}
	}
	else if( pstmt->asyn_on != en_Execute )
	{
		sqlstat = en_S1010;
	}
	
	if( sqlstat == en_00000 )
	{
		hproc = _iodbcdm_getproc( pstmt->hdbc, en_Execute );

		if( hproc == SQL_NULL_HPROC )
		{
			sqlstat = en_IM001;
		}
	}

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

		return SQL_ERROR;
	}
	
	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, 
		en_Execute, ( pstmt->dhstmt ) )
			
#if 0
	retcode = hproc ( pstmt->dhstmt );
#endif

	/* stmt state transition */
	if( pstmt->asyn_on == en_Execute )
	{
		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;
		}
	}

	switch( pstmt->state )
	{
		case en_stmt_prepared:
			switch( retcode )
			{
				case SQL_SUCCESS:
				case SQL_SUCCESS_WITH_INFO:
					do_cursoropen(hstmt);
					break;

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

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

				default:
					break;
			}
			break;

		case en_stmt_executed:
			switch( retcode )
			{
				case SQL_ERROR:
					pstmt->state = en_stmt_allocated;
					pstmt->cursor_state = en_stmt_cursor_no;
					pstmt->prep_state = 0;
					break;

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

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

				default:
					break;
			}
			break;

		default:
			break;
	}

	return retcode;
}

RETCODE SQL_API	SQLExecDirect (
			HSTMT		hstmt,
			UCHAR FAR*	szSqlStr,
			SDWORD		cbSqlStr )
{
	STMT_t FAR*	pstmt	= (STMT_t FAR*)hstmt;
	HPROC		hproc	= SQL_NULL_HPROC;

	int		sqlstat	= en_00000;
	RETCODE		retcode	= SQL_SUCCESS;

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

	/* check arguments */
	if( szSqlStr == NULL )
	{
		sqlstat = en_S1009;
	}
	else if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
	{
		sqlstat = en_S1090;
	}

	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_fetched:
			case en_stmt_xfetched:
				sqlstat = en_24000;
				break;
	
			case en_stmt_needdata:
			case en_stmt_mustput:
			case en_stmt_canput:
				sqlstat = en_S1010;
				break;
	
			default:
				break;
		}
	}
	else if( pstmt->asyn_on != en_ExecDirect )
	{
		sqlstat = en_S1010;
	}

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

		return SQL_ERROR;
	}

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

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

		return SQL_ERROR;
	}

	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ExecDirect, (
			pstmt->dhstmt, szSqlStr, cbSqlStr) )
	

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

	/* stmt state transition */
	if( pstmt->asyn_on == en_ExecDirect )
	{
		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;
		}
	}
	
	if( pstmt->state <= en_stmt_executed )
	{
		switch( retcode )
		{
			case SQL_SUCCESS:
			case SQL_SUCCESS_WITH_INFO:
				do_cursoropen(hstmt);
				break;

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

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

			case SQL_ERROR:
				pstmt->state = en_stmt_allocated;
				pstmt->cursor_state = en_stmt_cursor_no;
				pstmt->prep_state = 0;
				break;
			
			default:
				break;
		}
	}

	return retcode;
}

RETCODE SQL_API	SQLPutData( 
			HSTMT	hstmt,
			PTR	rgbValue,
			SDWORD	cbValue )
{
	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 value */
	if( rgbValue == NULL
	 && ( cbValue != SQL_DEFAULT_PARAM
	   && cbValue != SQL_NULL_DATA ) )
	{
		PUSHSQLERR ( pstmt->herr, en_S1009 );

		return SQL_ERROR;
	}

	/* check state */
	if( pstmt->asyn_on == en_NullProc )
	{
		if( pstmt->state <= en_stmt_xfetched )
		{
			PUSHSQLERR( pstmt->herr, en_S1010 );

			return SQL_ERROR;
		}
	}
	else if( pstmt->asyn_on != en_PutData )
	{
		PUSHSQLERR ( pstmt->herr, en_S1010 );

		return SQL_ERROR;
	}

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

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

		return SQL_ERROR;
	}
	
	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_PutData, (
			pstmt->dhstmt, rgbValue, cbValue ) )

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

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

			case SQL_STILL_EXECUTING:
			default:
				return retcode;
		}
	}

	/* must in mustput or canput states */
	switch( retcode )
	{
		case SQL_SUCCESS:
		case SQL_SUCCESS_WITH_INFO:
			pstmt->state = en_stmt_canput;
			break;

		case SQL_ERROR:
			switch( pstmt->need_on )
			{
				case en_ExecDirect:
					pstmt->state = en_stmt_allocated;
					pstmt->need_on = en_NullProc;
					break;

				case en_Execute:
					if( pstmt->prep_state )
					{
						pstmt->state = en_stmt_prepared;
						pstmt->need_on = en_NullProc;
					}
					break;

				case en_SetPos:
					/* Is this possible ???? */
					pstmt->state = en_stmt_xfetched;
					break;

				default:
					break;
			}
			break;

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

		default:
			break;
	}

	return retcode;
}

RETCODE SQL_API	SQLParamData (
			HSTMT		hstmt,
			PTR FAR*	prgbValue )
{
	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 */
	if( pstmt->asyn_on == en_NullProc )
	{
		if( pstmt->state <= en_stmt_xfetched )
		{
			PUSHSQLERR ( pstmt->herr, en_S1010 );

			return SQL_ERROR;
		}
	}
	else if( pstmt->asyn_on != en_ParamData )
	{
		PUSHSQLERR ( pstmt->herr, en_S1010 );

		return SQL_ERROR;
	}

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

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

		return SQL_ERROR;
	}

	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamData, (
			pstmt->dhstmt, prgbValue ) )

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

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

			case SQL_STILL_EXECUTING:
			default:
				return retcode;
		}
	}

	if( pstmt->state < en_stmt_needdata )
	{
		return retcode;
	}

	switch( retcode )
	{
		case SQL_ERROR:
			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;
					pstmt->cursor_state 
						= en_stmt_cursor_xfetched;
					break;

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

		case SQL_SUCCESS:
		case SQL_SUCCESS_WITH_INFO:
			switch( pstmt->state )
			{
				case en_stmt_needdata:
					pstmt->state = en_stmt_mustput;
					break;
				
				case en_stmt_canput: 
					switch( pstmt->need_on )
					{
						case en_SetPos:
							pstmt->state 
							= en_stmt_xfetched;
							pstmt->cursor_state 
							= en_stmt_cursor_xfetched;
							break;

						case en_ExecDirect:
						case en_Execute:
							do_cursoropen(hstmt);
							break;

						default:
							break;
					}
					break;

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

		case SQL_NEED_DATA:
			pstmt->state = en_stmt_mustput;
			break;

		default:
			break;
	}

	return retcode;
}


RETCODE SQL_API	SQLNumParams (
			HSTMT		hstmt,
			SWORD FAR*	pcpar )
{
	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 */
	if( pstmt->asyn_on == en_NullProc )
	{
		switch( pstmt->state )
		{
			case en_stmt_allocated:
			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_NumParams )
	{
		PUSHSQLERR ( pstmt->herr, en_S1010 );
		
		return SQL_ERROR;
	}

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

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

		return SQL_ERROR;
	}
	
	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_NumParams, (
			pstmt->dhstmt, pcpar) )


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

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

			default:
				return retcode;
		}
	}

	if( retcode == SQL_STILL_EXECUTING )
	{
		pstmt->asyn_on = en_NumParams;
	}

	return retcode;
}

RETCODE SQL_API	SQLDescribeParam (
			HSTMT		hstmt,
			UWORD		ipar,
			SWORD  FAR*	pfSqlType,
			UDWORD FAR*	pcbColDef,
			SWORD  FAR*	pibScale,
			SWORD  FAR*	pfNullable )
{
	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 */
	if( ipar == 0 )
	{
		PUSHSQLERR ( pstmt->herr, en_S1093 );

		return SQL_ERROR;
	}

	/* check state */
	if( pstmt->asyn_on == en_NullProc )
	{
		switch( pstmt->state )
		{
			case en_stmt_allocated:
			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_DescribeParam )
	{
		PUSHSQLERR ( pstmt->herr, en_S1010 );
		
		return SQL_ERROR;
	}

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

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

		return SQL_ERROR;
	}

	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_DescribeParam, (
			pstmt->dhstmt, 
			ipar,
			pfSqlType,
			pcbColDef,
			pibScale,
			pfNullable ) )

#if 0
	retcode = hproc(pstmt->dhstmt, 
			ipar,
			pfSqlType,
			pcbColDef,
			pibScale,
			pfNullable );
#endif

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

			default:
				return retcode;
		}
	}

	if( retcode == SQL_STILL_EXECUTING )
	{
		pstmt->asyn_on = en_DescribeParam;
	}

	return retcode;
}
Commit	Line	Data
1a6944fd RR	1	/** Invoke a query
	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	static void do_cursoropen(STMT_t FAR* pstmt)
	31	{
	32	RETCODE retcode;
	33	SWORD ncol;
	34
	35	pstmt->state = en_stmt_executed;
	36
	37	retcode = SQLNumResultCols( pstmt, &ncol );
	38
	39	if( retcode == SQL_SUCCESS
	40	\|\| retcode == SQL_SUCCESS_WITH_INFO )
	41	{
	42	if( ncol )
	43	{
	44	pstmt->state = en_stmt_cursoropen;
	45	pstmt->cursor_state = en_stmt_cursor_opened;
	46	}
	47	else
	48	{
	49	pstmt->state = en_stmt_executed;
	50	pstmt->cursor_state = en_stmt_cursor_no;
	51	}
	52	}
	53	}
	54
0d73e5a1	55	RETCODE SQL_API SQLExecute ( HSTMT hstmt )
1a6944fd RR	56	{
	57	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	58	HPROC hproc = SQL_NULL_HPROC;
	59	RETCODE retcode;
	60
	61	int sqlstat = en_00000;
	62
	63	if( hstmt == SQL_NULL_HSTMT
	64	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	65	{
	66	return SQL_INVALID_HANDLE;
	67	}
	68
	69	/* check state */
	70	if( pstmt->asyn_on == en_NullProc )
	71	{
	72	switch( pstmt->state )
	73	{
	74	case en_stmt_allocated:
	75	sqlstat = en_S1010;
	76	break;
	77
	78	case en_stmt_executed:
	79	if( ! pstmt->prep_state )
	80	{
	81	sqlstat = en_S1010;
	82	}
	83	break;
	84
	85	case en_stmt_cursoropen:
	86	if( ! pstmt->prep_state )
	87	{
	88	sqlstat = en_S1010;
	89	}
	90	break;
	91
	92	case en_stmt_fetched:
	93	case en_stmt_xfetched:
	94	if( ! pstmt->prep_state )
	95	{
	96	sqlstat = en_S1010;
	97	}
	98	else
	99	{
	100	sqlstat = en_24000;
	101	}
	102	break;
	103
	104	case en_stmt_needdata:
	105	case en_stmt_mustput:
	106	case en_stmt_canput:
	107	sqlstat = en_S1010;
	108	break;
	109
	110	default:
	111	break;
	112	}
	113	}
	114	else if( pstmt->asyn_on != en_Execute )
	115	{
	116	sqlstat = en_S1010;
	117	}
	118
	119	if( sqlstat == en_00000 )
120	{
121	hproc = _iodbcdm_getproc( pstmt->hdbc, en_Execute );
122
123	if( hproc == SQL_NULL_HPROC )
124	{
125	sqlstat = en_IM001;
126	}
127	}
128
129	if( sqlstat != en_00000 )
130	{
131	PUSHSQLERR ( pstmt->herr, sqlstat );
132
133	return SQL_ERROR;
134	}
135
136	CALL_DRIVER ( pstmt->hdbc, retcode, hproc,
137	en_Execute, ( pstmt->dhstmt ) )
138
139	#if 0
140	retcode = hproc ( pstmt->dhstmt );
141	#endif
142
143	/* stmt state transition */
144	if( pstmt->asyn_on == en_Execute )
145	{
146	switch ( retcode )
147	{
148	case SQL_SUCCESS:
149	case SQL_SUCCESS_WITH_INFO:
150	case SQL_NEED_DATA:
151	case SQL_ERROR:
152	pstmt->asyn_on = en_NullProc;
153	break;
154
155	case SQL_STILL_EXECUTING:
156	default:
157	return retcode;
158	}
159	}
160
161	switch( pstmt->state )
162	{
163	case en_stmt_prepared:
164	switch( retcode )
165	{
166	case SQL_SUCCESS:
167	case SQL_SUCCESS_WITH_INFO:
168	do_cursoropen(hstmt);
169	break;
170
171	case SQL_NEED_DATA:
172	pstmt->state = en_stmt_needdata;
173	pstmt->need_on = en_Execute;
174	break;
175
176	case SQL_STILL_EXECUTING:
177	pstmt->asyn_on = en_Execute;
178	break;
179
180	default:
181	break;
182	}
183	break;
184
185	case en_stmt_executed:
186	switch( retcode )
187	{
188	case SQL_ERROR:
189	pstmt->state = en_stmt_allocated;
190	pstmt->cursor_state = en_stmt_cursor_no;
191	pstmt->prep_state = 0;
192	break;
193
194	case SQL_NEED_DATA:
195	pstmt->state = en_stmt_needdata;
196	pstmt->need_on = en_Execute;
197	break;
198
199	case SQL_STILL_EXECUTING:
200	pstmt->asyn_on = en_Execute;
201	break;
202
203	default:
204	break;
205	}
206	break;
207
208	default:
209	break;
210	}
211
212	return retcode;
213	}
214
215	RETCODE SQL_API SQLExecDirect (
216	HSTMT hstmt,
217	UCHAR FAR* szSqlStr,
218	SDWORD cbSqlStr )
219	{
220	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
221	HPROC hproc = SQL_NULL_HPROC;
222
223	int sqlstat = en_00000;
224	RETCODE retcode = SQL_SUCCESS;
225
226	if( hstmt == SQL_NULL_HSTMT
227	\|\| pstmt->hdbc == SQL_NULL_HDBC )
228	{
229	return SQL_INVALID_HANDLE;
230	}
231
232	/* check arguments */
233	if( szSqlStr == NULL )
234	{
235	sqlstat = en_S1009;
236	}
237	else if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
238	{
239	sqlstat = en_S1090;
240	}
241
242	if( sqlstat != en_00000 )
243	{
244	PUSHSQLERR ( pstmt->herr, sqlstat );
245
246	return SQL_ERROR;
247	}
248
249	/* check state */
250	if( pstmt->asyn_on == en_NullProc )
251	{
252	switch ( pstmt->state )
253	{
254	case en_stmt_fetched:
255	case en_stmt_xfetched:
256	sqlstat = en_24000;
257	break;
258
259	case en_stmt_needdata:
260	case en_stmt_mustput:
261	case en_stmt_canput:
262	sqlstat = en_S1010;
263	break;
264
265	default:
266	break;
267	}
268	}
269	else if( pstmt->asyn_on != en_ExecDirect )
270	{
271	sqlstat = en_S1010;
272	}
273
274	if( sqlstat != en_00000 )
275	{
276	PUSHSQLERR ( pstmt->herr, sqlstat );
277
278	return SQL_ERROR;
279	}
280
281	hproc = _iodbcdm_getproc( pstmt->hdbc, en_ExecDirect);
282
283	if( hproc == SQL_NULL_HPROC )
284	{
285	PUSHSQLERR ( pstmt->herr, en_IM001 );
286
287	return SQL_ERROR;
288	}
289
290	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ExecDirect, (
291	pstmt->dhstmt, szSqlStr, cbSqlStr) )
292
293
294	#if 0
295	retcode = hproc ( pstmt->dhstmt, szSqlStr, cbSqlStr );
296	#endif
297
298	/* stmt state transition */
299	if( pstmt->asyn_on == en_ExecDirect )
300	{
301	switch ( retcode )
302	{
303	case SQL_SUCCESS:
304	case SQL_SUCCESS_WITH_INFO:
305	case SQL_NEED_DATA:
306	case SQL_ERROR:
307	pstmt->asyn_on = en_NullProc;
308	break;
309
310	case SQL_STILL_EXECUTING:
311	default:
312	return retcode;
313	}
314	}
315
316	if( pstmt->state <= en_stmt_executed )
317	{
318	switch( retcode )
319	{
320	case SQL_SUCCESS:
321	case SQL_SUCCESS_WITH_INFO:
322	do_cursoropen(hstmt);
323	break;
324
325	case SQL_NEED_DATA:
326	pstmt->state = en_stmt_needdata;
327	pstmt->need_on = en_ExecDirect;
328	break;
329
330	case SQL_STILL_EXECUTING:
331	pstmt->asyn_on = en_ExecDirect;
332	break;
333
334	case SQL_ERROR:
335	pstmt->state = en_stmt_allocated;
336	pstmt->cursor_state = en_stmt_cursor_no;
337	pstmt->prep_state = 0;
338	break;
339
340	default:
341	break;
342	}
343	}
344
345	return retcode;
346	}
347
348	RETCODE SQL_API SQLPutData(
349	HSTMT hstmt,
350	PTR rgbValue,
351	SDWORD cbValue )
352	{
353	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
354	HPROC hproc;
355	RETCODE retcode;
356
357	if( hstmt == SQL_NULL_HSTMT
358	\|\| pstmt->hdbc == SQL_NULL_HDBC )
359	{
360	return SQL_INVALID_HANDLE;
361	}
362
363	/* check argument value */
364	if( rgbValue == NULL
365	&& ( cbValue != SQL_DEFAULT_PARAM
366	&& cbValue != SQL_NULL_DATA ) )
367	{
368	PUSHSQLERR ( pstmt->herr, en_S1009 );
369
370	return SQL_ERROR;
371	}
372
373	/* check state */
374	if( pstmt->asyn_on == en_NullProc )
375	{
376	if( pstmt->state <= en_stmt_xfetched )
377	{
378	PUSHSQLERR( pstmt->herr, en_S1010 );
379
380	return SQL_ERROR;
381	}
382	}
383	else if( pstmt->asyn_on != en_PutData )
384	{
385	PUSHSQLERR ( pstmt->herr, en_S1010 );
386
387	return SQL_ERROR;
388	}
389
390	/* call driver */
391	hproc = _iodbcdm_getproc( pstmt->hdbc, en_PutData );
392
393	if( hproc == SQL_NULL_HPROC )
394	{
395	PUSHSQLERR ( pstmt->herr, en_IM001 );
396
397	return SQL_ERROR;
398	}
399
400	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_PutData, (
401	pstmt->dhstmt, rgbValue, cbValue ) )
402
403	#if 0
404	retcode = hproc(pstmt->dhstmt, rgbValue, cbValue );
405	#endif
406
407	/* state transition */
408	if( pstmt->asyn_on == en_PutData )
409	{
410	switch( retcode )
411	{
412	case SQL_SUCCESS:
413	case SQL_SUCCESS_WITH_INFO:
414	case SQL_ERROR:
415	pstmt->asyn_on = en_NullProc;
416	break;
417
418	case SQL_STILL_EXECUTING:
419	default:
420	return retcode;
421	}
422	}
423
424	/* must in mustput or canput states */
425	switch( retcode )
426	{
427	case SQL_SUCCESS:
428	case SQL_SUCCESS_WITH_INFO:
429	pstmt->state = en_stmt_canput;
430	break;
431
432	case SQL_ERROR:
433	switch( pstmt->need_on )
434	{
435	case en_ExecDirect:
436	pstmt->state = en_stmt_allocated;
437	pstmt->need_on = en_NullProc;
438	break;
439
440	case en_Execute:
441	if( pstmt->prep_state )
442	{
443	pstmt->state = en_stmt_prepared;
444	pstmt->need_on = en_NullProc;
445	}
446	break;
447
448	case en_SetPos:
449	/* Is this possible ???? */
450	pstmt->state = en_stmt_xfetched;
451	break;
452
453	default:
454	break;
455	}
456	break;
457
458	case SQL_STILL_EXECUTING:
459	pstmt->asyn_on = en_PutData;
460	break;
461
462	default:
463	break;
464	}
465
466	return retcode;
467	}
468
469	RETCODE SQL_API SQLParamData (
470	HSTMT hstmt,
471	PTR FAR* prgbValue )
472	{
473	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
474	HPROC hproc;
475	RETCODE retcode;
476
477	if( hstmt == SQL_NULL_HSTMT
478	\|\| pstmt->hdbc == SQL_NULL_HDBC )
479	{
480	return SQL_INVALID_HANDLE;
481	}
482
483	/* check argument */
484
485	/* check state */
486	if( pstmt->asyn_on == en_NullProc )
487	{
488	if( pstmt->state <= en_stmt_xfetched )
489	{
490	PUSHSQLERR ( pstmt->herr, en_S1010 );
491
492	return SQL_ERROR;
493	}
494	}
495	else if( pstmt->asyn_on != en_ParamData )
496	{
497	PUSHSQLERR ( pstmt->herr, en_S1010 );
498
499	return SQL_ERROR;
500	}
501
502	/* call driver */
503	hproc = _iodbcdm_getproc( pstmt->hdbc, en_ParamData );
504
505	if( hproc == SQL_NULL_HPROC )
506	{
507	PUSHSQLERR ( pstmt->herr, en_IM001 );
508
509	return SQL_ERROR;
510	}
511
512	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamData, (
513	pstmt->dhstmt, prgbValue ) )
514
515	#if 0
516	retcode = hproc ( pstmt->dhstmt, prgbValue );
517	#endif
518
519	/* state transition */
520	if( pstmt->asyn_on == en_ParamData )
521	{
522	switch( retcode )
523	{
524	case SQL_SUCCESS:
525	case SQL_SUCCESS_WITH_INFO:
526	case SQL_ERROR:
527	pstmt->asyn_on = en_NullProc;
528	break;
529
530	case SQL_STILL_EXECUTING:
531	default:
532	return retcode;
533	}
534	}
535
536	if( pstmt->state < en_stmt_needdata )
537	{
538	return retcode;
539	}
540
541	switch( retcode )
542	{
543	case SQL_ERROR:
544	switch( pstmt->need_on )
545	{
546	case en_ExecDirect:
547	pstmt->state = en_stmt_allocated;
548	break;
549
550	case en_Execute:
551	pstmt->state = en_stmt_prepared;
552	break;
553
554	case en_SetPos:
555	pstmt->state = en_stmt_xfetched;
556	pstmt->cursor_state
557	= en_stmt_cursor_xfetched;
558	break;
559
560	default:
561	break;
562	}
563	pstmt->need_on = en_NullProc;
564	break;
565
566	case SQL_SUCCESS:
567	case SQL_SUCCESS_WITH_INFO:
568	switch( pstmt->state )
569	{
570	case en_stmt_needdata:
571	pstmt->state = en_stmt_mustput;
572	break;
573
574	case en_stmt_canput:
575	switch( pstmt->need_on )
576	{
577	case en_SetPos:
578	pstmt->state
579	= en_stmt_xfetched;
580	pstmt->cursor_state
581	= en_stmt_cursor_xfetched;
582	break;
583
584	case en_ExecDirect:
585	case en_Execute:
586	do_cursoropen(hstmt);
587	break;
588
589	default:
590	break;
591	}
592	break;
593
594	default:
595	break;
596	}
597	pstmt->need_on = en_NullProc;
598	break;
599
600	case SQL_NEED_DATA:
601	pstmt->state = en_stmt_mustput;
602	break;
603
604	default:
605	break;
606	}
607
608	return retcode;
609	}
610
611
612	RETCODE SQL_API SQLNumParams (
613	HSTMT hstmt,
614	SWORD FAR* pcpar )
615	{
616	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
617	HPROC hproc;
618	RETCODE retcode;
619
620	if( hstmt == SQL_NULL_HSTMT
621	\|\| pstmt->hdbc == SQL_NULL_HDBC )
622	{
623	return SQL_INVALID_HANDLE;
624	}
625
626	/* check argument */
627
628	/* check state */
629	if( pstmt->asyn_on == en_NullProc )
630	{
631	switch( pstmt->state )
632	{
633	case en_stmt_allocated:
634	case en_stmt_needdata:
635	case en_stmt_mustput:
636	case en_stmt_canput:
637	PUSHSQLERR ( pstmt->herr, en_S1010 );
638	return SQL_ERROR;
639
640	default:
641	break;
642	}
643	}
644	else if( pstmt->asyn_on != en_NumParams )
645	{
646	PUSHSQLERR ( pstmt->herr, en_S1010 );
647
648	return SQL_ERROR;
649	}
650
651	/* call driver */
652	hproc = _iodbcdm_getproc ( pstmt->hdbc, en_NumParams );
653
654	if( hproc == SQL_NULL_HPROC )
655	{
656	PUSHSQLERR ( pstmt->herr, en_IM001 );
657
658	return SQL_ERROR;
659	}
660
661	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_NumParams, (
662	pstmt->dhstmt, pcpar) )
663
664
665	#if 0
666	retcode = hproc ( pstmt->dhstmt, pcpar );
667	#endif
668
669	/* state transition */
670	if( pstmt->asyn_on == en_NumParams )
671	{
672	switch ( retcode )
673	{
674	case SQL_SUCCESS:
675	case SQL_SUCCESS_WITH_INFO:
676	case SQL_ERROR:
677	break;
678
679	default:
680	return retcode;
681	}
682	}
683
684	if( retcode == SQL_STILL_EXECUTING )
685	{
686	pstmt->asyn_on = en_NumParams;
687	}
688
689	return retcode;
690	}
691
692	RETCODE SQL_API SQLDescribeParam (
693	HSTMT hstmt,
694	UWORD ipar,
695	SWORD FAR* pfSqlType,
696	UDWORD FAR* pcbColDef,
697	SWORD FAR* pibScale,
698	SWORD FAR* pfNullable )
699	{
700	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
701	HPROC hproc;
702	RETCODE retcode;
703
704	if( hstmt == SQL_NULL_HSTMT
705	\|\| pstmt->hdbc == SQL_NULL_HDBC )
706	{
707	return SQL_INVALID_HANDLE;
708	}
709
710	/* check argument */
711	if( ipar == 0 )
712	{
713	PUSHSQLERR ( pstmt->herr, en_S1093 );
714
715	return SQL_ERROR;
716	}
717
718	/* check state */
719	if( pstmt->asyn_on == en_NullProc )
720	{
721	switch( pstmt->state )
722	{
723	case en_stmt_allocated:
724	case en_stmt_needdata:
725	case en_stmt_mustput:
726	case en_stmt_canput:
727	PUSHSQLERR ( pstmt->herr, en_S1010 );
728	return SQL_ERROR;
729
730	default:
731	break;
732	}
733	}
734	else if( pstmt->asyn_on != en_DescribeParam )
735	{
736	PUSHSQLERR ( pstmt->herr, en_S1010 );
737
738	return SQL_ERROR;
739	}
740
741	/* call driver */
742	hproc = _iodbcdm_getproc ( pstmt->hdbc, en_DescribeParam );
743
744	if( hproc == SQL_NULL_HPROC )
745	{
746	PUSHSQLERR ( pstmt->herr, en_IM001 );
747
748	return SQL_ERROR;
749	}
750
751	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_DescribeParam, (
752	pstmt->dhstmt,
753	ipar,
754	pfSqlType,
755	pcbColDef,
756	pibScale,
757	pfNullable ) )
758
759	#if 0
760	retcode = hproc(pstmt->dhstmt,
761	ipar,
762	pfSqlType,
763	pcbColDef,
764	pibScale,
765	pfNullable );
766	#endif
767
768	/* state transition */
769	if( pstmt->asyn_on == en_DescribeParam )
770	{
771	switch ( retcode )
772	{
773	case SQL_SUCCESS:
774	case SQL_SUCCESS_WITH_INFO:
775	case SQL_ERROR:
776	break;
777
778	default:
779	return retcode;
780	}
781	}
782
783	if( retcode == SQL_STILL_EXECUTING )
784	{
785	pstmt->asyn_on = en_DescribeParam;
786	}
787
788	return retcode;
789	}