odbc3.c

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

    }
}


RETCODE SQL_API
SQLGetConnectAttr (SQLHDBC connectionHandle,
    SQLINTEGER Attribute,
    SQLPOINTER ValuePtr,
    SQLINTEGER StringLength,
    UNALIGNED SQLINTEGER * StringLengthPtr)
{
  CONN (con, connectionHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDBC (con);

  if (con->state == en_dbc_needdata)
    {
      PUSHSQLERR (con->herr, en_HY010);
      LEAVE_HDBC (con, SQL_ERROR);
    }

  hproc = _iodbcdm_getproc (con, en_GetConnectAttr);
  if (hproc)
    {
      CALL_DRIVER (con, con, retcode, hproc, en_GetConnectAttr,
	  (con->dhdbc, Attribute, ValuePtr, StringLength, StringLengthPtr));
      LEAVE_HDBC (con, retcode);
    }

  retcode = _iodbcdm_GetConnectOption (con, Attribute, ValuePtr);
  if (retcode != SQL_SUCCESS || retcode != SQL_SUCCESS_WITH_INFO)
    LEAVE_HDBC (con, retcode);

  if (StringLengthPtr)
    {
      *StringLengthPtr = 0;
      if (ValuePtr)
	switch (Attribute)
	  {
	  case SQL_ATTR_CURRENT_CATALOG:
	  case SQL_ATTR_TRACEFILE:
	  case SQL_ATTR_TRANSLATE_LIB:
	    *StringLengthPtr = strlen (ValuePtr);
	  }
    }
  LEAVE_HDBC (con, retcode);
}


RETCODE SQL_API
SQLGetDescField (SQLHDESC descriptorHandle,
    SQLSMALLINT RecNumber,
    SQLSMALLINT FieldIdentifier,
    SQLPOINTER ValuePtr,
    SQLINTEGER BufferLength,
    UNALIGNED SQLINTEGER * StringLengthPtr)
{
  DESC (desc, descriptorHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDESC (desc);

  hproc = _iodbcdm_getproc (desc->hdbc, en_GetDescField);
  if (!hproc)
    {
      PUSHSQLERR (desc->herr, en_IM001);
      LEAVE_HDESC (desc, SQL_ERROR);
    }

  CALL_DRIVER (desc->hdbc, desc, retcode, hproc, en_GetDescField,
      (desc->dhdesc, RecNumber, FieldIdentifier, ValuePtr, BufferLength,
	  StringLengthPtr));

  LEAVE_HDESC (desc, retcode);
}


RETCODE SQL_API
SQLSetDescField (SQLHDESC descriptorHandle,
    SQLSMALLINT RecNumber,
    SQLSMALLINT FieldIdentifier,
    SQLPOINTER ValuePtr,
    SQLINTEGER BufferLength)
{
  DESC (desc, descriptorHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDESC (desc);

  hproc = _iodbcdm_getproc (desc->hdbc, en_SetDescField);
  if (!hproc)
    {
      PUSHSQLERR (desc->herr, en_IM001);
      LEAVE_HDESC (desc, SQL_ERROR);
    }

  CALL_DRIVER (desc->hdbc, desc, retcode, hproc, en_SetDescField,
      (desc->dhdesc, RecNumber, FieldIdentifier, ValuePtr, BufferLength));

  LEAVE_HDESC (desc, retcode);
}


RETCODE SQL_API
SQLGetDescRec (SQLHDESC descriptorHandle,
    SQLSMALLINT RecNumber,
    SQLCHAR * Name,
    SQLSMALLINT BufferLength,
    UNALIGNED SQLSMALLINT * StringLengthPtr,
    UNALIGNED SQLSMALLINT * TypePtr,
    UNALIGNED SQLSMALLINT * SubTypePtr,
    UNALIGNED SQLINTEGER * LengthPtr,
    UNALIGNED SQLSMALLINT * PrecisionPtr,
    UNALIGNED SQLSMALLINT * ScalePtr,
    UNALIGNED SQLSMALLINT * NullablePtr)
{
  DESC (desc, descriptorHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDESC (desc);

  hproc = _iodbcdm_getproc (desc->hdbc, en_GetDescRec);
  if (!hproc)
    {
      PUSHSQLERR (desc->herr, en_IM001);
      LEAVE_HDESC (desc, SQL_ERROR);
    }

  CALL_DRIVER (desc->hdbc, desc, retcode, hproc, en_GetDescRec,
      (desc->dhdesc, RecNumber, Name, BufferLength, StringLengthPtr, TypePtr, SubTypePtr, LengthPtr, PrecisionPtr, ScalePtr, NullablePtr));

  LEAVE_HDESC (desc, retcode);
}


RETCODE SQL_API
SQLSetDescRec (SQLHDESC arg0,
    SQLSMALLINT arg1,
    SQLSMALLINT arg2,
    SQLSMALLINT arg3,
    SQLINTEGER arg4,
    SQLSMALLINT arg5,
    SQLSMALLINT arg6,
    SQLPOINTER arg7,
    UNALIGNED SQLINTEGER * arg8,
    UNALIGNED SQLINTEGER * arg9)
{
  DESC (desc, arg0);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDESC (desc);

  hproc = _iodbcdm_getproc (desc->hdbc, en_SetDescRec);
  if (!hproc)
    {
      PUSHSQLERR (desc->herr, en_IM001);
      LEAVE_HDESC (desc, SQL_ERROR);
    }

  CALL_DRIVER (desc->hdbc, desc, retcode, hproc, en_SetDescRec,
      (desc->dhdesc, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));

  LEAVE_HDESC (desc, retcode);
}


RETCODE SQL_API
SQLCopyDesc (
    SQLHDESC arg0,
    SQLHDESC arg1)
{

  DESC (desc, arg0);
  DESC (desc1, arg1);
  HPROC hproc;
  RETCODE retcode;

  ENTER_HDESC (desc);

  ODBC_LOCK ();
  if (!IS_VALID_HDESC (desc1))
    {
      ODBC_UNLOCK ();
      LEAVE_HDESC (desc, SQL_INVALID_HANDLE);
    }
  CLEAR_ERRORS (desc1);
  ODBC_UNLOCK ();

  hproc = _iodbcdm_getproc (desc->hdbc, en_CopyDesc);
  if (!hproc)
    {
      PUSHSQLERR (desc->herr, en_IM001);
      LEAVE_HDESC (desc, SQL_ERROR);
    }

  CALL_DRIVER (desc->hdbc, desc, retcode, hproc, en_CopyDesc,
      (desc->dhdesc, desc1->dhdesc));

  LEAVE_HDESC (desc, retcode);
}


RETCODE SQL_API
SQLColAttribute (
    SQLHSTMT statementHandle,
    SQLUSMALLINT ColumnNumber,
    SQLUSMALLINT FieldIdentifier,
    SQLPOINTER CharacterAttributePtr,
    SQLSMALLINT BufferLength,
    UNALIGNED SQLSMALLINT * StringLengthPtr,
    SQLPOINTER NumericAttributePtr)
{
  STMT (stmt, statementHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_STMT (stmt);

  hproc = _iodbcdm_getproc (stmt->hdbc, en_ColAttribute);
  if (hproc)
    {
      CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_ColAttribute,
	  (stmt->dhstmt, ColumnNumber, FieldIdentifier, CharacterAttributePtr, BufferLength, StringLengthPtr, NumericAttributePtr));
      LEAVE_STMT (stmt, retcode);
    }

  if (ColumnNumber == 0)
    {
      char *szval = "";
      int isSz = 0;
      SQLINTEGER val = 0;

      switch (FieldIdentifier)
	{
	case SQL_DESC_AUTO_UNIQUE_VALUE:
	case SQL_DESC_CASE_SENSITIVE:
	case SQL_DESC_FIXED_PREC_SCALE:
	case SQL_DESC_UNSIGNED:
	  val = SQL_FALSE;
	  break;

	case SQL_DESC_LABEL:
	case SQL_DESC_CATALOG_NAME:
	case SQL_DESC_LITERAL_PREFIX:
	case SQL_DESC_LITERAL_SUFFIX:
	case SQL_DESC_LOCAL_TYPE_NAME:
	case SQL_DESC_NAME:
	case SQL_DESC_SCHEMA_NAME:
	case SQL_DESC_TABLE_NAME:
	case SQL_DESC_TYPE_NAME:
	  isSz = 1;
	  break;

	case SQL_DESC_CONCISE_TYPE:
	case SQL_DESC_TYPE:
	  val = SQL_BINARY;
	  break;

	case SQL_DESC_COUNT:
	  hproc = _iodbcdm_getproc (stmt->hdbc, en_NumResultCols);
	  if (!hproc)
	    {
	      PUSHSQLERR (stmt->herr, en_IM001);
	      LEAVE_STMT (stmt, SQL_ERROR);
	    }
	  CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_NumResultCols,
	      (stmt->dhstmt, NumericAttributePtr));
	  LEAVE_STMT (stmt, retcode);

	case SQL_DESC_LENGTH:
	case SQL_DESC_DATETIME_INTERVAL_CODE:
	case SQL_DESC_SCALE:
	  val = 0;
	  break;

	case SQL_DESC_DISPLAY_SIZE:
	  val = 8;
	  break;

	case SQL_DESC_NULLABLE:
	  val = SQL_NO_NULLS;
	  break;

	case SQL_DESC_OCTET_LENGTH:
	case SQL_DESC_PRECISION:
	  val = 4;
	  break;

	case SQL_DESC_SEARCHABLE:
	  val = SQL_PRED_NONE;
	  break;

	case SQL_DESC_UNNAMED:
	  val = SQL_UNNAMED;
	  break;

	case SQL_DESC_UPDATABLE:
	  val = SQL_ATTR_READONLY;
	  break;

	default:
	  PUSHSQLERR (stmt->herr, en_HYC00);
	  LEAVE_STMT (stmt, SQL_ERROR);
	}
      if (isSz)
	{
	  int len = STRLEN (szval), len1;
	  len1 = len > BufferLength ? BufferLength - 1 : len;
	  if (CharacterAttributePtr)
	    {
	      STRNCPY (CharacterAttributePtr, szval, len1);
	      ((SQLCHAR FAR *) CharacterAttributePtr)[len1] = 0;
	    }
	  if (StringLengthPtr)
	    *StringLengthPtr = len;
	}
      else
	{
	  if (NumericAttributePtr)
	    *((SQLINTEGER *) NumericAttributePtr) = val;
	}
      LEAVE_STMT (stmt, SQL_SUCCESS);
    }
  else
    {				/* all other */
      switch (FieldIdentifier)
	{
	case SQL_DESC_SCALE:
	  FieldIdentifier = SQL_COLUMN_SCALE;
	  break;

	case SQL_DESC_LENGTH:
	  FieldIdentifier = SQL_COLUMN_LENGTH;
	  break;

	case SQL_DESC_PRECISION:
	  FieldIdentifier = SQL_COLUMN_PRECISION;
	  break;

	case SQL_DESC_COUNT:
	  FieldIdentifier = SQL_COLUMN_COUNT;
	  break;

	case SQL_DESC_NAME:
	  FieldIdentifier = SQL_COLUMN_NAME;
	  break;

	case SQL_DESC_NULLABLE:
	  FieldIdentifier = SQL_COLUMN_NULLABLE;
	  break;

	case SQL_DESC_TYPE:
	  FieldIdentifier = SQL_COLUMN_TYPE;
	  break;

	case SQL_DESC_BASE_COLUMN_NAME:
	case SQL_DESC_BASE_TABLE_NAME:
	case SQL_DESC_LITERAL_PREFIX:
	case SQL_DESC_LITERAL_SUFFIX:
	case SQL_DESC_LOCAL_TYPE_NAME:
	case SQL_DESC_NUM_PREC_RADIX:
	case SQL_DESC_OCTET_LENGTH:
	case SQL_DESC_UNNAMED:
	  PUSHSQLERR (stmt->herr, en_HY091);
	  LEAVE_STMT (stmt, SQL_ERROR);
	}
      hproc = _iodbcdm_getproc (stmt->hdbc, en_ColAttributes);
      if (hproc)
	{

	  CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_ColAttribute,
	      (stmt->dhstmt, ColumnNumber, FieldIdentifier, CharacterAttributePtr, BufferLength, StringLengthPtr, NumericAttributePtr));
	  LEAVE_STMT (stmt, retcode);
	}
      else
	{
	  PUSHSQLERR (stmt->herr, en_IM001);
	  LEAVE_STMT (stmt, SQL_ERROR);
	}
    }
}


RETCODE SQL_API
SQLEndTran (SQLSMALLINT handleType,
    SQLHANDLE Handle,
    SQLSMALLINT completionType)
{
  switch (handleType)
    {
    case SQL_HANDLE_DBC:
    case SQL_HANDLE_ENV:
      break;
    default:
      return SQL_INVALID_HANDLE;
    }

  return SQLTransact (
      handleType == SQL_HANDLE_ENV ? Handle : SQL_NULL_HENV,
      handleType == SQL_HANDLE_DBC ? Handle : SQL_NULL_HDBC,
      completionType);
}


RETCODE SQL_API
SQLBulkOperations (SQLHSTMT statementHandle,
    SQLSMALLINT Operation)
{
  STMT (stmt, statementHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_STMT (stmt);

  switch (Operation)
    {
    case SQL_ADD:
    case SQL_UPDATE_BY_BOOKMARK:
    case SQL_DELETE_BY_BOOKMARK:
    case SQL_FETCH_BY_BOOKMARK:
      break;
    default:
      PUSHSQLERR (stmt->herr, en_HY092);
      LEAVE_STMT (stmt, SQL_ERROR);
    }

  hproc = _iodbcdm_getproc (stmt->hdbc, en_BulkOperations);
  if (hproc)
    {
      CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_BulkOperations,
	  (stmt->dhstmt, Operation));
      LEAVE_STMT (stmt, retcode);
    }

  switch (Operation)
    {
    case SQL_ADD:
      retcode = _iodbcdm_SetPos (statementHandle, 
		0, SQL_ADD, SQL_LOCK_NO_CHANGE);
      LEAVE_STMT (stmt, retcode);

    default:
      PUSHSQLERR (stmt->herr, en_HYC00);
      LEAVE_STMT (stmt, SQL_ERROR);
    }
}


RETCODE SQL_API
SQLFetchScroll (SQLHSTMT statementHandle,
    SQLSMALLINT fetchOrientation,
    SQLINTEGER fetchOffset)
{
  STMT (stmt, statementHandle);
  HPROC hproc;
  RETCODE retcode;

  ENTER_STMT (stmt);

  switch (fetchOrientation)
    {
    case SQL_FETCH_NEXT:
    case SQL_FETCH_PRIOR:
    case SQL_FETCH_FIRST:
    case SQL_FETCH_LAST:
    case SQL_FETCH_ABSOLUTE:
    case SQL_FETCH_RELATIVE:
    case SQL_FETCH_BOOKMARK:
      break;
    default:
      PUSHSQLERR (stmt->herr, en_HY092);
      LEAVE_STMT (stmt, SQL_ERROR);
    }

  hproc = _iodbcdm_getproc (stmt->hdbc, en_FetchScroll);
  if (hproc)
    {
      CALL_DRIVER (stmt->hdbc, stmt, retcode, hproc, en_FetchScroll,
	  (stmt->dhstmt, fetchOrientation, fetchOffset));
      LEAVE_STMT (stmt, retcode);
    }

  if (!stmt->row_status_ptr)
    {
      PUSHSQLERR (stmt->herr, en_HYC00);
      LEAVE_STMT (stmt, SQL_ERROR);
    }

  if (fetchOrientation == SQL_FETCH_BOOKMARK)
    {
      if (fetchOffset)
	{
	  PUSHSQLERR (stmt->herr, en_HYC00);
	  LEAVE_STMT (stmt, SQL_ERROR);
	}
      retcode = _iodbcdm_ExtendedFetch (statementHandle, fetchOrientation,
	  stmt->fetch_bookmark_ptr ? *((SQLINTEGER *) stmt->fetch_bookmark_ptr) : 0,
	  stmt->rows_fetched_ptr, stmt->row_status_ptr);
    }
  else
    retcode =
	_iodbcdm_ExtendedFetch (statementHandle, fetchOrientation,
	fetchOffset, stmt->rows_fetched_ptr, stmt->row_status_ptr);

  LEAVE_STMT (stmt, retcode);
}


SQLRETURN SQL_API
SQLBindParam (
    SQLHSTMT hstmt,
    SQLUSMALLINT ipar,
    SQLSMALLINT fCType,
    SQLSMALLINT fSqlType,
    SQLUINTEGER cbParamDef,
    SQLSMALLINT ibScale,
    SQLPOINTER rgbValue,
    SQLINTEGER FAR * pcbValue)
{
  return SQLBindParameter (hstmt, ipar, SQL_PARAM_INPUT, fCType, fSqlType, cbParamDef, ibScale, rgbValue, SQL_MAX_OPTION_STRING_LENGTH, pcbValue);
}


SQLRETURN SQL_API
SQLCloseCursor (SQLHSTMT hstmt)
{
  STMT (pstmt, hstmt);
  DBC_t FAR *pdbc;
  HPROC hproc = SQL_NULL_HPROC;
  SQLRETURN retcode;

  ENTER_STMT (pstmt);

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

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

      LEAVE_STMT (pstmt, SQL_ERROR);
    }
  else if (pstmt->state < en_stmt_cursoropen)
    {
      PUSHSQLERR (pstmt->herr, en_24000);

      LEAVE_STMT (pstmt, SQL_ERROR);
    }

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

  if (hproc)
    {
      CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc, en_CloseCursor,
	  (pstmt->dhstmt));
    }

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

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

	  LEAVE_STMT (pstmt, SQL_ERROR);
	}

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

  if (retcode != SQL_SUCCESS
      && retcode != SQL_SUCCESS_WITH_INFO)
    {
      LEAVE_STMT (pstmt, retcode);
    }

  /*
   *  State transition
   */
  pstmt->cursor_state = en_stmt_cursor_no;

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

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

    default:
      break;
    }

  LEAVE_STMT (pstmt, retcode);
}

#endif	/* ODBCVER >= 0x0300 */