herr.c

一个可以替代windows ODBC驱动程序管理器的通用ODBC数据库引擎

	  char *errmsg;

	  /* get sql state message */
	  errmsg =
	      _iodbcdm_getsqlerrmsg (curr_err, (void FAR *) sqlerrmsg_tab);

	  if (errmsg == NULL)
	    {
	      errmsg = (char FAR *) "";
	    }

	  sprintf (msgbuf, "%s%s", sqlerrhd, errmsg);

	  len = STRLEN (msgbuf);

	  if (len < BufferLength - 1)
	    {
	      retcode = SQL_SUCCESS;
	    }
	  else
	    {
	      len = BufferLength - 1;
	      retcode = SQL_SUCCESS_WITH_INFO;
	      /* and not posts error for itself */
	    }

	  STRNCPY ((char *) MessageText, msgbuf, len);
	  MessageText[len] = 0;

	  if (TextLengthPtr != NULL)
	    {
	      *TextLengthPtr = (SWORD) len;
	    }
	}
      ODBC_UNLOCK ();
      return retcode;
    }
  else
    {				/* Driver errors */
      if (hdbc == SQL_NULL_HDBC)
	{
	  ODBC_UNLOCK ();
	  return SQL_NO_DATA_FOUND;
	}
      RecNumber -= nRecs;

      hproc = _iodbcdm_getproc (hdbc, en_GetDiagRec);
      if (hproc != SQL_NULL_HPROC)
	{
	  CALL_DRIVER (hdbc, Handle, retcode, hproc, en_GetDiagRec,
	      (HandleType, dhandle, RecNumber, Sqlstate, NativeErrorPtr,
		  MessageText, BufferLength, TextLengthPtr));

	  ODBC_UNLOCK ();
	  return retcode;
	}
      else
	{			/* no SQLGetDiagRec */
	  hproc = _iodbcdm_getproc (hdbc, en_Error);

	  if (hproc == SQL_NULL_HPROC || RecNumber > 1
	      || HandleType == SQL_HANDLE_DESC)
	    {
	      ODBC_UNLOCK ();
	      return SQL_NO_DATA_FOUND;
	    }

	  CALL_DRIVER (hdbc, Handle, retcode, hproc, en_Error,
	      (SQL_NULL_HENV,
	       HandleType == SQL_HANDLE_DBC ? dhandle : SQL_NULL_HDBC,
	       HandleType == SQL_HANDLE_STMT ? dhandle : SQL_NULL_HSTMT,
	       Sqlstate, NativeErrorPtr, MessageText, BufferLength, 
	       TextLengthPtr));

	  ODBC_UNLOCK ();
	  return retcode;
	}
    }
}


RETCODE SQL_API
SQLGetDiagField (SQLSMALLINT nHandleType,
    SQLHANDLE Handle,
    SQLSMALLINT nRecNumber,
    SQLSMALLINT nDiagIdentifier,
    SQLPOINTER pDiagInfoPtr,
    SQLSMALLINT nBufferLength,
    UNALIGNED SQLSMALLINT * pnStringLengthPtr)
{
  GENV (genv, Handle);
  CONN (con, Handle);
  STMT (stmt, Handle);
  DESC (desc, Handle);
  HERR err;
  int odbc_ver;
  HPROC hproc;
  RETCODE retcode;
  SQLHANDLE dhandle = SQL_NULL_HANDLE;

  ODBC_LOCK ();
  switch (nHandleType)
    {
    case SQL_HANDLE_ENV:
      if (!IS_VALID_HENV (Handle))
	{
	  ODBC_UNLOCK ();
	  return SQL_INVALID_HANDLE;
	}
      err = genv->herr;
      con = NULL;
      stmt = NULL;
      desc = NULL;
      break;

    case SQL_HANDLE_DBC:
      if (!IS_VALID_HDBC (Handle))
	{
	  ODBC_UNLOCK ();
	  return SQL_INVALID_HANDLE;
	}
      err = con->herr;
      genv = con->genv;
      stmt = NULL;
      desc = NULL;
      dhandle = con->dhdbc;
      break;

    case SQL_HANDLE_STMT:
      if (!IS_VALID_HSTMT (Handle))
	{
	  ODBC_UNLOCK ();
	  return SQL_INVALID_HANDLE;
	}
      err = stmt->herr;
      con = stmt->hdbc;
      genv = con->genv;
      desc = NULL;
      dhandle = stmt->dhstmt;
      break;

    case SQL_HANDLE_DESC:
      if (!IS_VALID_HDESC (Handle))
	{
	  ODBC_UNLOCK ();
	  return SQL_INVALID_HANDLE;
	}
      err = desc->herr;
      stmt = desc->hstmt;
      con = desc->hdbc;
      genv = con->genv;
      dhandle = desc->dhdesc;
      break;

    default:
      ODBC_UNLOCK ();
      return SQL_INVALID_HANDLE;
    }

  switch (nRecNumber)
    {

    case 0:			/* Header record */
      switch (nDiagIdentifier)
	{
	case SQL_DIAG_ROW_COUNT:
	  {
	    if (nHandleType != SQL_HANDLE_STMT || !stmt)
	      {
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }

	    if (stmt->state != en_stmt_executed &&
		stmt->state != en_stmt_cursoropen)
	      {
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }
	    if (!con)
	      {
		ODBC_UNLOCK ();
		return SQL_INVALID_HANDLE;
	      }
	    hproc = _iodbcdm_getproc (con, en_GetDiagField);
	    if (hproc)
	      {
		CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc,
		    en_GetDiagField, (SQL_HANDLE_DBC, stmt->dhstmt,
			nRecNumber, nDiagIdentifier, pDiagInfoPtr,
			nBufferLength, pnStringLengthPtr));
	      }
	    else
	      {
		if (!con)
		  {
		    ODBC_UNLOCK ();
		    return SQL_INVALID_HANDLE;
		  }
		hproc = _iodbcdm_getproc (con, en_RowCount);
		if (!hproc)
		  {
		    ODBC_UNLOCK ();
		    return SQL_ERROR;
		  }
		CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_RowCount,
		    (stmt->dhstmt, pDiagInfoPtr));
	      }
	    ODBC_UNLOCK ();
	    return retcode;
	  }

	case SQL_DIAG_CURSOR_ROW_COUNT:
	case SQL_DIAG_DYNAMIC_FUNCTION:
	case SQL_DIAG_DYNAMIC_FUNCTION_CODE:

	  {
	    if (nHandleType != SQL_HANDLE_STMT || !stmt)
	      {
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }

	    if (stmt->state != en_stmt_executed &&
		stmt->state != en_stmt_cursoropen)
	      {
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }
	    if (!con)
	      {
		ODBC_UNLOCK ();
		return SQL_INVALID_HANDLE;
	      }
	    hproc = _iodbcdm_getproc (con, en_GetDiagField);
	    if (hproc)
	      {
		CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc,
		    en_GetDiagField, (SQL_HANDLE_DBC, stmt->dhstmt,
			nRecNumber, nDiagIdentifier, pDiagInfoPtr,
			nBufferLength, pnStringLengthPtr));

		ODBC_UNLOCK ();
		return retcode;
	      }
	    else
	      {
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }
	  }

	case SQL_DIAG_RETURNCODE:

	  if (pDiagInfoPtr)
	    *((SQLRETURN *) pDiagInfoPtr) = ((GENV_t FAR *) Handle)->rc;
	  {
	    ODBC_UNLOCK ();
	    return SQL_SUCCESS;
	  }

	case SQL_DIAG_NUMBER:

	  if (pDiagInfoPtr)
	    {
	      (*(SQLINTEGER *) pDiagInfoPtr) = 0;
	      /* get the number from the driver */
	      if (con)
		{
		  hproc = _iodbcdm_getproc (con, en_GetDiagField);
		  if (hproc)
		    {
		      CALL_DRIVER (con, Handle, retcode, hproc,
			  en_GetDiagField, (nHandleType, dhandle, 0,
			      nDiagIdentifier, pDiagInfoPtr, nBufferLength,
			      pnStringLengthPtr));

		      if (retcode != SQL_SUCCESS)
			{
			  ODBC_UNLOCK ();
			  return retcode;
			}

		      /* and add the DM's value */
		      (*(SQLINTEGER *) pDiagInfoPtr) += error_rec_count (err);
		    }
		  else if (((ENV_t *) con->henv)->dodbc_ver == SQL_OV_ODBC2 &&
		      ((GENV_t FAR *) Handle)->rc)
		    {		/* ODBC2 drivers can only have one errror */
		      (*(SQLINTEGER *) pDiagInfoPtr) = 1;
		    }
		}
	      else if (genv)
		{
		  (*(SQLINTEGER *) pDiagInfoPtr) = error_rec_count (err);
		}

	    }
	  break;

	default:
	  ODBC_UNLOCK ();
	  return SQL_ERROR;
	}
      break;

    default:			/* status records */
      {
	int nRecs = 0;

	if (nRecNumber < 1)
	  {
	    ODBC_UNLOCK ();
	    return SQL_ERROR;
	  }
	nRecs = error_rec_count (err);
	if (nRecNumber <= nRecs)
	  {			/* DM Errors */
	    char *szval = "";
	    int ival = 0;
	    int isInt = 0;
	    sqlerr_t *rec = NULL;

	    rec = get_nth_error (err, nRecNumber - 1);

	    if (!rec)
	      {
		ODBC_UNLOCK ();
		return (SQL_NO_DATA_FOUND);
	      }

	    switch (nDiagIdentifier)
	      {

	      case SQL_DIAG_SUBCLASS_ORIGIN:
	      case SQL_DIAG_CLASS_ORIGIN:
		isInt = 0;

		szval = (rec->code >= en_HY001
		    && rec->code <= en_IM014) ? "ODBC 3.0" : "ISO 9075";
		break;

	      case SQL_DIAG_COLUMN_NUMBER:

		if (nHandleType != SQL_HANDLE_STMT || !stmt)
		  {
		    ODBC_UNLOCK ();
		    return SQL_ERROR;
		  }
		if (!con)
		  {
		    ODBC_UNLOCK ();
		    return SQL_INVALID_HANDLE;
		  }

		if (pDiagInfoPtr)
		  *((SQLINTEGER *) pDiagInfoPtr) = SQL_COLUMN_NUMBER_UNKNOWN;

		ODBC_UNLOCK ();
		return SQL_SUCCESS;

	      case SQL_DIAG_CONNECTION_NAME:
	      case SQL_DIAG_SERVER_NAME:

		isInt = 0;
		if (con)
		  {
		    retcode =
			SQLGetInfo (con, SQL_DATA_SOURCE_NAME, pDiagInfoPtr,
			nBufferLength, pnStringLengthPtr);

		    ODBC_UNLOCK ();
		    return retcode;
		  }
		else
		  break;

	      case SQL_DIAG_MESSAGE_TEXT:

		isInt = 0;
		szval =
		    _iodbcdm_getsqlerrmsg (rec, (void FAR *) sqlerrmsg_tab);
		break;

	      case SQL_DIAG_NATIVE:

		isInt = 1;
		ival = 0;
		break;

	      case SQL_DIAG_ROW_NUMBER:

		isInt = 1;
		if (nHandleType != SQL_HANDLE_STMT || !stmt)
		  {
		    ODBC_UNLOCK ();
		    return SQL_ERROR;
		  }
		if (!con)
		  {
		    ODBC_UNLOCK ();
		    return SQL_INVALID_HANDLE;
		  }
		hproc = _iodbcdm_getproc (con, en_GetDiagField);
		if (hproc)
		  {
		    CALL_DRIVER (con, Handle, retcode, hproc, en_GetDiagField,
			(nHandleType, dhandle, nRecNumber, nDiagIdentifier,
			    pDiagInfoPtr, nBufferLength, pnStringLengthPtr));

		    ODBC_UNLOCK ();
		    return retcode;
		  }
		else
		  {
		    ival = SQL_ROW_NUMBER_UNKNOWN;
		    break;
		  }

	      case SQL_DIAG_SQLSTATE:

		isInt = 0;
		szval =
		    _iodbcdm_getsqlstate (rec, (void FAR *) sqlerrmsg_tab);
		break;

	      default:
		ODBC_UNLOCK ();
		return SQL_ERROR;
	      }
	    if (isInt)
	      {
		if (pDiagInfoPtr)
		  *((SQLINTEGER *) pDiagInfoPtr) = ival;
	      }
	    else
	      {
		int len = strlen (szval), len1;
		len1 = len > nBufferLength ? nBufferLength : len;
		if (pnStringLengthPtr)
		  *pnStringLengthPtr = len;
		if (pDiagInfoPtr)
		  {
		    STRNCPY (pDiagInfoPtr, szval, len1);
		    *(((SQLCHAR FAR *) pDiagInfoPtr) + len1) = 0;
		  }
	      }
	    break;
	  }
	else
	  {			/* Driver's errors */
	    nRecNumber -= nRecs;

	    if (!con)
	      {
		ODBC_UNLOCK ();
		return SQL_NO_DATA_FOUND;
	      }

	    hproc = _iodbcdm_getproc (con, en_GetDiagField);
	    if (hproc != SQL_NULL_HPROC)
	      {
		CALL_DRIVER (con, Handle, retcode, hproc, en_GetDiagField,
		    (nHandleType, dhandle, nRecNumber, nDiagIdentifier,
			pDiagInfoPtr, nBufferLength, pnStringLengthPtr));

		ODBC_UNLOCK ();
		return retcode;
	      }
	    else
	      {			/* an ODBC2->ODBC3 translation */
		char *szval = "";
		char szState[6];
		SQLINTEGER nNative;

		if (nRecNumber > 1)
		  {
		    ODBC_UNLOCK ();
		    return SQL_NO_DATA_FOUND;
		  }

		hproc = _iodbcdm_getproc (con, en_Error);
		if (hproc == SQL_NULL_HPROC || nHandleType == SQL_HANDLE_DESC)
		  {
		    ODBC_UNLOCK ();
		    return SQL_INVALID_HANDLE;
		  }
		switch (nDiagIdentifier)
		  {
		  case SQL_DIAG_SUBCLASS_ORIGIN:
		  case SQL_DIAG_CLASS_ORIGIN:
		    CALL_DRIVER (con, Handle, retcode, hproc, en_Error,
			(SQL_NULL_HENV,
nHandleType == SQL_HANDLE_DBC ? dhandle : SQL_NULL_HDBC,
			    nHandleType ==
			    SQL_HANDLE_STMT ? dhandle : SQL_NULL_HSTMT,
			    szState, &nNative, NULL, 0, NULL));
		    if (retcode != SQL_SUCCESS)
		      {
			ODBC_UNLOCK ();
			return SQL_NO_DATA_FOUND;
		      }
		    szval =
			!strncmp (szState, "IM", 2) ? "ODBC 3.0" : "ISO 9075";
		    break;

		  case SQL_DIAG_ROW_NUMBER:
		  case SQL_DIAG_COLUMN_NUMBER:
		    if (nHandleType != SQL_HANDLE_STMT || !stmt)
		      {
			ODBC_UNLOCK ();
			return SQL_ERROR;
		      }
		    if (!con)
		      {
			ODBC_UNLOCK ();
			return SQL_INVALID_HANDLE;
		      }
		    if (pDiagInfoPtr)
		      *((SQLINTEGER *) pDiagInfoPtr) =
			  SQL_COLUMN_NUMBER_UNKNOWN;
		    {
		      ODBC_UNLOCK ();
		      return SQL_SUCCESS;
		    }

		  case SQL_DIAG_SERVER_NAME:
		  case SQL_DIAG_CONNECTION_NAME:
		    break;

		  case SQL_DIAG_MESSAGE_TEXT:
		    CALL_DRIVER (con, Handle, retcode, hproc, en_Error,
			(SQL_NULL_HENV,
nHandleType == SQL_HANDLE_DBC ? dhandle : SQL_NULL_HDBC,
			    nHandleType ==
			    SQL_HANDLE_STMT ? dhandle : SQL_NULL_HSTMT,
			    szState, &nNative, pDiagInfoPtr, nBufferLength,
			    pnStringLengthPtr));
		    ODBC_UNLOCK ();
		    return retcode;

		  case SQL_DIAG_NATIVE:
		    CALL_DRIVER (con, Handle, retcode, hproc, en_Error,
			(SQL_NULL_HENV,
nHandleType == SQL_HANDLE_DBC ? dhandle : SQL_NULL_HDBC,
			    nHandleType ==
			    SQL_HANDLE_STMT ? dhandle : SQL_NULL_HSTMT,
			    szState, &nNative, NULL, 0, NULL));
		    if (pDiagInfoPtr)
		      *((SQLINTEGER *) pDiagInfoPtr) = nNative;
		    ODBC_UNLOCK ();
		    return retcode;

		  case SQL_DIAG_SQLSTATE:
		    CALL_DRIVER (con, Handle, retcode, hproc, en_Error,
			(SQL_NULL_HENV,
nHandleType == SQL_HANDLE_DBC ? dhandle : SQL_NULL_HDBC,
			    nHandleType ==
			    SQL_HANDLE_STMT ? dhandle : SQL_NULL_HSTMT,
			    pDiagInfoPtr, &nNative, NULL, 0, NULL));

		    if (pnStringLengthPtr)
		      *pnStringLengthPtr = 5;

		    ODBC_UNLOCK ();
		    return retcode;

		  default:
		    ODBC_UNLOCK ();
		    return SQL_ERROR;
		  }
		if (pDiagInfoPtr)
		  {
		    int len = strlen (szval);
		    if (len > nBufferLength)
		      len = nBufferLength;
		    if (len)
		      strncpy (pDiagInfoPtr, szval, len);
		  }
		if (pnStringLengthPtr)
		  *pnStringLengthPtr = strlen (szval);
	      }			/* ODBC3->ODBC2 */
	  }			/* driver's errors */
      }				/* status records */
    }				/* switch (nRecNumber */
  ODBC_UNLOCK ();
  return (SQL_SUCCESS);
}
#endif