[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)
{
  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
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
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 VZ	39	#include "itrace.h"
88ac883a VZ	40	#include "stdio.h"
1a6944fd	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	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
7e616b10	297	#endif
cd5bf2a6 RR	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))
1a6944fd RR	325	#endif
1a6944fd RR	326
cd5bf2a6 RR	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;
1a6944fd RR	504	}
1a6944fd RR	505
7e616b10	506
cd5bf2a6 RR	507	RETCODE SQL_API
	508	SQLGetConnectOption (
	509	HDBC hdbc,
	510	UWORD fOption,
	511	PTR pvParam)
	512	{
cd5bf2a6 RR	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;
1a6944fd RR	631	}
1a6944fd RR	632
1a6944fd	633
cd5bf2a6 RR	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;
1a6944fd RR	753	}
1a6944fd RR	754
cd5bf2a6 RR	755
	756	RETCODE SQL_API
	757	SQLTransact (
	758	HENV henv,
	759	HDBC hdbc,
	760	UWORD fType)
1a6944fd	761	{
cd5bf2a6 RR	762	GENV_t FAR genv = (GENV_t FAR ) henv;
	763	DBC_t FAR pdbc = (DBC_t FAR ) hdbc;
	764	HERR herr;
88ac883a	765	RETCODE retcode = 0;
cd5bf2a6 RR	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;
1a6944fd	811	}