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

/*
 *  hstmt.c
 *
 *  $Id$
 *
 *  Query statement object management functions
 *
 *  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 
SQLAllocStmt (
    HDBC hdbc,
    HSTMT FAR * phstmt)
{
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  STMT_t FAR *pstmt = NULL;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode = SQL_SUCCESS;

#if (ODBCVER >= 0x0300)
  if (hdbc == SQL_NULL_HDBC || pdbc->type != SQL_HANDLE_DBC)
#else
  if (hdbc == SQL_NULL_HDBC)
#endif
    {
      return SQL_INVALID_HANDLE;
    }

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

      return SQL_ERROR;
    }

  /* check state */
  switch (pdbc->state)
     {
     case en_dbc_connected:
     case en_dbc_hstmt:
       break;

     case en_dbc_allocated:
     case en_dbc_needdata:
       PUSHSQLERR (pdbc->herr, en_08003);
       *phstmt = SQL_NULL_HSTMT;
       return SQL_ERROR;

     default:
       return SQL_INVALID_HANDLE;
     }

  pstmt = (STMT_t FAR *) MEM_ALLOC (sizeof (STMT_t));

  if (pstmt == NULL)
    {
      PUSHSQLERR (pdbc->herr, en_S1001);
      *phstmt = SQL_NULL_HSTMT;

      return SQL_ERROR;
    }

#if (ODBCVER >= 0x0300)
  pstmt->type = SQL_HANDLE_STMT;
#endif

  /* initiate the object */
  pstmt->herr = SQL_NULL_HERR;
  pstmt->hdbc = hdbc;
  pstmt->state = en_stmt_allocated;
  pstmt->cursor_state = en_stmt_cursor_no;
  pstmt->prep_state = 0;
  pstmt->asyn_on = en_NullProc;
  pstmt->need_on = en_NullProc;

  /* call driver's function */

#if (ODBCVER >= 0x0300)
  hproc = _iodbcdm_getproc (hdbc, en_AllocHandle);

  if (hproc)
    {
      CALL_DRIVER (pstmt->hdbc, hdbc, retcode, hproc, en_AllocHandle, 
        (SQL_HANDLE_STMT, pdbc->dhdbc, &(pstmt->dhstmt)))
    }
  else
#endif

    {
      hproc = _iodbcdm_getproc (hdbc, en_AllocStmt);

      if (hproc == SQL_NULL_HPROC)
	{
	  PUSHSQLERR (pstmt->herr, en_IM001);
	  *phstmt = SQL_NULL_HSTMT;
	  MEM_FREE (pstmt);

	  return SQL_ERROR;
	}

      CALL_DRIVER (hdbc, retcode, hproc, en_AllocStmt, 
        (pdbc->dhdbc, &(pstmt->dhstmt)))
    }

  if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
    {
      *phstmt = SQL_NULL_HSTMT;
      MEM_FREE (pstmt);

      return retcode;
    }

  /* insert into list */
  pstmt->next = pdbc->hstmt;
  pdbc->hstmt = pstmt;

  *phstmt = (HSTMT) pstmt;

  /* state transition */
  pdbc->state = en_dbc_hstmt;

  return SQL_SUCCESS;
}


RETCODE 
_iodbcdm_dropstmt (HSTMT hstmt)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  STMT_t FAR *tpstmt;
  DBC_t FAR *pdbc;

  if (hstmt == SQL_NULL_HSTMT)
    {
      return SQL_INVALID_HANDLE;
    }

  pdbc = (DBC_t FAR *) (pstmt->hdbc);

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

      if (tpstmt->next == pstmt)
	{
	  tpstmt->next = pstmt->next;
	  break;
	}
    }

  if (tpstmt == NULL)
    {
      return SQL_INVALID_HANDLE;
    }

  _iodbcdm_freesqlerrlist (pstmt->herr);
  MEM_FREE (hstmt);

  return SQL_SUCCESS;
}


RETCODE SQL_API 
SQLFreeStmt (
    HSTMT hstmt,
    UWORD fOption)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  STMT_t FAR *tpstmt;
  DBC_t FAR *pdbc;

  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;

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

  pdbc = (DBC_t FAR *) (pstmt->hdbc);

  /* check option */
  switch (fOption)
     {
     case SQL_DROP:
     case SQL_CLOSE:
     case SQL_UNBIND:
     case SQL_RESET_PARAMS:
       break;

     default:
       PUSHSQLERR (pstmt->herr, en_S1092);
       return SQL_ERROR;
     }

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

      return SQL_ERROR;
    }

  hproc = SQL_NULL_HPROC;

#if (ODBCVER >= 0x0300)
  if (fOption == SQL_DROP)
    {
      hproc = _iodbcdm_getproc (pstmt->hdbc, en_FreeHandle);

      if (hproc)
	{
	  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_FreeHandle, 
	    (SQL_HANDLE_STMT, pstmt->dhstmt))
	}
    }
#endif

  if (hproc == SQL_NULL_HPROC)
    {
      hproc = _iodbcdm_getproc (pstmt->hdbc, en_FreeStmt);

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

	  return SQL_ERROR;
	}

      CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_FreeStmt, 
	(pstmt->dhstmt, fOption))
    }

  if (retcode != SQL_SUCCESS
      && retcode != SQL_SUCCESS_WITH_INFO)
    {
      return retcode;
    }

  /* state transition */
  switch (fOption)
     {
     case SQL_DROP:
       /* delet this object (ignore return) */
       _iodbcdm_dropstmt (hstmt);
       break;

     case SQL_CLOSE:
       pstmt->cursor_state = en_stmt_cursor_no;
       /* This means cursor name set by
        * SQLSetCursorName() call will also 
        * be erased.
        */

       switch (pstmt->state)
	  {
	  case en_stmt_allocated:
	  case en_stmt_prepared:
	    break;

	  case en_stmt_executed:
	  case en_stmt_cursoropen:
	  case en_stmt_fetched:
	  case en_stmt_xfetched:
	    if (pstmt->prep_state)
	      {
		pstmt->state =
		    en_stmt_prepared;
	      }
	    else
	      {
		pstmt->state =
		    en_stmt_allocated;
	      }
	    break;

	  default:
	    break;
	  }
       break;

     case SQL_UNBIND:
     case SQL_RESET_PARAMS:
     default:
       break;
     }

  return retcode;
}


RETCODE SQL_API 
SQLSetStmtOption (
    HSTMT hstmt,
    UWORD fOption,
    UDWORD vParam)
{
  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;
    }

  /* check option */
  if (				/* fOption < SQL_STMT_OPT_MIN || */
      fOption > SQL_STMT_OPT_MAX)
    {
      PUSHSQLERR (pstmt->herr, en_S1092);

      return SQL_ERROR;
    }

  if (fOption == SQL_CONCURRENCY
      || fOption == SQL_CURSOR_TYPE
      || fOption == SQL_SIMULATE_CURSOR
      || fOption == SQL_USE_BOOKMARKS)
    {
      if (pstmt->asyn_on != en_NullProc)
	{
	  if (pstmt->prep_state)
	    {
	      sqlstat = en_S1011;
	    }
	}
      else
	{
	  switch (pstmt->state)
	     {
	     case en_stmt_prepared:
	       sqlstat = en_S1011;
	       break;

	     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:
	       if (pstmt->prep_state)
		 {
		   sqlstat = en_S1011;
		 }
	       break;

	     default:
	       break;
	     }
	}
    }
  else
    {
      if (pstmt->asyn_on != en_NullProc)
	{
	  if (!pstmt->prep_state)
	    {
	      sqlstat = en_S1010;
	    }
	}
      else
	{
	  if (pstmt->state >= en_stmt_needdata)
	    {
	      sqlstat = en_S1010;
	    }
	}
    }

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

      return SQL_ERROR;
    }

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

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SetStmtOption,
    (pstmt->dhstmt, fOption, vParam))

  return retcode;
}


RETCODE SQL_API 
SQLGetStmtOption (
    HSTMT hstmt,
    UWORD fOption,
    PTR pvParam)
{
  STMT_t FAR *pstmt = (STMT_t *) hstmt;
  HPROC hproc;
  int sqlstat = en_00000;
  RETCODE retcode;

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

  /* check option */
  if (				/* fOption < SQL_STMT_OPT_MIN || */
      fOption > SQL_STMT_OPT_MAX)
    {
      PUSHSQLERR (pstmt->herr, en_S1092);

      return SQL_ERROR;
    }

  /* check state */
  if (pstmt->state >= en_stmt_needdata
      || pstmt->asyn_on != en_NullProc)
    {
      sqlstat = en_S1010;
    }
  else
    {
      switch (pstmt->state)
	 {
	 case en_stmt_allocated:
	 case en_stmt_prepared:
	 case en_stmt_executed:
	 case en_stmt_cursoropen:
	   if (fOption == SQL_ROW_NUMBER || fOption == SQL_GET_BOOKMARK)
	     {
	       sqlstat = en_24000;
	     }
	   break;

	 default:
	   break;
	 }
    }

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

      return SQL_ERROR;
    }

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

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

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_GetStmtOption,
    (pstmt->dhstmt, fOption, pvParam))

  return retcode;
}


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

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

  /* check argument */
  /* check state */

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

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Cancel, 
    (pstmt->dhstmt))

  /* state transition */
  if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
    {
      return retcode;
    }

  switch (pstmt->state)
     {
     case en_stmt_allocated:
     case en_stmt_prepared:
       break;

     case en_stmt_executed:
       if (pstmt->prep_state)
	 {
	   pstmt->state = en_stmt_prepared;
	 }
       else
	 {
	   pstmt->state = en_stmt_allocated;
	 }
       break;

     case en_stmt_cursoropen:
     case en_stmt_fetched:
     case en_stmt_xfetched:
       if (pstmt->prep_state)
	 {
	   pstmt->state = en_stmt_prepared;
	 }
       else
	 {
	   pstmt->state = en_stmt_allocated;
	 }
       break;

     case en_stmt_needdata:
     case en_stmt_mustput:
     case en_stmt_canput:
       switch (pstmt->need_on)
	  {
	  case en_ExecDirect:
	    pstmt->state = en_stmt_allocated;
	    break;

	  case en_Execute:
	    pstmt->state = en_stmt_prepared;
	    break;

	  case en_SetPos:
	    pstmt->state = en_stmt_xfetched;
	    break;

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

     default:
       break;
     }

  return retcode;
}
Commit	Line	Data
cd5bf2a6 RR	1	/*
	2	* hstmt.c
	3	*
	4	* $Id$
	5	*
	6	* Query statement object management functions
	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
88ac883a	27	#include "config.h"
cd5bf2a6	28
88ac883a VZ	29	#include "isql.h"
88ac883a VZ	30	#include "isqlext.h"
cd5bf2a6	31
88ac883a	32	#include "dlproc.h"
cd5bf2a6	33
88ac883a VZ	34	#include "herr.h"
	35	#include "henv.h"
	36	#include "hdbc.h"
	37	#include "hstmt.h"
cd5bf2a6	38
88ac883a	39	#include "itrace.h"
cd5bf2a6 RR	40
	41	RETCODE SQL_API
	42	SQLAllocStmt (
	43	HDBC hdbc,
	44	HSTMT FAR * phstmt)
1a6944fd	45	{
cd5bf2a6 RR	46	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	47	STMT_t FAR *pstmt = NULL;
	48	HPROC hproc = SQL_NULL_HPROC;
	49	RETCODE retcode = SQL_SUCCESS;
1a6944fd RR	50
1a6944fd RR	51	#if (ODBCVER >= 0x0300)
cd5bf2a6	52	if (hdbc == SQL_NULL_HDBC \|\| pdbc->type != SQL_HANDLE_DBC)
1a6944fd	53	#else
cd5bf2a6	54	if (hdbc == SQL_NULL_HDBC)
1a6944fd	55	#endif
cd5bf2a6 RR	56	{
	57	return SQL_INVALID_HANDLE;
	58	}
7e616b10	59
cd5bf2a6 RR	60	if (phstmt == NULL)
	61	{
	62	PUSHSQLERR (pdbc->herr, en_S1009);
7e616b10	63
cd5bf2a6 RR	64	return SQL_ERROR;
cd5bf2a6 RR	65	}
7e616b10	66
cd5bf2a6 RR	67	/* check state */
	68	switch (pdbc->state)
	69	{
	70	case en_dbc_connected:
	71	case en_dbc_hstmt:
	72	break;
7e616b10	73
cd5bf2a6 RR	74	case en_dbc_allocated:
	75	case en_dbc_needdata:
	76	PUSHSQLERR (pdbc->herr, en_08003);
	77	*phstmt = SQL_NULL_HSTMT;
	78	return SQL_ERROR;
7e616b10	79
cd5bf2a6 RR	80	default:
	81	return SQL_INVALID_HANDLE;
	82	}
7e616b10	83
cd5bf2a6	84	pstmt = (STMT_t FAR *) MEM_ALLOC (sizeof (STMT_t));
7e616b10	85
cd5bf2a6 RR	86	if (pstmt == NULL)
	87	{
	88	PUSHSQLERR (pdbc->herr, en_S1001);
	89	*phstmt = SQL_NULL_HSTMT;
7e616b10	90
cd5bf2a6 RR	91	return SQL_ERROR;
cd5bf2a6 RR	92	}
1a6944fd RR	93
1a6944fd RR	94	#if (ODBCVER >= 0x0300)
cd5bf2a6	95	pstmt->type = SQL_HANDLE_STMT;
1a6944fd	96	#endif
cd5bf2a6 RR	97
	98	/* initiate the object */
	99	pstmt->herr = SQL_NULL_HERR;
	100	pstmt->hdbc = hdbc;
	101	pstmt->state = en_stmt_allocated;
	102	pstmt->cursor_state = en_stmt_cursor_no;
	103	pstmt->prep_state = 0;
	104	pstmt->asyn_on = en_NullProc;
	105	pstmt->need_on = en_NullProc;
	106
	107	/* call driver's function */
	108
1a6944fd	109	#if (ODBCVER >= 0x0300)
cd5bf2a6 RR	110	hproc = _iodbcdm_getproc (hdbc, en_AllocHandle);
	111
	112	if (hproc)
	113	{
	114	CALL_DRIVER (pstmt->hdbc, hdbc, retcode, hproc, en_AllocHandle,
	115	(SQL_HANDLE_STMT, pdbc->dhdbc, &(pstmt->dhstmt)))
	116	}
	117	else
1a6944fd	118	#endif
1a6944fd	119
cd5bf2a6 RR	120	{
cd5bf2a6 RR	121	hproc = _iodbcdm_getproc (hdbc, en_AllocStmt);
1a6944fd	122
cd5bf2a6 RR	123	if (hproc == SQL_NULL_HPROC)
	124	{
	125	PUSHSQLERR (pstmt->herr, en_IM001);
	126	*phstmt = SQL_NULL_HSTMT;
	127	MEM_FREE (pstmt);
1a6944fd	128
cd5bf2a6 RR	129	return SQL_ERROR;
cd5bf2a6 RR	130	}
1a6944fd	131
cd5bf2a6 RR	132	CALL_DRIVER (hdbc, retcode, hproc, en_AllocStmt,
	133	(pdbc->dhdbc, &(pstmt->dhstmt)))
	134	}
1a6944fd	135
cd5bf2a6 RR	136	if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
	137	{
	138	*phstmt = SQL_NULL_HSTMT;
	139	MEM_FREE (pstmt);
1a6944fd	140
cd5bf2a6 RR	141	return retcode;
cd5bf2a6 RR	142	}
1a6944fd	143
cd5bf2a6 RR	144	/* insert into list */
	145	pstmt->next = pdbc->hstmt;
	146	pdbc->hstmt = pstmt;
1a6944fd	147
cd5bf2a6	148	*phstmt = (HSTMT) pstmt;
1a6944fd	149
cd5bf2a6 RR	150	/* state transition */
	151	pdbc->state = en_dbc_hstmt;
	152
	153	return SQL_SUCCESS;
1a6944fd RR	154	}
1a6944fd RR	155
cd5bf2a6 RR	156
	157	RETCODE
	158	_iodbcdm_dropstmt (HSTMT hstmt)
1a6944fd	159	{
cd5bf2a6 RR	160	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	161	STMT_t FAR *tpstmt;
	162	DBC_t FAR *pdbc;
	163
	164	if (hstmt == SQL_NULL_HSTMT)
	165	{
	166	return SQL_INVALID_HANDLE;
	167	}
	168
	169	pdbc = (DBC_t FAR *) (pstmt->hdbc);
	170
	171	for (tpstmt = (STMT_t FAR *) pdbc->hstmt;
	172	tpstmt != NULL;
	173	tpstmt = tpstmt->next)
	174	{
	175	if (tpstmt == pstmt)
	176	{
	177	pdbc->hstmt = (HSTMT) pstmt->next;
	178	break;
	179	}
	180
	181	if (tpstmt->next == pstmt)
	182	{
	183	tpstmt->next = pstmt->next;
	184	break;
	185	}
	186	}
	187
	188	if (tpstmt == NULL)
	189	{
	190	return SQL_INVALID_HANDLE;
	191	}
	192
	193	_iodbcdm_freesqlerrlist (pstmt->herr);
	194	MEM_FREE (hstmt);
	195
	196	return SQL_SUCCESS;
1a6944fd RR	197	}
1a6944fd RR	198
cd5bf2a6 RR	199
	200	RETCODE SQL_API
	201	SQLFreeStmt (
	202	HSTMT hstmt,
	203	UWORD fOption)
1a6944fd	204	{
cd5bf2a6 RR	205	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	206	STMT_t FAR *tpstmt;
	207	DBC_t FAR *pdbc;
1a6944fd	208
cd5bf2a6 RR	209	HPROC hproc = SQL_NULL_HPROC;
cd5bf2a6 RR	210	RETCODE retcode;
1a6944fd	211
cd5bf2a6 RR	212	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	213	{
	214	return SQL_INVALID_HANDLE;
	215	}
1a6944fd	216
cd5bf2a6	217	pdbc = (DBC_t FAR *) (pstmt->hdbc);
1a6944fd	218
cd5bf2a6 RR	219	/* check option */
	220	switch (fOption)
	221	{
	222	case SQL_DROP:
	223	case SQL_CLOSE:
	224	case SQL_UNBIND:
	225	case SQL_RESET_PARAMS:
	226	break;
1a6944fd	227
cd5bf2a6 RR	228	default:
	229	PUSHSQLERR (pstmt->herr, en_S1092);
	230	return SQL_ERROR;
	231	}
7e616b10	232
cd5bf2a6 RR	233	/* check state */
	234	if (pstmt->state >= en_stmt_needdata \|\| pstmt->asyn_on != en_NullProc)
	235	{
	236	PUSHSQLERR (pstmt->herr, en_S1010);
1a6944fd	237
cd5bf2a6 RR	238	return SQL_ERROR;
cd5bf2a6 RR	239	}
1a6944fd	240
cd5bf2a6	241	hproc = SQL_NULL_HPROC;
1a6944fd	242
cd5bf2a6 RR	243	#if (ODBCVER >= 0x0300)
	244	if (fOption == SQL_DROP)
	245	{
	246	hproc = _iodbcdm_getproc (pstmt->hdbc, en_FreeHandle);
	247
	248	if (hproc)
	249	{
	250	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_FreeHandle,
	251	(SQL_HANDLE_STMT, pstmt->dhstmt))
	252	}
	253	}
	254	#endif
1a6944fd	255
cd5bf2a6 RR	256	if (hproc == SQL_NULL_HPROC)
	257	{
	258	hproc = _iodbcdm_getproc (pstmt->hdbc, en_FreeStmt);
	259
	260	if (hproc == SQL_NULL_HPROC)
	261	{
	262	PUSHSQLERR (pstmt->herr, en_IM001);
	263
	264	return SQL_ERROR;
	265	}
	266
	267	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_FreeStmt,
	268	(pstmt->dhstmt, fOption))
	269	}
	270
	271	if (retcode != SQL_SUCCESS
	272	&& retcode != SQL_SUCCESS_WITH_INFO)
	273	{
	274	return retcode;
	275	}
	276
	277	/* state transition */
	278	switch (fOption)
	279	{
	280	case SQL_DROP:
	281	/* delet this object (ignore return) */
	282	_iodbcdm_dropstmt (hstmt);
	283	break;
	284
	285	case SQL_CLOSE:
	286	pstmt->cursor_state = en_stmt_cursor_no;
	287	/* This means cursor name set by
	288	* SQLSetCursorName() call will also
	289	* be erased.
	290	*/
	291
	292	switch (pstmt->state)
	293	{
	294	case en_stmt_allocated:
	295	case en_stmt_prepared:
	296	break;
	297
	298	case en_stmt_executed:
	299	case en_stmt_cursoropen:
	300	case en_stmt_fetched:
	301	case en_stmt_xfetched:
	302	if (pstmt->prep_state)
	303	{
	304	pstmt->state =
	305	en_stmt_prepared;
	306	}
	307	else
	308	{
	309	pstmt->state =
	310	en_stmt_allocated;
	311	}
	312	break;
	313
	314	default:
	315	break;
	316	}
	317	break;
	318
	319	case SQL_UNBIND:
320	case SQL_RESET_PARAMS:
321	default:
322	break;
323	}
324
325	return retcode;
326	}
1a6944fd	327
1a6944fd	328
cd5bf2a6 RR	329	RETCODE SQL_API
	330	SQLSetStmtOption (
	331	HSTMT hstmt,
	332	UWORD fOption,
	333	UDWORD vParam)
	334	{
	335	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	336	HPROC hproc;
	337	int sqlstat = en_00000;
	338	RETCODE retcode;
	339
	340	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	341	{
	342	return SQL_INVALID_HANDLE;
	343	}
	344
	345	/* check option */
	346	if ( /* fOption < SQL_STMT_OPT_MIN \|\| */
	347	fOption > SQL_STMT_OPT_MAX)
	348	{
	349	PUSHSQLERR (pstmt->herr, en_S1092);
	350
	351	return SQL_ERROR;
	352	}
	353
	354	if (fOption == SQL_CONCURRENCY
	355	\|\| fOption == SQL_CURSOR_TYPE
	356	\|\| fOption == SQL_SIMULATE_CURSOR
	357	\|\| fOption == SQL_USE_BOOKMARKS)
	358	{
	359	if (pstmt->asyn_on != en_NullProc)
	360	{
	361	if (pstmt->prep_state)
	362	{
	363	sqlstat = en_S1011;
	364	}
	365	}
	366	else
	367	{
	368	switch (pstmt->state)
	369	{
	370	case en_stmt_prepared:
	371	sqlstat = en_S1011;
	372	break;
	373
	374	case en_stmt_executed:
	375	case en_stmt_cursoropen:
	376	case en_stmt_fetched:
	377	case en_stmt_xfetched:
	378	sqlstat = en_24000;
	379	break;
	380
	381	case en_stmt_needdata:
	382	case en_stmt_mustput:
	383	case en_stmt_canput:
	384	if (pstmt->prep_state)
	385	{
	386	sqlstat = en_S1011;
	387	}
	388	break;
	389
	390	default:
	391	break;
	392	}
393	}
394	}
395	else
396	{
397	if (pstmt->asyn_on != en_NullProc)
398	{
399	if (!pstmt->prep_state)
400	{
401	sqlstat = en_S1010;
402	}
403	}
404	else
405	{
406	if (pstmt->state >= en_stmt_needdata)
407	{
408	sqlstat = en_S1010;
409	}
410	}
411	}
412
413	if (sqlstat != en_00000)
414	{
415	PUSHSQLERR (pstmt->herr, sqlstat);
416
417	return SQL_ERROR;
418	}
419
420	hproc = _iodbcdm_getproc (pstmt->hdbc, en_SetStmtOption);
421
422	if (hproc == SQL_NULL_HPROC)
423	{
424	PUSHSQLERR (pstmt->herr, en_IM001);
425
426	return SQL_ERROR;
427	}
428
429	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SetStmtOption,
430	(pstmt->dhstmt, fOption, vParam))
431
432	return retcode;
433	}
1a6944fd	434
1a6944fd	435
cd5bf2a6 RR	436	RETCODE SQL_API
	437	SQLGetStmtOption (
	438	HSTMT hstmt,
	439	UWORD fOption,
	440	PTR pvParam)
	441	{
	442	STMT_t FAR pstmt = (STMT_t ) hstmt;
	443	HPROC hproc;
	444	int sqlstat = en_00000;
	445	RETCODE retcode;
	446
	447	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	448	{
	449	return SQL_INVALID_HANDLE;
	450	}
	451
	452	/* check option */
	453	if ( /* fOption < SQL_STMT_OPT_MIN \|\| */
	454	fOption > SQL_STMT_OPT_MAX)
	455	{
	456	PUSHSQLERR (pstmt->herr, en_S1092);
	457
	458	return SQL_ERROR;
	459	}
	460
	461	/* check state */
	462	if (pstmt->state >= en_stmt_needdata
	463	\|\| pstmt->asyn_on != en_NullProc)
	464	{
	465	sqlstat = en_S1010;
	466	}
	467	else
	468	{
	469	switch (pstmt->state)
	470	{
	471	case en_stmt_allocated:
	472	case en_stmt_prepared:
	473	case en_stmt_executed:
	474	case en_stmt_cursoropen:
	475	if (fOption == SQL_ROW_NUMBER \|\| fOption == SQL_GET_BOOKMARK)
	476	{
	477	sqlstat = en_24000;
	478	}
	479	break;
	480
	481	default:
	482	break;
	483	}
	484	}
	485
	486	if (sqlstat != en_00000)
	487	{
	488	PUSHSQLERR (pstmt->herr, sqlstat);
	489
	490	return SQL_ERROR;
	491	}
	492
	493	hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetStmtOption);
	494
	495	if (hproc == SQL_NULL_HPROC)
	496	{
	497	PUSHSQLERR (pstmt->herr, en_IM001);
	498	return SQL_ERROR;
	499	}
500
501	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_GetStmtOption,
502	(pstmt->dhstmt, fOption, pvParam))
503
504	return retcode;
505	}
1a6944fd	506
cd5bf2a6 RR	507
	508	RETCODE SQL_API
	509	SQLCancel (HSTMT hstmt)
	510	{
	511	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	512	HPROC hproc;
	513	RETCODE retcode;
	514
	515	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	516	{
	517	return SQL_INVALID_HANDLE;
	518	}
	519
	520	/* check argument */
	521	/* check state */
	522
	523	/* call driver */
	524	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Cancel);
	525
	526	if (hproc == SQL_NULL_HPROC)
	527	{
	528	PUSHSQLERR (pstmt->herr, en_IM001);
	529
	530	return SQL_ERROR;
	531	}
	532
	533	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Cancel,
	534	(pstmt->dhstmt))
	535
	536	/* state transition */
	537	if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
	538	{
	539	return retcode;
	540	}
	541
	542	switch (pstmt->state)
	543	{
	544	case en_stmt_allocated:
	545	case en_stmt_prepared:
	546	break;
	547
	548	case en_stmt_executed:
	549	if (pstmt->prep_state)
	550	{
	551	pstmt->state = en_stmt_prepared;
	552	}
	553	else
	554	{
	555	pstmt->state = en_stmt_allocated;
	556	}
	557	break;
	558
	559	case en_stmt_cursoropen:
	560	case en_stmt_fetched:
	561	case en_stmt_xfetched:
	562	if (pstmt->prep_state)
	563	{
	564	pstmt->state = en_stmt_prepared;
	565	}
	566	else
	567	{
	568	pstmt->state = en_stmt_allocated;
	569	}
	570	break;
571
572	case en_stmt_needdata:
573	case en_stmt_mustput:
574	case en_stmt_canput:
575	switch (pstmt->need_on)
576	{
577	case en_ExecDirect:
578	pstmt->state = en_stmt_allocated;
579	break;
580
581	case en_Execute:
582	pstmt->state = en_stmt_prepared;
583	break;
584
585	case en_SetPos:
586	pstmt->state = en_stmt_xfetched;
587	break;
588
589	default:
590	break;
591	}
592	pstmt->need_on = en_NullProc;
593	break;
594
595	default:
596	break;
597	}
598
599	return retcode;
1a6944fd	600	}