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

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

#include        <strings.h>
#include        <stdio.h>

RETCODE SQL_API SQLDataSources(
                        HENV            henv,
                        UWORD           fDir,
                        UCHAR  FAR*     szDSN,
                        SWORD           cbDSNMax,
                        SWORD  FAR*     pcbDSN,
                        UCHAR  FAR*     szDesc,
                        SWORD           cbDescMax,
                        SWORD  FAR*     pcbDesc )
{
        GENV_t FAR*     genv    = (GENV_t FAR*)henv;

        if( henv == SQL_NULL_HENV )
        {
                return SQL_INVALID_HANDLE;
        }

        /* check argument */
        if( cbDSNMax < 0 || cbDescMax < 0 )
        {
                PUSHSQLERR ( genv->herr, en_S1090 );

                return SQL_ERROR;
        }

        if( fDir != SQL_FETCH_FIRST
         && fDir != SQL_FETCH_NEXT )
        {
                PUSHSQLERR ( genv->herr, en_S1103 );

                return SQL_ERROR;
        }

        /*************************/

        return SQL_SUCCESS;
}

RETCODE SQL_API SQLDrivers(
                        HENV            henv,
                        UWORD           fDir,
                        UCHAR  FAR*     szDrvDesc,
                        SWORD           cbDrvDescMax,
                        SWORD  FAR*     pcbDrvDesc,
                        UCHAR  FAR*     szDrvAttr,
                        SWORD           cbDrvAttrMax,
                        SWORD  FAR*     pcbDrvAttr )
{
        GENV_t FAR*     genv    = (GENV_t FAR*)henv;

        if( henv == SQL_NULL_HENV )
        {
                return SQL_INVALID_HANDLE;
        }

        if( cbDrvDescMax <  0
         || cbDrvAttrMax <  0
         || cbDrvAttrMax == 1 )
        {
                PUSHSQLERR ( genv->herr, en_S1090 );

                return SQL_ERROR;
        }

        if( fDir != SQL_FETCH_FIRST
         || fDir != SQL_FETCH_NEXT )
        {
                PUSHSQLERR ( genv->herr, en_S1103 );

                return SQL_ERROR;
        }

        /*********************/
        return SQL_SUCCESS;
}


RETCODE SQL_API SQLGetInfo(
                        HDBC            hdbc,
                        UWORD           fInfoType,
                        PTR             rgbInfoValue,
                        SWORD           cbInfoValueMax,
                        SWORD FAR*      pcbInfoValue )
{
        DBC_t  FAR*     pdbc    = (DBC_t FAR*)hdbc;
        ENV_t  FAR*     penv;
        STMT_t FAR*     pstmt   = NULL;
        STMT_t FAR*     tpstmt;
        HPROC           hproc;
        RETCODE         retcode = SQL_SUCCESS;

        DWORD           dword;
        int             size = 0, len = 0;
        char            buf[16] = { '\0' };

        if( hdbc == SQL_NULL_HDBC
         || pdbc->henv == SQL_NULL_HENV )
        {
                return SQL_INVALID_HANDLE;
        }

        if( cbInfoValueMax < 0 )
        {
                PUSHSQLERR ( pdbc->herr, en_S1090 );

                return SQL_ERROR;
        }

        if( /* fInfoType < SQL_INFO_FIRST || */
            ( fInfoType > SQL_INFO_LAST
           && fInfoType < SQL_INFO_DRIVER_START ) )
        {
                PUSHSQLERR ( pdbc->herr, en_S1096 );

                return SQL_ERROR;
        }

        if( fInfoType == SQL_ODBC_VER )
        {
                sprintf( buf, "%02d.%02d",
                        (ODBCVER)>>8, 0x00FF&(ODBCVER) );


                if( rgbInfoValue != NULL
                 && cbInfoValueMax > 0 )
                {
                        len = STRLEN( buf );

                        if( len < cbInfoValueMax - 1 )
                        {
                                len = cbInfoValueMax - 1;
                                PUSHSQLERR ( pdbc->herr, en_01004 );

                                retcode = SQL_SUCCESS_WITH_INFO;
                        }

                        STRNCPY( rgbInfoValue, buf, len );
                        ((char FAR*)rgbInfoValue)[len] = '\0';
                }

                if( pcbInfoValue != NULL )
                {
                        *pcbInfoValue = (SWORD)len;
                }

                return retcode;
        }

        if( pdbc->state == en_dbc_allocated
         || pdbc->state == en_dbc_needdata )
        {
                PUSHSQLERR ( pdbc->herr, en_08003 );

                return SQL_ERROR;
        }

        switch( fInfoType )
        {
                case SQL_DRIVER_HDBC:
                        dword = (DWORD)(pdbc->dhdbc);
                        size  = sizeof(dword);
                        break;

                case SQL_DRIVER_HENV:
                        penv  = (ENV_t FAR*)(pdbc->henv);
                        dword = (DWORD)(penv->dhenv);
                        size  = sizeof(dword);
                        break;

                case SQL_DRIVER_HLIB:
                        penv  = (ENV_t FAR*)(pdbc->henv);
                        dword = (DWORD)(penv->hdll);
                        size  = sizeof(dword);
                        break;

                case SQL_DRIVER_HSTMT:
                        if( rgbInfoValue != NULL )
                        {
                                pstmt = *((STMT_t FAR**)rgbInfoValue);
                        }

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

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

                                return SQL_ERROR;
                        }

                        dword = (DWORD)(pstmt->dhstmt);
                        size  = sizeof(dword);
                        break;

                default:
                        break;
        }

        if( size )
        {
                if( rgbInfoValue != NULL )
                {
                        *((DWORD*)rgbInfoValue) = dword;
                }

                if( pcbInfoValue != NULL )
                {
                        *(pcbInfoValue) = (SWORD)size;
                }

                return SQL_SUCCESS;
        }

        hproc = _iodbcdm_getproc( hdbc, en_GetInfo );

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

                return SQL_ERROR;
        }

        CALL_DRIVER ( hdbc, retcode, hproc, en_GetInfo, (
                        pdbc->dhdbc,
                        fInfoType,
                        rgbInfoValue,
                        cbInfoValueMax,
                        pcbInfoValue ) )

#if 0
        retcode = hproc(pdbc->dhdbc,
                        fInfoType,
                        rgbInfoValue,
                        cbInfoValueMax,
                        pcbInfoValue );
#endif

        if( retcode == SQL_ERROR
         && fInfoType == SQL_DRIVER_ODBC_VER )
        {
                STRCPY( buf, "01.00" );

                if( rgbInfoValue != NULL
                 && cbInfoValueMax > 0 )
                {
                        len = STRLEN( buf );

                        if( len < cbInfoValueMax - 1 )
                        {
                                len = cbInfoValueMax - 1;
                                PUSHSQLERR ( pdbc->herr, en_01004 );
                        }

                        STRNCPY( rgbInfoValue, buf, len );
                        ((char FAR*)rgbInfoValue)[len] = '\0';
                }

                if( pcbInfoValue != NULL )
                {
                        *pcbInfoValue = (SWORD)len;
                }

                /* what should we return in this case ???? */
        }

        return retcode;
}

RETCODE SQL_API SQLGetFunctions(
                        HDBC            hdbc,
                        UWORD           fFunc,
                        UWORD FAR*      pfExists )
{
        DBC_t FAR*      pdbc    = (DBC_t FAR*)hdbc;
        HPROC           hproc;
        RETCODE         retcode;

        if( hdbc == SQL_NULL_HDBC )
        {
                return SQL_INVALID_HANDLE;
        }

        if( fFunc > SQL_EXT_API_LAST )
        {
                PUSHSQLERR ( pdbc->herr, en_S1095 );

                return SQL_ERROR;
        }

        if( pdbc->state == en_dbc_allocated
         || pdbc->state == en_dbc_needdata )
        {
                PUSHSQLERR ( pdbc->herr, en_S1010 );

                return SQL_ERROR;
        }

        if( pfExists == NULL )
        {
                return SQL_SUCCESS;
        }

        hproc = _iodbcdm_getproc( hdbc, en_GetFunctions );

        if( hproc != SQL_NULL_HPROC )
        {
                CALL_DRIVER ( hdbc, retcode, hproc, en_GetFunctions, (
                                pdbc->dhdbc, fFunc, pfExists ) )

#if 0
                retcode = hproc( pdbc->dhdbc, fFunc, pfExists );
#endif
                return retcode;
        }

        if( fFunc == SQL_API_SQLSETPARAM )
        {
                fFunc = SQL_API_SQLBINDPARAMETER;
        }

        if( fFunc != SQL_API_ALL_FUNCTIONS )
        {
                hproc = _iodbcdm_getproc( hdbc, fFunc );

                if( hproc == SQL_NULL_HPROC )
                {
                        *pfExists = (UWORD)0;
                }
                else
                {
                        *pfExists = (UWORD)1;
                }

                return SQL_SUCCESS;
        }

        for( fFunc=0 ; fFunc < 100; fFunc ++ )
        {
                hproc = _iodbcdm_getproc( hdbc, fFunc );

                if( hproc == SQL_NULL_HPROC )
                {
                        pfExists[fFunc] = (UWORD)0;
                }
                else
                {
                        pfExists[fFunc] = (UWORD)1;
                }
        }

        return SQL_SUCCESS;
}
Commit	Line	Data
1a6944fd	1	/** Information functions
7e616b10 RR	2
7e616b10 RR	3	Copyright (C) 1995 by Ke Jin <kejin@empress.com>
1a6944fd RR	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14	**/
	15
	16	#include <../iodbc/iodbc.h>
	17
	18	#include <../iodbc/isql.h>
	19	#include <../iodbc/isqlext.h>
	20
	21	#include <../iodbc/dlproc.h>
	22
	23	#include <../iodbc/herr.h>
	24	#include <../iodbc/henv.h>
	25	#include <../iodbc/hdbc.h>
	26	#include <../iodbc/hstmt.h>
	27
	28	#include <../iodbc/itrace.h>
	29
bd7d06f2 RR	30	#include <strings.h>
	31	#include <stdio.h>
	32
7e616b10 RR	33	RETCODE SQL_API SQLDataSources(
	34	HENV henv,
	35	UWORD fDir,
	36	UCHAR FAR* szDSN,
	37	SWORD cbDSNMax,
	38	SWORD FAR* pcbDSN,
	39	UCHAR FAR* szDesc,
	40	SWORD cbDescMax,
	41	SWORD FAR* pcbDesc )
1a6944fd	42	{
7e616b10 RR	43	GENV_t FAR* genv = (GENV_t FAR*)henv;
	44
	45	if( henv == SQL_NULL_HENV )
	46	{
	47	return SQL_INVALID_HANDLE;
	48	}
	49
	50	/* check argument */
	51	if( cbDSNMax < 0 \|\| cbDescMax < 0 )
	52	{
	53	PUSHSQLERR ( genv->herr, en_S1090 );
	54
	55	return SQL_ERROR;
	56	}
	57
	58	if( fDir != SQL_FETCH_FIRST
	59	&& fDir != SQL_FETCH_NEXT )
	60	{
	61	PUSHSQLERR ( genv->herr, en_S1103 );
	62
	63	return SQL_ERROR;
	64	}
	65
	66	/*************************/
	67
	68	return SQL_SUCCESS;
	69	}
	70
	71	RETCODE SQL_API SQLDrivers(
	72	HENV henv,
	73	UWORD fDir,
	74	UCHAR FAR* szDrvDesc,
	75	SWORD cbDrvDescMax,
	76	SWORD FAR* pcbDrvDesc,
	77	UCHAR FAR* szDrvAttr,
	78	SWORD cbDrvAttrMax,
	79	SWORD FAR* pcbDrvAttr )
1a6944fd	80	{
7e616b10 RR	81	GENV_t FAR* genv = (GENV_t FAR*)henv;
	82
	83	if( henv == SQL_NULL_HENV )
	84	{
	85	return SQL_INVALID_HANDLE;
	86	}
	87
	88	if( cbDrvDescMax < 0
	89	\|\| cbDrvAttrMax < 0
	90	\|\| cbDrvAttrMax == 1 )
	91	{
	92	PUSHSQLERR ( genv->herr, en_S1090 );
	93
	94	return SQL_ERROR;
	95	}
	96
	97	if( fDir != SQL_FETCH_FIRST
	98	\|\| fDir != SQL_FETCH_NEXT )
	99	{
	100	PUSHSQLERR ( genv->herr, en_S1103 );
	101
	102	return SQL_ERROR;
	103	}
	104
	105	/*********************/
	106	return SQL_SUCCESS;
1a6944fd RR	107	}
	108
	109
7e616b10 RR	110	RETCODE SQL_API SQLGetInfo(
	111	HDBC hdbc,
	112	UWORD fInfoType,
	113	PTR rgbInfoValue,
	114	SWORD cbInfoValueMax,
	115	SWORD FAR* pcbInfoValue )
1a6944fd	116	{
7e616b10 RR	117	DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
	118	ENV_t FAR* penv;
	119	STMT_t FAR* pstmt = NULL;
	120	STMT_t FAR* tpstmt;
	121	HPROC hproc;
	122	RETCODE retcode = SQL_SUCCESS;
	123
	124	DWORD dword;
	125	int size = 0, len = 0;
	126	char buf[16] = { '\0' };
	127
	128	if( hdbc == SQL_NULL_HDBC
	129	\|\| pdbc->henv == SQL_NULL_HENV )
	130	{
	131	return SQL_INVALID_HANDLE;
	132	}
	133
	134	if( cbInfoValueMax < 0 )
	135	{
	136	PUSHSQLERR ( pdbc->herr, en_S1090 );
	137
	138	return SQL_ERROR;
	139	}
	140
	141	if( /* fInfoType < SQL_INFO_FIRST \|\| */
	142	( fInfoType > SQL_INFO_LAST
	143	&& fInfoType < SQL_INFO_DRIVER_START ) )
	144	{
	145	PUSHSQLERR ( pdbc->herr, en_S1096 );
	146
	147	return SQL_ERROR;
	148	}
	149
	150	if( fInfoType == SQL_ODBC_VER )
	151	{
	152	sprintf( buf, "%02d.%02d",
	153	(ODBCVER)>>8, 0x00FF&(ODBCVER) );
	154
	155
	156	if( rgbInfoValue != NULL
	157	&& cbInfoValueMax > 0 )
	158	{
	159	len = STRLEN( buf );
	160
	161	if( len < cbInfoValueMax - 1 )
	162	{
	163	len = cbInfoValueMax - 1;
	164	PUSHSQLERR ( pdbc->herr, en_01004 );
	165
	166	retcode = SQL_SUCCESS_WITH_INFO;
	167	}
	168
	169	STRNCPY( rgbInfoValue, buf, len );
	170	((char FAR*)rgbInfoValue)[len] = '\0';
	171	}
	172
	173	if( pcbInfoValue != NULL )
	174	{
	175	*pcbInfoValue = (SWORD)len;
	176	}
	177
	178	return retcode;
	179	}
	180
181	if( pdbc->state == en_dbc_allocated
182	\|\| pdbc->state == en_dbc_needdata )
183	{
184	PUSHSQLERR ( pdbc->herr, en_08003 );
185
186	return SQL_ERROR;
187	}
188
189	switch( fInfoType )
190	{
191	case SQL_DRIVER_HDBC:
192	dword = (DWORD)(pdbc->dhdbc);
193	size = sizeof(dword);
194	break;
195
196	case SQL_DRIVER_HENV:
197	penv = (ENV_t FAR*)(pdbc->henv);
198	dword = (DWORD)(penv->dhenv);
199	size = sizeof(dword);
200	break;
201
202	case SQL_DRIVER_HLIB:
203	penv = (ENV_t FAR*)(pdbc->henv);
204	dword = (DWORD)(penv->hdll);
205	size = sizeof(dword);
206	break;
207
208	case SQL_DRIVER_HSTMT:
209	if( rgbInfoValue != NULL )
210	{
211	pstmt = ((STMT_t FAR*)rgbInfoValue);
212	}
213
214	for( tpstmt = (STMT_t FAR*)(pdbc->hstmt);
215	tpstmt != NULL;
216	tpstmt = tpstmt->next )
217	{
218	if( tpstmt == pstmt )
219	{
220	break;
221	}
222	}
223
224	if( tpstmt == NULL )
225	{
226	PUSHSQLERR ( pdbc->herr, en_S1009 );
227
228	return SQL_ERROR;
229	}
230
231	dword = (DWORD)(pstmt->dhstmt);
232	size = sizeof(dword);
233	break;
234
235	default:
236	break;
237	}
238
239	if( size )
240	{
241	if( rgbInfoValue != NULL )
242	{
243	((DWORD)rgbInfoValue) = dword;
244	}
245
246	if( pcbInfoValue != NULL )
247	{
248	*(pcbInfoValue) = (SWORD)size;
249	}
250
251	return SQL_SUCCESS;
252	}
253
254	hproc = _iodbcdm_getproc( hdbc, en_GetInfo );
255
256	if( hproc == SQL_NULL_HPROC )
257	{
258	PUSHSQLERR ( pdbc->herr, en_IM001 );
259
260	return SQL_ERROR;
261	}
262
263	CALL_DRIVER ( hdbc, retcode, hproc, en_GetInfo, (
264	pdbc->dhdbc,
265	fInfoType,
266	rgbInfoValue,
267	cbInfoValueMax,
268	pcbInfoValue ) )
1a6944fd RR	269
1a6944fd RR	270	#if 0
7e616b10 RR	271	retcode = hproc(pdbc->dhdbc,
	272	fInfoType,
	273	rgbInfoValue,
	274	cbInfoValueMax,
	275	pcbInfoValue );
1a6944fd RR	276	#endif
1a6944fd RR	277
7e616b10 RR	278	if( retcode == SQL_ERROR
	279	&& fInfoType == SQL_DRIVER_ODBC_VER )
	280	{
	281	STRCPY( buf, "01.00" );
1a6944fd	282
7e616b10 RR	283	if( rgbInfoValue != NULL
	284	&& cbInfoValueMax > 0 )
	285	{
	286	len = STRLEN( buf );
1a6944fd	287
7e616b10 RR	288	if( len < cbInfoValueMax - 1 )
	289	{
	290	len = cbInfoValueMax - 1;
	291	PUSHSQLERR ( pdbc->herr, en_01004 );
	292	}
1a6944fd	293
7e616b10 RR	294	STRNCPY( rgbInfoValue, buf, len );
	295	((char FAR*)rgbInfoValue)[len] = '\0';
	296	}
1a6944fd	297
7e616b10 RR	298	if( pcbInfoValue != NULL )
	299	{
	300	*pcbInfoValue = (SWORD)len;
	301	}
1a6944fd	302
7e616b10 RR	303	/* what should we return in this case ???? */
7e616b10 RR	304	}
1a6944fd	305
7e616b10 RR	306	return retcode;
7e616b10 RR	307	}
1a6944fd RR	308
1a6944fd RR	309	RETCODE SQL_API SQLGetFunctions(
7e616b10 RR	310	HDBC hdbc,
	311	UWORD fFunc,
	312	UWORD FAR* pfExists )
1a6944fd	313	{
7e616b10 RR	314	DBC_t FAR* pdbc = (DBC_t FAR*)hdbc;
	315	HPROC hproc;
	316	RETCODE retcode;
1a6944fd	317
7e616b10 RR	318	if( hdbc == SQL_NULL_HDBC )
	319	{
	320	return SQL_INVALID_HANDLE;
	321	}
1a6944fd	322
7e616b10 RR	323	if( fFunc > SQL_EXT_API_LAST )
	324	{
	325	PUSHSQLERR ( pdbc->herr, en_S1095 );
1a6944fd	326
7e616b10 RR	327	return SQL_ERROR;
7e616b10 RR	328	}
1a6944fd	329
7e616b10 RR	330	if( pdbc->state == en_dbc_allocated
	331	\|\| pdbc->state == en_dbc_needdata )
	332	{
	333	PUSHSQLERR ( pdbc->herr, en_S1010 );
1a6944fd	334
7e616b10 RR	335	return SQL_ERROR;
7e616b10 RR	336	}
1a6944fd	337
7e616b10 RR	338	if( pfExists == NULL )
	339	{
	340	return SQL_SUCCESS;
	341	}
1a6944fd	342
7e616b10	343	hproc = _iodbcdm_getproc( hdbc, en_GetFunctions );
1a6944fd	344
7e616b10 RR	345	if( hproc != SQL_NULL_HPROC )
	346	{
	347	CALL_DRIVER ( hdbc, retcode, hproc, en_GetFunctions, (
	348	pdbc->dhdbc, fFunc, pfExists ) )
1a6944fd RR	349
1a6944fd RR	350	#if 0
7e616b10	351	retcode = hproc( pdbc->dhdbc, fFunc, pfExists );
1a6944fd	352	#endif
7e616b10 RR	353	return retcode;
	354	}
	355
	356	if( fFunc == SQL_API_SQLSETPARAM )
	357	{
	358	fFunc = SQL_API_SQLBINDPARAMETER;
	359	}
	360
	361	if( fFunc != SQL_API_ALL_FUNCTIONS )
	362	{
	363	hproc = _iodbcdm_getproc( hdbc, fFunc );
	364
	365	if( hproc == SQL_NULL_HPROC )
	366	{
	367	*pfExists = (UWORD)0;
	368	}
	369	else
	370	{
	371	*pfExists = (UWORD)1;
	372	}
	373
	374	return SQL_SUCCESS;
	375	}
	376
	377	for( fFunc=0 ; fFunc < 100; fFunc ++ )
	378	{
	379	hproc = _iodbcdm_getproc( hdbc, fFunc );
	380
	381	if( hproc == SQL_NULL_HPROC )
	382	{
	383	pfExists[fFunc] = (UWORD)0;
	384	}
	385	else
	386	{
	387	pfExists[fFunc] = (UWORD)1;
	388	}
	389	}
	390
	391	return SQL_SUCCESS;
1a6944fd	392	}