src/iodbc/catalog.c

/*
 *  catalog.c
 *
 *  $Id$
 *
 *  Catalog 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"

#ifndef NULL
#define NULL 0
#endif

static RETCODE
_iodbcdm_cata_state_ok (
    HSTMT hstmt,
    int fidx)
/* check state for executing catalog functions */
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  int sqlstat = en_00000;

  if (pstmt->asyn_on == en_NullProc)
    {
      switch (pstmt->state)
	 {
	 case en_stmt_needdata:
	 case en_stmt_mustput:
	 case en_stmt_canput:
	   sqlstat = en_S1010;
	   break;

	 case en_stmt_fetched:
	 case en_stmt_xfetched:
	   sqlstat = en_24000;
	   break;

	 default:
	   break;
	 }
    }
  else if (pstmt->asyn_on != fidx)
    {
      sqlstat = en_S1010;
    }

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

      return SQL_ERROR;
    }

  return SQL_SUCCESS;
}


static RETCODE
_iodbcdm_cata_state_tr (
    HSTMT hstmt,
    int fidx,
    RETCODE result)
/* state transition for catalog function */
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  DBC_t FAR *pdbc;

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

  if (pstmt->asyn_on == fidx)
    {
      switch (result)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	 case SQL_ERROR:
	   pstmt->asyn_on = en_NullProc;
	   break;

	 case SQL_STILL_EXECUTING:
	 default:
	   return result;
	 }
    }

  if (pstmt->state <= en_stmt_executed)
    {
      switch (result)
	 {
	 case SQL_SUCCESS:
	 case SQL_SUCCESS_WITH_INFO:
	   pstmt->state = en_stmt_cursoropen;
	   break;

	 case SQL_ERROR:
	   pstmt->state = en_stmt_allocated;
	   pstmt->prep_state = 0;
	   break;

	 case SQL_STILL_EXECUTING:
	   pstmt->asyn_on = fidx;
	   break;

	 default:
	   break;
	 }
    }

  return result;
}


RETCODE SQL_API
SQLGetTypeInfo (
    HSTMT hstmt,
    SWORD fSqlType)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  int sqlstat = en_00000;
  RETCODE retcode;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if (fSqlType > SQL_TYPE_MAX)
	{
	  sqlstat = en_S1004;
	  break;
	}

      /* Note: SQL_TYPE_DRIVER_START is a negative number So, we use ">" */
      if (fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START)
	{
	  sqlstat = en_S1004;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_GetTypeInfo);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;
      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetTypeInfo,
    (pstmt->dhstmt, fSqlType))

  return _iodbcdm_cata_state_tr (hstmt, en_GetTypeInfo, retcode);
}


RETCODE SQL_API
SQLSpecialColumns (
    HSTMT hstmt,
    UWORD fColType,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName,
    UWORD fScope,
    UWORD fNullable)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER)
	{
	  sqlstat = en_S1097;
	  break;
	}

      if (fScope != SQL_SCOPE_CURROW
	  && fScope != SQL_SCOPE_TRANSACTION
	  && fScope != SQL_SCOPE_SESSION)
	{
	  sqlstat = en_S1098;
	  break;
	}

      if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE)
	{
	  sqlstat = en_S1099;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_SpecialColumns);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;
      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SpecialColumns, (
	  pstmt->dhstmt,
	  fColType,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName,
	  fScope,
	  fNullable))

  return _iodbcdm_cata_state_tr (hstmt, en_SpecialColumns, retcode);
}


RETCODE SQL_API
SQLStatistics (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName,
    UWORD fUnique,
    UWORD fAccuracy)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL)
	{
	  sqlstat = en_S1100;
	  break;
	}

      if (fAccuracy != SQL_ENSURE && fAccuracy != SQL_QUICK)
	{
	  sqlstat = en_S1101;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_Statistics);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Statistics, (
	  pstmt->dhstmt,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName,
	  fUnique,
	  fAccuracy))

  return _iodbcdm_cata_state_tr (hstmt, en_Statistics, retcode);
}


RETCODE SQL_API
SQLTables (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName,
    UCHAR FAR * szTableType,
    SWORD cbTableType)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS)
	  || (cbTableType < 0 && cbTableType != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_Tables);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Tables, (
	  pstmt->dhstmt,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName,
	  szTableType,
	  cbTableType))

  return _iodbcdm_cata_state_tr (hstmt, en_Tables, retcode);
}


RETCODE SQL_API
SQLColumnPrivileges (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName,
    UCHAR FAR * szColumnName,
    SWORD cbColumnName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS)
	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_ColumnPrivileges);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ColumnPrivileges, (
	  pstmt->dhstmt,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName,
	  szColumnName,
	  cbColumnName))

  return _iodbcdm_cata_state_tr (hstmt, en_ColumnPrivileges, retcode);
}


RETCODE SQL_API
SQLColumns (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName,
    UCHAR FAR * szColumnName,
    SWORD cbColumnName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS)
	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_Columns);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Columns, (
	  pstmt->dhstmt,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName,
	  szColumnName,
	  cbColumnName))

  return _iodbcdm_cata_state_tr (hstmt, en_Columns, retcode);
}


RETCODE SQL_API
SQLForeignKeys (
    HSTMT hstmt,
    UCHAR FAR * szPkTableQualifier,
    SWORD cbPkTableQualifier,
    UCHAR FAR * szPkTableOwner,
    SWORD cbPkTableOwner,
    UCHAR FAR * szPkTableName,
    SWORD cbPkTableName,
    UCHAR FAR * szFkTableQualifier,
    SWORD cbFkTableQualifier,
    UCHAR FAR * szFkTableOwner,
    SWORD cbFkTableOwner,
    UCHAR FAR * szFkTableName,
    SWORD cbFkTableName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbPkTableQualifier < 0 && cbPkTableQualifier != SQL_NTS)
	  || (cbPkTableOwner < 0 && cbPkTableOwner != SQL_NTS)
	  || (cbPkTableName < 0 && cbPkTableName != SQL_NTS)
	  || (cbFkTableQualifier < 0 && cbFkTableQualifier != SQL_NTS)
	  || (cbFkTableOwner < 0 && cbFkTableOwner != SQL_NTS)
	  || (cbFkTableName < 0 && cbFkTableName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_ForeignKeys);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ForeignKeys, (
	  pstmt->dhstmt,
	  szPkTableQualifier,
	  cbPkTableQualifier,
	  szPkTableOwner,
	  cbPkTableOwner,
	  szPkTableName,
	  cbPkTableName,
	  szFkTableQualifier,
	  cbFkTableQualifier,
	  szFkTableOwner,
	  cbFkTableOwner,
	  szFkTableName,
	  cbFkTableName))

  return _iodbcdm_cata_state_tr (hstmt, en_ForeignKeys, retcode);
}


RETCODE SQL_API
SQLPrimaryKeys (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_PrimaryKeys);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_PrimaryKeys, (
	  pstmt->dhstmt,
	  szTableQualifier,
	  cbTableQualifier,
	  szTableOwner,
	  cbTableOwner,
	  szTableName,
	  cbTableName))

  return _iodbcdm_cata_state_tr (hstmt, en_PrimaryKeys, retcode);
}


RETCODE SQL_API
SQLProcedureColumns (
    HSTMT hstmt,
    UCHAR FAR * szProcQualifier,
    SWORD cbProcQualifier,
    UCHAR FAR * szProcOwner,
    SWORD cbProcOwner,
    UCHAR FAR * szProcName,
    SWORD cbProcName,
    UCHAR FAR * szColumnName,
    SWORD cbColumnName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
	  || (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
	  || (cbProcName < 0 && cbProcName != SQL_NTS)
	  || (cbColumnName < 0 && cbColumnName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_ProcedureColumns);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ProcedureColumns, (
	  pstmt->dhstmt,
	  szProcQualifier,
	  cbProcQualifier,
	  szProcOwner,
	  cbProcOwner,
	  szProcName,
	  cbProcName,
	  szColumnName,
	  cbColumnName))

  return _iodbcdm_cata_state_tr (hstmt, en_ProcedureColumns, retcode);
}


RETCODE SQL_API
SQLProcedures (
    HSTMT hstmt,
    UCHAR FAR * szProcQualifier,
    SWORD cbProcQualifier,
    UCHAR FAR * szProcOwner,
    SWORD cbProcOwner,
    UCHAR FAR * szProcName,
    SWORD cbProcName)
{
  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
	  || (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
	  || (cbProcName < 0 && cbProcName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_Procedures);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Procedures, (
	  pstmt->dhstmt,
	  szProcQualifier,
	  cbProcQualifier,
	  szProcOwner,
	  cbProcOwner,
	  szProcName,
	  cbProcName))

  return _iodbcdm_cata_state_tr (hstmt, en_Procedures, retcode);
}


RETCODE SQL_API
SQLTablePrivileges (
    HSTMT hstmt,
    UCHAR FAR * szTableQualifier,
    SWORD cbTableQualifier,
    UCHAR FAR * szTableOwner,
    SWORD cbTableOwner,
    UCHAR FAR * szTableName,
    SWORD cbTableName)
{

  STMT_t FAR *pstmt = (STMT_t FAR *) hstmt;
  HPROC hproc = SQL_NULL_HPROC;
  RETCODE retcode;
  int sqlstat = en_00000;

  if (hstmt == SQL_NULL_HSTMT || pstmt->hdbc == SQL_NULL_HDBC)
    {
      return SQL_INVALID_HANDLE;
    }

  for (;;)
    {
      if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	  || (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	  || (cbTableName < 0 && cbTableName != SQL_NTS))
	{
	  sqlstat = en_S1090;
	  break;
	}

      retcode = _iodbcdm_cata_state_ok (hstmt, en_TablePrivileges);

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

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

      if (hproc == SQL_NULL_HPROC)
	{
	  sqlstat = en_IM001;
	  break;
	}

      sqlstat = en_00000;

      if (1)			/* turn off solaris warning message */
	break;
    }

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

      return SQL_ERROR;
    }

  CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_TablePrivileges,
    (pstmt->dhstmt, szTableQualifier, cbTableQualifier, szTableOwner,
	cbTableOwner, szTableName, cbTableName))

  return _iodbcdm_cata_state_tr (hstmt, en_TablePrivileges, retcode);
}
Commit	Line	Data
	1	/*
	2	* catalog.c
	3	*
	4	* $Id$
	5	*
	6	* Catalog 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
	41	#ifndef NULL
	42	#define NULL 0
	43	#endif
	44
	45	static RETCODE
	46	_iodbcdm_cata_state_ok (
	47	HSTMT hstmt,
	48	int fidx)
	49	/* check state for executing catalog functions */
	50	{
	51	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	52	int sqlstat = en_00000;
	53
	54	if (pstmt->asyn_on == en_NullProc)
	55	{
	56	switch (pstmt->state)
	57	{
	58	case en_stmt_needdata:
	59	case en_stmt_mustput:
	60	case en_stmt_canput:
	61	sqlstat = en_S1010;
	62	break;
	63
	64	case en_stmt_fetched:
	65	case en_stmt_xfetched:
	66	sqlstat = en_24000;
	67	break;
	68
	69	default:
	70	break;
	71	}
	72	}
	73	else if (pstmt->asyn_on != fidx)
	74	{
	75	sqlstat = en_S1010;
	76	}
	77
	78	if (sqlstat != en_00000)
	79	{
	80	PUSHSQLERR (pstmt->herr, sqlstat);
	81
	82	return SQL_ERROR;
	83	}
	84
	85	return SQL_SUCCESS;
	86	}
	87
	88
	89	static RETCODE
	90	_iodbcdm_cata_state_tr (
	91	HSTMT hstmt,
	92	int fidx,
	93	RETCODE result)
	94	/* state transition for catalog function */
	95	{
	96	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	97	DBC_t FAR *pdbc;
	98
	99	pdbc = (DBC_t FAR *) (pstmt->hdbc);
	100
	101	if (pstmt->asyn_on == fidx)
	102	{
	103	switch (result)
	104	{
	105	case SQL_SUCCESS:
	106	case SQL_SUCCESS_WITH_INFO:
	107	case SQL_ERROR:
	108	pstmt->asyn_on = en_NullProc;
	109	break;
	110
	111	case SQL_STILL_EXECUTING:
	112	default:
	113	return result;
	114	}
	115	}
	116
	117	if (pstmt->state <= en_stmt_executed)
	118	{
	119	switch (result)
	120	{
	121	case SQL_SUCCESS:
	122	case SQL_SUCCESS_WITH_INFO:
	123	pstmt->state = en_stmt_cursoropen;
	124	break;
	125
	126	case SQL_ERROR:
	127	pstmt->state = en_stmt_allocated;
	128	pstmt->prep_state = 0;
	129	break;
	130
	131	case SQL_STILL_EXECUTING:
	132	pstmt->asyn_on = fidx;
	133	break;
	134
	135	default:
	136	break;
	137	}
	138	}
	139
	140	return result;
	141	}
	142
	143
	144	RETCODE SQL_API
	145	SQLGetTypeInfo (
	146	HSTMT hstmt,
	147	SWORD fSqlType)
	148	{
	149	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	150	HPROC hproc = SQL_NULL_HPROC;
	151	int sqlstat = en_00000;
	152	RETCODE retcode;
	153
	154	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	155	{
	156	return SQL_INVALID_HANDLE;
	157	}
	158
	159	for (;;)
	160	{
	161	if (fSqlType > SQL_TYPE_MAX)
	162	{
	163	sqlstat = en_S1004;
	164	break;
	165	}
	166
	167	/* Note: SQL_TYPE_DRIVER_START is a negative number So, we use ">" */
	168	if (fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START)
	169	{
	170	sqlstat = en_S1004;
	171	break;
	172	}
	173
	174	retcode = _iodbcdm_cata_state_ok (hstmt, en_GetTypeInfo);
	175
	176	if (retcode != SQL_SUCCESS)
	177	{
	178	return SQL_ERROR;
	179	}
	180
	181	hproc = _iodbcdm_getproc (pstmt->hdbc, en_GetTypeInfo);
	182
	183	if (hproc == SQL_NULL_HPROC)
	184	{
	185	sqlstat = en_IM001;
	186	break;
	187	}
	188
	189	sqlstat = en_00000;
	190	if (1) /* turn off solaris warning message */
	191	break;
	192	}
	193
	194	if (sqlstat != en_00000)
	195	{
	196	PUSHSQLERR (pstmt->herr, sqlstat);
	197
	198	return SQL_ERROR;
	199	}
	200
	201	CALL_DRIVER ( pstmt->hdbc, retcode, hproc, en_GetTypeInfo,
	202	(pstmt->dhstmt, fSqlType))
	203
	204	return _iodbcdm_cata_state_tr (hstmt, en_GetTypeInfo, retcode);
	205	}
	206
	207
	208	RETCODE SQL_API
	209	SQLSpecialColumns (
	210	HSTMT hstmt,
	211	UWORD fColType,
	212	UCHAR FAR * szTableQualifier,
	213	SWORD cbTableQualifier,
	214	UCHAR FAR * szTableOwner,
	215	SWORD cbTableOwner,
	216	UCHAR FAR * szTableName,
	217	SWORD cbTableName,
	218	UWORD fScope,
	219	UWORD fNullable)
	220	{
	221	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	222	HPROC hproc = SQL_NULL_HPROC;
	223	RETCODE retcode;
	224	int sqlstat = en_00000;
	225
	226	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	227	{
	228	return SQL_INVALID_HANDLE;
	229	}
	230
	231	for (;;)
	232	{
	233	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	234	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	235	\|\| (cbTableName < 0 && cbTableName != SQL_NTS))
	236	{
	237	sqlstat = en_S1090;
	238	break;
	239	}
	240
	241	if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER)
	242	{
	243	sqlstat = en_S1097;
	244	break;
	245	}
	246
	247	if (fScope != SQL_SCOPE_CURROW
	248	&& fScope != SQL_SCOPE_TRANSACTION
	249	&& fScope != SQL_SCOPE_SESSION)
	250	{
	251	sqlstat = en_S1098;
	252	break;
	253	}
	254
	255	if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE)
	256	{
	257	sqlstat = en_S1099;
	258	break;
	259	}
	260
	261	retcode = _iodbcdm_cata_state_ok (hstmt, en_SpecialColumns);
	262
	263	if (retcode != SQL_SUCCESS)
	264	{
	265	return SQL_ERROR;
	266	}
	267
	268	hproc = _iodbcdm_getproc (pstmt->hdbc, en_SpecialColumns);
	269
	270	if (hproc == SQL_NULL_HPROC)
	271	{
	272	sqlstat = en_IM001;
	273	break;
	274	}
	275
	276	sqlstat = en_00000;
	277	if (1) /* turn off solaris warning message */
	278	break;
	279	}
	280
	281	if (sqlstat != en_00000)
	282	{
	283	PUSHSQLERR (pstmt->herr, sqlstat);
	284
	285	return SQL_ERROR;
	286	}
	287
	288	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_SpecialColumns, (
	289	pstmt->dhstmt,
	290	fColType,
	291	szTableQualifier,
	292	cbTableQualifier,
	293	szTableOwner,
	294	cbTableOwner,
	295	szTableName,
	296	cbTableName,
	297	fScope,
	298	fNullable))
	299
	300	return _iodbcdm_cata_state_tr (hstmt, en_SpecialColumns, retcode);
	301	}
	302
	303
	304	RETCODE SQL_API
	305	SQLStatistics (
	306	HSTMT hstmt,
	307	UCHAR FAR * szTableQualifier,
	308	SWORD cbTableQualifier,
	309	UCHAR FAR * szTableOwner,
	310	SWORD cbTableOwner,
	311	UCHAR FAR * szTableName,
	312	SWORD cbTableName,
	313	UWORD fUnique,
	314	UWORD fAccuracy)
	315	{
	316	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	317	HPROC hproc = SQL_NULL_HPROC;
	318	RETCODE retcode;
	319	int sqlstat = en_00000;
	320
	321	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	322	{
	323	return SQL_INVALID_HANDLE;
	324	}
	325
	326	for (;;)
	327	{
	328	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	329	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	330	\|\| (cbTableName < 0 && cbTableName != SQL_NTS))
	331	{
	332	sqlstat = en_S1090;
	333	break;
	334	}
	335
	336	if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL)
	337	{
	338	sqlstat = en_S1100;
	339	break;
	340	}
	341
	342	if (fAccuracy != SQL_ENSURE && fAccuracy != SQL_QUICK)
	343	{
	344	sqlstat = en_S1101;
	345	break;
	346	}
	347
	348	retcode = _iodbcdm_cata_state_ok (hstmt, en_Statistics);
	349
	350	if (retcode != SQL_SUCCESS)
	351	{
	352	return SQL_ERROR;
	353	}
	354
	355	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Statistics);
	356
	357	if (hproc == SQL_NULL_HPROC)
	358	{
	359	sqlstat = en_IM001;
	360	break;
	361	}
	362
	363	sqlstat = en_00000;
	364
	365	if (1) /* turn off solaris warning message */
	366	break;
	367	}
	368
	369	if (sqlstat != en_00000)
	370	{
	371	PUSHSQLERR (pstmt->herr, sqlstat);
	372
	373	return SQL_ERROR;
	374	}
	375
	376	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Statistics, (
	377	pstmt->dhstmt,
	378	szTableQualifier,
	379	cbTableQualifier,
	380	szTableOwner,
	381	cbTableOwner,
	382	szTableName,
	383	cbTableName,
	384	fUnique,
	385	fAccuracy))
	386
	387	return _iodbcdm_cata_state_tr (hstmt, en_Statistics, retcode);
	388	}
	389
	390
	391	RETCODE SQL_API
	392	SQLTables (
	393	HSTMT hstmt,
	394	UCHAR FAR * szTableQualifier,
	395	SWORD cbTableQualifier,
	396	UCHAR FAR * szTableOwner,
	397	SWORD cbTableOwner,
	398	UCHAR FAR * szTableName,
	399	SWORD cbTableName,
	400	UCHAR FAR * szTableType,
	401	SWORD cbTableType)
	402	{
	403	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	404	HPROC hproc = SQL_NULL_HPROC;
	405	RETCODE retcode;
	406	int sqlstat = en_00000;
	407
	408	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	409	{
	410	return SQL_INVALID_HANDLE;
	411	}
	412
	413	for (;;)
	414	{
	415	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	416	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	417	\|\| (cbTableName < 0 && cbTableName != SQL_NTS)
	418	\|\| (cbTableType < 0 && cbTableType != SQL_NTS))
	419	{
	420	sqlstat = en_S1090;
	421	break;
	422	}
	423
	424	retcode = _iodbcdm_cata_state_ok (hstmt, en_Tables);
	425
	426	if (retcode != SQL_SUCCESS)
	427	{
	428	return SQL_ERROR;
	429	}
	430
	431	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Tables);
	432
	433	if (hproc == SQL_NULL_HPROC)
	434	{
	435	sqlstat = en_IM001;
	436	break;
	437	}
	438
	439	sqlstat = en_00000;
	440
	441	if (1) /* turn off solaris warning message */
	442	break;
	443	}
	444
	445	if (sqlstat != en_00000)
	446	{
	447	PUSHSQLERR (pstmt->herr, sqlstat);
	448
	449	return SQL_ERROR;
	450	}
	451
	452	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Tables, (
	453	pstmt->dhstmt,
	454	szTableQualifier,
	455	cbTableQualifier,
	456	szTableOwner,
	457	cbTableOwner,
	458	szTableName,
	459	cbTableName,
	460	szTableType,
	461	cbTableType))
	462
	463	return _iodbcdm_cata_state_tr (hstmt, en_Tables, retcode);
	464	}
	465
	466
	467	RETCODE SQL_API
	468	SQLColumnPrivileges (
	469	HSTMT hstmt,
	470	UCHAR FAR * szTableQualifier,
	471	SWORD cbTableQualifier,
	472	UCHAR FAR * szTableOwner,
	473	SWORD cbTableOwner,
	474	UCHAR FAR * szTableName,
	475	SWORD cbTableName,
	476	UCHAR FAR * szColumnName,
	477	SWORD cbColumnName)
	478	{
	479	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	480	HPROC hproc = SQL_NULL_HPROC;
	481	RETCODE retcode;
	482	int sqlstat = en_00000;
	483
	484	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	485	{
	486	return SQL_INVALID_HANDLE;
	487	}
	488
	489	for (;;)
	490	{
	491	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	492	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	493	\|\| (cbTableName < 0 && cbTableName != SQL_NTS)
	494	\|\| (cbColumnName < 0 && cbColumnName != SQL_NTS))
	495	{
	496	sqlstat = en_S1090;
	497	break;
	498	}
	499
	500	retcode = _iodbcdm_cata_state_ok (hstmt, en_ColumnPrivileges);
	501
	502	if (retcode != SQL_SUCCESS)
	503	{
	504	return SQL_ERROR;
	505	}
	506
	507	hproc = _iodbcdm_getproc (pstmt->hdbc, en_ColumnPrivileges);
	508
	509	if (hproc == SQL_NULL_HPROC)
	510	{
	511	sqlstat = en_IM001;
	512	break;
	513	}
	514
	515	sqlstat = en_00000;
	516
	517	if (1) /* turn off solaris warning message */
	518	break;
	519	}
	520
	521	if (sqlstat != en_00000)
	522	{
	523	PUSHSQLERR (pstmt->herr, sqlstat);
	524
	525	return SQL_ERROR;
	526	}
	527
	528	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ColumnPrivileges, (
	529	pstmt->dhstmt,
	530	szTableQualifier,
	531	cbTableQualifier,
	532	szTableOwner,
	533	cbTableOwner,
	534	szTableName,
	535	cbTableName,
	536	szColumnName,
	537	cbColumnName))
	538
	539	return _iodbcdm_cata_state_tr (hstmt, en_ColumnPrivileges, retcode);
	540	}
	541
	542
	543	RETCODE SQL_API
	544	SQLColumns (
	545	HSTMT hstmt,
	546	UCHAR FAR * szTableQualifier,
	547	SWORD cbTableQualifier,
	548	UCHAR FAR * szTableOwner,
	549	SWORD cbTableOwner,
	550	UCHAR FAR * szTableName,
	551	SWORD cbTableName,
	552	UCHAR FAR * szColumnName,
	553	SWORD cbColumnName)
	554	{
	555	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	556	HPROC hproc = SQL_NULL_HPROC;
	557	RETCODE retcode;
	558	int sqlstat = en_00000;
	559
	560	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	561	{
	562	return SQL_INVALID_HANDLE;
	563	}
	564
	565	for (;;)
	566	{
	567	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	568	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	569	\|\| (cbTableName < 0 && cbTableName != SQL_NTS)
	570	\|\| (cbColumnName < 0 && cbColumnName != SQL_NTS))
	571	{
	572	sqlstat = en_S1090;
	573	break;
	574	}
	575
	576	retcode = _iodbcdm_cata_state_ok (hstmt, en_Columns);
	577
	578	if (retcode != SQL_SUCCESS)
	579	{
	580	return SQL_ERROR;
	581	}
	582
	583	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Columns);
	584
	585	if (hproc == SQL_NULL_HPROC)
	586	{
	587	sqlstat = en_IM001;
	588	break;
	589	}
	590
	591	sqlstat = en_00000;
	592
	593	if (1) /* turn off solaris warning message */
	594	break;
	595	}
	596
	597	if (sqlstat != en_00000)
	598	{
	599	PUSHSQLERR (pstmt->herr, sqlstat);
	600
	601	return SQL_ERROR;
	602	}
	603
	604	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Columns, (
	605	pstmt->dhstmt,
	606	szTableQualifier,
	607	cbTableQualifier,
	608	szTableOwner,
	609	cbTableOwner,
	610	szTableName,
	611	cbTableName,
	612	szColumnName,
	613	cbColumnName))
	614
	615	return _iodbcdm_cata_state_tr (hstmt, en_Columns, retcode);
	616	}
	617
	618
	619	RETCODE SQL_API
	620	SQLForeignKeys (
	621	HSTMT hstmt,
	622	UCHAR FAR * szPkTableQualifier,
	623	SWORD cbPkTableQualifier,
	624	UCHAR FAR * szPkTableOwner,
	625	SWORD cbPkTableOwner,
	626	UCHAR FAR * szPkTableName,
	627	SWORD cbPkTableName,
	628	UCHAR FAR * szFkTableQualifier,
	629	SWORD cbFkTableQualifier,
	630	UCHAR FAR * szFkTableOwner,
	631	SWORD cbFkTableOwner,
	632	UCHAR FAR * szFkTableName,
	633	SWORD cbFkTableName)
	634	{
	635	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	636	HPROC hproc = SQL_NULL_HPROC;
	637	RETCODE retcode;
	638	int sqlstat = en_00000;
	639
	640	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	641	{
	642	return SQL_INVALID_HANDLE;
	643	}
	644
	645	for (;;)
	646	{
	647	if ((cbPkTableQualifier < 0 && cbPkTableQualifier != SQL_NTS)
	648	\|\| (cbPkTableOwner < 0 && cbPkTableOwner != SQL_NTS)
	649	\|\| (cbPkTableName < 0 && cbPkTableName != SQL_NTS)
	650	\|\| (cbFkTableQualifier < 0 && cbFkTableQualifier != SQL_NTS)
	651	\|\| (cbFkTableOwner < 0 && cbFkTableOwner != SQL_NTS)
	652	\|\| (cbFkTableName < 0 && cbFkTableName != SQL_NTS))
	653	{
	654	sqlstat = en_S1090;
	655	break;
	656	}
	657
	658	retcode = _iodbcdm_cata_state_ok (hstmt, en_ForeignKeys);
	659
	660	if (retcode != SQL_SUCCESS)
	661	{
	662	return SQL_ERROR;
	663	}
	664
	665	hproc = _iodbcdm_getproc (pstmt->hdbc, en_ForeignKeys);
	666
	667	if (hproc == SQL_NULL_HPROC)
	668	{
	669	sqlstat = en_IM001;
	670	break;
	671	}
	672
	673	sqlstat = en_00000;
	674
	675	if (1) /* turn off solaris warning message */
	676	break;
	677	}
	678
	679	if (sqlstat != en_00000)
	680	{
	681	PUSHSQLERR (pstmt->herr, sqlstat);
	682
	683	return SQL_ERROR;
	684	}
	685
	686	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ForeignKeys, (
	687	pstmt->dhstmt,
	688	szPkTableQualifier,
	689	cbPkTableQualifier,
	690	szPkTableOwner,
	691	cbPkTableOwner,
	692	szPkTableName,
	693	cbPkTableName,
	694	szFkTableQualifier,
	695	cbFkTableQualifier,
	696	szFkTableOwner,
	697	cbFkTableOwner,
	698	szFkTableName,
	699	cbFkTableName))
	700
	701	return _iodbcdm_cata_state_tr (hstmt, en_ForeignKeys, retcode);
	702	}
	703
	704
	705	RETCODE SQL_API
	706	SQLPrimaryKeys (
	707	HSTMT hstmt,
	708	UCHAR FAR * szTableQualifier,
	709	SWORD cbTableQualifier,
	710	UCHAR FAR * szTableOwner,
	711	SWORD cbTableOwner,
	712	UCHAR FAR * szTableName,
	713	SWORD cbTableName)
	714	{
	715	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	716	HPROC hproc = SQL_NULL_HPROC;
	717	RETCODE retcode;
	718	int sqlstat = en_00000;
	719
	720	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	721	{
	722	return SQL_INVALID_HANDLE;
	723	}
	724
	725	for (;;)
	726	{
	727	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	728	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	729	\|\| (cbTableName < 0 && cbTableName != SQL_NTS))
	730	{
	731	sqlstat = en_S1090;
	732	break;
	733	}
	734
	735	retcode = _iodbcdm_cata_state_ok (hstmt, en_PrimaryKeys);
	736
	737	if (retcode != SQL_SUCCESS)
	738	{
	739	return SQL_ERROR;
	740	}
	741
	742	hproc = _iodbcdm_getproc (pstmt->hdbc, en_PrimaryKeys);
	743
	744	if (hproc == SQL_NULL_HPROC)
	745	{
	746	sqlstat = en_IM001;
	747	break;
	748	}
	749
	750	sqlstat = en_00000;
	751
	752	if (1) /* turn off solaris warning message */
	753	break;
	754	}
	755
	756	if (sqlstat != en_00000)
	757	{
	758	PUSHSQLERR (pstmt->herr, sqlstat);
	759
	760	return SQL_ERROR;
	761	}
	762
	763	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_PrimaryKeys, (
	764	pstmt->dhstmt,
	765	szTableQualifier,
	766	cbTableQualifier,
	767	szTableOwner,
	768	cbTableOwner,
	769	szTableName,
	770	cbTableName))
	771
	772	return _iodbcdm_cata_state_tr (hstmt, en_PrimaryKeys, retcode);
	773	}
	774
	775
	776	RETCODE SQL_API
	777	SQLProcedureColumns (
	778	HSTMT hstmt,
	779	UCHAR FAR * szProcQualifier,
	780	SWORD cbProcQualifier,
	781	UCHAR FAR * szProcOwner,
	782	SWORD cbProcOwner,
	783	UCHAR FAR * szProcName,
	784	SWORD cbProcName,
	785	UCHAR FAR * szColumnName,
	786	SWORD cbColumnName)
	787	{
	788	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	789	HPROC hproc = SQL_NULL_HPROC;
	790	RETCODE retcode;
	791	int sqlstat = en_00000;
	792
	793	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	794	{
	795	return SQL_INVALID_HANDLE;
	796	}
	797
	798	for (;;)
	799	{
	800	if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
	801	\|\| (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
	802	\|\| (cbProcName < 0 && cbProcName != SQL_NTS)
	803	\|\| (cbColumnName < 0 && cbColumnName != SQL_NTS))
	804	{
	805	sqlstat = en_S1090;
	806	break;
	807	}
	808
	809	retcode = _iodbcdm_cata_state_ok (hstmt, en_ProcedureColumns);
	810
	811	if (retcode != SQL_SUCCESS)
	812	{
	813	return SQL_ERROR;
	814	}
	815
	816	hproc = _iodbcdm_getproc (pstmt->hdbc, en_ProcedureColumns);
	817
	818	if (hproc == SQL_NULL_HPROC)
	819	{
	820	sqlstat = en_IM001;
	821	break;
	822	}
	823
	824	sqlstat = en_00000;
	825
	826	if (1) /* turn off solaris warning message */
	827	break;
	828	}
	829
	830	if (sqlstat != en_00000)
	831	{
	832	PUSHSQLERR (pstmt->herr, sqlstat);
	833
	834	return SQL_ERROR;
	835	}
	836
	837	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_ProcedureColumns, (
	838	pstmt->dhstmt,
	839	szProcQualifier,
	840	cbProcQualifier,
	841	szProcOwner,
	842	cbProcOwner,
	843	szProcName,
	844	cbProcName,
	845	szColumnName,
	846	cbColumnName))
	847
	848	return _iodbcdm_cata_state_tr (hstmt, en_ProcedureColumns, retcode);
	849	}
	850
	851
	852	RETCODE SQL_API
	853	SQLProcedures (
	854	HSTMT hstmt,
	855	UCHAR FAR * szProcQualifier,
	856	SWORD cbProcQualifier,
	857	UCHAR FAR * szProcOwner,
	858	SWORD cbProcOwner,
	859	UCHAR FAR * szProcName,
	860	SWORD cbProcName)
	861	{
	862	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	863	HPROC hproc = SQL_NULL_HPROC;
	864	RETCODE retcode;
	865	int sqlstat = en_00000;
	866
	867	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	868	{
	869	return SQL_INVALID_HANDLE;
	870	}
	871
	872	for (;;)
	873	{
	874	if ((cbProcQualifier < 0 && cbProcQualifier != SQL_NTS)
	875	\|\| (cbProcOwner < 0 && cbProcOwner != SQL_NTS)
	876	\|\| (cbProcName < 0 && cbProcName != SQL_NTS))
	877	{
	878	sqlstat = en_S1090;
	879	break;
	880	}
	881
	882	retcode = _iodbcdm_cata_state_ok (hstmt, en_Procedures);
	883
	884	if (retcode != SQL_SUCCESS)
	885	{
	886	return SQL_ERROR;
	887	}
	888
	889	hproc = _iodbcdm_getproc (pstmt->hdbc, en_Procedures);
	890
	891	if (hproc == SQL_NULL_HPROC)
	892	{
	893	sqlstat = en_IM001;
	894	break;
	895	}
	896
	897	sqlstat = en_00000;
	898
	899	if (1) /* turn off solaris warning message */
	900	break;
	901	}
	902
	903	if (sqlstat != en_00000)
	904	{
	905	PUSHSQLERR (pstmt->herr, sqlstat);
	906
	907	return SQL_ERROR;
	908	}
	909
	910	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_Procedures, (
	911	pstmt->dhstmt,
	912	szProcQualifier,
	913	cbProcQualifier,
	914	szProcOwner,
	915	cbProcOwner,
	916	szProcName,
	917	cbProcName))
	918
	919	return _iodbcdm_cata_state_tr (hstmt, en_Procedures, retcode);
	920	}
	921
	922
	923	RETCODE SQL_API
	924	SQLTablePrivileges (
	925	HSTMT hstmt,
	926	UCHAR FAR * szTableQualifier,
	927	SWORD cbTableQualifier,
	928	UCHAR FAR * szTableOwner,
	929	SWORD cbTableOwner,
	930	UCHAR FAR * szTableName,
	931	SWORD cbTableName)
	932	{
	933
	934	STMT_t FAR pstmt = (STMT_t FAR ) hstmt;
	935	HPROC hproc = SQL_NULL_HPROC;
	936	RETCODE retcode;
	937	int sqlstat = en_00000;
	938
	939	if (hstmt == SQL_NULL_HSTMT \|\| pstmt->hdbc == SQL_NULL_HDBC)
	940	{
	941	return SQL_INVALID_HANDLE;
	942	}
	943
	944	for (;;)
	945	{
	946	if ((cbTableQualifier < 0 && cbTableQualifier != SQL_NTS)
	947	\|\| (cbTableOwner < 0 && cbTableOwner != SQL_NTS)
	948	\|\| (cbTableName < 0 && cbTableName != SQL_NTS))
	949	{
	950	sqlstat = en_S1090;
	951	break;
	952	}
	953
	954	retcode = _iodbcdm_cata_state_ok (hstmt, en_TablePrivileges);
	955
	956	if (retcode != SQL_SUCCESS)
	957	{
	958	return SQL_ERROR;
	959	}
	960
	961	hproc = _iodbcdm_getproc (pstmt->hdbc, en_TablePrivileges);
	962
	963	if (hproc == SQL_NULL_HPROC)
	964	{
	965	sqlstat = en_IM001;
	966	break;
	967	}
	968
	969	sqlstat = en_00000;
	970
	971	if (1) /* turn off solaris warning message */
	972	break;
	973	}
	974
	975	if (sqlstat != en_00000)
	976	{
	977	PUSHSQLERR (pstmt->herr, sqlstat);
	978
	979	return SQL_ERROR;
	980	}
	981
	982	CALL_DRIVER (pstmt->hdbc, retcode, hproc, en_TablePrivileges,
	983	(pstmt->dhstmt, szTableQualifier, cbTableQualifier, szTableOwner,
	984	cbTableOwner, szTableName, cbTableName))
	985
	986	return _iodbcdm_cata_state_tr (hstmt, en_TablePrivileges, retcode);
	987	}