Logo Search packages:      
Sourcecode: psqlodbc version File versions

odbcapi30.c

/*-------
 * Module:              odbcapi30.c
 *
 * Description:         This module contains routines related to ODBC 3.0
 *                most of their implementations are temporary
 *                and must be rewritten properly.
 *                2001/07/23  inoue
 *
 * Classes:             n/a
 *
 * API functions: SQLAllocHandle, SQLBindParam, SQLCloseCursor,
                  SQLColAttribute, SQLCopyDesc, SQLEndTran,
                  SQLFetchScroll, SQLFreeHandle, SQLGetDescField,
                  SQLGetDescRec, SQLGetDiagField, SQLGetDiagRec,
                  SQLGetEnvAttr, SQLGetConnectAttr, SQLGetStmtAttr,
                  SQLSetConnectAttr, SQLSetDescField, SQLSetDescRec,
                  SQLSetEnvAttr, SQLSetStmtAttr, SQLBulkOperations
 *-------
 */

#include "psqlodbc.h"

#if (ODBCVER >= 0x0300)
#include <stdio.h>
#include <string.h>

#include "environ.h"
#include "connection.h"
#include "statement.h"
#include "pgapifunc.h"

/*    SQLAllocConnect/SQLAllocEnv/SQLAllocStmt -> SQLAllocHandle */
RETCODE           SQL_API
SQLAllocHandle(SQLSMALLINT HandleType,
                     SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
{
      RETCODE           ret;
      ConnectionClass   *conn;

      mylog("[[SQLAllocHandle]]");
      switch (HandleType)
      {
            case SQL_HANDLE_ENV:
                  ret = PGAPI_AllocEnv(OutputHandle);
                  break;
            case SQL_HANDLE_DBC:
                  ENTER_ENV_CS((EnvironmentClass *) InputHandle);
                  ret = PGAPI_AllocConnect(InputHandle, OutputHandle);
                  LEAVE_ENV_CS((EnvironmentClass *) InputHandle);
                  break;
            case SQL_HANDLE_STMT:
                  ENTER_CONN_CS((ConnectionClass *) InputHandle);
                  ret = PGAPI_AllocStmt(InputHandle, OutputHandle);
                  LEAVE_CONN_CS((ConnectionClass *) InputHandle);
                  break;
            case SQL_HANDLE_DESC:
                  conn = (ConnectionClass *) InputHandle;
                  ENTER_CONN_CS(conn);
                  CC_set_error(conn, CONN_NOT_IMPLEMENTED_ERROR, "can't alloc Desc Handle yet"); 
                  LEAVE_CONN_CS(conn);
                  ret = SQL_ERROR;
                  break;
            default:
                  ret = SQL_ERROR;
                  break;
      }
      return ret;
}

/*    SQLBindParameter/SQLSetParam -> SQLBindParam */
RETCODE           SQL_API
SQLBindParam(HSTMT StatementHandle,
                   SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
                   SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
                   SQLSMALLINT ParameterScale, PTR ParameterValue,
                   SQLINTEGER *StrLen_or_Ind)
{
      RETCODE                 ret;
      int               BufferLength = 512;           /* Is it OK ? */

      mylog("[[SQLBindParam]]");
      ENTER_STMT_CS((StatementClass *) StatementHandle);
      SC_clear_error((StatementClass *) StatementHandle);
      ret = PGAPI_BindParameter(StatementHandle, ParameterNumber, SQL_PARAM_INPUT, ValueType, ParameterType, LengthPrecision, ParameterScale, ParameterValue, BufferLength, StrLen_or_Ind);
      LEAVE_STMT_CS((StatementClass *) StatementHandle);
      return ret;
}

/*    New function */
RETCODE           SQL_API
SQLCloseCursor(HSTMT StatementHandle)
{
      RETCODE     ret;

      mylog("[[SQLCloseCursor]]");
      ENTER_STMT_CS((StatementClass *) StatementHandle);
      SC_clear_error((StatementClass *) StatementHandle);
      ret = PGAPI_FreeStmt(StatementHandle, SQL_CLOSE);
      LEAVE_STMT_CS((StatementClass *) StatementHandle);
      return ret;
}

/*    SQLColAttributes -> SQLColAttribute */
RETCODE           SQL_API
SQLColAttribute(HSTMT StatementHandle,
                        SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
                        PTR CharacterAttribute, SQLSMALLINT BufferLength,
                        SQLSMALLINT *StringLength, PTR NumericAttribute)
{
      RETCODE     ret;

      mylog("[[SQLColAttribute]]");
      ENTER_STMT_CS((StatementClass *) StatementHandle);
      SC_clear_error((StatementClass *) StatementHandle);
      ret = PGAPI_ColAttributes(StatementHandle, ColumnNumber,
                                 FieldIdentifier, CharacterAttribute, BufferLength,
                                             StringLength, NumericAttribute);
      LEAVE_STMT_CS((StatementClass *) StatementHandle);
      return ret;
}

static HSTMT
descHandleFromStatementHandle(HSTMT StatementHandle, SQLINTEGER descType) 
{
      switch (descType)
      {
            case SQL_ATTR_APP_ROW_DESC:         /* 10010 */
                  return StatementHandle; /* this is bogus */
            case SQL_ATTR_APP_PARAM_DESC: /* 10011 */
                  return (HSTMT) ((SQLUINTEGER) StatementHandle + 1) ; /* this is bogus */
            case SQL_ATTR_IMP_ROW_DESC:         /* 10012 */
                  return (HSTMT) ((SQLUINTEGER) StatementHandle + 2); /* this is bogus */
            case SQL_ATTR_IMP_PARAM_DESC: /* 10013 */
                  return (HSTMT) ((SQLUINTEGER) StatementHandle + 3); /* this is bogus */
      }
      return (HSTMT) 0;
}
static HSTMT
statementHandleFromDescHandle(HSTMT DescHandle, SQLINTEGER *descType) 
{
      SQLUINTEGER res = (SQLUINTEGER) DescHandle % 4;
      switch (res)
      {
            case 0: *descType = SQL_ATTR_APP_ROW_DESC; /* 10010 */
                  break;
            case 1: *descType = SQL_ATTR_APP_PARAM_DESC; /* 10011 */
                  break;
            case 2: *descType = SQL_ATTR_IMP_ROW_DESC; /* 10012 */
                  break;
            case 3: *descType = SQL_ATTR_IMP_PARAM_DESC; /* 10013 */
                  break;
      }
      return (HSTMT) ((SQLUINTEGER) DescHandle - res);
}

/*    new function */
RETCODE           SQL_API
SQLCopyDesc(SQLHDESC SourceDescHandle,
                  SQLHDESC TargetDescHandle)
{
      mylog("[[SQLCopyDesc]]\n");
      mylog("Error not implemented\n");
      return SQL_ERROR;
}

/*    SQLTransact -> SQLEndTran */
RETCODE           SQL_API
SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle,
               SQLSMALLINT CompletionType)
{
      RETCODE     ret;

      mylog("[[SQLEndTran]]");
      switch (HandleType)
      {
            case SQL_HANDLE_ENV:
                  ENTER_ENV_CS((EnvironmentClass *) Handle);
                  ret = PGAPI_Transact(Handle, SQL_NULL_HDBC, CompletionType);
                  LEAVE_ENV_CS((EnvironmentClass *) Handle);
                  break;
            case SQL_HANDLE_DBC:
                  ENTER_CONN_CS((ConnectionClass *) Handle);
                  CC_clear_error((ConnectionClass *) Handle);
                  ret = PGAPI_Transact(SQL_NULL_HENV, Handle, CompletionType);
                  LEAVE_CONN_CS((ConnectionClass *) Handle);
                  break;
            default:
                  ret = SQL_ERROR;
                  break;
      }
      return ret;
}

/*    SQLExtendedFetch -> SQLFetchScroll */
RETCODE           SQL_API
SQLFetchScroll(HSTMT StatementHandle,
                     SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)
{
      CSTR func = "SQLFetchScroll";
      StatementClass *stmt = (StatementClass *) StatementHandle;
      RETCODE           ret = SQL_SUCCESS;
      IRDFields   *irdopts = SC_get_IRD(stmt);
      SQLUSMALLINT *rowStatusArray = irdopts->rowStatusArray;
      SQLINTEGER *pcRow = irdopts->rowsFetched, bkmarkoff = 0;

      mylog("[[%s]] %d,%d\n", func, FetchOrientation, FetchOffset);
      ENTER_STMT_CS(stmt);
      SC_clear_error(stmt);
      if (FetchOrientation == SQL_FETCH_BOOKMARK)
      {
            if (stmt->options.bookmark_ptr)
            {
                  bkmarkoff = FetchOffset;
                  FetchOffset = *((Int4 *) stmt->options.bookmark_ptr);
mylog("bookmark=%u FetchOffset = %d\n", FetchOffset, bkmarkoff);
            }
            else
            {
                  SC_set_error(stmt, STMT_SEQUENCE_ERROR, "Bookmark isn't specifed yet");
                  SC_log_error(func, "", stmt);
                  ret = SQL_ERROR;
            }
      }
      if (SQL_SUCCESS == ret)
      {
            ARDFields   *opts = SC_get_ARD(stmt);

            ret = PGAPI_ExtendedFetch(StatementHandle, FetchOrientation, FetchOffset,
                        pcRow, rowStatusArray, bkmarkoff, opts->size_of_rowset);
            stmt->transition_status = 6;
      }
      LEAVE_STMT_CS(stmt);
      if (ret != SQL_SUCCESS)
            mylog("%s return = %d\n", func, ret);
      return ret;
}

/*    SQLFree(Connect/Env/Stmt) -> SQLFreeHandle */
RETCODE           SQL_API
SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
{
      RETCODE           ret;
      mylog("[[SQLFreeHandle]]");
      switch (HandleType)
      {
            case SQL_HANDLE_ENV:
                  ret = PGAPI_FreeEnv(Handle);
                  break;
            case SQL_HANDLE_DBC:
                  ret = PGAPI_FreeConnect(Handle);
                  break;
            case SQL_HANDLE_STMT:
                  ret = PGAPI_FreeStmt(Handle, SQL_DROP);
                  break;
            default:
                  ret = SQL_ERROR;
                  break;
      }
      return ret;
}

/*    new function */
RETCODE           SQL_API
SQLGetDescField(SQLHDESC DescriptorHandle,
                        SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
                        PTR Value, SQLINTEGER BufferLength,
                        SQLINTEGER *StringLength)
{
      RETCODE     ret;

      mylog("[[SQLGetDescField]]\n");
      ret = PGAPI_GetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
                  Value, BufferLength, StringLength);
      return ret;
}

/*    new function */
RETCODE           SQL_API
SQLGetDescRec(SQLHDESC DescriptorHandle,
                    SQLSMALLINT RecNumber, SQLCHAR *Name,
                    SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
                    SQLSMALLINT *Type, SQLSMALLINT *SubType,
                    SQLINTEGER *Length, SQLSMALLINT *Precision,
                    SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
      mylog("[[SQLGetDescRec]]\n");
      mylog("Error not implemented\n");
      return SQL_ERROR;
}

/*    new function */
RETCODE           SQL_API
SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
                        SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
                        PTR DiagInfo, SQLSMALLINT BufferLength,
                        SQLSMALLINT *StringLength)
{
      RETCODE     ret;

      mylog("[[SQLGetDiagField]] Handle=(%u,%x) Rec=%d Id=%d\n", HandleType, Handle, RecNumber, DiagIdentifier);
      ret = PGAPI_GetDiagField(HandleType, Handle, RecNumber, DiagIdentifier,
                        DiagInfo, BufferLength, StringLength);
      return ret;
}

/*    SQLError -> SQLDiagRec */
RETCODE           SQL_API
SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
                    SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
                    SQLINTEGER *NativeError, SQLCHAR *MessageText,
                    SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
{
      RETCODE     ret;

      mylog("[[SQLGetDiagRec]]\n");
      ret = PGAPI_GetDiagRec(HandleType, Handle, RecNumber, Sqlstate,
                  NativeError, MessageText, BufferLength, TextLength);
      return ret;
}

/*    new function */
RETCODE           SQL_API
SQLGetEnvAttr(HENV EnvironmentHandle,
                    SQLINTEGER Attribute, PTR Value,
                    SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
      RETCODE     ret;
      EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;

      mylog("[[SQLGetEnvAttr]] %d\n", Attribute);
      ENTER_ENV_CS(env);
      ret = SQL_SUCCESS;
      switch (Attribute)
      {
            case SQL_ATTR_CONNECTION_POOLING:
                  *((unsigned int *) Value) = EN_is_pooling(env) ? SQL_CP_ONE_PER_DRIVER : SQL_CP_OFF;
                  break;
            case SQL_ATTR_CP_MATCH:
                  *((unsigned int *) Value) = SQL_CP_RELAXED_MATCH;
                  break;
            case SQL_ATTR_ODBC_VERSION:
                  *((unsigned int *) Value) = EN_is_odbc2(env) ? SQL_OV_ODBC2 : SQL_OV_ODBC3;
                  break;
            case SQL_ATTR_OUTPUT_NTS:
                  *((unsigned int *) Value) = SQL_TRUE;
                  break;
            default:
                  env->errornumber = CONN_INVALID_ARGUMENT_NO;
                  ret = SQL_ERROR;
      }
      LEAVE_ENV_CS(env);
      return ret;
}

/*    SQLGetConnectOption -> SQLGetconnectAttr */
RETCODE           SQL_API
SQLGetConnectAttr(HDBC ConnectionHandle,
                          SQLINTEGER Attribute, PTR Value,
                          SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
      RETCODE     ret;

      mylog("[[SQLGetConnectAttr]] %d\n", Attribute);
      ENTER_CONN_CS((ConnectionClass *) ConnectionHandle);
      CC_clear_error((ConnectionClass *) ConnectionHandle);
      ret = PGAPI_GetConnectAttr(ConnectionHandle, Attribute,Value,
                  BufferLength, StringLength);
      LEAVE_CONN_CS((ConnectionClass *) ConnectionHandle);
      return ret;
}

/*    SQLGetStmtOption -> SQLGetStmtAttr */
RETCODE           SQL_API
SQLGetStmtAttr(HSTMT StatementHandle,
                     SQLINTEGER Attribute, PTR Value,
                     SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
      RETCODE     ret;
      CSTR func = "SQLGetStmtAttr";

      mylog("[[%s]] Handle=%u %d\n", func, StatementHandle, Attribute);
      ENTER_STMT_CS((StatementClass *) StatementHandle);
      SC_clear_error((StatementClass *) StatementHandle);
      ret = PGAPI_GetStmtAttr(StatementHandle, Attribute, Value,
                  BufferLength, StringLength);
      LEAVE_STMT_CS((StatementClass *) StatementHandle);
      return ret;
}

/*    SQLSetConnectOption -> SQLSetConnectAttr */
RETCODE           SQL_API
SQLSetConnectAttr(HDBC ConnectionHandle,
                          SQLINTEGER Attribute, PTR Value,
                          SQLINTEGER StringLength)
{
      RETCODE     ret;
      ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;

      mylog("[[SQLSetConnectAttr]] %d\n", Attribute);
      ENTER_CONN_CS(conn);
      CC_clear_error(conn);
      ret = PGAPI_SetConnectAttr(ConnectionHandle, Attribute, Value,
                          StringLength);
      LEAVE_CONN_CS(conn);
      return ret;
}

/*    new function */
RETCODE           SQL_API
SQLSetDescField(SQLHDESC DescriptorHandle,
                        SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
                        PTR Value, SQLINTEGER BufferLength)
{
      RETCODE           ret;

      mylog("[[SQLSetDescField]] h=%u rec=%d field=%d val=%x\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
      ret = PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
                        Value, BufferLength);
      return ret;
}

/*    new fucntion */
RETCODE           SQL_API
SQLSetDescRec(SQLHDESC DescriptorHandle,
                    SQLSMALLINT RecNumber, SQLSMALLINT Type,
                    SQLSMALLINT SubType, SQLINTEGER Length,
                    SQLSMALLINT Precision, SQLSMALLINT Scale,
                    PTR Data, SQLINTEGER *StringLength,
                    SQLINTEGER *Indicator)
{
      CSTR func = "SQLSetDescRec";

      mylog("[[SQLSetDescRec]]\n");
      mylog("Error not implemented\n");
      return SQL_ERROR;
}

/*    new function */
RETCODE           SQL_API
SQLSetEnvAttr(HENV EnvironmentHandle,
                    SQLINTEGER Attribute, PTR Value,
                    SQLINTEGER StringLength)
{
      RETCODE     ret;
      EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;

      mylog("[[SQLSetEnvAttr]] att=%d,%u\n", Attribute, Value);
      ENTER_ENV_CS(env);
      switch (Attribute)
      {
            case SQL_ATTR_CONNECTION_POOLING:
                  switch ((SQLUINTEGER) Value)
                  {
                        case SQL_CP_OFF:
                              EN_unset_pooling(env);
                              ret = SQL_SUCCESS;
                              break;
#if defined(WIN_MULTITHREAD_SUPPORT) || defined(POSIX_MULTITHREAD_SUPPORT)
                        case SQL_CP_ONE_PER_DRIVER:
                              EN_set_pooling(env);
                              ret = SQL_SUCCESS;
                              break;
#endif /* WIN_MULTITHREAD_SUPPORT */
                        default:
                              ret = SQL_SUCCESS_WITH_INFO;
                  }
                  break;
            case SQL_ATTR_CP_MATCH:
                  /* *((unsigned int *) Value) = SQL_CP_RELAXED_MATCH; */
                  ret = SQL_SUCCESS;
                  break;
            case SQL_ATTR_ODBC_VERSION:
                  if ((SQLUINTEGER) Value == SQL_OV_ODBC2)
                        EN_set_odbc2(env);
                  else
                        EN_set_odbc3(env);
                  ret = SQL_SUCCESS;
                  break;
            case SQL_ATTR_OUTPUT_NTS:
                  if ((SQLUINTEGER) Value == SQL_TRUE)
                        ret = SQL_SUCCESS;
                  else
                        ret = SQL_SUCCESS_WITH_INFO;
      
                  break;
            default:
                  env->errornumber = CONN_INVALID_ARGUMENT_NO;
                  ret = SQL_ERROR;
      }
      if (SQL_SUCCESS_WITH_INFO == ret)
      {
            env->errornumber = CONN_OPTION_VALUE_CHANGED;
            env->errormsg = "SetEnv changed to ";
      }
      LEAVE_ENV_CS(env);
      return ret;
}

/*    SQLSet(Param/Scroll/Stmt)Option -> SQLSetStmtAttr */
RETCODE           SQL_API
SQLSetStmtAttr(HSTMT StatementHandle,
                     SQLINTEGER Attribute, PTR Value,
                     SQLINTEGER StringLength)
{
      CSTR func = "SQLSetStmtAttr";
      StatementClass *stmt = (StatementClass *) StatementHandle;
      RETCODE     ret;

      mylog("[[%s]] Handle=%u %d,%u\n", func, StatementHandle, Attribute, Value);
      ENTER_STMT_CS(stmt);
      SC_clear_error(stmt);
      ret = PGAPI_SetStmtAttr(StatementHandle, Attribute, Value, StringLength);
      LEAVE_STMT_CS(stmt);
      return ret;
}

#define SQL_FUNC_ESET(pfExists, uwAPI) \
            (*(((UWORD*) (pfExists)) + ((uwAPI) >> 4)) \
                  |= (1 << ((uwAPI) & 0x000F)) \
                        )
RETCODE           SQL_API
PGAPI_GetFunctions30(HDBC hdbc, UWORD fFunction, UWORD FAR * pfExists)
{
      ConnectionClass   *conn = (ConnectionClass *) hdbc;
      ConnInfo    *ci = &(conn->connInfo);

      CC_clear_error(conn);
      if (fFunction != SQL_API_ODBC3_ALL_FUNCTIONS)
            return SQL_ERROR;
      memset(pfExists, 0, sizeof(UWORD) * SQL_API_ODBC3_ALL_FUNCTIONS_SIZE);

      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCCONNECT); 1 deprecated */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCENV); 2 deprecated */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCSTMT); 3 deprecated */

      /*
       * for (i = SQL_API_SQLBINDCOL; i <= 23; i++) SQL_FUNC_ESET(pfExists,
       * i);
       */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDCOL);          /* 4 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLCANCEL); /* 5 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLATTRIBUTE);     /* 6 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLCONNECT);          /* 7 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBECOL);      /* 8 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLDISCONNECT);       /* 9 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLERROR);  10 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECDIRECT);       /* 11 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLEXECUTE);          /* 12 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCH);      /* 13 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREECONNECT); 14 deprecated */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEENV); 15 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLFREESTMT);         /* 16 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCURSORNAME);    /* 17 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMRESULTCOLS);    /* 18 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPREPARE);          /* 19 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLROWCOUNT);         /* 20 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCURSORNAME);    /* 21 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPARAM); 22 deprecated */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLTRANSACT); 23 deprecated */

      /*
       * for (i = 40; i < SQL_API_SQLEXTENDEDFETCH; i++)
       * SQL_FUNC_ESET(pfExists, i);
       */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNS);          /* 40 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERCONNECT);    /* 41 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTOPTION); 42 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDATA);          /* 43 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETFUNCTIONS);     /* 44 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETINFO);          /* 45 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTOPTION); 46 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETTYPEINFO);      /* 47 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMDATA);        /* 48 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPUTDATA);          /* 49 */

      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTIONOPTION); 50 deprecated */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTOPTION); 51 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSPECIALCOLUMNS);   /* 52 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSTATISTICS);       /* 53 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLES); /* 54 */
      if (ci->drivers.lie)
            SQL_FUNC_ESET(pfExists, SQL_API_SQLBROWSECONNECT); /* 55 not implemented yet */
      if (ci->drivers.lie)
            SQL_FUNC_ESET(pfExists, SQL_API_SQLCOLUMNPRIVILEGES); /* 56 not implemented yet */ 
      SQL_FUNC_ESET(pfExists, SQL_API_SQLDATASOURCES);      /* 57 */
      if (ci->drivers.lie)
            SQL_FUNC_ESET(pfExists, SQL_API_SQLDESCRIBEPARAM); /* 58 not properly implemented */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLEXTENDEDFETCH); /* 59 deprecated ? */

      /*
       * for (++i; i < SQL_API_SQLBINDPARAMETER; i++)
       * SQL_FUNC_ESET(pfExists, i);
       */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLFOREIGNKEYS);      /* 60 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLMORERESULTS);      /* 61 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLNATIVESQL);        /* 62 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLNUMPARAMS);        /* 63 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLPARAMOPTIONS); 64 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPRIMARYKEYS);      /* 65 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURECOLUMNS); /* 66 */ 
      SQL_FUNC_ESET(pfExists, SQL_API_SQLPROCEDURES);       /* 67 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETPOS);           /* 68 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSCROLLOPTIONS); 69 deprecated */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLTABLEPRIVILEGES);        /* 70 */
      /* SQL_FUNC_ESET(pfExists, SQL_API_SQLDRIVERS); */    /* 71 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAMETER);    /* 72 */

      SQL_FUNC_ESET(pfExists, SQL_API_SQLALLOCHANDLE);      /* 1001 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLBINDPARAM);        /* 1002 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLCLOSECURSOR);      /* 1003 */
      if (ci->drivers.lie)
            SQL_FUNC_ESET(pfExists, SQL_API_SQLCOPYDESC); /* 1004 not implemented yet */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLENDTRAN);          /* 1005 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLFREEHANDLE);       /* 1006 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETCONNECTATTR);   /* 1007 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCFIELD);     /* 1008 */
      if (ci->drivers.lie)
      {
            SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDESCREC); /* 1009 not implemented yet */
      }
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGFIELD); /* 1010 minimal implementation */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETDIAGREC);       /* 1011 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETENVATTR);       /* 1012 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLGETSTMTATTR);      /* 1014 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETCONNECTATTR);   /* 1016 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCFIELD);     /* 1017 */
      if (ci->drivers.lie)
      {
            SQL_FUNC_ESET(pfExists, SQL_API_SQLSETDESCREC); /* 1018 not implemented yet */
      }
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETENVATTR);       /* 1019 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLSETSTMTATTR);      /* 1020 */
      SQL_FUNC_ESET(pfExists, SQL_API_SQLFETCHSCROLL);      /* 1021 */
      if (ci->updatable_cursors)
            SQL_FUNC_ESET(pfExists, SQL_API_SQLBULKOPERATIONS);   /* 24 */

      return SQL_SUCCESS;
}

RETCODE     SQL_API
SQLBulkOperations(HSTMT hstmt, SQLSMALLINT operation)
{
      RETCODE     ret;
      CSTR func = "SQLBulkOperations";
      StatementClass    *stmt = (StatementClass *) hstmt;

      ENTER_STMT_CS(stmt);
#ifndef     DRIVER_CURSOR_IMPLEMENT
      SC_set_error(stmt, STMT_NOT_IMPLEMENTED_ERROR,
      "driver must be compiled with the DRIVER_CURSOR_IMPLEMENT option");
      SC_log_error(func, "", stmt);
      ret = SQL_ERROR;
#else
      mylog("[[%s]] Handle=%u %d\n", func, hstmt, operation);
      SC_clear_error((StatementClass *) hstmt);
      ret = PGAPI_BulkOperations(hstmt, operation);
#endif /* DRIVER_CURSOR_IMPLEMENT */
      LEAVE_STMT_CS(stmt);
      return ret;
}     
#endif /* ODBCVER >= 0x0300 */

Generated by  Doxygen 1.6.0   Back to index