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

/** Prepare for getting query result

    Copyright (C) 1995 by Ke Jin <kejin@empress.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
**/

#include	<../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 SQLBindCol (
                        HSTMT           hstmt,
                        UWORD           icol,
                        SWORD           fCType,
                        PTR             rgbValue,
                        SDWORD          cbValueMax,
                        SDWORD FAR*     pcbValue )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc   = SQL_NULL_HPROC;
        RETCODE         retcode;

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

        /* check argument */
        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:
                        PUSHSQLERR ( pstmt->herr, en_S1003);
                        return SQL_ERROR;
        }

        if( cbValueMax < 0 )
        {
                PUSHSQLERR ( pstmt->herr, en_S1090 );

                return SQL_ERROR;
        }

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

        /* call driver's function */
        hproc = _iodbcdm_getproc( pstmt->hdbc, en_BindCol );

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_BindCol, (
                        pstmt->dhstmt,
                        icol,
                        fCType,
                        rgbValue,
                        cbValueMax,
                        pcbValue ) )

#if 0
        retcode = hproc(pstmt->dhstmt,
                        icol,
                        fCType,
                        rgbValue,
                        cbValueMax,
                        pcbValue );
#endif

        return retcode;
}

RETCODE SQL_API SQLGetCursorName(
                        HSTMT           hstmt,
                        UCHAR FAR*      szCursor,
                        SWORD           cbCursorMax,
                        SWORD FAR*      pcbCursor )
{
        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( cbCursorMax < (SWORD)0 )
        {
                PUSHSQLERR ( pstmt->herr, en_S1090 );

                return SQL_ERROR;
        }

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

                return SQL_ERROR;
        }

        if( pstmt->state < en_stmt_cursoropen
         && pstmt->cursor_state == en_stmt_cursor_no )
        {
                PUSHSQLERR ( pstmt->herr, en_S1015 );

                return SQL_ERROR;
        }

        /* call driver's function */
        hproc = _iodbcdm_getproc ( pstmt->hdbc, en_GetCursorName );

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetCursorName, (
                        pstmt->dhstmt,
                        szCursor,
                        cbCursorMax,
                        pcbCursor ) )

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

        return retcode;
}

RETCODE SQL_API SQLRowCount(
                        HSTMT           hstmt,
                        SDWORD FAR*     pcrow )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc;
        RETCODE         retcode;

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

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_RowCount, (
                        pstmt->dhstmt, pcrow) )

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

        return retcode;
}

RETCODE SQL_API SQLNumResultCols(
                        HSTMT           hstmt,
                        SWORD FAR*      pccol )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc;
        RETCODE         retcode;
        SWORD           ccol;

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

        /* check state */
        if( pstmt->asyn_on == en_NullProc )
        {
                if( pstmt->state == en_stmt_allocated
                 || pstmt->state >= en_stmt_needdata )
                {
                        PUSHSQLERR ( pstmt->herr, en_S1010 );
                        return SQL_ERROR;
                }
        }
        else if( pstmt->asyn_on != en_NumResultCols )
        {
                PUSHSQLERR ( pstmt->herr, en_S1010 );

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc,  retcode, hproc, en_NumResultCols, (
                        pstmt->dhstmt, &ccol) )

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

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

                        case SQL_STILL_EXECUTING:
                        default:
                                break;
                }
        }

        switch( retcode )
        {
                case SQL_SUCCESS:
                case SQL_SUCCESS_WITH_INFO:
                        break;

                case SQL_STILL_EXECUTING:
                        ccol = 0;
                        pstmt->asyn_on = en_NumResultCols;
                        break;

                default:
                        ccol = 0;
                        break;
        }

        if( pccol )
        {
                *pccol = ccol;
        }

        return retcode;
}

RETCODE SQL_API SQLDescribeCol(
                        HSTMT           hstmt,
                        UWORD           icol,
                        UCHAR  FAR*     szColName,
                        SWORD           cbColNameMax,
                        SWORD  FAR*     pcbColName,
                        SWORD  FAR*     pfSqlType,
                        UDWORD FAR*     pcbColDef,
                        SWORD  FAR*     pibScale,
                        SWORD  FAR*     pfNullable )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc;
        RETCODE         retcode;
        int             sqlstat = en_00000;

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

        /* check arguments */
        if( icol == 0 )
        {
                sqlstat = en_S1002;
        }
        else if( cbColNameMax < 0 )
        {
                sqlstat = en_S1090;
        }

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

                return SQL_ERROR;
        }

        /* check state */
        if( pstmt->asyn_on == en_NullProc )
        {
                if( pstmt->asyn_on == en_stmt_allocated
                 || pstmt->asyn_on >= en_stmt_needdata )
                {
                        sqlstat = en_S1010;
                }
        }
        else if( pstmt->asyn_on != en_DescribeCol )
        {
                sqlstat = en_S1010;
        }

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_DescribeCol, (
                        pstmt->dhstmt,
                        icol,
                        szColName,
                        cbColNameMax,
                        pcbColName,
                        pfSqlType,
                        pcbColDef,
                        pibScale,
                        pfNullable) )

#if 0
        retcode = hproc(pstmt->dhstmt,
                        icol,
                        szColName,
                        cbColNameMax,
                        pcbColName,
                        pfSqlType,
                        pcbColDef,
                        pibScale,
                        pfNullable );
#endif

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

                        default:
                                return retcode;
                }
        }

        switch( pstmt->state )
        {
                case en_stmt_prepared:
                case en_stmt_cursoropen:
                case en_stmt_fetched:
                case en_stmt_xfetched:
                        if( retcode == SQL_STILL_EXECUTING )
                        {
                                pstmt->asyn_on = en_DescribeCol;
                        }
                        break;

                default:
                        break;
        }

        return retcode;
}

RETCODE SQL_API SQLColAttributes(
                        HSTMT           hstmt,
                        UWORD           icol,
                        UWORD           fDescType,
                        PTR             rgbDesc,
                        SWORD           cbDescMax,
                        SWORD  FAR*     pcbDesc,
                        SDWORD FAR*     pfDesc )
{
        STMT_t FAR*     pstmt   = (STMT_t FAR*)hstmt;
        HPROC           hproc;
        RETCODE         retcode;
        int             sqlstat = en_00000;

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

        /* check arguments */
        if( icol == 0 && fDescType != SQL_COLUMN_COUNT )
        {
                sqlstat = en_S1002;
        }
        else if( cbDescMax < 0 )
        {
                sqlstat = en_S1090;
        }
        else if(/* fDescType < SQL_COLATT_OPT_MIN || */ /* turnoff warning */
                 ( fDescType > SQL_COLATT_OPT_MAX
                && fDescType < SQL_COLUMN_DRIVER_START ) )
        {
                sqlstat = en_S1091;
        }

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

                return SQL_ERROR;
        }

        /* check state */
        if( pstmt->asyn_on == en_NullProc )
        {
                if( pstmt->asyn_on == en_stmt_allocated
                 || pstmt->asyn_on >= en_stmt_needdata )
                {
                        sqlstat = en_S1010;
                }
        }
        else if( pstmt->asyn_on != en_ColAttributes )
        {
                sqlstat = en_S1010;
        }

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

                return SQL_ERROR;
        }

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

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( pstmt->hdbc,  retcode, hproc, en_ColAttributes, (
                        pstmt->dhstmt,
                        icol,
                        fDescType,
                        rgbDesc,
                        cbDescMax,
                        pcbDesc,
                        pfDesc) )

#if 0
        retcode = hproc(pstmt->dhstmt,
                        icol,
                        fDescType,
                        rgbDesc,
                        cbDescMax,
                        pcbDesc,
                        pfDesc );
#endif

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

                        default:
                                return retcode;
                }
        }

        switch( pstmt->state )
        {
                case en_stmt_prepared:
                case en_stmt_cursoropen:
                case en_stmt_fetched:
                case en_stmt_xfetched:
                        if( retcode == SQL_STILL_EXECUTING )
                        {
                                pstmt->asyn_on = en_ColAttributes;
                        }
                        break;

                default:
                        break;
        }

        return retcode;
}
Commit	Line	Data
1a6944fd	1	/** Prepare for getting query result
7e616b10 RR	2
7e616b10 RR	3	Copyright (C) 1995 by Ke Jin <kejin@empress.com>
1a6944fd RR	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14	**/
	15
	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 SQLBindCol (
	31	HSTMT hstmt,
	32	UWORD icol,
	33	SWORD fCType,
	34	PTR rgbValue,
	35	SDWORD cbValueMax,
	36	SDWORD FAR* pcbValue )
1a6944fd	37	{
7e616b10 RR	38	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	39	HPROC hproc = SQL_NULL_HPROC;
	40	RETCODE retcode;
	41
	42	if( hstmt == SQL_NULL_HSTMT
	43	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	44	{
	45	return SQL_INVALID_HANDLE;
	46	}
	47
	48	/* check argument */
	49	switch(fCType)
	50	{
	51	case SQL_C_DEFAULT:
	52	case SQL_C_CHAR:
	53	case SQL_C_BINARY:
	54	case SQL_C_BIT:
	55	case SQL_C_TINYINT:
	56	case SQL_C_STINYINT:
	57	case SQL_C_UTINYINT:
	58	case SQL_C_SHORT:
	59	case SQL_C_SSHORT:
	60	case SQL_C_USHORT:
	61	case SQL_C_LONG:
	62	case SQL_C_SLONG:
	63	case SQL_C_ULONG:
	64	case SQL_C_FLOAT:
	65	case SQL_C_DOUBLE:
	66	case SQL_C_DATE:
	67	case SQL_C_TIME:
	68	case SQL_C_TIMESTAMP:
	69	break;
	70
	71	default:
	72	PUSHSQLERR ( pstmt->herr, en_S1003);
	73	return SQL_ERROR;
	74	}
	75
	76	if( cbValueMax < 0 )
	77	{
	78	PUSHSQLERR ( pstmt->herr, en_S1090 );
	79
	80	return SQL_ERROR;
	81	}
	82
	83	/* check state */
	84	if( pstmt->state > en_stmt_needdata
	85	\|\| pstmt->asyn_on != en_NullProc )
	86	{
	87	PUSHSQLERR ( pstmt->herr, en_S1010 );
	88	return SQL_ERROR;
	89	}
	90
	91	/* call driver's function */
	92	hproc = _iodbcdm_getproc( pstmt->hdbc, en_BindCol );
	93
	94	if( hproc == SQL_NULL_HPROC )
	95	{
	96	PUSHSQLERR ( pstmt->herr, en_IM001 );
	97
	98	return SQL_ERROR;
	99	}
	100
	101	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_BindCol, (
102	pstmt->dhstmt,
103	icol,
104	fCType,
105	rgbValue,
106	cbValueMax,
107	pcbValue ) )
1a6944fd RR	108
1a6944fd RR	109	#if 0
7e616b10 RR	110	retcode = hproc(pstmt->dhstmt,
	111	icol,
	112	fCType,
	113	rgbValue,
	114	cbValueMax,
	115	pcbValue );
1a6944fd RR	116	#endif
1a6944fd RR	117
7e616b10	118	return retcode;
1a6944fd RR	119	}
1a6944fd RR	120
7e616b10 RR	121	RETCODE SQL_API SQLGetCursorName(
	122	HSTMT hstmt,
	123	UCHAR FAR* szCursor,
	124	SWORD cbCursorMax,
	125	SWORD FAR* pcbCursor )
1a6944fd	126	{
7e616b10 RR	127	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	128	HPROC hproc;
	129	RETCODE retcode;
	130
	131	if( hstmt == SQL_NULL_HSTMT
	132	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	133	{
	134	return SQL_INVALID_HANDLE;
	135	}
	136
	137	/* check argument */
	138	if( cbCursorMax < (SWORD)0 )
	139	{
	140	PUSHSQLERR ( pstmt->herr, en_S1090 );
	141
	142	return SQL_ERROR;
	143	}
	144
	145	/* check state */
	146	if( pstmt->state >= en_stmt_needdata
	147	\|\| pstmt->asyn_on != en_NullProc )
	148	{
	149	PUSHSQLERR ( pstmt->herr, en_S1010 );
	150
	151	return SQL_ERROR;
	152	}
	153
	154	if( pstmt->state < en_stmt_cursoropen
	155	&& pstmt->cursor_state == en_stmt_cursor_no )
	156	{
	157	PUSHSQLERR ( pstmt->herr, en_S1015 );
	158
	159	return SQL_ERROR;
	160	}
	161
	162	/* call driver's function */
	163	hproc = _iodbcdm_getproc ( pstmt->hdbc, en_GetCursorName );
	164
	165	if( hproc == SQL_NULL_HPROC )
	166	{
	167	PUSHSQLERR ( pstmt->herr, en_IM001 );
	168
	169	return SQL_ERROR;
	170	}
	171
	172	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetCursorName, (
	173	pstmt->dhstmt,
	174	szCursor,
	175	cbCursorMax,
	176	pcbCursor ) )
1a6944fd RR	177
1a6944fd RR	178	#if 0
7e616b10 RR	179	retcode = hproc(pstmt->dhstmt,
	180	szCursor,
	181	cbCursorMax,
	182	pcbCursor );
1a6944fd RR	183	#endif
1a6944fd RR	184
7e616b10	185	return retcode;
1a6944fd RR	186	}
1a6944fd RR	187
7e616b10 RR	188	RETCODE SQL_API SQLRowCount(
	189	HSTMT hstmt,
	190	SDWORD FAR* pcrow )
1a6944fd	191	{
7e616b10 RR	192	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	193	HPROC hproc;
	194	RETCODE retcode;
1a6944fd	195
7e616b10 RR	196	if( hstmt == SQL_NULL_HSTMT
	197	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	198	{
	199	return SQL_INVALID_HANDLE;
	200	}
1a6944fd	201
7e616b10 RR	202	/* check state */
	203	if( pstmt->state >= en_stmt_needdata
	204	\|\| pstmt->state <= en_stmt_prepared
	205	\|\| pstmt->asyn_on != en_NullProc )
	206	{
	207	PUSHSQLERR ( pstmt->herr, en_S1010 );
1a6944fd	208
7e616b10 RR	209	return SQL_ERROR;
7e616b10 RR	210	}
1a6944fd	211
7e616b10 RR	212	/* call driver */
7e616b10 RR	213	hproc = _iodbcdm_getproc( pstmt->hdbc, en_RowCount );
1a6944fd	214
7e616b10 RR	215	if( hproc == SQL_NULL_HPROC )
	216	{
	217	PUSHSQLERR ( pstmt->herr, en_IM001 );
1a6944fd	218
7e616b10 RR	219	return SQL_ERROR;
7e616b10 RR	220	}
1a6944fd	221
7e616b10 RR	222	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_RowCount, (
7e616b10 RR	223	pstmt->dhstmt, pcrow) )
1a6944fd RR	224
1a6944fd RR	225	#if 0
7e616b10	226	retcode = hproc ( pstmt->dhstmt, pcrow );
1a6944fd RR	227	#endif
1a6944fd RR	228
7e616b10	229	return retcode;
1a6944fd RR	230	}
1a6944fd RR	231
7e616b10 RR	232	RETCODE SQL_API SQLNumResultCols(
	233	HSTMT hstmt,
	234	SWORD FAR* pccol )
1a6944fd	235	{
7e616b10 RR	236	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	237	HPROC hproc;
	238	RETCODE retcode;
	239	SWORD ccol;
	240
	241	if( hstmt == SQL_NULL_HSTMT
	242	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	243	{
	244	return SQL_INVALID_HANDLE;
	245	}
	246
	247	/* check state */
	248	if( pstmt->asyn_on == en_NullProc )
	249	{
	250	if( pstmt->state == en_stmt_allocated
	251	\|\| pstmt->state >= en_stmt_needdata )
	252	{
	253	PUSHSQLERR ( pstmt->herr, en_S1010 );
	254	return SQL_ERROR;
	255	}
	256	}
	257	else if( pstmt->asyn_on != en_NumResultCols )
	258	{
	259	PUSHSQLERR ( pstmt->herr, en_S1010 );
	260
	261	return SQL_ERROR;
	262	}
	263
	264	/* call driver */
	265	hproc = _iodbcdm_getproc( pstmt->hdbc, en_NumResultCols );
	266
	267	if( hproc == SQL_NULL_HPROC )
	268	{
	269	PUSHSQLERR ( pstmt->herr, en_IM001 );
	270
	271	return SQL_ERROR;
	272	}
	273
	274	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_NumResultCols, (
	275	pstmt->dhstmt, &ccol) )
1a6944fd RR	276
1a6944fd RR	277	#if 0
7e616b10	278	retcode = hproc( pstmt->dhstmt, &ccol );
1a6944fd RR	279	#endif
1a6944fd RR	280
7e616b10 RR	281	/* state transition */
	282	if( pstmt->asyn_on == en_NumResultCols )
	283	{
	284	switch( retcode )
	285	{
	286	case SQL_SUCCESS:
	287	case SQL_SUCCESS_WITH_INFO:
	288	case SQL_ERROR:
	289	pstmt->asyn_on = en_NullProc;
	290
	291	case SQL_STILL_EXECUTING:
	292	default:
	293	break;
	294	}
	295	}
	296
	297	switch( retcode )
	298	{
	299	case SQL_SUCCESS:
	300	case SQL_SUCCESS_WITH_INFO:
	301	break;
	302
	303	case SQL_STILL_EXECUTING:
	304	ccol = 0;
	305	pstmt->asyn_on = en_NumResultCols;
	306	break;
	307
	308	default:
	309	ccol = 0;
	310	break;
	311	}
	312
	313	if( pccol )
	314	{
	315	*pccol = ccol;
	316	}
	317
	318	return retcode;
1a6944fd RR	319	}
1a6944fd RR	320
7e616b10 RR	321	RETCODE SQL_API SQLDescribeCol(
	322	HSTMT hstmt,
	323	UWORD icol,
	324	UCHAR FAR* szColName,
	325	SWORD cbColNameMax,
	326	SWORD FAR* pcbColName,
	327	SWORD FAR* pfSqlType,
	328	UDWORD FAR* pcbColDef,
	329	SWORD FAR* pibScale,
	330	SWORD FAR* pfNullable )
1a6944fd	331	{
7e616b10 RR	332	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	333	HPROC hproc;
	334	RETCODE retcode;
	335	int sqlstat = en_00000;
	336
	337	if( hstmt == SQL_NULL_HSTMT
	338	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	339	{
	340	return SQL_INVALID_HANDLE;
	341	}
	342
	343	/* check arguments */
	344	if( icol == 0 )
	345	{
	346	sqlstat = en_S1002;
	347	}
	348	else if( cbColNameMax < 0 )
	349	{
	350	sqlstat = en_S1090;
	351	}
	352
	353	if( sqlstat != en_00000 )
	354	{
	355	PUSHSQLERR ( pstmt->herr, sqlstat );
	356
	357	return SQL_ERROR;
	358	}
	359
	360	/* check state */
	361	if( pstmt->asyn_on == en_NullProc )
	362	{
	363	if( pstmt->asyn_on == en_stmt_allocated
	364	\|\| pstmt->asyn_on >= en_stmt_needdata )
	365	{
	366	sqlstat = en_S1010;
	367	}
	368	}
	369	else if( pstmt->asyn_on != en_DescribeCol )
	370	{
	371	sqlstat = en_S1010;
	372	}
	373
	374	if( sqlstat != en_00000 )
	375	{
	376	PUSHSQLERR ( pstmt->herr, sqlstat );
	377
	378	return SQL_ERROR;
	379	}
	380
	381	/* call driver */
	382	hproc = _iodbcdm_getproc( pstmt->hdbc, en_DescribeCol );
	383
	384	if( hproc == SQL_NULL_HPROC )
	385	{
	386	PUSHSQLERR ( pstmt->herr, en_IM001 );
	387
	388	return SQL_ERROR;
	389	}
	390
	391	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_DescribeCol, (
	392	pstmt->dhstmt,
	393	icol,
	394	szColName,
	395	cbColNameMax,
396	pcbColName,
397	pfSqlType,
398	pcbColDef,
399	pibScale,
400	pfNullable) )
1a6944fd RR	401
1a6944fd RR	402	#if 0
7e616b10 RR	403	retcode = hproc(pstmt->dhstmt,
	404	icol,
	405	szColName,
	406	cbColNameMax,
	407	pcbColName,
	408	pfSqlType,
	409	pcbColDef,
	410	pibScale,
	411	pfNullable );
1a6944fd RR	412	#endif
1a6944fd RR	413
7e616b10 RR	414	/* state transition */
	415	if( pstmt->asyn_on == en_DescribeCol )
	416	{
	417	switch( retcode )
	418	{
	419	case SQL_SUCCESS:
	420	case SQL_SUCCESS_WITH_INFO:
	421	case SQL_ERROR:
	422	pstmt->asyn_on = en_NullProc;
	423	break;
	424
	425	default:
	426	return retcode;
	427	}
	428	}
	429
	430	switch( pstmt->state )
	431	{
	432	case en_stmt_prepared:
	433	case en_stmt_cursoropen:
	434	case en_stmt_fetched:
	435	case en_stmt_xfetched:
	436	if( retcode == SQL_STILL_EXECUTING )
	437	{
	438	pstmt->asyn_on = en_DescribeCol;
	439	}
	440	break;
	441
	442	default:
	443	break;
	444	}
	445
	446	return retcode;
1a6944fd RR	447	}
1a6944fd RR	448
7e616b10 RR	449	RETCODE SQL_API SQLColAttributes(
	450	HSTMT hstmt,
	451	UWORD icol,
	452	UWORD fDescType,
	453	PTR rgbDesc,
	454	SWORD cbDescMax,
	455	SWORD FAR* pcbDesc,
	456	SDWORD FAR* pfDesc )
1a6944fd	457	{
7e616b10 RR	458	STMT_t FAR* pstmt = (STMT_t FAR*)hstmt;
	459	HPROC hproc;
	460	RETCODE retcode;
	461	int sqlstat = en_00000;
	462
	463	if( hstmt == SQL_NULL_HSTMT
	464	\|\| pstmt->hdbc == SQL_NULL_HDBC )
	465	{
	466	return SQL_INVALID_HANDLE;
	467	}
	468
	469	/* check arguments */
	470	if( icol == 0 && fDescType != SQL_COLUMN_COUNT )
	471	{
	472	sqlstat = en_S1002;
	473	}
	474	else if( cbDescMax < 0 )
	475	{
	476	sqlstat = en_S1090;
	477	}
	478	else if(/* fDescType < SQL_COLATT_OPT_MIN \|\| / / turnoff warning */
	479	( fDescType > SQL_COLATT_OPT_MAX
	480	&& fDescType < SQL_COLUMN_DRIVER_START ) )
	481	{
	482	sqlstat = en_S1091;
	483	}
	484
	485	if( sqlstat != en_00000 )
	486	{
	487	PUSHSQLERR ( pstmt->herr, sqlstat );
	488
	489	return SQL_ERROR;
	490	}
	491
	492	/* check state */
	493	if( pstmt->asyn_on == en_NullProc )
	494	{
	495	if( pstmt->asyn_on == en_stmt_allocated
	496	\|\| pstmt->asyn_on >= en_stmt_needdata )
	497	{
	498	sqlstat = en_S1010;
	499	}
	500	}
	501	else if( pstmt->asyn_on != en_ColAttributes )
	502	{
	503	sqlstat = en_S1010;
	504	}
	505
	506	if( sqlstat != en_00000 )
	507	{
	508	PUSHSQLERR ( pstmt->herr, sqlstat );
	509
	510	return SQL_ERROR;
	511	}
	512
	513	/* call driver */
	514	hproc = _iodbcdm_getproc( pstmt->hdbc, en_ColAttributes );
	515
	516	if( hproc == SQL_NULL_HPROC )
	517	{
	518	PUSHSQLERR ( pstmt->herr, en_IM001 );
	519
	520	return SQL_ERROR;
	521	}
522
523	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_ColAttributes, (
524	pstmt->dhstmt,
525	icol,
526	fDescType,
527	rgbDesc,
528	cbDescMax,
529	pcbDesc,
530	pfDesc) )
1a6944fd RR	531
1a6944fd RR	532	#if 0
7e616b10 RR	533	retcode = hproc(pstmt->dhstmt,
	534	icol,
	535	fDescType,
	536	rgbDesc,
	537	cbDescMax,
	538	pcbDesc,
	539	pfDesc );
1a6944fd RR	540	#endif
1a6944fd RR	541
7e616b10 RR	542	/* state transition */
	543	if( pstmt->asyn_on == en_ColAttributes )
	544	{
	545	switch( retcode )
	546	{
	547	case SQL_SUCCESS:
	548	case SQL_SUCCESS_WITH_INFO:
	549	case SQL_ERROR:
	550	pstmt->asyn_on = en_NullProc;
	551	break;
	552
	553	default:
	554	return retcode;
	555	}
	556	}
	557
	558	switch( pstmt->state )
	559	{
	560	case en_stmt_prepared:
	561	case en_stmt_cursoropen:
	562	case en_stmt_fetched:
	563	case en_stmt_xfetched:
	564	if( retcode == SQL_STILL_EXECUTING )
	565	{
	566	pstmt->asyn_on = en_ColAttributes;
	567	}
	568	break;
	569
	570	default:
	571	break;
	572	}
	573
	574	return retcode;
1a6944fd	575	}