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)
{
  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)
{
  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 = 0;

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