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

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


RETCODE SQL_API SQLPrepare (
                        HSTMT           hstmt,
                        UCHAR FAR*      szSqlStr,
                        SDWORD          cbSqlStr )
{
        STMT_t FAR*     pstmt   = (STMT_t*)hstmt;

        HPROC           hproc   = SQL_NULL_HPROC;
        RETCODE         retcode = SQL_SUCCESS;
        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 )
        {
                /* not on asyn state */
                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_Prepare )
        {
                /* asyn on other */
                sqlstat = en_S1010;
        }

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

                return SQL_ERROR;
        }

        if( szSqlStr == NULL )
        {
                PUSHSQLERR ( pstmt->herr, en_S1009 );

                return SQL_ERROR;
        }

        if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
        {
                PUSHSQLERR ( pstmt->herr, en_S1090 );

                return SQL_ERROR;
        }

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

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

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

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

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

                        case SQL_STILL_EXECUTING:
                        default:
                                return retcode;
                }
        }

        switch( retcode )
        {
                case SQL_STILL_EXECUTING:
                        pstmt->asyn_on = en_Prepare;
                        break;

                case SQL_SUCCESS:
                case SQL_SUCCESS_WITH_INFO:
                        pstmt->state = en_stmt_prepared;
                        pstmt->prep_state = 1;
                        break;

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

                                default:
                                        break;
                        }

                default:
                        break;
        }

        return retcode;
}

RETCODE SQL_API SQLSetCursorName (
                        HSTMT           hstmt,
                        UCHAR FAR*      szCursor,
                        SWORD           cbCursor )
{
        STMT_t FAR*     pstmt   = (STMT_t*)hstmt;
        HPROC           hproc   = SQL_NULL_HPROC;

        RETCODE         retcode = SQL_SUCCESS;
        int             sqlstat = en_00000;

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

        if( szCursor == NULL )
        {
                PUSHSQLERR ( pstmt->herr, en_S1009 );

                return SQL_ERROR;
        }

        if( cbCursor < 0 && cbCursor != SQL_NTS )
        {
                PUSHSQLERR ( pstmt->herr, en_S1090 );

                return SQL_ERROR;
        }

        /* check state */
        if( pstmt->asyn_on != en_NullProc )
        {
                sqlstat = en_S1010;
        }
        else
        {
                switch( pstmt->state )
                {
                        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:
                                sqlstat = en_S1010;
                                break;

                        default:
                                break;
                }
        }

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetCursorName, (
                        pstmt->dhstmt, szCursor, cbCursor ) )

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

        if( retcode == SQL_SUCCESS
         || retcode == SQL_SUCCESS_WITH_INFO )
        {
                pstmt->cursor_state = en_stmt_cursor_named;
        }

        return retcode;
}

RETCODE SQL_API SQLBindParameter (
                        HSTMT           hstmt,
                        UWORD           ipar,
                        SWORD           fParamType,
                        SWORD           fCType,
                        SWORD           fSqlType,
                        UDWORD          cbColDef,
                        SWORD           ibScale,
                        PTR             rgbValue,
                        SDWORD          cbValueMax,
                        SDWORD FAR*     pcbValue )
{
        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 param */
        if( fSqlType > SQL_TYPE_MAX
         || ( fSqlType < SQL_TYPE_MIN
           && fSqlType > SQL_TYPE_DRIVER_START ) )
        /* Note: SQL_TYPE_DRIVER_START is a nagtive number
         * So, we use ">" */
        {
                sqlstat = en_S1004;
        }
        else if ( ipar < 1 )
        {
                sqlstat = en_S1093;
        }
        else if( (rgbValue == NULL && pcbValue == NULL)
              && fParamType != SQL_PARAM_OUTPUT )
        {
                sqlstat = en_S1009;
                /* This means, I allow output to nowhere
                 * (i.e. * junk output result). But I can't
                 * allow input from nowhere.
                 */
        }
/**********
        else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX )
        {
                sqlstat = en_S1090;
        }
**********/
        else if( fParamType != SQL_PARAM_INPUT
              && fParamType != SQL_PARAM_OUTPUT
              && fParamType != SQL_PARAM_INPUT_OUTPUT )
        {
                sqlstat = en_S1105;
        }
        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->state >= en_stmt_needdata
         || pstmt->asyn_on != en_NullProc )
        {
                PUSHSQLERR ( pstmt->herr, en_S1010 );

                retcode = SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_BindParameter, (
                        pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
                        cbColDef, ibScale, rgbValue, cbValueMax, pcbValue ) )

#if 0
        retcode = hproc(pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
                        cbColDef, ibScale, rgbValue, cbValueMax, pcbValue );
#endif

        return retcode;
}

RETCODE SQL_API SQLParamOptions(
                        HSTMT           hstmt,
                        UDWORD          crow,
                        UDWORD FAR*     pirow )
{
        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;
        }

        if( crow == (UDWORD)0UL )
        {
                PUSHSQLERR ( pstmt->herr, en_S1107 );

                return SQL_ERROR;
        }

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamOptions, (
                        pstmt->dhstmt, crow, pirow) )

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

        return retcode;
}

RETCODE SQL_API SQLSetScrollOptions(
                        HSTMT           hstmt,
                        UWORD           fConcurrency,
                        SDWORD          crowKeyset,
                        UWORD           crowRowset )
{
        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;
        }

        for(;;)
        {
                if( crowRowset == (UWORD)0 )
                {
                        sqlstat = en_S1107;
                        break;
                }

                if( crowKeyset > (SDWORD)0L && crowKeyset < (SDWORD)crowRowset )
                {
                        sqlstat = en_S1107;
                        break;
                }

                if( crowKeyset < 1 )
                {
                        if( crowKeyset != SQL_SCROLL_FORWARD_ONLY
                         && crowKeyset != SQL_SCROLL_STATIC
                         && crowKeyset != SQL_SCROLL_KEYSET_DRIVEN
                         && crowKeyset != SQL_SCROLL_DYNAMIC )
                        {
                                sqlstat = en_S1107;
                                break;
                        }
                }

                if( fConcurrency != SQL_CONCUR_READ_ONLY
                 && fConcurrency != SQL_CONCUR_LOCK
                 && fConcurrency != SQL_CONCUR_ROWVER
                 && fConcurrency != SQL_CONCUR_VALUES )
                {
                        sqlstat = en_S1108;
                        break;
                }

                if( pstmt->state != en_stmt_allocated )
                {
                        sqlstat = en_S1010;
                        break;
                }

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

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

                sqlstat = en_00000;
                if( 1 ) /* turn off solaris warning message */
                        break;
        }

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetScrollOptions, (
                        pstmt->dhstmt,
                        fConcurrency,
                        crowKeyset,
                        crowRowset ) )

#if 0
        retcode = hproc(pstmt->dhstmt,
                        fConcurrency,
                        crowKeyset,
                        crowRowset );
#endif

        return retcode;
}

RETCODE SQL_API SQLSetParam (
                        HSTMT       hstmt,
                        UWORD       ipar,
                        SWORD       fCType,
                        SWORD       fSqlType,
                        UDWORD      cbColDef,
                        SWORD       ibScale,
                        PTR         rgbValue,
                        SDWORD FAR *pcbValue)
{
        return SQLBindParameter(hstmt,
                                ipar,
                                (SWORD)SQL_PARAM_INPUT_OUTPUT,
                                fCType,
                                fSqlType,
                                cbColDef,
                                ibScale,
                                rgbValue,
                                SQL_SETPARAM_VALUE_MAX,
                                pcbValue );
}
Commit	Line	Data
1a6944fd RR	1	/** Prepare a query
1a6944fd RR	2
7e616b10	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
	31	RETCODE SQL_API SQLPrepare (
	32	HSTMT hstmt,
	33	UCHAR FAR* szSqlStr,
	34	SDWORD cbSqlStr )
1a6944fd	35	{
7e616b10 RR	36	STMT_t FAR* pstmt = (STMT_t*)hstmt;
	37
	38	HPROC hproc = SQL_NULL_HPROC;
	39	RETCODE retcode = SQL_SUCCESS;
	40	int sqlstat = en_00000;
	41
	42	if( hstmt == SQL_NULL_HSTMT
	43	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	44	{
	45	return SQL_INVALID_HANDLE;
	46	}
	47
	48	/* check state */
	49	if( pstmt->asyn_on == en_NullProc )
	50	{
	51	/* not on asyn state */
	52	switch( pstmt->state )
	53	{
	54	case en_stmt_fetched:
	55	case en_stmt_xfetched:
	56	sqlstat = en_24000;
	57	break;
	58
	59	case en_stmt_needdata:
	60	case en_stmt_mustput:
	61	case en_stmt_canput:
	62	sqlstat = en_S1010;
	63	break;
	64
	65	default:
	66	break;
	67	}
	68	}
	69	else if( pstmt->asyn_on != en_Prepare )
	70	{
	71	/* asyn on other */
	72	sqlstat = en_S1010;
	73	}
	74
	75	if( sqlstat != en_00000 )
	76	{
	77	PUSHSQLERR ( pstmt->herr, sqlstat );
	78
	79	return SQL_ERROR;
	80	}
	81
	82	if( szSqlStr == NULL )
	83	{
	84	PUSHSQLERR ( pstmt->herr, en_S1009 );
	85
	86	return SQL_ERROR;
	87	}
	88
	89	if( cbSqlStr < 0 && cbSqlStr != SQL_NTS )
	90	{
	91	PUSHSQLERR ( pstmt->herr, en_S1090 );
	92
	93	return SQL_ERROR;
	94	}
	95
	96	hproc = _iodbcdm_getproc( pstmt->hdbc, en_Prepare );
	97
	98	if( hproc == SQL_NULL_HPROC )
	99	{
100	PUSHSQLERR ( pstmt->herr, en_IM001 );
101	return SQL_ERROR;
102	}
103
104	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_Prepare, (
105	pstmt->dhstmt, szSqlStr, cbSqlStr) )
1a6944fd RR	106
1a6944fd RR	107	#if 0
7e616b10	108	retcode = hproc ( pstmt->dhstmt, szSqlStr, cbSqlStr );
1a6944fd RR	109	#endif
1a6944fd RR	110
7e616b10 RR	111	/* stmt state transition */
	112	if( pstmt->asyn_on == en_Prepare )
	113	{
	114	switch( retcode )
	115	{
	116	case SQL_SUCCESS:
	117	case SQL_SUCCESS_WITH_INFO:
	118	case SQL_ERROR:
	119	pstmt->asyn_on = en_NullProc;
	120	return retcode;
	121
	122	case SQL_STILL_EXECUTING:
	123	default:
	124	return retcode;
	125	}
	126	}
	127
	128	switch( retcode )
	129	{
	130	case SQL_STILL_EXECUTING:
	131	pstmt->asyn_on = en_Prepare;
	132	break;
	133
	134	case SQL_SUCCESS:
	135	case SQL_SUCCESS_WITH_INFO:
	136	pstmt->state = en_stmt_prepared;
	137	pstmt->prep_state = 1;
	138	break;
	139
	140	case SQL_ERROR:
	141	switch( pstmt->state )
	142	{
	143	case en_stmt_prepared:
	144	case en_stmt_executed:
	145	pstmt->state = en_stmt_allocated;
	146	pstmt->prep_state = 0;
	147	break;
	148
	149	default:
	150	break;
	151	}
	152
	153	default:
	154	break;
	155	}
	156
	157	return retcode;
1a6944fd RR	158	}
1a6944fd RR	159
7e616b10 RR	160	RETCODE SQL_API SQLSetCursorName (
	161	HSTMT hstmt,
	162	UCHAR FAR* szCursor,
	163	SWORD cbCursor )
1a6944fd	164	{
7e616b10 RR	165	STMT_t FAR* pstmt = (STMT_t*)hstmt;
	166	HPROC hproc = SQL_NULL_HPROC;
	167
	168	RETCODE retcode = SQL_SUCCESS;
	169	int sqlstat = en_00000;
	170
	171	if( hstmt == SQL_NULL_HSTMT
	172	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	173	{
	174	return SQL_INVALID_HANDLE;
	175	}
	176
	177	if( szCursor == NULL )
	178	{
	179	PUSHSQLERR ( pstmt->herr, en_S1009 );
	180
	181	return SQL_ERROR;
	182	}
	183
	184	if( cbCursor < 0 && cbCursor != SQL_NTS )
	185	{
	186	PUSHSQLERR ( pstmt->herr, en_S1090 );
	187
	188	return SQL_ERROR;
	189	}
	190
	191	/* check state */
	192	if( pstmt->asyn_on != en_NullProc )
	193	{
	194	sqlstat = en_S1010;
	195	}
	196	else
	197	{
	198	switch( pstmt->state )
	199	{
	200	case en_stmt_executed:
	201	case en_stmt_cursoropen:
	202	case en_stmt_fetched:
	203	case en_stmt_xfetched:
	204	sqlstat = en_24000;
	205	break;
	206
	207	case en_stmt_needdata:
	208	case en_stmt_mustput:
	209	case en_stmt_canput:
	210	sqlstat = en_S1010;
	211	break;
	212
	213	default:
	214	break;
	215	}
	216	}
	217
	218	if( sqlstat != en_00000 )
	219	{
	220	PUSHSQLERR ( pstmt->herr, sqlstat );
	221
	222	return SQL_ERROR;
	223	}
	224
	225	hproc = _iodbcdm_getproc( pstmt->hdbc, en_SetCursorName);
	226
	227	if( hproc == SQL_NULL_HPROC )
	228	{
229	PUSHSQLERR ( pstmt->herr, en_IM001 );
230
231	return SQL_ERROR;
232	}
233
234	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetCursorName, (
235	pstmt->dhstmt, szCursor, cbCursor ) )
1a6944fd RR	236
1a6944fd RR	237	#if 0
7e616b10	238	retcode = hproc ( pstmt->dhstmt, szCursor, cbCursor );
1a6944fd RR	239	#endif
1a6944fd RR	240
7e616b10 RR	241	if( retcode == SQL_SUCCESS
	242	\|\| retcode == SQL_SUCCESS_WITH_INFO )
	243	{
	244	pstmt->cursor_state = en_stmt_cursor_named;
	245	}
1a6944fd	246
7e616b10	247	return retcode;
1a6944fd RR	248	}
1a6944fd RR	249
7e616b10 RR	250	RETCODE SQL_API SQLBindParameter (
	251	HSTMT hstmt,
	252	UWORD ipar,
	253	SWORD fParamType,
	254	SWORD fCType,
	255	SWORD fSqlType,
	256	UDWORD cbColDef,
	257	SWORD ibScale,
	258	PTR rgbValue,
	259	SDWORD cbValueMax,
	260	SDWORD FAR* pcbValue )
1a6944fd	261	{
7e616b10 RR	262	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	263	HPROC hproc = SQL_NULL_HPROC;
	264
	265	int sqlstat = en_00000;
	266	RETCODE retcode = SQL_SUCCESS;
	267
	268	if( hstmt == SQL_NULL_HSTMT
	269	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	270	{
	271	return SQL_INVALID_HANDLE;
	272	}
	273
	274	/* check param */
	275	if( fSqlType > SQL_TYPE_MAX
	276	\|\| ( fSqlType < SQL_TYPE_MIN
	277	&& fSqlType > SQL_TYPE_DRIVER_START ) )
	278	/* Note: SQL_TYPE_DRIVER_START is a nagtive number
	279	* So, we use ">" */
	280	{
	281	sqlstat = en_S1004;
	282	}
	283	else if ( ipar < 1 )
	284	{
	285	sqlstat = en_S1093;
	286	}
	287	else if( (rgbValue == NULL && pcbValue == NULL)
	288	&& fParamType != SQL_PARAM_OUTPUT )
	289	{
	290	sqlstat = en_S1009;
	291	/* This means, I allow output to nowhere
	292	* (i.e. * junk output result). But I can't
	293	* allow input from nowhere.
	294	*/
	295	}
1a6944fd	296	/**********
7e616b10 RR	297	else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX )
	298	{
	299	sqlstat = en_S1090;
	300	}
1a6944fd	301	**********/
7e616b10 RR	302	else if( fParamType != SQL_PARAM_INPUT
	303	&& fParamType != SQL_PARAM_OUTPUT
	304	&& fParamType != SQL_PARAM_INPUT_OUTPUT )
	305	{
	306	sqlstat = en_S1105;
	307	}
	308	else
	309	{
	310	switch( fCType )
	311	{
	312	case SQL_C_DEFAULT:
	313	case SQL_C_CHAR:
	314	case SQL_C_BINARY:
	315	case SQL_C_BIT:
	316	case SQL_C_TINYINT:
	317	case SQL_C_STINYINT:
	318	case SQL_C_UTINYINT:
	319	case SQL_C_SHORT:
	320	case SQL_C_SSHORT:
	321	case SQL_C_USHORT:
	322	case SQL_C_LONG:
	323	case SQL_C_SLONG:
	324	case SQL_C_ULONG:
	325	case SQL_C_FLOAT:
	326	case SQL_C_DOUBLE:
	327	case SQL_C_DATE:
	328	case SQL_C_TIME:
	329	case SQL_C_TIMESTAMP:
	330	break;
	331
	332	default:
	333	sqlstat = en_S1003;
	334	break;
	335	}
	336	}
	337
	338	if(sqlstat != en_00000 )
	339	{
	340	PUSHSQLERR ( pstmt->herr, sqlstat );
	341
	342	return SQL_ERROR;
	343	}
	344
	345	/* check state */
	346	if( pstmt->state >= en_stmt_needdata
	347	\|\| pstmt->asyn_on != en_NullProc )
	348	{
	349	PUSHSQLERR ( pstmt->herr, en_S1010 );
	350
	351	retcode = SQL_ERROR;
	352	}
	353
	354	hproc = _iodbcdm_getproc( pstmt->hdbc, en_BindParameter );
	355
	356	if( hproc == SQL_NULL_HPROC )
	357	{
	358	PUSHSQLERR ( pstmt->herr, en_IM001 );
	359
	360	return SQL_ERROR;
	361	}
	362
	363	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_BindParameter, (
	364	pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
	365	cbColDef, ibScale, rgbValue, cbValueMax, pcbValue ) )
1a6944fd RR	366
1a6944fd RR	367	#if 0
7e616b10 RR	368	retcode = hproc(pstmt->dhstmt, ipar, fParamType, fCType, fSqlType,
7e616b10 RR	369	cbColDef, ibScale, rgbValue, cbValueMax, pcbValue );
1a6944fd RR	370	#endif
1a6944fd RR	371
7e616b10	372	return retcode;
1a6944fd RR	373	}
	374
	375	RETCODE SQL_API SQLParamOptions(
7e616b10 RR	376	HSTMT hstmt,
	377	UDWORD crow,
	378	UDWORD FAR* pirow )
1a6944fd	379	{
7e616b10 RR	380	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	381	HPROC hproc;
	382	RETCODE retcode;
	383
	384	if( hstmt == SQL_NULL_HSTMT
	385	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	386	{
	387	return SQL_INVALID_HANDLE;
	388	}
1a6944fd	389
7e616b10 RR	390	if( crow == (UDWORD)0UL )
	391	{
	392	PUSHSQLERR ( pstmt->herr, en_S1107 );
1a6944fd	393
7e616b10 RR	394	return SQL_ERROR;
7e616b10 RR	395	}
1a6944fd	396
7e616b10 RR	397	if( pstmt->state >= en_stmt_needdata
	398	\|\| pstmt->asyn_on != en_NullProc )
	399	{
	400	PUSHSQLERR ( pstmt->herr, en_S1010 );
1a6944fd	401
7e616b10 RR	402	return SQL_ERROR;
7e616b10 RR	403	}
1a6944fd	404
7e616b10	405	hproc = _iodbcdm_getproc ( pstmt->hdbc, en_ParamOptions );
1a6944fd	406
7e616b10 RR	407	if( hproc == SQL_NULL_HPROC )
	408	{
	409	PUSHSQLERR ( pstmt->herr, en_IM001 );
1a6944fd	410
7e616b10 RR	411	return SQL_ERROR;
7e616b10 RR	412	}
1a6944fd	413
7e616b10 RR	414	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ParamOptions, (
7e616b10 RR	415	pstmt->dhstmt, crow, pirow) )
1a6944fd RR	416
1a6944fd RR	417	#if 0
7e616b10	418	retcode = hproc ( pstmt->dhstmt, crow, pirow );
1a6944fd RR	419	#endif
1a6944fd RR	420
7e616b10	421	return retcode;
1a6944fd RR	422	}
1a6944fd RR	423
7e616b10 RR	424	RETCODE SQL_API SQLSetScrollOptions(
	425	HSTMT hstmt,
	426	UWORD fConcurrency,
	427	SDWORD crowKeyset,
	428	UWORD crowRowset )
1a6944fd	429	{
7e616b10 RR	430	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	431	HPROC hproc;
	432	int sqlstat = en_00000;
	433	RETCODE retcode;
	434
	435	if( hstmt == SQL_NULL_HSTMT
	436	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	437	{
	438	return SQL_INVALID_HANDLE;
	439	}
	440
	441	for(;;)
	442	{
	443	if( crowRowset == (UWORD)0 )
	444	{
	445	sqlstat = en_S1107;
	446	break;
	447	}
	448
	449	if( crowKeyset > (SDWORD)0L && crowKeyset < (SDWORD)crowRowset )
	450	{
	451	sqlstat = en_S1107;
	452	break;
	453	}
	454
	455	if( crowKeyset < 1 )
	456	{
	457	if( crowKeyset != SQL_SCROLL_FORWARD_ONLY
	458	&& crowKeyset != SQL_SCROLL_STATIC
	459	&& crowKeyset != SQL_SCROLL_KEYSET_DRIVEN
	460	&& crowKeyset != SQL_SCROLL_DYNAMIC )
	461	{
	462	sqlstat = en_S1107;
	463	break;
	464	}
	465	}
	466
	467	if( fConcurrency != SQL_CONCUR_READ_ONLY
	468	&& fConcurrency != SQL_CONCUR_LOCK
	469	&& fConcurrency != SQL_CONCUR_ROWVER
	470	&& fConcurrency != SQL_CONCUR_VALUES )
	471	{
	472	sqlstat = en_S1108;
	473	break;
	474	}
	475
	476	if( pstmt->state != en_stmt_allocated )
	477	{
	478	sqlstat = en_S1010;
	479	break;
	480	}
	481
	482	hproc = _iodbcdm_getproc( pstmt->hdbc, en_SetScrollOptions );
	483
	484	if( hproc == SQL_NULL_HPROC )
	485	{
	486	sqlstat = en_IM001;
	487	break;
	488	}
	489
	490	sqlstat = en_00000;
	491	if( 1 ) /* turn off solaris warning message */
	492	break;
	493	}
494
495	if( sqlstat != en_00000 )
496	{
497	PUSHSQLERR ( pstmt->herr, sqlstat );
498
499	return SQL_ERROR;
500	}
501
502	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_SetScrollOptions, (
503	pstmt->dhstmt,
504	fConcurrency,
505	crowKeyset,
506	crowRowset ) )
1a6944fd RR	507
1a6944fd RR	508	#if 0
7e616b10 RR	509	retcode = hproc(pstmt->dhstmt,
	510	fConcurrency,
	511	crowKeyset,
	512	crowRowset );
1a6944fd RR	513	#endif
1a6944fd RR	514
7e616b10	515	return retcode;
1a6944fd RR	516	}
1a6944fd RR	517
7e616b10 RR	518	RETCODE SQL_API SQLSetParam (
	519	HSTMT hstmt,
	520	UWORD ipar,
	521	SWORD fCType,
	522	SWORD fSqlType,
	523	UDWORD cbColDef,
	524	SWORD ibScale,
	525	PTR rgbValue,
	526	SDWORD FAR *pcbValue)
1a6944fd	527	{
7e616b10 RR	528	return SQLBindParameter(hstmt,
	529	ipar,
	530	(SWORD)SQL_PARAM_INPUT_OUTPUT,
	531	fCType,
	532	fSqlType,
	533	cbColDef,
	534	ibScale,
	535	rgbValue,
	536	SQL_SETPARAM_VALUE_MAX,
	537	pcbValue );
1a6944fd	538	}