src/iodbc/result.c

/*
 *  result.c
 *
 *  $Id$
 *
 *  Prepare for getting query result
 *
 *  The iODBC driver manager.
 *
 *  Copyright (C) 1995 by Ke Jin <kejin@empress.com>
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include	"config.h"

#include	"isql.h"
#include	"isqlext.h"

#include        "dlproc.h"

#include	"herr.h"
#include	"henv.h"
#include	"hdbc.h"
#include	"hstmt.h"

#include	"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))

  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))

  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))

  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))

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

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

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