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

/*
 *  hdbc.c
 *
 *  $Id$
 *
 *  Data source connect 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>
#include	<stdio.h>

extern	RETCODE	_iodbcdm_driverunload();


RETCODE SQL_API 
SQLAllocConnect (
    HENV henv,
    HDBC FAR * phdbc)
{
  GENV_t FAR *genv = (GENV_t FAR *) henv;
  DBC_t FAR *pdbc;

#if (ODBCVER >= 0x0300)
  if (henv == SQL_NULL_HENV || genv->type != SQL_HANDLE_ENV)
#else
  if (henv == SQL_NULL_HENV)
#endif

    {
      return SQL_INVALID_HANDLE;
    }

  if (phdbc == NULL)
    {
      PUSHSQLERR (genv->herr, en_S1009);

      return SQL_ERROR;
    }

  pdbc = (DBC_t FAR *) MEM_ALLOC (sizeof (DBC_t));

  if (pdbc == NULL)
    {
      *phdbc = SQL_NULL_HDBC;

      PUSHSQLERR (genv->herr, en_S1001);

      return SQL_ERROR;
    }

#if (ODBCVER >= 0x0300)
  pdbc->type = SQL_HANDLE_DBC;
#endif

  /* insert this dbc entry into the link list */
  pdbc->next = genv->hdbc;
  genv->hdbc = pdbc;
  pdbc->genv = henv;

  pdbc->henv = SQL_NULL_HENV;
  pdbc->hstmt = SQL_NULL_HSTMT;
  pdbc->herr = SQL_NULL_HERR;
  pdbc->dhdbc = SQL_NULL_HDBC;
  pdbc->state = en_dbc_allocated;
  pdbc->trace = 0;
  pdbc->tstm = NULL;
  pdbc->tfile = NULL;

  /* set connect options to default values */
  pdbc->access_mode = SQL_MODE_DEFAULT;
  pdbc->autocommit = SQL_AUTOCOMMIT_DEFAULT;
  pdbc->current_qualifier = NULL;
  pdbc->login_timeout = 0UL;
  pdbc->odbc_cursors = SQL_CUR_DEFAULT;
  pdbc->packet_size = 0UL;
  pdbc->quiet_mode = (UDWORD) NULL;
  pdbc->txn_isolation = SQL_TXN_READ_UNCOMMITTED;
  pdbc->cb_commit = (SWORD) SQL_CB_DELETE;
  pdbc->cb_rollback = (SWORD) SQL_CB_DELETE;

  *phdbc = (HDBC) pdbc;

  return SQL_SUCCESS;
}


RETCODE SQL_API 
SQLFreeConnect (HDBC hdbc)
{
  GENV_t FAR *genv;
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  DBC_t FAR *tpdbc;

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

  /* check state */
  if (pdbc->state != en_dbc_allocated)
    {
      PUSHSQLERR (pdbc->herr, en_S1010);

      return SQL_ERROR;
    }

  genv = (GENV_t FAR *) pdbc->genv;

  for (tpdbc = (DBC_t FAR *) genv->hdbc;
      tpdbc != NULL;
      tpdbc = tpdbc->next)
    {
      if (pdbc == tpdbc)
	{
	  genv->hdbc = pdbc->next;
	  break;
	}

      if (pdbc == tpdbc->next)
	{
	  tpdbc->next = pdbc->next;
	  break;
	}
    }

  /* free this dbc */
  _iodbcdm_driverunload (pdbc);
  _iodbcdm_freesqlerrlist (pdbc->herr);

  if (pdbc->tfile)
    {
      MEM_FREE (pdbc->tfile);
    }

  SQLSetConnectOption (pdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);

  MEM_FREE (pdbc);

  return SQL_SUCCESS;
}


RETCODE SQL_API 
SQLSetConnectOption (
    HDBC hdbc,
    UWORD fOption,
    UDWORD vParam)
{
  GENV_t FAR *genv;
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  STMT_t FAR *pstmt;
  HPROC hproc = SQL_NULL_HPROC;
  int sqlstat = en_00000;
  RETCODE retcode = SQL_SUCCESS;

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

  /* check option */
  if (fOption < SQL_CONN_OPT_MIN || 
	(fOption > SQL_CONN_OPT_MAX && fOption < SQL_CONNECT_OPT_DRVR_START))
    {
      PUSHSQLERR (pdbc->herr, en_S1092);

      return SQL_ERROR;
    }

  /* check state of connection handle */
  switch (pdbc->state)
     {
     case en_dbc_allocated:
       if (fOption == SQL_TRANSLATE_DLL || fOption == SQL_TRANSLATE_OPTION)
	 {
	   /* This two options are only meaningful
	    * for specified driver. So, has to be
	    * set after a dirver has been loaded.
	    */
	   sqlstat = en_08003;
	   break;
	 }

       if (fOption >= SQL_CONNECT_OPT_DRVR_START && pdbc->henv == SQL_NULL_HENV)
	 /* An option only meaningful for drivers
	  * is passed before loading a driver.
	  * We classify this as an invalid option error.
	  * This is not documented by MS SDK guide.
	  */
	 {
	   sqlstat = en_S1092;
	   break;
	 }
       break;

     case en_dbc_needdata:
       sqlstat = en_S1010;
       break;

     case en_dbc_connected:
     case en_dbc_hstmt:
       if (fOption == SQL_ODBC_CURSORS)
	 {
	   sqlstat = en_08002;
	 }
       break;

     default:
       break;
     }

  /* check state of statement handle(s) */
  for (pstmt = (STMT_t FAR *) pdbc->hstmt;
      pstmt != NULL && sqlstat == en_00000;
      pstmt = (STMT_t FAR *) pstmt->next)
    {
      if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc)
	{
	  sqlstat = en_S1010;
	}
    }

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

      return SQL_ERROR;
    }

  if (fOption == SQL_OPT_TRACE)
    /* tracing flag can be set before and after connect 
     * and only meaningful for driver manager(actually
     * there is only one tracing file under one global
     * environment).
     */
    {
      switch (vParam)
	 {
	 case SQL_OPT_TRACE_ON:
	   if (pdbc->tfile == NULL)
	     {
	       pdbc->tfile = (char FAR *) MEM_ALLOC (1 +
		   STRLEN (SQL_OPT_TRACE_FILE_DEFAULT));

	       if (pdbc->tfile == NULL)
		 {
		   PUSHSQLERR (pdbc->herr, en_S1001);

		   return SQL_ERROR;
		 }

	       STRCPY (pdbc->tfile, SQL_OPT_TRACE_FILE_DEFAULT);
	     }

	   if (pdbc->tstm == NULL)
	     {

#if	defined(stderr) && defined(stdout)
	       if (STREQ (pdbc->tfile, "stderr"))
		 {
		   pdbc->tstm = stderr;
		 }
	       else if (STREQ (pdbc->tfile, "stdout"))
		 {
		   pdbc->tstm = stdout;
		 }
	       else
#endif

		 {
		   pdbc->tstm
		       = fopen (pdbc->tfile, "a+");
		 }

	       if (pdbc->tstm)
		 {
		   pdbc->trace = 1;
		 }
	       else
		 {
		   pdbc->trace = 0;

		   sqlstat = en_IM013;
		   retcode = SQL_ERROR;
		 }
	     }
	   break;

	 case SQL_OPT_TRACE_OFF:
	   if (pdbc->trace && pdbc->tstm)
	     {

#if	defined(stderr) && defined(stdout)
	       if (stderr != (FILE FAR *) (pdbc->tstm)
		   && stdout != (FILE FAR *) (pdbc->tstm))
#endif

		 {
		   fclose (pdbc->tstm);
		 }
	     }
	   pdbc->tstm = NULL;
	   pdbc->trace = 0;
	   break;

	 default:
	   PUSHSQLERR (pdbc->herr, en_S1009);
	   retcode = SQL_ERROR;
	 }

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

      return retcode;
    }

  if (fOption == SQL_OPT_TRACEFILE)
    /* Tracing file can be set before and after connect 
     * and only meaningful for driver manager. 
     */
    {
      if (vParam == 0UL || ((char FAR *) vParam)[0] == 0)
	{
	  PUSHSQLERR (pdbc->herr, en_S1009);

	  return SQL_ERROR;
	}

      if (pdbc->tfile && STREQ (pdbc->tfile, vParam))
	{
	  return SQL_SUCCESS;
	}

      if (pdbc->trace)
	{
	  PUSHSQLERR (pdbc->herr, en_IM014);

	  return SQL_ERROR;
	}

      if (pdbc->tfile)
	{
	  MEM_FREE (pdbc->tfile);
	}

      pdbc->tfile = (char FAR *) MEM_ALLOC (1 + STRLEN (vParam));

      if (pdbc->tfile == NULL)
	{
	  PUSHSQLERR (pdbc->herr, en_S1001);

	  return SQL_ERROR;
	}

      STRCPY (pdbc->tfile, vParam);

      return SQL_SUCCESS;
    }

  if (pdbc->state != en_dbc_allocated)
    {
      /* If already connected, then, driver's odbc call
       * will be invoked. Otherwise, we only save the options
       * and delay the setting process until the connection 
       * been established.  
       */
      hproc = _iodbcdm_getproc (hdbc, en_SetConnectOption);

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

	  return SQL_ERROR;
	}

      CALL_DRIVER (hdbc, retcode, hproc, en_SetConnectOption, 
        (pdbc->dhdbc, fOption, vParam))

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

  /* 
   * Now, either driver's odbc call was successed or
   * driver has not been loaded yet. In the first case, we
   * need flip flag for(such as access_mode, autocommit, ...)
   * for our finit state machine. While in the second case, 
   * we need save option values(such as current_qualifier, ...)
   * for delaied setting. So, ...
   */

  /* No matter what state we are(i.e. allocated or connected, ..)
   * we need to flip the flag.
   */
  switch (fOption)
     {
     case SQL_ACCESS_MODE:
       pdbc->access_mode = vParam;
       break;

     case SQL_AUTOCOMMIT:
       pdbc->autocommit = vParam;
       break;
     }

  /* state transition */
  if (pdbc->state != en_dbc_allocated)
    {
      return retcode;
    }

  /* Only 'allocated' state is possible here, and we need to
   * save the options for delaied setting.
   */
  switch (fOption)
     {
     case SQL_CURRENT_QUALIFIER:
       if (pdbc->current_qualifier != NULL)
	 {
	   MEM_FREE (pdbc->current_qualifier);
	 }

       if (vParam == 0UL)
	 {
	   pdbc->current_qualifier = NULL;

	   break;
	 }

       pdbc->current_qualifier
	   = (char FAR *) MEM_ALLOC (
	   STRLEN (vParam) + 1);

       if (pdbc->current_qualifier == NULL)
	 {
	   PUSHSQLERR (pdbc->herr, en_S1001);
	   return SQL_ERROR;
	 }

       STRCPY (pdbc->current_qualifier, vParam);
       break;

     case SQL_LOGIN_TIMEOUT:
       pdbc->login_timeout = vParam;
       break;

     case SQL_ODBC_CURSORS:
       pdbc->odbc_cursors = vParam;
       break;

     case SQL_PACKET_SIZE:
       pdbc->packet_size = vParam;
       break;

     case SQL_QUIET_MODE:
       pdbc->quiet_mode = vParam;
       break;

     case SQL_TXN_ISOLATION:
       pdbc->txn_isolation = vParam;
       break;

     default:
       /* Since we didn't save the option value for delaied
        * setting, we should raise an error here.
        */
       break;
     }

  return retcode;
}


RETCODE SQL_API 
SQLGetConnectOption (
    HDBC hdbc,
    UWORD fOption,
    PTR pvParam)
{
  GENV_t FAR *genv;
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  int sqlstat = en_00000;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;

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

  /* check option */
  if (fOption < SQL_CONN_OPT_MIN || 
	(fOption > SQL_CONN_OPT_MAX && fOption < SQL_CONNECT_OPT_DRVR_START))
    {
      PUSHSQLERR (pdbc->herr, en_S1092);

      return SQL_ERROR;
    }

  /* check state */
  switch (pdbc->state)
     {
     case en_dbc_allocated:
       if (fOption != SQL_ACCESS_MODE
	   && fOption != SQL_AUTOCOMMIT
	   && fOption != SQL_LOGIN_TIMEOUT
	   && fOption != SQL_OPT_TRACE
	   && fOption != SQL_OPT_TRACEFILE)
	 {
	   sqlstat = en_08003;
	 }
       /* MS ODBC SDK document only
        * allows SQL_ACCESS_MODE
        * and SQL_AUTOCOMMIT in this
        * dbc state. We allow another 
        * two options, because they 
        * are only meaningful for driver 
        * manager.  
        */
       break;

     case en_dbc_needdata:
       sqlstat = en_S1010;
       break;

     default:
       break;
     }

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

      return SQL_ERROR;
    }

  /* Tracing and tracing file options are only 
   * meaningful for driver manager
   */
  if (fOption == SQL_OPT_TRACE)
    {
      if (pdbc->trace)
	*((UDWORD *) pvParam) = (UDWORD) SQL_OPT_TRACE_ON;
      else
	*((UDWORD *) pvParam) = (UDWORD) SQL_OPT_TRACE_OFF;

      return SQL_SUCCESS;
    }

  if (fOption == SQL_OPT_TRACEFILE)
    {
      STRCPY (pvParam, pdbc->tfile);

      return SQL_ERROR;
    }

  if (pdbc->state != en_dbc_allocated)
    /* if already connected, we will invoke driver's function */
    {
      hproc = _iodbcdm_getproc (hdbc, en_GetConnectOption);

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

	  return SQL_ERROR;
	}

      CALL_DRIVER (hdbc, retcode, hproc, en_GetConnectOption,
	(pdbc->dhdbc, fOption, pvParam))

      return retcode;
    }

  /* We needn't to handle options which are not allowed 
   * to be *get* at a allocated dbc state(and two tracing
   * options which has been handled and returned). Thus, 
   * there are only two possible cases. 
   */
  switch (fOption)
     {
     case SQL_ACCESS_MODE:
       *((UDWORD *) pvParam) = pdbc->access_mode;
       break;

     case SQL_AUTOCOMMIT:
       *((UDWORD *) pvParam) = pdbc->autocommit;
       break;

     case SQL_LOGIN_TIMEOUT:
       *((UDWORD *) pvParam) = pdbc->login_timeout;
       break;

     default:
       break;
     }

  return SQL_SUCCESS;
}


static RETCODE 
_iodbcdm_transact (
    HDBC hdbc,
    UWORD fType)
{
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  STMT_t FAR *pstmt;
  HPROC hproc;
  RETCODE retcode;

  /* check state */
  switch (pdbc->state)
     {
     case en_dbc_allocated:
     case en_dbc_needdata:
       PUSHSQLERR (pdbc->herr, en_08003);
       return SQL_ERROR;

     case en_dbc_connected:
       return SQL_SUCCESS;

     case en_dbc_hstmt:
     default:
       break;
     }

  for (pstmt = (STMT_t FAR *) (pdbc->hstmt);
      pstmt != NULL;
      pstmt = pstmt->next)
    {
      if (pstmt->state >= en_stmt_needdata
	  || pstmt->asyn_on != en_NullProc)
	{
	  PUSHSQLERR (pdbc->herr, en_S1010);

	  return SQL_ERROR;
	}
    }

  hproc = _iodbcdm_getproc (hdbc, en_Transact);

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

      return SQL_ERROR;
    }

  CALL_DRIVER (hdbc, retcode, hproc, en_Transact,
    (SQL_NULL_HENV, pdbc->dhdbc, fType))

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

  pdbc->state = en_dbc_hstmt;

  for (pstmt = (STMT_t FAR *) (pdbc->hstmt);
      pstmt != NULL;
      pstmt = pstmt->next)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_prepared:
	   if (pdbc->cb_commit == SQL_CB_DELETE
	       || pdbc->cb_rollback == SQL_CB_DELETE)
	     {
	       pstmt->state = en_stmt_allocated;
	       pstmt->prep_state = 0;
	       break;
	     }
	   break;

	 case en_stmt_executed:
	 case en_stmt_cursoropen:
	 case en_stmt_fetched:
	 case en_stmt_xfetched:
	   if (!pstmt->prep_state
	       && pdbc->cb_commit != SQL_CB_PRESERVE
	       && pdbc->cb_rollback != SQL_CB_PRESERVE)
	     {
	       pstmt->state = en_stmt_allocated;
	       pstmt->prep_state = 0;
	       pstmt->cursor_state = en_stmt_cursor_no;
	       break;
	     }

	   if (pstmt->prep_state)
	     {
	       if (pdbc->cb_commit == SQL_CB_DELETE
		   || pdbc->cb_rollback == SQL_CB_DELETE)
		 {
		   pstmt->state = en_stmt_allocated;
		   pstmt->prep_state = 0;
		   pstmt->cursor_state = en_stmt_cursor_no;
		   break;
		 }

	       if (pdbc->cb_commit == SQL_CB_CLOSE
		   || pdbc->cb_rollback == SQL_CB_CLOSE)
		 {
		   pstmt->state
		       = en_stmt_prepared;
		   pstmt->cursor_state
		       = en_stmt_cursor_no;
		   break;
		 }
	       break;
	     }
	   break;

	 default:
	   break;
	 }
    }

  return retcode;
}


RETCODE SQL_API 
SQLTransact (
    HENV henv,
    HDBC hdbc,
    UWORD fType)
{
  GENV_t FAR *genv = (GENV_t FAR *) henv;
  DBC_t FAR *pdbc = (DBC_t FAR *) hdbc;
  HERR herr;
  RETCODE retcode;

  if (hdbc != SQL_NULL_HDBC)
    {
      herr = pdbc->herr;
    }
  else if (henv != SQL_NULL_HENV)
    {
      herr = genv->herr;
    }
  else
    {
      return SQL_INVALID_HANDLE;
    }

  /* check argument */
  if (fType != SQL_COMMIT
      && fType != SQL_ROLLBACK)
    {
      PUSHSQLERR (herr, en_S1012);

      return SQL_ERROR;
    }

  if (hdbc != SQL_NULL_HDBC)
    {
      retcode = _iodbcdm_transact (hdbc, fType);
    }
  else
    {
      for (pdbc = (DBC_t FAR *) (genv->hdbc);
	  pdbc != NULL;
	  pdbc = pdbc->next)
	{
	  retcode |= _iodbcdm_transact (hdbc, fType);
	}
    }

  if (retcode != SQL_SUCCESS
      && retcode != SQL_SUCCESS_WITH_INFO)
    {
      /* fail on one of the connection */
      return SQL_ERROR;
    }

  return retcode;
}
Commit	Line	Data
cd5bf2a6 RR	1	/*
	2	* hdbc.c
	3	*
	4	* $Id$
	5	*
	6	* Data source connect 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
	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>
1a6944fd RR	40	#include <stdio.h>
1a6944fd RR	41
e3e65dac RR	42	extern RETCODE _iodbcdm_driverunload();
e3e65dac RR	43
cd5bf2a6 RR	44
	45	RETCODE SQL_API
	46	SQLAllocConnect (
	47	HENV henv,
	48	HDBC FAR * phdbc)
1a6944fd	49	{
cd5bf2a6 RR	50	GENV_t FAR genv = (GENV_t FAR ) henv;
cd5bf2a6 RR	51	DBC_t FAR *pdbc;
1a6944fd RR	52
1a6944fd RR	53	#if (ODBCVER >= 0x0300)
cd5bf2a6	54	if (henv == SQL_NULL_HENV \|\| genv->type != SQL_HANDLE_ENV)
1a6944fd	55	#else
cd5bf2a6	56	if (henv == SQL_NULL_HENV)
1a6944fd	57	#endif
1a6944fd	58
cd5bf2a6 RR	59	{
	60	return SQL_INVALID_HANDLE;
	61	}
1a6944fd	62
cd5bf2a6 RR	63	if (phdbc == NULL)
	64	{
	65	PUSHSQLERR (genv->herr, en_S1009);
1a6944fd	66
cd5bf2a6 RR	67	return SQL_ERROR;
cd5bf2a6 RR	68	}
1a6944fd	69
cd5bf2a6	70	pdbc = (DBC_t FAR *) MEM_ALLOC (sizeof (DBC_t));
1a6944fd	71
cd5bf2a6 RR	72	if (pdbc == NULL)
	73	{
	74	*phdbc = SQL_NULL_HDBC;
1a6944fd	75
cd5bf2a6 RR	76	PUSHSQLERR (genv->herr, en_S1001);
	77
	78	return SQL_ERROR;
	79	}
1a6944fd RR	80
1a6944fd RR	81	#if (ODBCVER >= 0x0300)
cd5bf2a6	82	pdbc->type = SQL_HANDLE_DBC;
1a6944fd	83	#endif
cd5bf2a6 RR	84
	85	/* insert this dbc entry into the link list */
	86	pdbc->next = genv->hdbc;
	87	genv->hdbc = pdbc;
	88	pdbc->genv = henv;
	89
	90	pdbc->henv = SQL_NULL_HENV;
	91	pdbc->hstmt = SQL_NULL_HSTMT;
	92	pdbc->herr = SQL_NULL_HERR;
	93	pdbc->dhdbc = SQL_NULL_HDBC;
	94	pdbc->state = en_dbc_allocated;
	95	pdbc->trace = 0;
	96	pdbc->tstm = NULL;
	97	pdbc->tfile = NULL;
	98
	99	/* set connect options to default values */
	100	pdbc->access_mode = SQL_MODE_DEFAULT;
	101	pdbc->autocommit = SQL_AUTOCOMMIT_DEFAULT;
	102	pdbc->current_qualifier = NULL;
	103	pdbc->login_timeout = 0UL;
	104	pdbc->odbc_cursors = SQL_CUR_DEFAULT;
	105	pdbc->packet_size = 0UL;
	106	pdbc->quiet_mode = (UDWORD) NULL;
	107	pdbc->txn_isolation = SQL_TXN_READ_UNCOMMITTED;
	108	pdbc->cb_commit = (SWORD) SQL_CB_DELETE;
	109	pdbc->cb_rollback = (SWORD) SQL_CB_DELETE;
	110
	111	*phdbc = (HDBC) pdbc;
	112
	113	return SQL_SUCCESS;
1a6944fd RR	114	}
1a6944fd RR	115
cd5bf2a6 RR	116
	117	RETCODE SQL_API
	118	SQLFreeConnect (HDBC hdbc)
1a6944fd	119	{
cd5bf2a6 RR	120	GENV_t FAR *genv;
	121	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	122	DBC_t FAR *tpdbc;
	123
	124	if (hdbc == SQL_NULL_HDBC)
	125	{
	126	return SQL_INVALID_HANDLE;
	127	}
	128
	129	/* check state */
	130	if (pdbc->state != en_dbc_allocated)
	131	{
	132	PUSHSQLERR (pdbc->herr, en_S1010);
	133
	134	return SQL_ERROR;
	135	}
	136
	137	genv = (GENV_t FAR *) pdbc->genv;
	138
	139	for (tpdbc = (DBC_t FAR *) genv->hdbc;
	140	tpdbc != NULL;
	141	tpdbc = tpdbc->next)
	142	{
	143	if (pdbc == tpdbc)
	144	{
	145	genv->hdbc = pdbc->next;
	146	break;
	147	}
	148
	149	if (pdbc == tpdbc->next)
	150	{
	151	tpdbc->next = pdbc->next;
	152	break;
	153	}
	154	}
	155
	156	/* free this dbc */
	157	_iodbcdm_driverunload (pdbc);
	158	_iodbcdm_freesqlerrlist (pdbc->herr);
	159
	160	if (pdbc->tfile)
	161	{
	162	MEM_FREE (pdbc->tfile);
	163	}
	164
	165	SQLSetConnectOption (pdbc, SQL_OPT_TRACE, SQL_OPT_TRACE_OFF);
	166
	167	MEM_FREE (pdbc);
	168
	169	return SQL_SUCCESS;
1a6944fd RR	170	}
1a6944fd RR	171
cd5bf2a6 RR	172
	173	RETCODE SQL_API
	174	SQLSetConnectOption (
	175	HDBC hdbc,
	176	UWORD fOption,
	177	UDWORD vParam)
1a6944fd	178	{
cd5bf2a6 RR	179	GENV_t FAR *genv;
	180	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	181	STMT_t FAR *pstmt;
	182	HPROC hproc = SQL_NULL_HPROC;
	183	int sqlstat = en_00000;
	184	RETCODE retcode = SQL_SUCCESS;
	185
	186	if (hdbc == SQL_NULL_HDBC)
	187	{
	188	return SQL_INVALID_HANDLE;
	189	}
	190
	191	/* check option */
	192	if (fOption < SQL_CONN_OPT_MIN \|\|
	193	(fOption > SQL_CONN_OPT_MAX && fOption < SQL_CONNECT_OPT_DRVR_START))
	194	{
	195	PUSHSQLERR (pdbc->herr, en_S1092);
	196
	197	return SQL_ERROR;
	198	}
	199
	200	/* check state of connection handle */
	201	switch (pdbc->state)
	202	{
	203	case en_dbc_allocated:
	204	if (fOption == SQL_TRANSLATE_DLL \|\| fOption == SQL_TRANSLATE_OPTION)
	205	{
	206	/* This two options are only meaningful
	207	* for specified driver. So, has to be
	208	* set after a dirver has been loaded.
	209	*/
	210	sqlstat = en_08003;
	211	break;
	212	}
	213
	214	if (fOption >= SQL_CONNECT_OPT_DRVR_START && pdbc->henv == SQL_NULL_HENV)
	215	/* An option only meaningful for drivers
	216	* is passed before loading a driver.
	217	* We classify this as an invalid option error.
	218	* This is not documented by MS SDK guide.
	219	*/
	220	{
	221	sqlstat = en_S1092;
	222	break;
	223	}
	224	break;
	225
	226	case en_dbc_needdata:
	227	sqlstat = en_S1010;
	228	break;
	229
	230	case en_dbc_connected:
	231	case en_dbc_hstmt:
	232	if (fOption == SQL_ODBC_CURSORS)
	233	{
	234	sqlstat = en_08002;
	235	}
	236	break;
	237
	238	default:
	239	break;
	240	}
	241
	242	/* check state of statement handle(s) */
243	for (pstmt = (STMT_t FAR *) pdbc->hstmt;
244	pstmt != NULL && sqlstat == en_00000;
245	pstmt = (STMT_t FAR *) pstmt->next)
246	{
247	if (pstmt->state >= en_stmt_needdata \|\| pstmt->asyn_on != en_NullProc)
248	{
249	sqlstat = en_S1010;
250	}
251	}
252
253	if (sqlstat != en_00000)
254	{
255	PUSHSQLERR (pdbc->herr, sqlstat);
256
257	return SQL_ERROR;
258	}
259
260	if (fOption == SQL_OPT_TRACE)
261	/* tracing flag can be set before and after connect
262	* and only meaningful for driver manager(actually
263	* there is only one tracing file under one global
264	* environment).
265	*/
266	{
267	switch (vParam)
268	{
269	case SQL_OPT_TRACE_ON:
270	if (pdbc->tfile == NULL)
271	{
272	pdbc->tfile = (char FAR *) MEM_ALLOC (1 +
273	STRLEN (SQL_OPT_TRACE_FILE_DEFAULT));
274
275	if (pdbc->tfile == NULL)
276	{
277	PUSHSQLERR (pdbc->herr, en_S1001);
278
279	return SQL_ERROR;
280	}
281
282	STRCPY (pdbc->tfile, SQL_OPT_TRACE_FILE_DEFAULT);
283	}
284
285	if (pdbc->tstm == NULL)
286	{
287
288	#if defined(stderr) && defined(stdout)
289	if (STREQ (pdbc->tfile, "stderr"))
290	{
291	pdbc->tstm = stderr;
292	}
293	else if (STREQ (pdbc->tfile, "stdout"))
294	{
295	pdbc->tstm = stdout;
296	}
297	else
7e616b10	298	#endif
cd5bf2a6 RR	299
	300	{
	301	pdbc->tstm
	302	= fopen (pdbc->tfile, "a+");
	303	}
	304
	305	if (pdbc->tstm)
	306	{
	307	pdbc->trace = 1;
	308	}
	309	else
	310	{
	311	pdbc->trace = 0;
	312
	313	sqlstat = en_IM013;
	314	retcode = SQL_ERROR;
	315	}
	316	}
	317	break;
	318
	319	case SQL_OPT_TRACE_OFF:
	320	if (pdbc->trace && pdbc->tstm)
	321	{
	322
	323	#if defined(stderr) && defined(stdout)
	324	if (stderr != (FILE FAR *) (pdbc->tstm)
	325	&& stdout != (FILE FAR *) (pdbc->tstm))
1a6944fd RR	326	#endif
1a6944fd RR	327
cd5bf2a6 RR	328	{
	329	fclose (pdbc->tstm);
	330	}
	331	}
	332	pdbc->tstm = NULL;
	333	pdbc->trace = 0;
	334	break;
	335
	336	default:
	337	PUSHSQLERR (pdbc->herr, en_S1009);
	338	retcode = SQL_ERROR;
	339	}
	340
	341	if (sqlstat != en_00000)
	342	{
	343	PUSHSQLERR (pdbc->herr, sqlstat);
	344	}
	345
	346	return retcode;
	347	}
	348
	349	if (fOption == SQL_OPT_TRACEFILE)
	350	/* Tracing file can be set before and after connect
	351	* and only meaningful for driver manager.
	352	*/
	353	{
	354	if (vParam == 0UL \|\| ((char FAR *) vParam)[0] == 0)
	355	{
	356	PUSHSQLERR (pdbc->herr, en_S1009);
	357
	358	return SQL_ERROR;
	359	}
	360
	361	if (pdbc->tfile && STREQ (pdbc->tfile, vParam))
	362	{
	363	return SQL_SUCCESS;
	364	}
	365
	366	if (pdbc->trace)
	367	{
	368	PUSHSQLERR (pdbc->herr, en_IM014);
	369
	370	return SQL_ERROR;
	371	}
	372
	373	if (pdbc->tfile)
	374	{
	375	MEM_FREE (pdbc->tfile);
	376	}
	377
	378	pdbc->tfile = (char FAR *) MEM_ALLOC (1 + STRLEN (vParam));
	379
	380	if (pdbc->tfile == NULL)
	381	{
	382	PUSHSQLERR (pdbc->herr, en_S1001);
	383
	384	return SQL_ERROR;
	385	}
	386
	387	STRCPY (pdbc->tfile, vParam);
	388
	389	return SQL_SUCCESS;
	390	}
	391
392	if (pdbc->state != en_dbc_allocated)
393	{
394	/* If already connected, then, driver's odbc call
395	* will be invoked. Otherwise, we only save the options
396	* and delay the setting process until the connection
397	* been established.
398	*/
399	hproc = _iodbcdm_getproc (hdbc, en_SetConnectOption);
400
401	if (hproc == SQL_NULL_HPROC)
402	{
403	PUSHSQLERR (pdbc->herr, en_IM001);
404
405	return SQL_ERROR;
406	}
407
408	CALL_DRIVER (hdbc, retcode, hproc, en_SetConnectOption,
409	(pdbc->dhdbc, fOption, vParam))
410
411	if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
412	{
413	return retcode;
414	}
415	}
416
417	/*
418	* Now, either driver's odbc call was successed or
419	* driver has not been loaded yet. In the first case, we
420	* need flip flag for(such as access_mode, autocommit, ...)
421	* for our finit state machine. While in the second case,
422	* we need save option values(such as current_qualifier, ...)
423	* for delaied setting. So, ...
424	*/
425
426	/* No matter what state we are(i.e. allocated or connected, ..)
427	* we need to flip the flag.
428	*/
429	switch (fOption)
430	{
431	case SQL_ACCESS_MODE:
432	pdbc->access_mode = vParam;
433	break;
434
435	case SQL_AUTOCOMMIT:
436	pdbc->autocommit = vParam;
437	break;
438	}
439
440	/* state transition */
441	if (pdbc->state != en_dbc_allocated)
442	{
443	return retcode;
444	}
445
446	/* Only 'allocated' state is possible here, and we need to
447	* save the options for delaied setting.
448	*/
449	switch (fOption)
450	{
451	case SQL_CURRENT_QUALIFIER:
452	if (pdbc->current_qualifier != NULL)
453	{
454	MEM_FREE (pdbc->current_qualifier);
455	}
456
457	if (vParam == 0UL)
458	{
459	pdbc->current_qualifier = NULL;
460
461	break;
462	}
463
464	pdbc->current_qualifier
465	= (char FAR *) MEM_ALLOC (
466	STRLEN (vParam) + 1);
467
468	if (pdbc->current_qualifier == NULL)
469	{
470	PUSHSQLERR (pdbc->herr, en_S1001);
471	return SQL_ERROR;
472	}
473
474	STRCPY (pdbc->current_qualifier, vParam);
475	break;
476
477	case SQL_LOGIN_TIMEOUT:
478	pdbc->login_timeout = vParam;
479	break;
480
481	case SQL_ODBC_CURSORS:
482	pdbc->odbc_cursors = vParam;
483	break;
484
485	case SQL_PACKET_SIZE:
486	pdbc->packet_size = vParam;
487	break;
488
489	case SQL_QUIET_MODE:
490	pdbc->quiet_mode = vParam;
491	break;
492
493	case SQL_TXN_ISOLATION:
494	pdbc->txn_isolation = vParam;
495	break;
496
497	default:
498	/* Since we didn't save the option value for delaied
499	* setting, we should raise an error here.
500	*/
501	break;
502	}
503
504	return retcode;
1a6944fd RR	505	}
1a6944fd RR	506
7e616b10	507
cd5bf2a6 RR	508	RETCODE SQL_API
	509	SQLGetConnectOption (
	510	HDBC hdbc,
	511	UWORD fOption,
	512	PTR pvParam)
	513	{
	514	GENV_t FAR *genv;
	515	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	516	int sqlstat = en_00000;
	517	HPROC hproc = SQL_NULL_HPROC;
	518	RETCODE retcode;
	519
	520	if (hdbc == SQL_NULL_HDBC)
	521	{
	522	return SQL_INVALID_HANDLE;
	523	}
	524
	525	/* check option */
	526	if (fOption < SQL_CONN_OPT_MIN \|\|
	527	(fOption > SQL_CONN_OPT_MAX && fOption < SQL_CONNECT_OPT_DRVR_START))
	528	{
	529	PUSHSQLERR (pdbc->herr, en_S1092);
	530
	531	return SQL_ERROR;
	532	}
	533
	534	/* check state */
	535	switch (pdbc->state)
	536	{
	537	case en_dbc_allocated:
	538	if (fOption != SQL_ACCESS_MODE
	539	&& fOption != SQL_AUTOCOMMIT
	540	&& fOption != SQL_LOGIN_TIMEOUT
	541	&& fOption != SQL_OPT_TRACE
	542	&& fOption != SQL_OPT_TRACEFILE)
	543	{
	544	sqlstat = en_08003;
	545	}
	546	/* MS ODBC SDK document only
	547	* allows SQL_ACCESS_MODE
	548	* and SQL_AUTOCOMMIT in this
	549	* dbc state. We allow another
	550	* two options, because they
	551	* are only meaningful for driver
	552	* manager.
	553	*/
	554	break;
	555
	556	case en_dbc_needdata:
	557	sqlstat = en_S1010;
	558	break;
	559
	560	default:
	561	break;
	562	}
	563
	564	if (sqlstat != en_00000)
	565	{
	566	PUSHSQLERR (pdbc->herr, sqlstat);
	567
	568	return SQL_ERROR;
	569	}
	570
	571	/* Tracing and tracing file options are only
572	* meaningful for driver manager
573	*/
574	if (fOption == SQL_OPT_TRACE)
575	{
576	if (pdbc->trace)
577	((UDWORD ) pvParam) = (UDWORD) SQL_OPT_TRACE_ON;
578	else
579	((UDWORD ) pvParam) = (UDWORD) SQL_OPT_TRACE_OFF;
580
581	return SQL_SUCCESS;
582	}
583
584	if (fOption == SQL_OPT_TRACEFILE)
585	{
586	STRCPY (pvParam, pdbc->tfile);
587
588	return SQL_ERROR;
589	}
590
591	if (pdbc->state != en_dbc_allocated)
592	/* if already connected, we will invoke driver's function */
593	{
594	hproc = _iodbcdm_getproc (hdbc, en_GetConnectOption);
595
596	if (hproc == SQL_NULL_HPROC)
597	{
598	PUSHSQLERR (pdbc->herr, en_IM001);
599
600	return SQL_ERROR;
601	}
602
603	CALL_DRIVER (hdbc, retcode, hproc, en_GetConnectOption,
604	(pdbc->dhdbc, fOption, pvParam))
605
606	return retcode;
607	}
608
609	/* We needn't to handle options which are not allowed
610	* to be get at a allocated dbc state(and two tracing
611	* options which has been handled and returned). Thus,
612	* there are only two possible cases.
613	*/
614	switch (fOption)
615	{
616	case SQL_ACCESS_MODE:
617	((UDWORD ) pvParam) = pdbc->access_mode;
618	break;
619
620	case SQL_AUTOCOMMIT:
621	((UDWORD ) pvParam) = pdbc->autocommit;
622	break;
623
624	case SQL_LOGIN_TIMEOUT:
625	((UDWORD ) pvParam) = pdbc->login_timeout;
626	break;
627
628	default:
629	break;
630	}
631
632	return SQL_SUCCESS;
1a6944fd RR	633	}
1a6944fd RR	634
1a6944fd	635
cd5bf2a6 RR	636	static RETCODE
	637	_iodbcdm_transact (
	638	HDBC hdbc,
	639	UWORD fType)
	640	{
	641	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	642	STMT_t FAR *pstmt;
	643	HPROC hproc;
	644	RETCODE retcode;
	645
	646	/* check state */
	647	switch (pdbc->state)
	648	{
	649	case en_dbc_allocated:
	650	case en_dbc_needdata:
	651	PUSHSQLERR (pdbc->herr, en_08003);
	652	return SQL_ERROR;
	653
	654	case en_dbc_connected:
	655	return SQL_SUCCESS;
	656
	657	case en_dbc_hstmt:
	658	default:
	659	break;
	660	}
	661
	662	for (pstmt = (STMT_t FAR *) (pdbc->hstmt);
	663	pstmt != NULL;
	664	pstmt = pstmt->next)
	665	{
	666	if (pstmt->state >= en_stmt_needdata
	667	\|\| pstmt->asyn_on != en_NullProc)
	668	{
	669	PUSHSQLERR (pdbc->herr, en_S1010);
	670
	671	return SQL_ERROR;
	672	}
	673	}
	674
	675	hproc = _iodbcdm_getproc (hdbc, en_Transact);
	676
	677	if (hproc == SQL_NULL_HPROC)
	678	{
	679	PUSHSQLERR (pdbc->herr, en_IM001);
	680
	681	return SQL_ERROR;
	682	}
	683
	684	CALL_DRIVER (hdbc, retcode, hproc, en_Transact,
	685	(SQL_NULL_HENV, pdbc->dhdbc, fType))
	686
	687	/* state transition */
	688	if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
	689	{
	690	return retcode;
	691	}
	692
	693	pdbc->state = en_dbc_hstmt;
	694
	695	for (pstmt = (STMT_t FAR *) (pdbc->hstmt);
	696	pstmt != NULL;
	697	pstmt = pstmt->next)
	698	{
	699	switch (pstmt->state)
700	{
701	case en_stmt_prepared:
702	if (pdbc->cb_commit == SQL_CB_DELETE
703	\|\| pdbc->cb_rollback == SQL_CB_DELETE)
704	{
705	pstmt->state = en_stmt_allocated;
706	pstmt->prep_state = 0;
707	break;
708	}
709	break;
710
711	case en_stmt_executed:
712	case en_stmt_cursoropen:
713	case en_stmt_fetched:
714	case en_stmt_xfetched:
715	if (!pstmt->prep_state
716	&& pdbc->cb_commit != SQL_CB_PRESERVE
717	&& pdbc->cb_rollback != SQL_CB_PRESERVE)
718	{
719	pstmt->state = en_stmt_allocated;
720	pstmt->prep_state = 0;
721	pstmt->cursor_state = en_stmt_cursor_no;
722	break;
723	}
724
725	if (pstmt->prep_state)
726	{
727	if (pdbc->cb_commit == SQL_CB_DELETE
728	\|\| pdbc->cb_rollback == SQL_CB_DELETE)
729	{
730	pstmt->state = en_stmt_allocated;
731	pstmt->prep_state = 0;
732	pstmt->cursor_state = en_stmt_cursor_no;
733	break;
734	}
735
736	if (pdbc->cb_commit == SQL_CB_CLOSE
737	\|\| pdbc->cb_rollback == SQL_CB_CLOSE)
738	{
739	pstmt->state
740	= en_stmt_prepared;
741	pstmt->cursor_state
742	= en_stmt_cursor_no;
743	break;
744	}
745	break;
746	}
747	break;
748
749	default:
750	break;
751	}
752	}
753
754	return retcode;
1a6944fd RR	755	}
1a6944fd RR	756
cd5bf2a6 RR	757
	758	RETCODE SQL_API
	759	SQLTransact (
	760	HENV henv,
	761	HDBC hdbc,
	762	UWORD fType)
1a6944fd	763	{
cd5bf2a6 RR	764	GENV_t FAR genv = (GENV_t FAR ) henv;
	765	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	766	HERR herr;
	767	RETCODE retcode;
	768
	769	if (hdbc != SQL_NULL_HDBC)
	770	{
	771	herr = pdbc->herr;
	772	}
	773	else if (henv != SQL_NULL_HENV)
	774	{
	775	herr = genv->herr;
	776	}
	777	else
	778	{
	779	return SQL_INVALID_HANDLE;
	780	}
	781
	782	/* check argument */
	783	if (fType != SQL_COMMIT
	784	&& fType != SQL_ROLLBACK)
	785	{
	786	PUSHSQLERR (herr, en_S1012);
	787
	788	return SQL_ERROR;
	789	}
	790
	791	if (hdbc != SQL_NULL_HDBC)
	792	{
	793	retcode = _iodbcdm_transact (hdbc, fType);
	794	}
	795	else
	796	{
	797	for (pdbc = (DBC_t FAR *) (genv->hdbc);
	798	pdbc != NULL;
	799	pdbc = pdbc->next)
	800	{
	801	retcode \|= _iodbcdm_transact (hdbc, fType);
	802	}
	803	}
	804
	805	if (retcode != SQL_SUCCESS
	806	&& retcode != SQL_SUCCESS_WITH_INFO)
	807	{
	808	/* fail on one of the connection */
	809	return SQL_ERROR;
	810	}
	811
	812	return retcode;
1a6944fd	813	}