/* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. */ /* * Project: TimesTen Driver Manager * Version: 1.9 * Date: 6th January 2010 * Author: chris.jenkins@oracle.com * ****************************************************************** * * This is a lightweight ODBC driver manager. It is specifically * designed for use with the Oracle TimesTen IMDB to allow a * single application to utilise both direct mode and client/server * connections concurrently. Unlike many other driver managers, * the performance penalty from using this DM is very small. * * To use this DM, link with this (as an object or a shared library) * instead of one of the TimesTen libraries (client or direct mode). * As long as your LD_LIBRARY_PATH is set correctly, the TimesTen * libraries will be loaded dynamically at run-time. * * Since it is intended for use with TimesTen, this DM only provides * the ODBC functions that are supported and exposed by the TimesTen * driver libraries. In addition, for direct mode connections * this DM supports use of the XLA API and the TimesTen utility API. * * The choice between a direct mode or client/server connection is * made dynamically at connection time (when application calls * SQLConnect() or SQLDriverConnect()) based on whether the DSN * being conencted to is a direct mode DSN or a client DSN. * * For TimesTen applications, use of the DM should be transparent. * An application coded to work with one of the TimesTen drivers * (direct or client) should work with the DM without any code * changes. * * The accompanying demo programs illustrate the usage of the DM. * ****************************************************************** */ #include #include #include #if defined(WINDOWS) #define WINVER 0x500 #define _WIN32_WINNT 0x500 #if defined(_WIN64) #define BITS64 1 #endif #else /* !WINDOWS */ #include #endif /* !WINDOWS */ #include /* ======================================================================== Build control defines ======================================================================== */ #include /* ======================================================================== Other defines ======================================================================== */ #if defined(ENABLE_XLA_DIRECT) #include #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) #define TT_UTILLIB #include #undef TT_UTILLIB #endif /* ENABLE_UTIL_LIB */ #if defined(BITS64) /* 64 bit */ #define FMT_HVAL "%16.16x" #else /* 32 bit */ #define FMT_HVAL "%8.8x" #endif /* BITS64 */ #if defined(FUNC_TRACING) #define TRACE_FENTER(x) fprintf(stderr,"TRACE: FENTER: %s\n",(x)) #define TRACE_FLEAVE(x) fprintf(stderr,"TRACE: FLEAVE: %s\n",(x)) #define TRACE_FLEAVE_RC(x,rc) fprintf(stderr,"TRACE: FLEAVE: %s, rc = %d\n", \ (x),(rc)) #else /* !FUNC_TRACING */ #define TRACE_FENTER(x) #define TRACE_FLEAVE(x) #define TRACE_FLEAVE_RC(x,rc) #endif /* !FUNC_TRACING */ #if defined(FUNC_TRACING) && defined(HVAL_TRACING) #define TRACE_HVAL(nm,val) fprintf(stderr,"TRACE: HVAL: %s = " FMT_HVAL "\n",\ (nm),(val)); #else /* !HVAL_TRACING */ #define TRACE_HVAL(nm,val) #endif /* !HVAL_TRACING */ #if defined(WINDOWS) typedef HINSTANCE tt_libptr_t; typedef FARPROC tt_funcptr_t; #if defined(STATICOBJECT) #define DLLEXPORT #else /* !STATICOBJECT */ #define DLLEXPORT __declspec(dllexport) #endif /* !STATICOBJECT */ #if defined(SQL_API) #undef SQL_API #endif #define SQL_API __stdcall #define XLA_API __cdecl #define UTIL_API __cdecl #else /* !WINDOWS */ typedef void * tt_libptr_t; typedef void * tt_funcptr_t; #define DLLEXPORT #if defined(SQL_API) #undef SQL_API #endif #define SQL_API #define XLA_API #define UTIL_API #endif /* !WINDOWS */ #if defined(ENABLE_THREAD_SAFETY) #if defined(WINDOWS) #if !defined(MUTEX_SPINCOUNT) #define MUTEX_SPINCOUNT 15000 #endif /* MUTEX_SPINCOUNT */ typedef LPCRITICAL_SECTION tt_mutex_t; #else /* !WINDOWS */ #include typedef pthread_mutex_t * tt_mutex_t; #endif /* !WINDOWS */ #define MUTEX_INITIALISER NULL #define MUTEX_LOCK(m) ttMutexLock(m) #define MUTEX_UNLOCK(m) ttMutexUnlock(m) #define MUTEX_CREATE(m) m = ttMutexCreate() #define MUTEX_INIT(m) ttMutexInit(m) #define MUTEX_DESTROY(m) ttMutexDestroy(m) #define CLEAR_ERROR_STACK_LOCK(obj) clearErrorStackLock(&((obj)->errorStack), \ (obj)->mutex) #define CLEAR_ERROR_STACK(obj) clearErrorStack(&((obj)->errorStack)) #else /* !ENABLE_THREAD_SAFETY */ #define MUTEX_INITIALISER NULL #define MUTEX_LOCK(m) #define MUTEX_UNLOCK(m) #define MUTEX_CREATE(m) #define MUTEX_INIT(m) #define MUTEX_DESTROY(m) #define CLEAR_ERROR_STACK_LOCK(obj) clearErrorStack(&((obj)->errorStack)) #define CLEAR_ERROR_STACK(obj) clearErrorStack(&((obj)->errorStack)) #endif /* !ENABLE_THREAD_SAFETY */ #define TTDM_CONNSTR_MAX 256 #define TTDM_STRUCT_TAG 0x5474446d /* TtDm */ /* * SQLSTATE related values */ #define TT_SQLSTATE_LEN 5 #define TT_DM_SQLSTATE_CONNERR "S1000" #define TT_DM_SQLSTATE_NOMEM "S1001" #define TT_DM_SQLSTATE_LIBLOAD "IM003" #define TT_DM_SQLSTATE_FUNCSEQ "S1010" #define TT_DM_SQLSTATE_ARGERR "S1009" /* * Library related values */ #define _ARG2STRING(n) #n #define ARG2STRING(n) _ARG2STRING(n) #ifdef TTDEBUG #define DBG_LIB_EXTENSION "D" #else #define DBG_LIB_EXTENSION #endif #define TT_LIB_NO_TYPE 0 #define TT_LIB_DM_TYPE 1 #define TT_LIB_CS_TYPE 2 #if defined(WINDOWS) #if TT_LIB_VERSION < 1121 #define TT_LIB_DM_NAME "ttdv" ARG2STRING(TT_LIB_VERSION) DBG_LIB_EXTENSION SHLIB_SUFFIX #define TT_LIB_CS_NAME "ttcl" ARG2STRING(TT_LIB_VERSION) SHLIB_SUFFIX #else #define TT_LIB_DM_NAME "ttdv" ARG2STRING(TT_LIB_VERSION) DBG_LIB_EXTENSION SHLIB_SUFFIX #define TT_LIB_CS_NAME "ttclient" ARG2STRING(TT_LIB_VERSION) SHLIB_SUFFIX #endif #else /* !WINDOWS */ #define TT_LIB_DM_NAME "libtten" DBG_LIB_EXTENSION SHLIB_SUFFIX #define TT_LIB_CS_NAME "libttclient" SHLIB_SUFFIX #endif /* !WINDOWS */ #if defined(ENABLE_UTIL_LIB) #define TT_LIB_UT_TYPE 3 #if defined(WINDOWS) #if TT_LIB_VERSION < 1121 #define TT_LIB_UT_NAME "ttut" ARG2STRING(TT_LIB_VERSION) DBG_LIB_EXTENSION SHLIB_SUFFIX #else #define TT_LIB_UT_NAME "ttutil" ARG2STRING(TT_LIB_VERSION) DBG_LIB_EXTENSION SHLIB_SUFFIX #endif #else /* !WINDOWS */ #define TT_LIB_UT_NAME "libttutil" DBG_LIB_EXTENSION SHLIB_SUFFIX #endif /* !WINDOWS */ #define TT_DM_UTIL_LIBERR "TimesTen Driver Manager: ttUtilAllocEnv: " \ "Utility library not loaded" #define TT_DM_UTIL_ENV1ERR "TimesTen Driver Manager: ttUtilAllocEnv: " \ "Unable to allocate an ODBC environment" #define TT_DM_UTIL_MEMERR "TimesTen Driver Manager: ttUtilAllocEnv: " \ "Unable to allocate memory" #define TT_DM_UTIL_ENV2ERR "TimesTen Driver Manager: ttUtilFreeEnv: " \ "Unable to free the ODBC environment" #endif /* ENABLE_UTIL_LIB */ /* * Values for ODBC function tables */ #define NUM_ODBC_FUNCTIONS 51 #define MAX_ODBC_FUNCNAME_LEN 25 #define F_POS_ODBC_SQLAllocEnv 0 #define F_NM_ODBC_SQLAllocEnv "SQLAllocEnv" #define F_POS_ODBC_SQLAllocConnect 1 #define F_NM_ODBC_SQLAllocConnect "SQLAllocConnect" #define F_POS_ODBC_SQLDriverConnect 2 #define F_NM_ODBC_SQLDriverConnect "SQLDriverConnect" #define F_POS_ODBC_SQLDisconnect 3 #define F_NM_ODBC_SQLDisconnect "SQLDisconnect" #define F_POS_ODBC_SQLFreeConnect 4 #define F_NM_ODBC_SQLFreeConnect "SQLFreeConnect" #define F_POS_ODBC_SQLFreeEnv 5 #define F_NM_ODBC_SQLFreeEnv "SQLFreeEnv" #define F_POS_ODBC_SQLAllocStmt 6 #define F_NM_ODBC_SQLAllocStmt "SQLAllocStmt" #define F_POS_ODBC_SQLError 7 #define F_NM_ODBC_SQLError "SQLError" #define F_POS_ODBC_SQLBindCol 8 #define F_NM_ODBC_SQLBindCol "SQLBindCol" #define F_POS_ODBC_SQLCancel 9 #define F_NM_ODBC_SQLCancel "SQLCancel" #define F_POS_ODBC_SQLColAttributes 10 #define F_NM_ODBC_SQLColAttributes "SQLColAttributes" #define F_POS_ODBC_SQLConnect 11 #define F_NM_ODBC_SQLConnect "SQLConnect" #define F_POS_ODBC_SQLDescribeCol 12 #define F_NM_ODBC_SQLDescribeCol "SQLDescribeCol" #define F_POS_ODBC_SQLExecDirect 13 #define F_NM_ODBC_SQLExecDirect "SQLExecDirect" #define F_POS_ODBC_SQLExecute 14 #define F_NM_ODBC_SQLExecute "SQLExecute" #define F_POS_ODBC_SQLFetch 15 #define F_NM_ODBC_SQLFetch "SQLFetch" #define F_POS_ODBC_SQLFreeStmt 16 #define F_NM_ODBC_SQLFreeStmt "SQLFreeStmt" #define F_POS_ODBC_SQLGetCursorName 17 #define F_NM_ODBC_SQLGetCursorName "SQLGetCursorName" #define F_POS_ODBC_SQLNumResultCols 18 #define F_NM_ODBC_SQLNumResultCols "SQLNumResultCols" #define F_POS_ODBC_SQLPrepare 19 #define F_NM_ODBC_SQLPrepare "SQLPrepare" #define F_POS_ODBC_SQLRowCount 20 #define F_NM_ODBC_SQLRowCount "SQLRowCount" #define F_POS_ODBC_SQLSetCursorName 21 #define F_NM_ODBC_SQLSetCursorName "SQLSetCursorName" #define F_POS_ODBC_SQLTransact 22 #define F_NM_ODBC_SQLTransact "SQLTransact" #define F_POS_ODBC_SQLColumns 23 #define F_NM_ODBC_SQLColumns "SQLColumns" #define F_POS_ODBC_SQLGetConnectOption 24 #define F_NM_ODBC_SQLGetConnectOption "SQLGetConnectOption" #define F_POS_ODBC_SQLGetData 25 #define F_NM_ODBC_SQLGetData "SQLGetData" #define F_POS_ODBC_SQLGetFunctions 26 #define F_NM_ODBC_SQLGetFunctions "SQLGetFunctions" #define F_POS_ODBC_SQLGetInfo 27 #define F_NM_ODBC_SQLGetInfo "SQLGetInfo" #define F_POS_ODBC_SQLBindParameter 28 #define F_NM_ODBC_SQLBindParameter "SQLBindParameter" #define F_POS_ODBC_SQLGetStmtOption 29 #define F_NM_ODBC_SQLGetStmtOption "SQLGetStmtOption" #define F_POS_ODBC_SQLGetTypeInfo 30 #define F_NM_ODBC_SQLGetTypeInfo "SQLGetTypeInfo" #define F_POS_ODBC_SQLParamData 31 #define F_NM_ODBC_SQLParamData "SQLParamData" #define F_POS_ODBC_SQLPutData 32 #define F_NM_ODBC_SQLPutData "SQLPutData" #define F_POS_ODBC_SQLSetConnectOption 33 #define F_NM_ODBC_SQLSetConnectOption "SQLSetConnectOption" #define F_POS_ODBC_SQLSetStmtOption 34 #define F_NM_ODBC_SQLSetStmtOption "SQLSetStmtOption" #define F_POS_ODBC_SQLSpecialColumns 35 #define F_NM_ODBC_SQLSpecialColumns "SQLSpecialColumns" #define F_POS_ODBC_SQLStatistics 36 #define F_NM_ODBC_SQLStatistics "SQLStatistics" #define F_POS_ODBC_SQLTables 37 #define F_NM_ODBC_SQLTables "SQLTables" #define F_POS_ODBC_SQLColumnPrivileges 38 #define F_NM_ODBC_SQLColumnPrivileges "SQLColumnPrivileges" #define F_POS_ODBC_SQLDescribeParam 39 #define F_NM_ODBC_SQLDescribeParam "SQLDescribeParam" #define F_POS_ODBC_SQLExtendedFetch 40 #define F_NM_ODBC_SQLExtendedFetch "SQLExtendedFetch" #define F_POS_ODBC_SQLForeignKeys 41 #define F_NM_ODBC_SQLForeignKeys "SQLForeignKeys" #define F_POS_ODBC_SQLMoreResults 42 #define F_NM_ODBC_SQLMoreResults "SQLMoreResults" #define F_POS_ODBC_SQLNativeSql 43 #define F_NM_ODBC_SQLNativeSql "SQLNativeSql" #define F_POS_ODBC_SQLNumParams 44 #define F_NM_ODBC_SQLNumParams "SQLNumParams" #define F_POS_ODBC_SQLParamOptions 45 #define F_NM_ODBC_SQLParamOptions "SQLParamOptions" #define F_POS_ODBC_SQLPrimaryKeys 46 #define F_NM_ODBC_SQLPrimaryKeys "SQLPrimaryKeys" #define F_POS_ODBC_SQLProcedureColumns 47 #define F_NM_ODBC_SQLProcedureColumns "SQLProcedureColumns" #define F_POS_ODBC_SQLProcedures 48 #define F_NM_ODBC_SQLProcedures "SQLProcedures" #define F_POS_ODBC_SQLSetPos 49 #define F_NM_ODBC_SQLSetPos "SQLSetPos" #define F_POS_ODBC_SQLTablePrivileges 50 #define F_NM_ODBC_SQLTablePrivileges "SQLTablePrivileges" #if defined(ENABLE_XLA_DIRECT) /* * Values for XLA function tables */ #define NUM_XLA_FUNCTIONS 49 #define MAX_XLA_FUNCNAME_LEN 35 #define F_POS_XLA_ttXlaAcknowledge 0 #define F_NM_XLA_ttXlaAcknowledge "ttXlaAcknowledge" #define F_POS_XLA_ttXlaApply 1 #define F_NM_XLA_ttXlaApply "ttXlaApply" #define F_POS_XLA_ttXlaClose 2 #define F_NM_XLA_ttXlaClose "ttXlaClose" #define F_POS_XLA_ttXlaCommit 3 #define F_NM_XLA_ttXlaCommit "ttXlaCommit" #define F_POS_XLA_ttXlaConvertCharType 4 #define F_NM_XLA_ttXlaConvertCharType "ttXlaConvertCharType" #define F_POS_XLA_ttXlaDateToODBCCType 5 #define F_NM_XLA_ttXlaDateToODBCCType "ttXlaDateToODBCCType" #define F_POS_XLA_ttXlaDecimalToCString 6 #define F_NM_XLA_ttXlaDecimalToCString "ttXlaDecimalToCString" #define F_POS_XLA_ttXlaDeleteBookmark 7 #define F_NM_XLA_ttXlaDeleteBookmark "ttXlaDeleteBookmark" #define F_POS_XLA_ttXlaError 8 #define F_NM_XLA_ttXlaError "ttXlaError" #define F_POS_XLA_ttXlaErrorRestart 9 #define F_NM_XLA_ttXlaErrorRestart "ttXlaErrorRestart" #define F_POS_XLA_ttXlaGenerateSQL 10 #define F_NM_XLA_ttXlaGenerateSQL "ttXlaGenerateSQL" #define F_POS_XLA_ttXlaGetColumnInfo 11 #define F_NM_XLA_ttXlaGetColumnInfo "ttXlaGetColumnInfo" #define F_POS_XLA_ttXlaGetLSN 12 #define F_NM_XLA_ttXlaGetLSN "ttXlaGetLSN" #define F_POS_XLA_ttXlaGetTableInfo 13 #define F_NM_XLA_ttXlaGetTableInfo "ttXlaGetTableInfo" #define F_POS_XLA_ttXlaGetVersion 14 #define F_NM_XLA_ttXlaGetVersion "ttXlaGetVersion" #define F_POS_XLA_ttXlaLookup 15 #define F_NM_XLA_ttXlaLookup "ttXlaLookup" #define F_POS_XLA_ttXlaNextUpdate 16 #define F_NM_XLA_ttXlaNextUpdate "ttXlaNextUpdate" #define F_POS_XLA_ttXlaNextUpdateWait 17 #define F_NM_XLA_ttXlaNextUpdateWait "ttXlaNextUpdateWait" #define F_POS_XLA_ttXlaNumberToBigInt 18 #define F_NM_XLA_ttXlaNumberToBigInt "ttXlaNumberToBigInt" #define F_POS_XLA_ttXlaNumberToCString 19 #define F_NM_XLA_ttXlaNumberToCString "ttXlaNumberToCString" #define F_POS_XLA_ttXlaNumberToDouble 20 #define F_NM_XLA_ttXlaNumberToDouble "ttXlaNumberToDouble" #define F_POS_XLA_ttXlaNumberToInt 21 #define F_NM_XLA_ttXlaNumberToInt "ttXlaNumberToInt" #define F_POS_XLA_ttXlaNumberToSmallInt 22 #define F_NM_XLA_ttXlaNumberToSmallInt "ttXlaNumberToSmallInt" #define F_POS_XLA_ttXlaNumberToTinyInt 23 #define F_NM_XLA_ttXlaNumberToTinyInt "ttXlaNumberToTinyInt" #define F_POS_XLA_ttXlaNumberToUInt 24 #define F_NM_XLA_ttXlaNumberToUInt "ttXlaNumberToUInt" #define F_POS_XLA_ttXlaOraDateToODBCTimeStamp 25 #define F_NM_XLA_ttXlaOraDateToODBCTimeStamp "ttXlaOraDateToODBCTimeStamp" #define F_POS_XLA_ttXlaOraTimeStampToODBCTimeStamp 26 #define F_NM_XLA_ttXlaOraTimeStampToODBCTimeStamp "ttXlaOraTimeStampToODBCTimeStamp" #define F_POS_XLA_ttXlaPersistOpen 27 #define F_NM_XLA_ttXlaPersistOpen "ttXlaPersistOpen" #define F_POS_XLA_ttXlaResetStatus 28 #define F_NM_XLA_ttXlaResetStatus "ttXlaResetStatus" #define F_POS_XLA_ttXlaRollback 29 #define F_NM_XLA_ttXlaRollback "ttXlaRollback" #define F_POS_XLA_ttXlaSetLSN 30 #define F_NM_XLA_ttXlaSetLSN "ttXlaSetLSN" #define F_POS_XLA_ttXlaSetVersion 31 #define F_NM_XLA_ttXlaSetVersion "ttXlaSetVersion" #define F_POS_XLA_ttXlaStatus 32 #define F_NM_XLA_ttXlaStatus "ttXlaStatus" #define F_POS_XLA_ttXlaTableByName 33 #define F_NM_XLA_ttXlaTableByName "ttXlaTableByName" #define F_POS_XLA_ttXlaTableCheck 34 #define F_NM_XLA_ttXlaTableCheck "ttXlaTableCheck" #define F_POS_XLA_ttXlaTableStatus 35 #define F_NM_XLA_ttXlaTableStatus "ttXlaTableStatus" #define F_POS_XLA_ttXlaTableVersionVerify 36 #define F_NM_XLA_ttXlaTableVersionVerify "ttXlaTableVersionVerify" #define F_POS_XLA_ttXlaTimeStampToODBCCType 37 #define F_NM_XLA_ttXlaTimeStampToODBCCType "ttXlaTimeStampToODBCCType" #define F_POS_XLA_ttXlaTimeToODBCCType 38 #define F_NM_XLA_ttXlaTimeToODBCCType "ttXlaTimeToODBCCType" #define F_POS_XLA_ttXlaVersionColumnInfo 39 #define F_NM_XLA_ttXlaVersionColumnInfo "ttXlaVersionColumnInfo" #define F_POS_XLA_ttXlaVersionCompare 40 #define F_NM_XLA_ttXlaVersionCompare "ttXlaVersionCompare" #define F_POS_XLA_ttXlaVersionTableInfo 41 #define F_NM_XLA_ttXlaVersionTableInfo "ttXlaVersionTableInfo" /* * Functions for legacy (non persistent) XLA */ #define F_POS_XLA_ttXlaOpenTimesTen 42 #define F_NM_XLA_ttXlaOpenTimesTen "ttXlaOpenTimesTen" #define F_POS_XLA_ttXlaConfigBuffer 43 #define F_NM_XLA_ttXlaConfigBuffer "ttXlaConfigBuffer" /* * Undocumented public functions */ #define F_POS_XLA_ttXlaEpilog2 44 #define F_NM_XLA_ttXlaEpilog2 "ttXlaEpilog2" #define F_POS_XLA_ttXlaInvalidateTbl2 45 #define F_NM_XLA_ttXlaInvalidateTbl2 "ttXlaInvalidateTbl2" #define F_POS_XLA_ttXlaGenerateSQL2 46 #define F_NM_XLA_ttXlaGenerateSQL2 "ttXlaGenerateSQL2" #define F_POS_XLA_ttXlaTranslate 47 #define F_NM_XLA_ttXlaTranslate "ttXlaTranslate" #define F_POS_XLA_ttXlaSqlOption 48 #define F_NM_XLA_ttXlaSqlOption "ttXlaSqlOption" #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) /* * Values for Utility function tables */ #define NUM_UTIL_FUNCTIONS 14 #define MAX_UTIL_FUNCNAME_LEN 32 #define F_POS_UTIL_ttUtilAllocEnv 0 #define F_NM_UTIL_ttUtilAllocEnv "ttUtilAllocEnv" #define F_POS_UTIL_ttUtilFreeEnv 1 #define F_NM_UTIL_ttUtilFreeEnv "ttUtilFreeEnv" #define F_POS_UTIL_ttUtilGetErrorCount 2 #define F_NM_UTIL_ttUtilGetErrorCount "ttUtilGetErrorCount" #define F_POS_UTIL_ttUtilGetError 3 #define F_NM_UTIL_ttUtilGetError "ttUtilGetError" #define F_POS_UTIL_ttBackup 4 #define F_NM_UTIL_ttBackup "ttBackup" #define F_POS_UTIL_ttDestroyDataStore 5 #define F_NM_UTIL_ttDestroyDataStore "ttDestroyDataStore" #define F_POS_UTIL_ttDestroyDataStoreForce 6 #define F_NM_UTIL_ttDestroyDataStoreForce "ttDestroyDataStoreForce" #define F_POS_UTIL_ttRamGrace 7 #define F_NM_UTIL_ttRamGrace "ttRamGrace" #define F_POS_UTIL_ttRamLoad 8 #define F_NM_UTIL_ttRamLoad "ttRamLoad" #define F_POS_UTIL_ttRamPolicy 9 #define F_NM_UTIL_ttRamPolicy "ttRamPolicy" #define F_POS_UTIL_ttRamUnload 10 #define F_NM_UTIL_ttRamUnload "ttRamUnload" #define F_POS_UTIL_ttRepDuplicateEx 11 #define F_NM_UTIL_ttRepDuplicateEx "ttRepDuplicateEx" #define F_POS_UTIL_ttRestore 12 #define F_NM_UTIL_ttRestore "ttRestore" #define F_POS_UTIL_ttXactIdRollback 13 #define F_NM_UTIL_ttXactIdRollback "ttXactIdRollback" #endif /* ENABLE_UTIL_LIB */ /* ======================================================================== Type definitions ======================================================================== */ /* * Structure used to map functions to library specific entry points */ typedef struct s_funcmapper { int libType; /* TT_LIB_DM_TYPE, TT_LIB_CS_TYPE or TT_LIB_UT_TYPE */ tt_libptr_t libHandle; void * * odbcFuncPtr; #if defined(ENABLE_XLA_DIRECT) void * * xlaFuncPtr; #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) void * * utilFuncPtr; #endif /* ENABLE_UTIL_LIB */ } funcmapper_t; /* * ODBC Error/Warning Information */ typedef struct s_ODBC_ERR { SQLRETURN rc; SQLCHAR sqlState[TT_SQLSTATE_LEN+1]; SQLINTEGER nativeError; SQLCHAR errorMsg[SQL_MAX_MESSAGE_LENGTH]; struct s_ODBC_ERR * next; } ODBC_ERR_t; /* * Our version of an Environment. There is a dependency between * an environment and the connections allocated from it so the * environment maintains a list of all its dependent connections. */ typedef struct s_TT_ENV { unsigned int tag; /* Structure validation tag */ SQLHENV directEnv; /* The direct ODBC HENV for this TT_ENV_t */ SQLHENV clientEnv; /* The client ODBC HENV for this TT_ENV_t */ funcmapper_t * pDirectMap; /* pointer to Direct function map */ funcmapper_t * pClientMap; /* pointer to Client function map */ ODBC_ERR_t * errorStack; struct s_TT_ENV * prev; /* List of all TT_ENV_t */ struct s_TT_ENV * next; struct s_TT_DBC * head; /* List of all associated TT_DBC_t */ struct s_TT_DBC * tail; #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex; #endif /* ENABLE_THREAD_SAFETY */ } TT_ENV_t; typedef TT_ENV_t * TTSQLHENV; /* * Our version of a Connection */ typedef struct s_TT_DBC { unsigned int tag; /* Structure validation tag */ TTSQLHENV TThEnv; /* The TT_ENV_t that owns this connection */ SQLHENV directEnv; /* The direct ODBC HENV for this TT_ENV_t */ SQLHENV clientEnv; /* The client ODBC HENV for this TT_ENV_t */ SQLHENV hEnv; /* The actual HENV that owns this connection */ SQLHDBC directDbc; /* The direct ODBC HDBC for this connection */ SQLHDBC clientDbc; /* The client ODBC HDBC for this connection */ SQLHDBC hDbc; /* The actual HDBC for this connection */ funcmapper_t * pDirectMap; /* pointer to Client function map */ funcmapper_t * pClientMap; /* pointer to Direct function map */ funcmapper_t * pFuncMap; /* pointer to actual function map */ ODBC_ERR_t * errorStack; #if defined(ENABLE_XLA_DIRECT) struct s_ttXlaHandle * TThXla; #endif /* ENABLE_XLA_DIRECT */ struct s_TT_DBC * prev; /* List of all TT_DBC_t bellonging to TThEnv */ struct s_TT_DBC * next; struct s_TT_STMT * head; /* List of all associated TT_STMT_t */ struct s_TT_STMT * tail; #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex; #endif /* ENABLE_THREAD_SAFETY */ } TT_DBC_t; typedef TT_DBC_t * TTSQLHDBC; /* * Our version of a Statement */ typedef struct s_TT_STMT { unsigned int tag; /* Structure validation tag */ TTSQLHENV TThEnv; /* The TT_ENV_t that owns this statement */ TTSQLHDBC TThDbc; /* The TT_DBC_t that owns this statement */ SQLHENV hEnv; /* The real ODBC HENV that owns this statement */ SQLHDBC hDbc; /* The real ODBC HDBC that owns this statement */ SQLHSTMT hStmt; /* The real ODBC HSTMT for this statement */ funcmapper_t * pFuncMap; /* pointer to function map */ ODBC_ERR_t * errorStack; struct s_TT_STMT * prev; /* List of all TT_STMT_t bellonging to TThDbc */ struct s_TT_STMT * next; #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex; #endif /* ENABLE_THREAD_SAFETY */ } TT_STMT_t; typedef TT_STMT_t * TTSQLHSTMT; #if defined(ENABLE_XLA_DIRECT) /* * Our version of a ttXlaHandle */ typedef struct s_ttXlaHandle { unsigned int tag; /* Structure validation tag */ TTSQLHENV TThEnv; TTSQLHDBC TThDbc; ttXlaHandle_h hXla; funcmapper_t * pFuncMap; /* pointer to function map */ #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t pMutex; /* pointer to mutex */ #endif /* ENABLE_THREAD_SAFETY */ } TTXlaHandle_t; #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) /* * Our version of a ttUtilHandle */ typedef struct s_TTUtilH { unsigned int tag; ttUtilHandle hUtil; /* actual utility library handle */ struct s_TTUtilH * prev; struct s_TTUtilH * next; #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex; #endif /* ENABLE_THREAD_SAFETY */ } TTUtilHandle_t; typedef TTUtilHandle_t * TTUtilHandle; #endif /* ENABLE_UTIL_LIB */ /* * Global data for an instance of the driver manager (i.e. a process). * * This is all localised into a single structure to facilitate making the * DM thread safe. */ typedef struct s_DMGlobalData { /* Master list of all environments */ TTSQLHENV ELhead; TTSQLHENV ELtail; funcmapper_t * directFuncs; funcmapper_t * clientFuncs; #if defined(ENABLE_UTIL_LIB) TTUtilHandle UThead; TTUtilHandle UTtail; funcmapper_t * utilFuncs; TTSQLHENV utilEnv; #endif /* ENABLE_UTIL_LIB */ #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex; #if defined(ENABLE_UTIL_LIB) tt_mutex_t utilMutex; #endif /* ENABLE_UTIL_LIB */ #endif /* ENABLE_THREAD_SAFETY */ } DMGlobalData_t; /* ======================================================================== Private Data ======================================================================== */ #if defined(ENABLE_THREAD_SAFETY) /* * For platforms that use pthread base threading, the following are used * to avoid any race condition on initialisation. Windows platforms handle * this somewhat differently. */ #if !defined(WINDOWS) static pthread_mutex_t globalMutex = PTHREAD_MUTEX_INITIALIZER; #if defined(ENABLE_UTIL_LIB) static pthread_mutex_t globalUtilMutex = PTHREAD_MUTEX_INITIALIZER; #endif /* ENABLE_UTIL_LIB */ #endif /* !WINDOWS */ #endif /* ENABLE_THREAD_SAFETY */ /* * Array of ODBC Function Names. * * This is never modified during execution. */ static const char ODBCFuncName[NUM_ODBC_FUNCTIONS][MAX_ODBC_FUNCNAME_LEN+1] = { F_NM_ODBC_SQLAllocEnv, F_NM_ODBC_SQLAllocConnect, F_NM_ODBC_SQLDriverConnect, F_NM_ODBC_SQLDisconnect, F_NM_ODBC_SQLFreeConnect, F_NM_ODBC_SQLFreeEnv, F_NM_ODBC_SQLAllocStmt, F_NM_ODBC_SQLError, F_NM_ODBC_SQLBindCol, F_NM_ODBC_SQLCancel, F_NM_ODBC_SQLColAttributes, F_NM_ODBC_SQLConnect, F_NM_ODBC_SQLDescribeCol, F_NM_ODBC_SQLExecDirect, F_NM_ODBC_SQLExecute, F_NM_ODBC_SQLFetch, F_NM_ODBC_SQLFreeStmt, F_NM_ODBC_SQLGetCursorName, F_NM_ODBC_SQLNumResultCols, F_NM_ODBC_SQLPrepare, F_NM_ODBC_SQLRowCount, F_NM_ODBC_SQLSetCursorName, F_NM_ODBC_SQLTransact, F_NM_ODBC_SQLColumns, F_NM_ODBC_SQLGetConnectOption, F_NM_ODBC_SQLGetData, F_NM_ODBC_SQLGetFunctions, F_NM_ODBC_SQLGetInfo, F_NM_ODBC_SQLBindParameter, F_NM_ODBC_SQLGetStmtOption, F_NM_ODBC_SQLGetTypeInfo, F_NM_ODBC_SQLParamData, F_NM_ODBC_SQLPutData, F_NM_ODBC_SQLSetConnectOption, F_NM_ODBC_SQLSetStmtOption, F_NM_ODBC_SQLSpecialColumns, F_NM_ODBC_SQLStatistics, F_NM_ODBC_SQLTables, F_NM_ODBC_SQLColumnPrivileges, F_NM_ODBC_SQLDescribeParam, F_NM_ODBC_SQLExtendedFetch, F_NM_ODBC_SQLForeignKeys, F_NM_ODBC_SQLMoreResults, F_NM_ODBC_SQLNativeSql, F_NM_ODBC_SQLNumParams, F_NM_ODBC_SQLParamOptions, F_NM_ODBC_SQLPrimaryKeys, F_NM_ODBC_SQLProcedureColumns, F_NM_ODBC_SQLProcedures, F_NM_ODBC_SQLSetPos, F_NM_ODBC_SQLTablePrivileges }; #if defined(ENABLE_XLA_DIRECT) /* * Array of ODBC Function Names. * * This is never modified during execution. */ static const char XLAFuncName[NUM_XLA_FUNCTIONS][MAX_XLA_FUNCNAME_LEN+1] = { F_NM_XLA_ttXlaAcknowledge, F_NM_XLA_ttXlaApply, F_NM_XLA_ttXlaClose, F_NM_XLA_ttXlaCommit, F_NM_XLA_ttXlaConvertCharType, F_NM_XLA_ttXlaDateToODBCCType, F_NM_XLA_ttXlaDecimalToCString, F_NM_XLA_ttXlaDeleteBookmark, F_NM_XLA_ttXlaError, F_NM_XLA_ttXlaErrorRestart, F_NM_XLA_ttXlaGenerateSQL, F_NM_XLA_ttXlaGetColumnInfo, F_NM_XLA_ttXlaGetLSN, F_NM_XLA_ttXlaGetTableInfo, F_NM_XLA_ttXlaGetVersion, F_NM_XLA_ttXlaLookup, F_NM_XLA_ttXlaNextUpdate, F_NM_XLA_ttXlaNextUpdateWait, F_NM_XLA_ttXlaNumberToBigInt, F_NM_XLA_ttXlaNumberToCString, F_NM_XLA_ttXlaNumberToDouble, F_NM_XLA_ttXlaNumberToInt, F_NM_XLA_ttXlaNumberToSmallInt, F_NM_XLA_ttXlaNumberToTinyInt, F_NM_XLA_ttXlaNumberToUInt, F_NM_XLA_ttXlaOraDateToODBCTimeStamp, F_NM_XLA_ttXlaOraTimeStampToODBCTimeStamp, F_NM_XLA_ttXlaPersistOpen, F_NM_XLA_ttXlaResetStatus, F_NM_XLA_ttXlaRollback, F_NM_XLA_ttXlaSetLSN, F_NM_XLA_ttXlaSetVersion, F_NM_XLA_ttXlaStatus, F_NM_XLA_ttXlaTableByName, F_NM_XLA_ttXlaTableCheck, F_NM_XLA_ttXlaTableStatus, F_NM_XLA_ttXlaTableVersionVerify, F_NM_XLA_ttXlaTimeStampToODBCCType, F_NM_XLA_ttXlaTimeToODBCCType, F_NM_XLA_ttXlaVersionColumnInfo, F_NM_XLA_ttXlaVersionCompare, F_NM_XLA_ttXlaVersionTableInfo, F_NM_XLA_ttXlaOpenTimesTen, F_NM_XLA_ttXlaConfigBuffer, F_NM_XLA_ttXlaEpilog2, F_NM_XLA_ttXlaInvalidateTbl2, F_NM_XLA_ttXlaGenerateSQL2, F_NM_XLA_ttXlaTranslate, F_NM_XLA_ttXlaSqlOption }; #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) /* * Array of Utility Function Names. * * This is never modified during execution. */ static const char UTILFuncName[NUM_UTIL_FUNCTIONS][MAX_UTIL_FUNCNAME_LEN+1] = { F_NM_UTIL_ttUtilAllocEnv, F_NM_UTIL_ttUtilFreeEnv, F_NM_UTIL_ttUtilGetErrorCount, F_NM_UTIL_ttUtilGetError, F_NM_UTIL_ttBackup, F_NM_UTIL_ttDestroyDataStore, F_NM_UTIL_ttDestroyDataStoreForce, F_NM_UTIL_ttRamGrace, F_NM_UTIL_ttRamLoad, F_NM_UTIL_ttRamPolicy, F_NM_UTIL_ttRamUnload, F_NM_UTIL_ttRepDuplicateEx, F_NM_UTIL_ttRestore, F_NM_UTIL_ttXactIdRollback }; #endif /* ENABLE_UTIL_LIB */ /* * Global Data for this DM instance. * * This is modified during execution. */ static DMGlobalData_t DMGlobalData = { NULL, NULL, NULL, NULL #if defined(ENABLE_UTIL_LIB) , NULL , NULL , NULL , NULL #endif /* ENABLE_UTIL_LIB */ #if defined(ENABLE_THREAD_SAFETY) /* * Initialisation of global mutexes is handled differently for Windows * and non-Windows (pthreads) platforms. */ #if defined(WINDOWS) , MUTEX_INITIALISER #if defined(ENABLE_UTIL_LIB) , MUTEX_INITIALISER #endif /* ENABLE_UTIL_LIB */ #else /* !WINDOWS */ , &globalMutex #if defined(ENABLE_UTIL_LIB) , &globalUtilMutex #endif /* ENABLE_UTIL_LIB */ #endif /* !WINDOWS */ #endif /* ENABLE_THREAD_SAFETY */ }; /* ======================================================================== Special (public) DEBUG functions Intended to aid debugging the Driver Manager ======================================================================== */ #if defined(ENABLE_DEBUG_FUNCTIONS) #endif /* ======================================================================== Private Functions ======================================================================== */ #if defined(ENABLE_THREAD_SAFETY) /* * Initialises an existing mutex */ static void ttMutexInit(tt_mutex_t mutex) { #if defined(WINDOWS) InitializeCriticalSectionAndSpinCount(mutex, (DWORD)MUTEX_SPINCOUNT); #else /* !WINDOWS */ pthread_mutex_init(mutex,NULL); #endif /* !WINDOWS */ } /* * Creates an initialised mutex and returns it */ static tt_mutex_t ttMutexCreate(void) { tt_mutex_t mutex; #if defined(WINDOWS) mutex = (tt_mutex_t)calloc(1, sizeof(CRITICAL_SECTION)); #else /* !WINDOWS */ mutex = (tt_mutex_t)calloc(1, sizeof(pthread_mutex_t)); #endif /* !WINDOWS */ if ( mutex != NULL ) ttMutexInit(mutex); return mutex; } /* * Destroys a mutex */ static int ttMutexDestroy(tt_mutex_t mutex) { int retval = 0; #if defined(WINDOWS) DeleteCriticalSection(mutex); #else /* !WINDOWS */ retval = pthread_mutex_destroy(mutex); if ( retval == 0 ) free(mutex); #endif /* !WINDOWS */ return retval; } /* * Locks a mutex */ static int ttMutexLock(tt_mutex_t mutex) { int retval = 0; #if defined(WINDOWS) EnterCriticalSection(mutex); #else /* !WINDOWS */ retval = pthread_mutex_lock(mutex); #endif /* !WINDOWS */ return retval; } /* * Unlocks a mutex */ static int ttMutexUnlock(tt_mutex_t mutex) { int retval = 0; #if defined(WINDOWS) LeaveCriticalSection(mutex); #else /* !WINDOWS */ retval = pthread_mutex_unlock(mutex); #endif /* !WINDOWS */ return retval; } #endif /* ENABLE_THREAD_SAFETY */ #if defined(ENABLE_UTIL_LIB) /* * Post ttUtilAllocEnv and ttUtilFreeEnv errors */ static void postUtilEnvError( char* errMsg, char* errBuff, unsigned int buffLen, unsigned int* errLen ) { int msgLen; TRACE_FENTER("postUtilEnvError"); msgLen = strlen(errMsg); if ( errLen != NULL ) *errLen = msgLen; if ( (buffLen > 0) && (errBuff != NULL) ) { if ( msgLen < buffLen ) strcpy(errBuff,errMsg); else { strncpy(errBuff,errMsg,(buffLen-1)); errBuff[buffLen-1] = '\0'; } } TRACE_FLEAVE("postUtilEnvError"); } #endif /* ENABLE_UTIL_LIB */ /* * maxODBCError * * Takes two ODBC return codes and returns the 'most severe' according * to this order of prcedence (from least to most severe): * SQL_SUCCESS * SQL_NO_DATA_FOUND * SQL_SUCCESS_WITH_INFO * SQL_ERROR * SQL_INVALID_HANDLE */ static SQLRETURN maxODBCError( SQLRETURN rc1, SQLRETURN rc2 ) { SQLRETURN finalrc = SQL_SUCCESS; TRACE_FENTER("maxODBCError"); if ( (rc1 == SQL_INVALID_HANDLE) || (rc2 == SQL_INVALID_HANDLE) ) finalrc = SQL_INVALID_HANDLE; else if ( (rc1 == SQL_ERROR) || (rc2 == SQL_ERROR) ) finalrc = SQL_ERROR; else if ( (rc1 == SQL_SUCCESS_WITH_INFO) || (rc2 == SQL_SUCCESS_WITH_INFO) ) finalrc = SQL_SUCCESS_WITH_INFO; else if ( (rc1 == SQL_NO_DATA_FOUND) || (rc2 == SQL_NO_DATA_FOUND) ) finalrc = SQL_NO_DATA_FOUND; TRACE_FLEAVE_RC("maxODBCError",finalrc); return finalrc; } #if defined(ENABLE_THREAD_SAFETY) static void clearErrorStackLock( ODBC_ERR_t * * stkptr, tt_mutex_t mutex ) { ODBC_ERR_t * p = NULL; ODBC_ERR_t * np; TRACE_FENTER("clearErrorStackLock"); TRACE_HVAL("stkptr",stkptr); if ( (stkptr != NULL) && (mutex != NULL) ) { MUTEX_LOCK(mutex); TRACE_HVAL("*stkptr",*stkptr); if ( *stkptr != NULL ) { p = *stkptr; *stkptr = NULL; } MUTEX_UNLOCK(mutex); while ( p != NULL ) { np = p; p = p->next; free( (void *)np ); } } TRACE_FLEAVE("clearErrorStackLock"); } #endif /* ENABLE_THREAD_SAFETY */ static void clearErrorStack( ODBC_ERR_t * * stkptr ) { ODBC_ERR_t * p; ODBC_ERR_t * np; TRACE_FENTER("clearErrorStack"); TRACE_HVAL("stkptr",stkptr); if ( stkptr != NULL ) { TRACE_HVAL("*stkptr",*stkptr); if ( *stkptr != NULL ) { p = *stkptr; while ( p != NULL ) { np = p; p = p->next; free( (void *)np ); } *stkptr = NULL; } } TRACE_FLEAVE("clearErrorStack"); } static SQLRETURN pushError( ODBC_ERR_t * * stkptr, SQLRETURN RC, SQLCHAR * SQLSTATE, SQLINTEGER NATIVEERROR, SQLCHAR * ERRMSG ) { SQLRETURN rc = SQL_SUCCESS; ODBC_ERR_t * err = NULL; TRACE_FENTER("pushError"); TRACE_HVAL("stkptr",stkptr); if ( stkptr == NULL ) rc = SQL_ERROR; else { TRACE_HVAL("*stkptr",*stkptr); err = (ODBC_ERR_t *)malloc(sizeof(ODBC_ERR_t)); if ( err == NULL ) rc = SQL_ERROR; else { err->rc = RC; strcpy((char *)err->sqlState,(char *)SQLSTATE); err->nativeError = NATIVEERROR; strcpy((char *)err->errorMsg,(char *)ERRMSG); err->next = *stkptr; *stkptr = err; } } TRACE_FLEAVE_RC("pushError",rc); return rc; } static SQLRETURN popError( ODBC_ERR_t * * stkptr, SQLRETURN * RC, SQLCHAR * SQLSTATE, SQLINTEGER * NATIVEERROR, SQLCHAR * ERRMSG ) { SQLRETURN rc = SQL_SUCCESS; ODBC_ERR_t * err = NULL; TRACE_FENTER("popError"); TRACE_HVAL("stkptr",stkptr); if ( stkptr == NULL ) rc = SQL_NO_DATA_FOUND; else if ( *stkptr == NULL ) rc = SQL_NO_DATA_FOUND; else { err = *stkptr; *stkptr = err->next; *RC = err->rc; strcpy((char *)SQLSTATE,(char *)err->sqlState); *NATIVEERROR = err->nativeError; strcpy((char *)ERRMSG,(char *)err->errorMsg); free( (void *)err ); } TRACE_FLEAVE_RC("popError",rc); return rc; } static SQLRETURN getODBCConnectError( void * pSQLError, SQLHDBC hdbc, SQLCHAR * SQLSTATE, SQLINTEGER * NATIVEERROR, SQLCHAR * ERRMSG ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("getODBCConnectError"); TRACE_HVAL("hdbc",hdbc); rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (pSQLError))) (SQL_NULL_HENV,hdbc,SQL_NULL_HSTMT, SQLSTATE, NATIVEERROR, ERRMSG, SQL_MAX_MESSAGE_LENGTH,NULL); TRACE_FLEAVE_RC("getODBCConnectError",rc); return rc; } static SQLRETURN clearODBCErrorStack( void * pSQLError, SQLHDBC hdbc ) { SQLRETURN rc = SQL_SUCCESS; SQLCHAR sqlState[TT_SQLSTATE_LEN+1]; SQLINTEGER nativeError= 0; SQLCHAR errorMsg[SQL_MAX_MESSAGE_LENGTH+1]; TRACE_FENTER("clearODBCErrorStack"); TRACE_HVAL("hdbc",hdbc); while ( rc == SQL_SUCCESS ) rc = getODBCConnectError( pSQLError, hdbc, sqlState, &nativeError, errorMsg ); TRACE_FLEAVE_RC("clearODBCErrorStack",rc); return rc; } static int loadODBCfunctions( tt_libptr_t lh, funcmapper_t * libFuncs ) { int i; int ret = 0; tt_funcptr_t fptr; TRACE_FENTER("loadODBCfunctions"); TRACE_HVAL("lh",lh); TRACE_HVAL("libFuncs",libFuncs); for (i = 0; (ret==0) && (i < NUM_ODBC_FUNCTIONS); i++) { #if defined(WINDOWS) fptr = GetProcAddress((HMODULE)lh, (LPCSTR)ODBCFuncName[i]); #else /* !WINDOWS */ fptr = dlsym(lh, ODBCFuncName[i]); #endif /* !WINDOWS */ if ( fptr == NULL ) { ret = 1; } else { libFuncs->odbcFuncPtr[i] = fptr; } } libFuncs->odbcFuncPtr[i] = NULL; TRACE_FLEAVE_RC("loadODBCfunctions", ret); return ret; } #if defined(ENABLE_XLA_DIRECT) static int loadXLAfunctions( tt_libptr_t lh, funcmapper_t * libFuncs ) { int i; int ret = 0; tt_funcptr_t fptr; TRACE_FENTER("loadXLAfunctions"); TRACE_HVAL("lh", lh); TRACE_HVAL("libFuncs",libFuncs); for (i = 0; (ret==0) && (i < NUM_XLA_FUNCTIONS); i++) { #if defined(WINDOWS) fptr = GetProcAddress((HMODULE)lh, (LPCSTR)XLAFuncName[i]); #else /* !WINDOWS */ fptr = dlsym(lh, XLAFuncName[i]); #endif /* !WINDOWS */ if ( fptr == NULL ) { ret = 1; } else { libFuncs->xlaFuncPtr[i] = fptr; } } libFuncs->xlaFuncPtr[i] = NULL; TRACE_FLEAVE_RC("loadXLAfunctions", ret); return ret; } #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) static int loadUTILfunctions( tt_libptr_t lh, funcmapper_t * libFuncs ) { int i; int ret = 0; tt_funcptr_t fptr; TRACE_FENTER("loadUTILfunctions"); TRACE_HVAL("lh", lh); TRACE_HVAL("libFuncs",libFuncs); for (i = 0; (ret==0) && (i < NUM_UTIL_FUNCTIONS); i++) { #if defined(WINDOWS) fptr = GetProcAddress((HMODULE)lh, (LPCSTR)UTILFuncName[i]); #else /* !WINDOWS */ fptr = dlsym(lh, UTILFuncName[i]); #endif /* !WINDOWS */ if ( fptr == NULL ) { ret = 1; } else { libFuncs->utilFuncPtr[i] = fptr; } } libFuncs->utilFuncPtr[i] = NULL; TRACE_FLEAVE_RC("loadUTILfunctions", ret); return ret; } #endif /* ENABLE_UTIL_LIB */ static int loadLibrary( char * libName, int libType, funcmapper_t * libFuncs ) { tt_libptr_t lh; int ret = 0; TRACE_FENTER("loadLibrary"); if ( libName == NULL || libFuncs == NULL ) return -1; libFuncs->libHandle = NULL; libFuncs->odbcFuncPtr = NULL; #if defined(ENABLE_XLA_DIRECT) libFuncs->xlaFuncPtr = NULL; #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) libFuncs->utilFuncPtr = NULL; #endif /* ENABLE_UTIL_LIB */ if ( !*libName ) ret = -1; else { #if defined(WINDOWS) lh = LoadLibrary(libName); #else /* !WINDOWS */ lh = dlopen(libName, RTLD_NOW); #endif /* !WINDOWS */ if ( lh == NULL ) ret = -1; else { libFuncs->libType = libType; libFuncs->libHandle = lh; switch ( libType ) { case TT_LIB_DM_TYPE: libFuncs->odbcFuncPtr = (void * *)malloc(sizeof(void *) * NUM_ODBC_FUNCTIONS+1); if ( libFuncs->odbcFuncPtr == NULL ) ret = -1; #if defined(ENABLE_XLA_DIRECT) else { libFuncs->xlaFuncPtr = (void * *)malloc(sizeof(void *) * NUM_XLA_FUNCTIONS+1); if ( libFuncs->xlaFuncPtr == NULL ) { free( (void *)libFuncs->odbcFuncPtr); ret = -1; } } #endif /* ENABLE_XLA_DIRECT */ if ( ret == 0 ) { ret = loadODBCfunctions(lh, libFuncs); #if defined(ENABLE_XLA_DIRECT) if ( ret == 0 ) ret = loadXLAfunctions(lh, libFuncs); #endif /* ENABLE_XLA_DIRECT */ } break; case TT_LIB_CS_TYPE: libFuncs->odbcFuncPtr = (void * *)malloc(sizeof(void *) * NUM_ODBC_FUNCTIONS+1); if ( libFuncs->odbcFuncPtr == NULL ) ret = -1; else { ret = loadODBCfunctions(lh, libFuncs); } break; #if defined(ENABLE_UTIL_LIB) case TT_LIB_UT_TYPE: libFuncs->utilFuncPtr = (void * *)malloc(sizeof(void *) * NUM_UTIL_FUNCTIONS+1); if ( libFuncs->utilFuncPtr == NULL ) ret = -1; else { ret = loadUTILfunctions(lh, libFuncs); } break; #endif /* ENABLE_UTIL_LIB */ default: ret = -1; break; } } if ( ret != 0 ) { libFuncs->libType = TT_LIB_NO_TYPE; if ( libFuncs->libHandle != NULL ) { #if defined(WINDOWS) FreeLibrary((HMODULE)libFuncs->libHandle); #else /* !WINDOWS */ dlclose(libFuncs->libHandle); #endif /* !WINDOWS */ libFuncs->libHandle = NULL; } if ( libFuncs->odbcFuncPtr != NULL ) { free( (void *)libFuncs->odbcFuncPtr); libFuncs->odbcFuncPtr = NULL; } #if defined(ENABLE_XLA_DIRECT) if ( libFuncs->xlaFuncPtr != NULL ) { free( (void *)libFuncs->xlaFuncPtr); libFuncs->xlaFuncPtr = NULL; } #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) if ( libFuncs->utilFuncPtr != NULL ) { free( (void *)libFuncs->utilFuncPtr); libFuncs->utilFuncPtr = NULL; } #endif /* ENABLE_UTIL_LIB */ } } TRACE_FLEAVE_RC("loadLibrary",ret); return ret; } static int unloadLibrary( funcmapper_t * libFuncs ) { int ret = 0; TRACE_FENTER("unloadLibrary"); if ( libFuncs != NULL ) { if ( libFuncs->libHandle != NULL ) #if defined(WINDOWS) FreeLibrary((HMODULE)libFuncs->libHandle); #else /* !WINDOWS */ dlclose(libFuncs->libHandle); #endif /* !WINDOWS */ if ( libFuncs->odbcFuncPtr != NULL ) free( (void *)libFuncs->odbcFuncPtr); #if defined(ENABLE_XLA_DIRECT) if ( libFuncs->xlaFuncPtr != NULL ) free( (void *)libFuncs->xlaFuncPtr); #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) if ( libFuncs->utilFuncPtr != NULL ) free( (void *)libFuncs->utilFuncPtr); #endif /* ENABLE_UTIL_LIB */ } TRACE_FLEAVE_RC("unloadLibrary",ret); return ret; } static void freeTThStmt( TTSQLHSTMT hstmt ) { TRACE_FENTER("freeTThStmt"); TRACE_HVAL("hstmt",hstmt); CLEAR_ERROR_STACK(hstmt); hstmt->TThEnv = NULL; hstmt->TThDbc = NULL; hstmt->hEnv = SQL_NULL_HENV; hstmt->hDbc = SQL_NULL_HDBC; hstmt->hStmt = SQL_NULL_HSTMT; hstmt->pFuncMap = NULL; hstmt->prev = NULL; hstmt->next = NULL; free( (void *)hstmt); TRACE_FLEAVE("freeTThStmt"); } static void freeTThDbc( TTSQLHDBC hdbc ) { TRACE_FENTER("freeTThDbc"); TRACE_HVAL("hdbc",hdbc); CLEAR_ERROR_STACK(hdbc); hdbc->TThEnv = NULL; hdbc->clientEnv = SQL_NULL_HENV; hdbc->directEnv = SQL_NULL_HENV; hdbc->hEnv = SQL_NULL_HENV; hdbc->clientDbc = SQL_NULL_HDBC; hdbc->directDbc = SQL_NULL_HDBC; hdbc->hDbc = SQL_NULL_HDBC; hdbc->pClientMap = NULL; hdbc->pDirectMap = NULL; hdbc->pFuncMap = NULL; #if defined(ENABLE_XLA_DIRECT) hdbc->TThXla = NULL; #endif /* ENABLE_XLA_DIRECT */ hdbc->prev = NULL; hdbc->next = NULL; hdbc->head = NULL; hdbc->tail = NULL; free( (void *)hdbc); TRACE_FLEAVE("freeTThDbc"); } static void freeTThEnv( TTSQLHENV henv ) { TRACE_FENTER("freeTThEnv"); TRACE_HVAL("henv",henv); CLEAR_ERROR_STACK(henv); henv->directEnv = SQL_NULL_HENV; henv->clientEnv = SQL_NULL_HENV; henv->pDirectMap = NULL; henv->pClientMap = NULL; henv->prev = NULL; henv->next = NULL; henv->head = NULL; henv->tail = NULL; free( (void *)henv); TRACE_FLEAVE("freeTThEnv"); } #if defined(WINDOWS) /* ======================================================================== Public functions - DLL load and unload ======================================================================== */ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { switch ( fdwReason ) { case DLL_PROCESS_ATTACH: #if defined(ENABLE_THREAD_SAFETY) DMGlobalData.mutex = ttMutexCreate(); if ( DMGlobalData.mutex == NULL ) return FALSE; #if defined(ENABLE_UTIL_LIB) DMGlobalData.utilMutex = ttMutexCreate(); if ( DMGlobalData.utilMutex == NULL ) { CloseHandle(DMGlobalData.mutex); DMGlobalData.mutex = NULL; return FALSE; } #endif /* ENABLE_UTIL_LIB */ #endif /* ENABLE_THREAD_SAFETY */ break; case DLL_PROCESS_DETACH: #if defined(ENABLE_THREAD_SAFETY) #if defined(ENABLE_UTIL_LIB) CloseHandle(DMGlobalData.utilMutex); DMGlobalData.utilMutex = NULL; #endif /* ENABLE_UTIL_LIB */ CloseHandle(DMGlobalData.mutex); DMGlobalData.mutex = NULL; #endif /* ENABLE_THREAD_SAFETY */ break; } return TRUE; } #endif /* WINDOWS */ /* ======================================================================== Public functions - ODBC Analogues ======================================================================== */ DLLEXPORT SQLRETURN SQL_API SQLAllocEnv( SQLHENV *phenv ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TRACE_FENTER("SQLAllocEnv"); TRACE_HVAL("phenv",phenv); if ( phenv == NULL ) rc = SQL_INVALID_HANDLE; else { *phenv = SQL_NULL_HENV; TThEnv = (TTSQLHENV)malloc(sizeof(TT_ENV_t)); if ( TThEnv == NULL ) rc = SQL_INVALID_HANDLE; else { #if defined(ENABLE_THREAD_SAFETY) MUTEX_CREATE(TThEnv->mutex); if ( TThEnv->mutex == NULL ) rc = SQL_INVALID_HANDLE; else { #endif /* ENABLE_THREAD_SAFETY */ MUTEX_LOCK(DMGlobalData.mutex); TThEnv->tag = TTDM_STRUCT_TAG; TThEnv->directEnv = SQL_NULL_HENV; TThEnv->clientEnv = SQL_NULL_HENV; TThEnv->errorStack = NULL; TThEnv->head = NULL; TThEnv->tail = NULL; /* First check if we are initialised and if not then do it */ /* Try to load direct mode library first */ if ( DMGlobalData.directFuncs == NULL ) { DMGlobalData.directFuncs = (funcmapper_t *)malloc(sizeof(funcmapper_t)); if ( DMGlobalData.directFuncs == NULL ) pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to allocate memory " "to load direct mode driver"); else { if ( loadLibrary(TT_LIB_DM_NAME, TT_LIB_DM_TYPE, DMGlobalData.directFuncs) ) { free( (void *)DMGlobalData.directFuncs ); DMGlobalData.directFuncs = NULL; pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_LIBLOAD, tt_ErrDMDriverLoad, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to load " "direct mode driver"); } } } TThEnv->pDirectMap = DMGlobalData.directFuncs; /* Now try loading client library */ if ( DMGlobalData.clientFuncs == NULL ) { DMGlobalData.clientFuncs = (funcmapper_t *)malloc(sizeof(funcmapper_t)); if ( DMGlobalData.clientFuncs == NULL ) pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to allocate memory " "to load client/server driver"); else { if ( loadLibrary(TT_LIB_CS_NAME, TT_LIB_CS_TYPE, DMGlobalData.clientFuncs) ) { free( (void *)DMGlobalData.clientFuncs ); DMGlobalData.clientFuncs = NULL; pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_LIBLOAD, tt_ErrDMDriverLoad, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to load " "client/server driver"); } } } TThEnv->pClientMap = DMGlobalData.clientFuncs; #if defined(ENABLE_UTIL_LIB) /* Now try loading util library - depends on the direct library */ if ( (DMGlobalData.utilFuncs == NULL) && (DMGlobalData.directFuncs != NULL) ) { DMGlobalData.utilFuncs = (funcmapper_t *)malloc(sizeof(funcmapper_t)); if ( DMGlobalData.utilFuncs == NULL ) pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to allocate memory " "to load utility library"); else { if ( loadLibrary(TT_LIB_UT_NAME, TT_LIB_UT_TYPE, DMGlobalData.utilFuncs) ) { free( (void *)DMGlobalData.utilFuncs ); DMGlobalData.utilFuncs = NULL; pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_LIBLOAD, tt_ErrDMDriverLoad, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocEnv: " "Unable to load " "utility library"); } } } #endif /* ENABLE_UTIL_LIB */ if ( (TThEnv->pDirectMap == NULL) && (TThEnv->pClientMap == NULL) ) rc = SQL_ERROR; else { if ( TThEnv->pDirectMap != NULL ) rc1 = (*((SQLRETURN (SQL_API *)(SQLHENV *))(TThEnv->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLAllocEnv])))(&(TThEnv->directEnv)); if ( TThEnv->pClientMap != NULL ) rc2 = (*((SQLRETURN (SQL_API *)(SQLHENV *))(TThEnv->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLAllocEnv])))(&(TThEnv->clientEnv)); rc = maxODBCError(rc1, rc2); if ( rc != SQL_SUCCESS ) { if ( TThEnv->clientEnv != SQL_NULL_HENV ) (*((SQLRETURN (SQL_API *)(SQLHENV))(TThEnv->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLFreeEnv])))(TThEnv->clientEnv); if ( TThEnv->directEnv != SQL_NULL_HENV ) (*((SQLRETURN (SQL_API *)(SQLHENV))(TThEnv->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLFreeEnv])))(TThEnv->directEnv); free( (void *)TThEnv ); TThEnv = NULL; } else { /* Link it into list */ if ( DMGlobalData.ELhead == NULL ) { DMGlobalData.ELhead = DMGlobalData.ELtail = TThEnv; TThEnv->prev = TThEnv->next = NULL; } else { DMGlobalData.ELtail->next = (void *)TThEnv; TThEnv->prev = DMGlobalData.ELtail; TThEnv->next = NULL; DMGlobalData.ELtail = TThEnv; } *phenv = (SQLHENV)TThEnv; } } MUTEX_UNLOCK(DMGlobalData.mutex); #if defined(ENABLE_THREAD_SAFETY) } if ( TThEnv->mutex == NULL ) { free( (void *)TThEnv ); TThEnv = NULL; } #endif /* ENABLE_THREAD_SAFETY */ } } TRACE_FLEAVE_RC("SQLAllocEnv",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLAllocConnect( SQLHENV henv, SQLHDBC *phdbc ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLAllocConnect"); TRACE_HVAL("henv",henv); if ( henv == NULL || phdbc == NULL ) rc = SQL_INVALID_HANDLE; else { *phdbc = SQL_NULL_HDBC; TThEnv = (TTSQLHENV)henv; if ( (TThEnv->tag != TTDM_STRUCT_TAG) || ((TThEnv->directEnv == SQL_NULL_HENV) && (TThEnv->clientEnv == SQL_NULL_HENV)) ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(TThEnv->mutex); CLEAR_ERROR_STACK(TThEnv); TThDbc = (TTSQLHDBC)malloc(sizeof(TT_DBC_t)); if ( TThDbc == NULL ) pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: SQLAllocConnect:" " Unable to allocate memory for Connection" ); else { TThDbc->tag = TTDM_STRUCT_TAG; TThDbc->TThEnv = TThEnv; TThDbc->directEnv = TThEnv->directEnv; TThDbc->clientEnv = TThEnv->clientEnv; TThDbc->hEnv = SQL_NULL_HENV; TThDbc->clientDbc = SQL_NULL_HDBC; TThDbc->directDbc = SQL_NULL_HDBC; TThDbc->hDbc = SQL_NULL_HDBC; TThDbc->pDirectMap = TThEnv->pDirectMap; TThDbc->pClientMap = TThEnv->pClientMap; TThDbc->pFuncMap = NULL; TThDbc->errorStack = NULL; #if defined(ENABLE_XLA_DIRECT) TThDbc->TThXla = NULL; #endif /* ENABLE_XLA_DIRECT */ TThDbc->head = NULL; TThDbc->tail = NULL; #if defined(ENABLE_THREAD_SAFETY) MUTEX_CREATE(TThDbc->mutex); if ( TThDbc->mutex == NULL ) pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocConnect:" " Unable to allocate memory for mutex" ); else { #endif /* ENABLE_THREAD_SAFETY */ if ( TThDbc->pDirectMap != NULL ) rc1 = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC * ))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLAllocConnect])))(TThDbc->directEnv,&(TThDbc->directDbc)); if ( TThDbc->pClientMap != NULL ) rc2 = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC * ))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLAllocConnect])))(TThDbc->clientEnv,&(TThDbc->clientDbc)); rc = maxODBCError(rc1, rc2); #if defined(ENABLE_THREAD_SAFETY) } #endif /* ENABLE_THREAD_SAFETY */ if ( rc != SQL_SUCCESS ) { if ( TThDbc->directDbc != SQL_NULL_HDBC ) (*((SQLRETURN (SQL_API *)(SQLHDBC))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLFreeConnect])))(TThDbc->directDbc); if ( TThDbc->clientDbc != SQL_NULL_HDBC ) (*((SQLRETURN (SQL_API *)(SQLHDBC))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLFreeConnect])))(TThDbc->clientDbc); free( (void *)TThDbc ); } else { /* Link it into list */ if ( TThEnv->head == NULL ) { TThEnv->head = TThEnv->tail = TThDbc; TThDbc->prev = TThDbc->next = NULL; } else { TThEnv->tail->next = TThDbc; TThDbc->prev = TThEnv->tail; TThDbc->next = NULL; TThEnv->tail = TThDbc; } *phdbc = (SQLHDBC)TThDbc; } } MUTEX_UNLOCK(TThEnv->mutex); } } TRACE_FLEAVE_RC("SQLAllocConnect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLAllocStmt( SQLHDBC hdbc, SQLHSTMT *phstmt ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLAllocStmt"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL || phstmt == NULL ) rc = SQL_INVALID_HANDLE; else { *phstmt = SQL_NULL_HSTMT; TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(TThDbc->mutex); CLEAR_ERROR_STACK(TThDbc); TThStmt = (TTSQLHSTMT)malloc(sizeof(TT_STMT_t)); if ( TThStmt == NULL ) pushError(&(TThDbc->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: SQLAllocStmt: " "Unable to allocate memory for Statement" ); else { TThStmt->tag = TTDM_STRUCT_TAG; TThStmt->TThEnv = TThDbc->TThEnv; TThStmt->hEnv = TThDbc->hEnv; TThStmt->TThDbc = TThDbc; TThStmt->hDbc = TThDbc->hDbc; TThStmt->hStmt = SQL_NULL_HSTMT; TThStmt->pFuncMap = TThDbc->pFuncMap; TThStmt->errorStack = NULL; #if defined(ENABLE_THREAD_SAFETY) MUTEX_CREATE(TThStmt->mutex); if ( TThStmt->mutex == NULL ) pushError(&(TThDbc->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "SQLAllocStmt:" " Unable to allocate memory for mutex" ); else { #endif /* ENABLE_THREAD_SAFETY */ rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLHSTMT * ))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLAllocStmt])))(TThStmt->hDbc,&(TThStmt->hStmt)); #if defined(ENABLE_THREAD_SAFETY) } #endif /* ENABLE_THREAD_SAFETY */ if ( rc != SQL_SUCCESS ) free( (void *)TThStmt ); else { /* Link it into list */ if ( TThDbc->head == NULL ) { TThDbc->head = TThDbc->tail = TThStmt; TThStmt->prev = TThStmt->next = NULL; } else { TThDbc->tail->next = (void *)TThStmt; TThStmt->prev = TThDbc->tail; TThStmt->next = NULL; TThDbc->tail = TThStmt; } *phstmt = (SQLHSTMT)TThStmt; } } MUTEX_UNLOCK(TThDbc->mutex); } } TRACE_FLEAVE_RC("SQLAllocStmt",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLError( SQLHENV henv, SQLHDBC hdbc, SQLHSTMT hstmt, SQLCHAR * szSqlState, SQLINTEGER * pfNativeError, SQLCHAR * szErrorMsg, SQLSMALLINT cbErrorMsgMax, SQLSMALLINT * pcbErrorMsg ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN errRC = SQL_SUCCESS; SQLCHAR sqlState[TT_SQLSTATE_LEN+1]; SQLINTEGER nativeError= 0; SQLCHAR errorMsg[SQL_MAX_MESSAGE_LENGTH+1]; TTSQLHENV TThEnv = NULL; TTSQLHDBC TThDbc = NULL; TTSQLHSTMT TThStmt = NULL; SQLHENV hEnv1 = SQL_NULL_HENV; SQLHENV hEnv2 = SQL_NULL_HENV; SQLHDBC hDbc1 = SQL_NULL_HDBC; SQLHDBC hDbc2 = SQL_NULL_HDBC; SQLHSTMT hStmt = SQL_NULL_HSTMT; void * odbcFuncPtr1 = NULL; void * odbcFuncPtr2 = NULL; int errMsgLen = 0; ODBC_ERR_t * * errorStack = NULL; #if defined(ENABLE_THREAD_SAFETY) tt_mutex_t mutex = MUTEX_INITIALISER; #endif /* ENABLE_THREAD_SAFETY */ TRACE_FENTER("SQLError"); TRACE_HVAL("henv",henv); TRACE_HVAL("hdbc",hdbc); TRACE_HVAL("hstm",hstmt); TThEnv = (TTSQLHENV)henv; TThDbc = (TTSQLHDBC)hdbc; TThStmt = (TTSQLHSTMT)hstmt; if ( hstmt != SQL_NULL_HSTMT ) /* want errors from hstmt */ { if ( TThStmt->tag != TTDM_STRUCT_TAG ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(mutex = TThStmt->mutex); errorStack = &(TThStmt->errorStack); hStmt = TThStmt->hStmt; odbcFuncPtr1 = TThStmt->pFuncMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } } else if ( hdbc != SQL_NULL_HDBC ) /* want errors from hdbc */ { if ( TThDbc->tag != TTDM_STRUCT_TAG ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(mutex = TThDbc->mutex); errorStack = &(TThDbc->errorStack); if ( TThDbc->hDbc != SQL_NULL_HDBC ) /* connected */ { hDbc1 = TThDbc->hDbc; odbcFuncPtr1 = TThDbc->pFuncMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } else /* not connected */ { if ( TThDbc->clientDbc != SQL_NULL_HDBC ) { hDbc1 = TThDbc->clientDbc; odbcFuncPtr1 = TThDbc->pClientMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; if ( TThDbc->directDbc != SQL_NULL_HDBC ) { hDbc2 = TThDbc->directDbc; odbcFuncPtr2 = TThDbc->pDirectMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } } else { hDbc1 = TThDbc->directDbc; odbcFuncPtr1 = TThDbc->pDirectMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } } } } else if ( henv != SQL_NULL_HENV ) /* want errors from henv */ { if ( TThEnv->tag != TTDM_STRUCT_TAG ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(mutex = TThEnv->mutex); errorStack = &(TThEnv->errorStack); if ( TThEnv->clientEnv != SQL_NULL_HENV ) { hEnv1 = TThEnv->clientEnv; odbcFuncPtr1 = TThEnv->pClientMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; if ( TThEnv->directEnv != SQL_NULL_HENV ) { hEnv2 = TThEnv->directEnv; odbcFuncPtr2 = TThEnv->pDirectMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } } else { hEnv1 = TThEnv->directEnv; odbcFuncPtr1 = TThEnv->pDirectMap-> odbcFuncPtr[F_POS_ODBC_SQLError]; } } } else { errorStack = NULL; rc = SQL_INVALID_HANDLE; } if ( rc == SQL_SUCCESS ) { rc = popError(errorStack, &errRC, sqlState, &nativeError, errorMsg); if ( rc == SQL_SUCCESS ) { strcpy((char *)szSqlState,(char *)sqlState); *pfNativeError = nativeError; errMsgLen = strlen((char *)errorMsg); *pcbErrorMsg = (SQLSMALLINT)errMsgLen; if ( errMsgLen < (int)cbErrorMsgMax ) strcpy((char *)szErrorMsg,(char *)errorMsg); else { rc = SQL_SUCCESS_WITH_INFO; if ( cbErrorMsgMax > 0 ) { strncpy((char *)szErrorMsg,(char *)errorMsg, (cbErrorMsgMax-1)); szErrorMsg[cbErrorMsgMax-1] = '\0'; } else szErrorMsg[0] = '\0'; } } else { if ( hstmt != SQL_NULL_HSTMT ) rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (odbcFuncPtr1))) (SQL_NULL_HENV,SQL_NULL_HDBC,hStmt, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax,pcbErrorMsg); else if ( hdbc != SQL_NULL_HDBC ) { rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (odbcFuncPtr1))) (SQL_NULL_HENV,hDbc1,SQL_NULL_HSTMT, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax,pcbErrorMsg); if ( (rc == SQL_NO_DATA_FOUND) && (odbcFuncPtr2 != NULL) ) rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (odbcFuncPtr2))) (SQL_NULL_HENV,hDbc2,SQL_NULL_HSTMT, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax,pcbErrorMsg); } else { rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (odbcFuncPtr1))) (hEnv1,SQL_NULL_HDBC,SQL_NULL_HSTMT, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax,pcbErrorMsg); if ( (rc == SQL_NO_DATA_FOUND) && (odbcFuncPtr2 != NULL) ) rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR *, SQLINTEGER *, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *)) (odbcFuncPtr2))) (hEnv2,SQL_NULL_HDBC,SQL_NULL_HSTMT, szSqlState, pfNativeError, szErrorMsg, cbErrorMsgMax,pcbErrorMsg); } } MUTEX_UNLOCK(mutex); } TRACE_FLEAVE_RC("SQLError",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLDriverConnect( SQLHDBC hdbc, SQLHWND hwnd, SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT * pcbConnStrOut, SQLUSMALLINT fDriverCompletion ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; SQLCHAR sqlState[TT_SQLSTATE_LEN+1]; SQLINTEGER nativeError = 0; SQLCHAR errorMsg[SQL_MAX_MESSAGE_LENGTH+1]; TRACE_FENTER("SQLDriverConnect"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || ((TThDbc->directDbc == SQL_NULL_HDBC) && (TThDbc->clientDbc == SQL_NULL_HDBC)) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); if ( (TThDbc->directDbc != SQL_NULL_HDBC) && (TThDbc->clientDbc != SQL_NULL_HDBC) ) { rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLHWND, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *, SQLUSMALLINT))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLDriverConnect])))(TThDbc->clientDbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); if ( (rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO) ) { TThDbc->hEnv = TThDbc->clientEnv; TThDbc->hDbc = TThDbc->clientDbc; TThDbc->pFuncMap = TThDbc->pClientMap; } else if ( rc == SQL_ERROR ) { sqlState[0] = '\0'; getODBCConnectError(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLError],TThDbc->clientDbc, sqlState, &nativeError, errorMsg); if ( (nativeError != 0) || strcmp((char *)sqlState,TT_DM_SQLSTATE_CONNERR) ) pushError(&(TThDbc->errorStack), rc, sqlState, nativeError, errorMsg); else { clearODBCErrorStack(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLError],TThDbc->clientDbc); /* ... then direct */ rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLHWND, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *, SQLUSMALLINT))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLDriverConnect])))(TThDbc->directDbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); if ( (rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO) ) { TThDbc->hEnv = TThDbc->directEnv; TThDbc->hDbc = TThDbc->directDbc; TThDbc->pFuncMap = TThDbc->pDirectMap; } } } } else if ( TThDbc->directDbc != SQL_NULL_HDBC ) { /* Just try direct */ rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLHWND, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *, SQLUSMALLINT))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLDriverConnect])))(TThDbc->directDbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); if ( (rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO) ) { TThDbc->hEnv = TThDbc->directEnv; TThDbc->hDbc = TThDbc->directDbc; TThDbc->pFuncMap = TThDbc->pDirectMap; } } else { /* Just try client */ rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLHWND, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *, SQLUSMALLINT))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLDriverConnect])))(TThDbc->clientDbc, hwnd, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, fDriverCompletion); if ( (rc == SQL_SUCCESS) || (rc == SQL_SUCCESS_WITH_INFO) ) { TThDbc->hEnv = TThDbc->clientEnv; TThDbc->hDbc = TThDbc->clientDbc; TThDbc->pFuncMap = TThDbc->pClientMap; } } } } TRACE_FLEAVE_RC("SQLDriverConnect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLConnect( SQLHDBC hdbc, SQLCHAR * szDSN, SQLSMALLINT cbDSN, SQLCHAR * szUID, SQLSMALLINT cbUID, SQLCHAR * szAuthStr, SQLSMALLINT cbAuthStr ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; SQLCHAR connStr[TTDM_CONNSTR_MAX+1]; TRACE_FENTER("SQLConnect"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || ((TThDbc->directDbc == SQL_NULL_HDBC) && (TThDbc->clientDbc == SQL_NULL_HDBC)) ) rc = SQL_INVALID_HANDLE; else { if ( cbDSN == SQL_NTS ) cbDSN = (SQLSMALLINT)strlen((char *)szDSN); if ( cbUID == SQL_NTS ) cbUID = (SQLSMALLINT)strlen((char *)szUID); if ( cbAuthStr == SQL_NTS ) cbAuthStr = (SQLSMALLINT)strlen((char *)szAuthStr); sprintf((char *)connStr,"DSN=%*.*s;UID=%*.*s;PWD=%*.*s", (int)cbDSN, (int)cbDSN, (char *)szDSN, (int)cbUID, (int)cbUID, (char *)szUID, (int)cbAuthStr, (int)cbAuthStr, (char *)szAuthStr); rc = SQLDriverConnect(hdbc, NULL, connStr, (SQLSMALLINT)SQL_NTS, (SQLCHAR *)NULL, (SQLSMALLINT)0, NULL, SQL_DRIVER_NOPROMPT); } } TRACE_FLEAVE_RC("SQLConnect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLCancel( SQLHSTMT hstmt ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLCancel"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLCancel])))(TThStmt->hStmt); } } TRACE_FLEAVE_RC("SQLCancel",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLDescribeCol( SQLHSTMT hstmt, SQLUSMALLINT icol, SQLCHAR* szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT* pcbColName, SQLSMALLINT* pfSqlType, SQLULEN* pcbColDef, SQLSMALLINT* pibScale, SQLSMALLINT* pfNullable ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLDescribeCol"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *, SQLSMALLINT *, SQLULEN *, SQLSMALLINT *, SQLSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLDescribeCol])))(TThStmt->hStmt, icol, szColName, cbColNameMax, pcbColName, pfSqlType, pcbColDef, pibScale, pfNullable); } } TRACE_FLEAVE_RC("SQLDescribeCol",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLExecDirect( SQLHSTMT hstmt, SQLCHAR* szSqlStr, SQLINTEGER cbSqlStr ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLExecDirect"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLINTEGER))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLExecDirect])))(TThStmt->hStmt,szSqlStr,cbSqlStr); } } TRACE_FLEAVE_RC("SQLExecDirect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetCursorName( SQLHSTMT hstmt, SQLCHAR* szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT* pcbCursor ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLGetCursorName"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetCursorName])))(TThStmt->hStmt,szCursor,cbCursorMax,pcbCursor); } } TRACE_FLEAVE_RC("SQLGetCursorName",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLNumResultCols( SQLHSTMT hstmt, SQLSMALLINT* pccol ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLNumResultCols"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLNumResultCols])))(TThStmt->hStmt,pccol); } } TRACE_FLEAVE_RC("SQLNumResultCols",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLPrepare( SQLHSTMT hstmt, SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLPrepare"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLINTEGER))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLPrepare])))(TThStmt->hStmt,szSqlStr,cbSqlStr); } } TRACE_FLEAVE_RC("SQLPrepare",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLRowCount( SQLHSTMT hstmt, SQLLEN* pcrow ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLRowCount"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLLEN *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLRowCount])))(TThStmt->hStmt,pcrow); } } TRACE_FLEAVE_RC("SQLRowcount",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLSetCursorName( SQLHSTMT hstmt, SQLCHAR* szCursor, SQLSMALLINT cbCursor ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLSetCursorName"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLSetCursorName])))(TThStmt->hStmt,szCursor,cbCursor); } } TRACE_FLEAVE_RC("SQLCursorName",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetStmtOption( SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLPOINTER pvParam ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLGetStmtOption"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLPOINTER))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetStmtOption])))(TThStmt->hStmt, fOption, pvParam); } } TRACE_FLEAVE_RC("SQLGetStmtOption",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLSetStmtOption( SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLROWCOUNT vParam ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLSetStmtOption"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLROWCOUNT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLSetStmtOption])))(TThStmt->hStmt, fOption, vParam); } } TRACE_FLEAVE_RC("SQLSetStmtOption",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLParamData( SQLHSTMT hstmt, SQLPOINTER * prgbValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLParamData"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLPOINTER *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLParamData])))(TThStmt->hStmt, prgbValue); } } TRACE_FLEAVE_RC("SQLParamData",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLPutData( SQLHSTMT hstmt, SQLPOINTER rgbValue, SQLLEN cbValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLPutData"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLPOINTER, SQLLEN))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLPutData])))(TThStmt->hStmt, rgbValue, cbValue); } } TRACE_FLEAVE_RC("SQLPutData",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLSpecialColumns( SQLHSTMT hstmt, SQLUSMALLINT fColType, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fScope, SQLUSMALLINT fNullable ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLSpecialColumns"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLUSMALLINT, SQLUSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLSpecialColumns])))(TThStmt->hStmt, fColType, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, fScope, fNullable); } } TRACE_FLEAVE_RC("SQLSpecialColumns",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLStatistics( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLUSMALLINT fUnique, SQLUSMALLINT fAccuracy ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLStatistics"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLUSMALLINT, SQLUSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLStatistics])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, fUnique, fAccuracy); } } TRACE_FLEAVE_RC("SQLStatistics",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLTables( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLCHAR * szTableType, SQLSMALLINT cbTableType ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLTables"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLTables])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, szTableType, cbTableType); } } TRACE_FLEAVE_RC("SQLTables",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetTypeInfo( SQLHSTMT hstmt, SQLSMALLINT fSqlType ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLGetTypeInfo"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetTypeInfo])))(TThStmt->hStmt, fSqlType); } } TRACE_FLEAVE_RC("SQLGetTypeInfo",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLExecute( SQLHSTMT hstmt ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLExecute"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLExecute])))(TThStmt->hStmt); } } TRACE_FLEAVE_RC("SQLExecute",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLFetch( SQLHSTMT hstmt ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLFetch"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLFetch])))(TThStmt->hStmt); } } TRACE_FLEAVE_RC("SQLFetch",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLTransact( SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLTransact"); TRACE_HVAL("henv",henv); TRACE_HVAL("hdbc",hdbc); if ( hdbc != NULL ) { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); rc = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLUSMALLINT))(TThDbc->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLTransact])))(SQL_NULL_HENV, TThDbc->hDbc, fType); } } else if ( henv != NULL ) { TThEnv = (TTSQLHENV)henv; if ( (TThEnv->tag != TTDM_STRUCT_TAG) || ((TThEnv->directEnv == SQL_NULL_HENV) && (TThEnv->directEnv == SQL_NULL_HENV)) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThEnv); if ( TThEnv->directEnv != NULL ) rc1 = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLUSMALLINT))(TThEnv->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLTransact])))(TThEnv->directEnv, SQL_NULL_HDBC, fType); if ( TThEnv->clientEnv != NULL ) rc2 = (*((SQLRETURN (SQL_API *)(SQLHENV, SQLHDBC, SQLUSMALLINT))(TThEnv->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLTransact])))(TThEnv->clientEnv, SQL_NULL_HDBC, fType); rc = maxODBCError(rc1, rc2); } } else rc = SQL_INVALID_HANDLE; TRACE_FLEAVE_RC("SQLTransact",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLColAttributes( SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT * pcbDesc, SQLLEN * pfDesc ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLColAttributes"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLUSMALLINT, SQLPOINTER, SQLSMALLINT, SQLSMALLINT *, SQLLEN *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLColAttributes])))(TThStmt->hStmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc); } } TRACE_FLEAVE_RC("SQLColAttributes",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLColumns( SQLHSTMT hstmt, SQLCHAR* szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR* szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR* szTableName, SQLSMALLINT cbTableName, SQLCHAR* szColumnName, SQLSMALLINT cbColumnName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLColumns"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLColumns])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, szColumnName, cbColumnName); } } TRACE_FLEAVE_RC("SQLColumns",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetConnectOption( SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLGetConnectOption"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || ((TThDbc->directDbc == SQL_NULL_HDBC) && (TThDbc->clientDbc == SQL_NULL_HDBC)) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); if ( fOption == TTDM_CONNECTION_TYPE ) { /* we must handle this one! */ if ( TThDbc->hDbc == NULL ) *(SQLINTEGER *)pvParam = TTDM_CONN_NONE; else if ( TThDbc->hDbc == TThDbc->directDbc ) *(SQLINTEGER *)pvParam = TTDM_CONN_DIRECT; else *(SQLINTEGER *)pvParam = TTDM_CONN_CLIENT; } else if ( TThDbc->directDbc != SQL_NULL_HDBC ) rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLPOINTER))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLGetConnectOption])))(TThDbc->directDbc, fOption, pvParam); else rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLPOINTER))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLGetConnectOption])))(TThDbc->clientDbc, fOption, pvParam); } } TRACE_FLEAVE_RC("SQLGetConnectOption",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetFunctions( SQLHDBC hdbc, SQLUSMALLINT fFunction, SQLUSMALLINT * pfExists ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLGetFunctions"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLUSMALLINT *))(TThDbc->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetFunctions])))(TThDbc->hDbc, fFunction, pfExists); } } TRACE_FLEAVE_RC("SQLGetFunctions",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetInfo( SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax, SQLSMALLINT * pcbInfoValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLGetInfo"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); /* ** If SQLGetInfo() is called specifying one of ** SQL_DRIVER_HENV ** SQL_DRIVER_HDBC ** then this needs special handling. In this case ** we simply return the real driver handle value ** without calling the 'real' SQLGetInfo(). ** ** In the case of a request for ** SQL_DRIVER_HSTMT ** we still don't need to call the real SQLGetInfo but ** some additional work and validation is needed to get ** the areal dribe HSTMT value. */ switch (fInfoType) { case SQL_DRIVER_HENV: if (TThDbc->hEnv != SQL_NULL_HENV) *(SQLHENV *)rgbInfoValue = TThDbc->hEnv; else rc = SQL_INVALID_HANDLE; break; case SQL_DRIVER_HDBC: *(SQLHDBC *)rgbInfoValue = TThDbc->hDbc; break; case SQL_DRIVER_HSTMT: TThStmt = *(TTSQLHSTMT*)(rgbInfoValue); if ( (TThStmt == NULL) || (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) pushError(&(TThDbc->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_ARGERR, tt_ErrDMInvalidArg, (SQLCHAR *)"TimesTen Driver Manager: " "SQLGetInfo: " "Invalid value passed for" "SQLHSTMT value"); else if ( TThStmt->hDbc != TThDbc->hDbc ) pushError(&(TThDbc->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_ARGERR, tt_ErrDMInvalidArg, (SQLCHAR *)"TimesTen Driver Manager: " "SQLGetInfo: " "SQLHSTMT does not belong" "to the passed SQLHDBC"); else *(SQLHSTMT *)rgbInfoValue = TThStmt->hStmt; break; default: rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLPOINTER, SQLSMALLINT, SQLSMALLINT *))(TThDbc->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetInfo])))(TThDbc->hDbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue); break; } } } TRACE_FLEAVE_RC("SQLGetInfo",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLSetConnectOption( SQLHDBC hdbc, SQLUSMALLINT fOption, SQLULEN pvParam ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLSetConnectOption"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || ((TThDbc->directDbc == SQL_NULL_HDBC) && (TThDbc->clientDbc == SQL_NULL_HDBC)) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); if ( TThDbc->directDbc != SQL_NULL_HDBC ) rc1 = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLULEN))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLSetConnectOption])))(TThDbc->directDbc, fOption, pvParam); if ( TThDbc->clientDbc != SQL_NULL_HDBC ) rc2 = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLUSMALLINT, SQLULEN))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLSetConnectOption])))(TThDbc->clientDbc, fOption, pvParam); rc = maxODBCError(rc1, rc2); } } TRACE_FLEAVE_RC("SQLSetConnectOption",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLBindCol( SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN * pcbValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLBindCol"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLBindCol])))(TThStmt->hStmt, icol, fCType, rgbValue, cbValueMax, pcbValue); } } TRACE_FLEAVE_RC("SQLBindCol",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLGetData( SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN * pcbValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLGetData"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLGetData])))(TThStmt->hStmt, icol, fCType, rgbValue, cbValueMax, pcbValue); } } TRACE_FLEAVE_RC("SQLGetData",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLBindParameter( SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN * pcbValue ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLBindParameter"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLULEN, SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLBindParameter])))(TThStmt->hStmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue); } } TRACE_FLEAVE_RC("SQLBindParameter",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLFreeStmt( SQLHSTMT hstmt, SQLUSMALLINT fOption ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLFreeStmt"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { TThDbc = TThStmt->TThDbc; if ( fOption == SQL_DROP ) { MUTEX_LOCK(TThDbc->mutex); MUTEX_LOCK(TThStmt->mutex); CLEAR_ERROR_STACK(TThStmt); } else CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLFreeStmt])))(TThStmt->hStmt, fOption); if ( fOption == SQL_DROP ) { /* mark invalid */ TThStmt->tag = 0; /* unlink from list in TThDbc and free */ if ( TThDbc->head == TThDbc->tail ) { /* Only entry in list */ TThDbc->head = TThDbc->tail = NULL; } else if ( TThStmt == TThDbc->head ) { /* First entry in list */ TThDbc->head = TThDbc->head->next; TThDbc->head->prev = NULL; } else if ( TThStmt == TThDbc->tail ) { /* Last entry in list */ TThDbc->tail = TThDbc->tail->prev; TThDbc->tail->next = NULL; } else { /* somewhere else in list */ TThStmt->prev->next = TThStmt->next; TThStmt->next->prev = TThStmt->prev; } MUTEX_UNLOCK(TThStmt->mutex); MUTEX_UNLOCK(TThDbc->mutex); MUTEX_DESTROY(TThStmt->mutex); freeTThStmt(TThStmt); } } } TRACE_FLEAVE_RC("SQLFreeStmt",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLDisconnect( SQLHDBC hdbc ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TTSQLHDBC TThDbc = NULL; TTSQLHSTMT currTThStmt = NULL; TTSQLHSTMT nextTThStmt = NULL; TRACE_FENTER("SQLDisconnect"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); rc = (*((SQLRETURN (SQL_API *)(SQLHDBC))(TThDbc->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLDisconnect])))(TThDbc->hDbc); if ( rc == SQL_SUCCESS ) { /* reset direct/client pointers */ TThDbc->hEnv = SQL_NULL_HENV; TThDbc->hDbc = SQL_NULL_HDBC; TThDbc->pFuncMap = NULL; /* free all dependant TThStmt */ currTThStmt = TThDbc->head; while ( currTThStmt != NULL ) { nextTThStmt = currTThStmt->next; freeTThStmt(currTThStmt); currTThStmt = nextTThStmt; } TThDbc->head = NULL; TThDbc->tail = NULL; } } } TRACE_FLEAVE_RC("SQLDisconnect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLFreeConnect( SQLHDBC hdbc ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLFreeConnect"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || ((TThDbc->directDbc == SQL_NULL_HDBC) && (TThDbc->clientDbc == SQL_NULL_HDBC)) ) rc = SQL_INVALID_HANDLE; else if ( TThDbc->hDbc != NULL ) /* still connected */ { pushError(&(TThEnv->errorStack), rc = SQL_ERROR, (SQLCHAR *)TT_DM_SQLSTATE_FUNCSEQ, tt_ErrDMNotDisconnected, (SQLCHAR *)"TimesTen Driver Manager: SQLFreeConnect: " "connection is still connected"); } else { TThEnv = TThDbc->TThEnv; MUTEX_LOCK(TThEnv->mutex); MUTEX_LOCK(TThDbc->mutex); CLEAR_ERROR_STACK(TThDbc); if ( TThDbc->directDbc != SQL_NULL_HDBC ) { rc1 = (*((SQLRETURN (SQL_API *)(SQLHDBC))(TThDbc->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLFreeConnect])))(TThDbc->directDbc); if ( rc1 == SQL_SUCCESS ) TThDbc->directDbc = SQL_NULL_HDBC; } if ( TThDbc->clientDbc != SQL_NULL_HDBC ) { rc2 = (*((SQLRETURN (SQL_API *)(SQLHDBC))(TThDbc->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLFreeConnect])))(TThDbc->clientDbc); if ( rc2 == SQL_SUCCESS ) TThDbc->clientDbc = SQL_NULL_HDBC; } rc = maxODBCError(rc1, rc2); if ( rc == SQL_SUCCESS ) { /* mark invalid */ TThDbc->tag = 0; /* unlink from list in TThEnv and free */ TThEnv = TThDbc->TThEnv; if ( TThEnv->head == TThEnv->tail ) { /* Only entry in list */ TThEnv->head = TThEnv->tail = NULL; } else if ( TThDbc == TThEnv->head ) { /* First entry in list */ TThEnv->head = TThEnv->head->next; TThEnv->head->prev = NULL; } else if ( TThDbc == TThEnv->tail ) { /* Last entry in list */ TThEnv->tail = TThEnv->tail->prev; TThEnv->tail->next = NULL; } else { /* somewhere else in list */ TThDbc->prev->next = TThDbc->next; TThDbc->next->prev = TThDbc->prev; } MUTEX_UNLOCK(TThDbc->mutex); MUTEX_DESTROY(TThDbc->mutex); freeTThDbc(TThDbc); } else MUTEX_UNLOCK(TThDbc->mutex); MUTEX_UNLOCK(TThEnv->mutex); } } TRACE_FLEAVE_RC("SQLFreeConnect",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLFreeEnv( SQLHENV henv ) { SQLRETURN rc = SQL_SUCCESS; SQLRETURN rc1 = SQL_SUCCESS; SQLRETURN rc2 = SQL_SUCCESS; TTSQLHENV TThEnv = NULL; TRACE_FENTER("SQLFreeEnv"); TRACE_HVAL("henv",henv); if ( henv == NULL ) rc = SQL_INVALID_HANDLE; else { TThEnv = (TTSQLHENV)henv; if ( (TThEnv->tag != TTDM_STRUCT_TAG) || ((TThEnv->directEnv == SQL_NULL_HENV) && (TThEnv->clientEnv == SQL_NULL_HENV)) ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(DMGlobalData.mutex); MUTEX_LOCK(TThEnv->mutex); CLEAR_ERROR_STACK(TThEnv); if ( TThEnv->directEnv != NULL ) { rc1 = (*((SQLRETURN (SQL_API *)(SQLHENV))(TThEnv->pDirectMap->odbcFuncPtr[F_POS_ODBC_SQLFreeEnv])))(TThEnv->directEnv); if ( rc1 == SQL_SUCCESS ) TThEnv->directEnv = SQL_NULL_HENV; } if ( TThEnv->clientEnv != NULL ) { rc2 = (*((SQLRETURN (SQL_API *)(SQLHENV))(TThEnv->pClientMap->odbcFuncPtr[F_POS_ODBC_SQLFreeEnv])))(TThEnv->clientEnv); if ( rc2 == SQL_SUCCESS ) TThEnv->clientEnv = SQL_NULL_HENV; } rc = maxODBCError(rc1, rc2); if ( rc == SQL_SUCCESS ) { /* mark invalid */ TThEnv->tag = 0; /* unlink from master list and free */ if ( DMGlobalData.ELhead == DMGlobalData.ELtail ) { /* Only entry in list */ DMGlobalData.ELhead = DMGlobalData.ELtail = NULL; } else if ( TThEnv == DMGlobalData.ELhead ) { /* First entry in list */ DMGlobalData.ELhead = DMGlobalData.ELhead->next; DMGlobalData.ELhead->prev = NULL; } else if ( TThEnv == DMGlobalData.ELtail ) { /* Last entry in list */ DMGlobalData.ELtail = DMGlobalData.ELtail->prev; DMGlobalData.ELtail->next = NULL; } else { /* somewhere else in list */ TThEnv->prev->next = TThEnv->next; TThEnv->next->prev = TThEnv->prev; } MUTEX_UNLOCK(TThEnv->mutex); MUTEX_DESTROY(TThEnv->mutex); freeTThEnv(TThEnv); /* if no more Environments, unload libraries */ if ( DMGlobalData.ELhead == NULL ) { if ( DMGlobalData.directFuncs != NULL ) { unloadLibrary(DMGlobalData.directFuncs); free( (void *)DMGlobalData.directFuncs ); DMGlobalData.directFuncs = NULL; } if ( DMGlobalData.clientFuncs != NULL ) { unloadLibrary(DMGlobalData.clientFuncs); free( (void *)DMGlobalData.clientFuncs ); DMGlobalData.clientFuncs = NULL; } #if defined(ENABLE_UTIL_LIB) if ( DMGlobalData.utilFuncs != NULL ) { unloadLibrary(DMGlobalData.utilFuncs); free( (void *)DMGlobalData.utilFuncs ); DMGlobalData.utilFuncs = NULL; } #endif /* ENABLE_UTIL_LIB */ } else MUTEX_UNLOCK(TThEnv->mutex); } MUTEX_UNLOCK(DMGlobalData.mutex); } } TRACE_FLEAVE_RC("SQLFreeEnv",rc); return rc; } #if 0 /* NOT SUPPORTED */ DLLEXPORT SQLRETURN SQL_API SQLColumnPrivileges( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName, SQLCHAR * szColumnName, SQLSMALLINT cbColumnName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLColumnPrivileges"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLColumnPrivileges])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, szColumnName, cbColumnName); } } TRACE_FLEAVE_RC("SQLColumnPrivileges",rc); return rc; } #endif DLLEXPORT SQLRETURN SQL_API SQLDescribeParam( SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT* pfSqlType, SQLULEN* pcbColDef, SQLSMALLINT* pibScale, SQLSMALLINT* pfNullable ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLDescribeParam"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT *, SQLULEN *, SQLSMALLINT *, SQLSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLDescribeParam])))(TThStmt->hStmt, ipar, pfSqlType, pcbColDef, pibScale, pfNullable); } } TRACE_FLEAVE_RC("SQLDescribeParam",rc); return rc; } #if 0 /* NOT SUPPORTED */ DLLEXPORT SQLRETURN SQL_API SQLExtendedFetch( SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLROWOFFSET irow, SQLROWSETSIZE * pcrow, SQLUSMALLINT * rgfRowStatus ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLExtendedFetch"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLUSMALLINT, SQLROWOFFSET, SQLROWSETSIZE *, SQLUSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLExtendedFetch])))(TThStmt->hStmt, fFetchType, irow, pcrow, rgfRowStatus); } } TRACE_FLEAVE_RC("SQLExtendedFetch",rc); return rc; } #endif DLLEXPORT SQLRETURN SQL_API SQLForeignKeys( SQLHSTMT hstmt, SQLCHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName, SQLCHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName, SQLCHAR * szPkTableName, SQLSMALLINT cbPkTableName, SQLCHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName, SQLCHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName, SQLCHAR * szFkTableName, SQLSMALLINT cbFkTableName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLForeignKeys"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLForeignKeys])))(TThStmt->hStmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName, szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName, szFkSchemaName, cbFkSchemaName, szFkTableName, cbFkTableName); } } TRACE_FLEAVE_RC("SQLForeignKeys",rc); return rc; } #if 0 /* NOT SUPPORTED */ DLLEXPORT SQLRETURN SQL_API SQLMoreResults( SQLHSTMT hstmt ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLMoreResults"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLMoreResults])))(TThStmt->hStmt); } } TRACE_FLEAVE_RC("SQLMoreResults",rc); return rc; } #endif DLLEXPORT SQLRETURN SQL_API SQLNativeSql( SQLHDBC hdbc, SQLCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER * pcbSqlStr ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TRACE_FENTER("SQLNativeSql"); TRACE_HVAL("hdbc",hdbc); if ( hdbc == NULL ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; if ( TThDbc->hDbc == SQL_NULL_HDBC ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThDbc); rc = (*((SQLRETURN (SQL_API *)(SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLINTEGER *))(TThDbc->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLNativeSql])))(TThDbc->hDbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr); } } TRACE_FLEAVE_RC("SQLNativeSql",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLNumParams( SQLHSTMT hstmt, SQLSMALLINT * pcpar ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLNumParams"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( TThStmt->hStmt == SQL_NULL_HSTMT ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLSMALLINT *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLNumParams])))(TThStmt->hStmt, pcpar); } } TRACE_FLEAVE_RC("SQLNumParams",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLParamOptions( SQLHSTMT hstmt, SQLROWSETSIZE crow, SQLROWSETSIZE * pirow ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLParamOptions"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLROWSETSIZE, SQLROWSETSIZE *))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLParamOptions])))(TThStmt->hStmt, crow, pirow); } } TRACE_FLEAVE_RC("SQLParamOptions",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLPrimaryKeys( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szTableName, SQLSMALLINT cbTableName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLPrimaryKeys"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLPrimaryKeys])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName); } } TRACE_FLEAVE_RC("SQLPrimaryKeys",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLProcedureColumns( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szProcName, SQLSMALLINT cbProcName, SQLCHAR * szColumnName, SQLSMALLINT cbColumnName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLProcedureColumns"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLProcedureColumns])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szProcName, cbProcName, szColumnName, cbColumnName); } } TRACE_FLEAVE_RC("SQLProcedureColumns",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLProcedures( SQLHSTMT hstmt, SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName, SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR * szProcName, SQLSMALLINT cbProcName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLProcedures"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLProcedures])))(TThStmt->hStmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szProcName, cbProcName); } } TRACE_FLEAVE_RC("SQLProcedures",rc); return rc; } #if 0 /* NOT SUPPORTED */ DLLEXPORT SQLRETURN SQL_API SQLSetPos( SQLHSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLSetPos"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLSETPOSIROW, SQLUSMALLINT, SQLUSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLSetPos])))(TThStmt->hStmt, irow, fOption, fLock); } } TRACE_FLEAVE_RC("SQLSetPos",rc); return rc; } DLLEXPORT SQLRETURN SQL_API SQLTablePrivileges( SQLHSTMT hstmt, SQLCHAR * szTableQualifier, SQLSMALLINT cbTableQualifier, SQLCHAR * szTableOwner, SQLSMALLINT cbTableOwner, SQLCHAR * szTableName, SQLSMALLINT cbTableName ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHSTMT TThStmt = NULL; TRACE_FENTER("SQLTablePrivileges"); TRACE_HVAL("hstmt",hstmt); if ( hstmt == NULL ) rc = SQL_INVALID_HANDLE; else { TThStmt = (TTSQLHSTMT)hstmt; if ( (TThStmt->tag != TTDM_STRUCT_TAG) || (TThStmt->hStmt == SQL_NULL_HSTMT) ) rc = SQL_INVALID_HANDLE; else { CLEAR_ERROR_STACK_LOCK(TThStmt); rc = (*((SQLRETURN (SQL_API *)(SQLHSTMT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT, SQLCHAR *, SQLSMALLINT))(TThStmt->pFuncMap->odbcFuncPtr[F_POS_ODBC_SQLTablePrivileges])))(TThStmt->hStmt, szTableQualifier, cbTableQualifier, szTableOwner, cbTableOwner, szTableName, cbTableName); } } TRACE_FLEAVE_RC("SQLTablePrivileges",rc); return rc; } #endif #if defined(ENABLE_XLA_DIRECT) /* ======================================================================== Public functions - XLA Analogues ======================================================================== */ DLLEXPORT SQLRETURN XLA_API ttXlaPersistOpen( SQLHDBC hdbc, SQLCHAR *tag, SQLUINTEGER options, ttXlaHandle_h *handle ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaPersistOpen"); TRACE_HVAL("hdbc",hdbc); TRACE_HVAL("handle",handle); if ( (hdbc == NULL) || (handle == NULL) ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; *handle = NULL; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) || (TThDbc->pFuncMap->libType != TT_LIB_DM_TYPE) /*not direct mode*/ ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(TThDbc->mutex); CLEAR_ERROR_STACK(TThDbc); TThXla = (TTXlaHandle_t *)malloc(sizeof(TTXlaHandle_t)); if ( TThXla == NULL ) pushError(&(TThDbc->errorStack), rc = SQL_INVALID_HANDLE, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "ttXlaPersistOpen: " "Unable to allocate memory for XLA handle" ); else { TThXla->tag = TTDM_STRUCT_TAG; TThXla->hXla = NULL; TThXla->TThEnv = SQL_NULL_HENV; TThXla->TThDbc = SQL_NULL_HDBC; TThXla->pFuncMap = NULL; #if defined(ENABLE_THREAD_SAFETY) TThXla->pMutex = NULL; #endif /* ENABLE_THREAD_SAFETY */ rc = (*((SQLRETURN (XLA_API *)(SQLHDBC, SQLCHAR *, SQLUINTEGER, ttXlaHandle_h *))(TThDbc->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaPersistOpen])))((SQLHDBC)(TThDbc->hDbc), tag, options, (ttXlaHandle_h *)&(TThXla->hXla)); TThDbc->TThXla = TThXla; TThXla->TThEnv = TThDbc->TThEnv; TThXla->TThDbc = TThDbc; TThXla->pFuncMap = TThDbc->pFuncMap; #if defined(ENABLE_THREAD_SAFETY) TThXla->pMutex = TThDbc->mutex; #endif /* ENABLE_THREAD_SAFETY */ *handle = (ttXlaHandle_h)TThXla; } MUTEX_UNLOCK(TThDbc->mutex); } } TRACE_FLEAVE_RC("ttXlaPersistOpen",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaClose( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaClose"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else { rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaClose])))(TThXla->hXla); if ( rc == SQL_SUCCESS ) { MUTEX_LOCK(TThXla->pMutex); /* mark invalid */ TThXla->tag = 0; TThXla->TThDbc->TThXla = NULL; MUTEX_UNLOCK(TThXla->pMutex); TThXla->TThEnv = SQL_NULL_HENV; TThXla->TThDbc = SQL_NULL_HDBC; TThXla->hXla = NULL; #if defined(ENABLE_THREAD_SAFETY) TThXla->pMutex = NULL; #endif /* ENABLE_THREAD_SAFETY */ free( (void *)TThXla ); } } } TRACE_FLEAVE_RC("ttXlaClose",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaAcknowledge( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaAcknowledge"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaAcknowledge])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaAcknowledge",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaDeleteBookmark( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaDeleteBookmark"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaDeleteBookmark])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaDeleteBookmark",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGetLSN( ttXlaHandle_h handle, tt_XlaLsn_t *LSNP ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaGetLSN"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, tt_XlaLsn_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGetLSN])))(TThXla->hXla, LSNP); } TRACE_FLEAVE_RC("ttXlaGetLSN",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaSetLSN( ttXlaHandle_h handle, tt_XlaLsn_t *LSNP ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaSetLSN"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, tt_XlaLsn_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaSetLSN])))(TThXla->hXla, LSNP); } TRACE_FLEAVE_RC("ttXlaSetLSN",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGetVersion( ttXlaHandle_h handle, ttXlaVersion_t *configuredVersion, ttXlaVersion_t *actualVersion ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaGetVersion"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaVersion_t *, ttXlaVersion_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGetVersion])))(TThXla->hXla, configuredVersion, actualVersion); } TRACE_FLEAVE_RC("ttXlaGetVersion",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaSetVersion( ttXlaHandle_h handle, ttXlaVersion_t *version ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaSetVersion"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaVersion_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaSetVersion])))(TThXla->hXla, version); } TRACE_FLEAVE_RC("ttXlaSetVersion",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaVersionCompare( ttXlaHandle_h handle, ttXlaVersion_t *version1, ttXlaVersion_t *version2, SQLINTEGER *result ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaVersionCompare"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaVersion_t *, ttXlaVersion_t *, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaVersionCompare])))(TThXla->hXla, version1, version2, result); } TRACE_FLEAVE_RC("ttXlaVersionCompare",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGenerateSQL( ttXlaHandle_h handle, ttXlaUpdateDesc_t *record, char *buffer, SQLINTEGER maxlen, SQLINTEGER *actuallen ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaGenerateSQL"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t *, char *, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGenerateSQL])))(TThXla->hXla, record, buffer, maxlen, actuallen); } TRACE_FLEAVE_RC("ttXlaVersionCompare",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaError( ttXlaHandle_h handle, SQLINTEGER *errCode, char *errMessage, SQLINTEGER maxLen, SQLINTEGER *retLen ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaError"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLINTEGER *, char *, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaError])))(TThXla->hXla, errCode, errMessage, maxLen, retLen); } TRACE_FLEAVE_RC("ttXlaError", rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaErrorRestart( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaErrorRestart"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaErrorRestart])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaErrorRestart",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTableVersionVerify( ttXlaHandle_h handle, ttXlaTblVerDesc_t *tblInfo, ttXlaUpdateDesc_t *record, SQLINTEGER *compat ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaTableVersionVerify"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaTblVerDesc_t *, ttXlaUpdateDesc_t *, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaTableVersionVerify])))(TThXla->hXla, tblInfo, record, compat); } TRACE_FLEAVE_RC("ttXlaTableVersionVerify",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaVersionTableInfo( ttXlaHandle_h handle, ttXlaUpdateDesc_t *record, ttXlaTblVerDesc_t *tblinfo ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaVersionTableInfo"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t *, ttXlaTblVerDesc_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaVersionTableInfo])))(TThXla->hXla, record, tblinfo); } TRACE_FLEAVE_RC("ttXlaVersionTableInfo",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaVersionColumnInfo( ttXlaHandle_h handle, ttXlaUpdateDesc_t *record, ttXlaColDesc_t *colinfo, SQLINTEGER maxcols, SQLINTEGER *nreturned ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaVersionColumnInfo"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t *, ttXlaColDesc_t *, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaVersionColumnInfo])))(TThXla->hXla, record, colinfo, maxcols, nreturned); } TRACE_FLEAVE_RC("ttXlaVersionColumnInfo",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTableStatus( ttXlaHandle_h handle, SQLUBIGINT systemTableID, SQLUBIGINT userTableID, SQLINTEGER *oldStatus, SQLINTEGER *newStatus ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaTableStatus"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLUBIGINT, SQLUBIGINT, SQLINTEGER *, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaTableStatus])))(TThXla->hXla, systemTableID, userTableID, oldStatus, newStatus); } TRACE_FLEAVE_RC("ttXlaTableStatus",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGetTableInfo( ttXlaHandle_h handle, SQLUBIGINT systemTableID, SQLUBIGINT userTableID, ttXlaTblDesc_t *tblinfo ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaGetTableInfo"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLUBIGINT, SQLUBIGINT, ttXlaTblDesc_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGetTableInfo])))(TThXla->hXla, systemTableID, userTableID, tblinfo); } TRACE_FLEAVE_RC("ttXlaGetTableInfo",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGetColumnInfo( ttXlaHandle_h handle, SQLUBIGINT systemTableID, SQLUBIGINT userTableID, ttXlaColDesc_t *colinfo, SQLINTEGER maxcols, SQLINTEGER *nreturned ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaGetColumnInfo"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLUBIGINT, SQLUBIGINT, ttXlaColDesc_t *, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGetColumnInfo])))(TThXla->hXla, systemTableID, userTableID, colinfo, maxcols, nreturned); } TRACE_FLEAVE_RC("ttXlaGetColumnInfo",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNextUpdate( ttXlaHandle_h handle, ttXlaUpdateDesc_t ***records, SQLINTEGER maxrecords, SQLINTEGER *nreturned ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaNextUpdate"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t ***, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaNextUpdate])))(TThXla->hXla, records, maxrecords, nreturned); } TRACE_FLEAVE_RC("ttXlaNextUpdate",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNextUpdateWait( ttXlaHandle_h handle, ttXlaUpdateDesc_t ***records, SQLINTEGER maxrecords, SQLINTEGER *nreturned, SQLINTEGER seconds ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaNextUpdateWait"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t ***, SQLINTEGER, SQLINTEGER *, SQLINTEGER))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaNextUpdateWait])))(TThXla->hXla, records, maxrecords, nreturned, seconds); } TRACE_FLEAVE_RC("ttXlaNextUpdateWait",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaStatus( ttXlaHandle_h handle, ttXlaStatus_t *status ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaStatus"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaStatus_t *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaStatus])))(TThXla->hXla, status); } TRACE_FLEAVE_RC("ttXlaStatus",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaResetStatus( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaResetStatus"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaResetStatus])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaResetStatus",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTableCheck( ttXlaHandle_h handle, ttXlaTblDesc_t *table, ttXlaColDesc_t *columns, SQLINTEGER *compatP ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaTableCheck"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaTblDesc_t *, ttXlaColDesc_t *, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaTableCheck])))(TThXla->hXla, table, columns, compatP); } TRACE_FLEAVE_RC("ttXlaTableCheck",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaApply( ttXlaHandle_h handle, ttXlaUpdateDesc_t *record, SQLINTEGER test ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaApply"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t *, SQLINTEGER))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaApply])))(TThXla->hXla, record, test); } TRACE_FLEAVE_RC("ttXlaApply",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaLookup( ttXlaHandle_h handle, ttXlaTblDesc_t *table, void *keys, void *result, SQLINTEGER maxsize, SQLINTEGER *retsize ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaLookup"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaTblDesc_t *, void *, void *, SQLINTEGER, SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaLookup])))(TThXla->hXla, table, keys, result, maxsize, retsize); } TRACE_FLEAVE_RC("ttXlaLookup",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaRollback( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaRollback"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaRollback])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaRollback",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaCommit( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaCommit"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaCommit])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaCommit",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTableByName( ttXlaHandle_h handle, char *owner, char *name, SQLUBIGINT *sysTableID, SQLUBIGINT *userTableID ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaTableByName"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, char *, char *, SQLUBIGINT *, SQLUBIGINT *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaTableByName])))(TThXla->hXla, owner, name, sysTableID, userTableID); } TRACE_FLEAVE_RC("ttXlaTableByName",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaDateToODBCCType( void *fromData, DATE_STRUCT *returnData ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaDateToODBCCType"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, DATE_STRUCT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaDateToODBCCType])))(fromData, returnData); } TRACE_FLEAVE_RC("ttXlaDateToODBCCType",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTimeToODBCCType( void *fromData, TIME_STRUCT *returnData ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaTimeToODBCCType"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, TIME_STRUCT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaTimeToODBCCType])))(fromData, returnData); } TRACE_FLEAVE_RC("ttXlaTimeToODBCCType",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTimeStampToODBCCType( void *fromData, TIMESTAMP_STRUCT *returnData ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaTimeStampToODBCCType"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, TIMESTAMP_STRUCT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaTimeStampToODBCCType])))(fromData, returnData); } TRACE_FLEAVE_RC("ttXlaTimeStampToODBCCType",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaDecimalToCString( void *fromData, char *returnData, SQLSMALLINT precision, SQLSMALLINT scale ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaDecimalToCString"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, char *, SQLSMALLINT, SQLSMALLINT))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaDecimalToCString])))(fromData, returnData, precision, scale); } TRACE_FLEAVE_RC("ttXlaDecimalToCString",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToCString( ttXlaHandle_h handle, void *fromData, char *buf, int buflen ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaNumberToCString"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else { rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, void *, char *, int))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaNumberToCString])))(TThXla->hXla, fromData, buf, buflen); } } TRACE_FLEAVE_RC("ttXlaNumberToCString",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToTinyInt( void *fromData, SQLCHAR *tiny ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToTinyInt"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, SQLCHAR *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToTinyInt])))(fromData, tiny); } TRACE_FLEAVE_RC("ttXlaNumberToTinyInt",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToSmallInt( void *fromData, SQLSMALLINT *smint ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToSmallInt"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, SQLSMALLINT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToSmallInt])))(fromData, smint); } TRACE_FLEAVE_RC("ttXlaNumberToSmallInt",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToInt( void *fromData, SQLINTEGER *ival ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToInt"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, SQLINTEGER *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToInt])))(fromData, ival); } TRACE_FLEAVE_RC("ttXlaNumberToInt",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToUInt( void *fromData, SQLUINTEGER *ival ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToUInt"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, SQLUINTEGER *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToUInt])))(fromData, ival); } TRACE_FLEAVE_RC("ttXlaNumberToUInt",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToBigInt( void *fromData, SQLBIGINT *bint ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToBigInt"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, SQLBIGINT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToBigInt])))(fromData, bint); } TRACE_FLEAVE_RC("ttXlaNumberToBigInt",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaNumberToDouble( void *fromData, double *dbl ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaNumberToDouble"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, double *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaNumberToDouble])))(fromData, dbl); } TRACE_FLEAVE_RC("ttXlaNumberToDouble",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaOraDateToODBCTimeStamp( void *fromData, TIMESTAMP_STRUCT *returnData ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaOraDateToODBCTimeStamp"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, TIMESTAMP_STRUCT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaOraDateToODBCTimeStamp])))(fromData, returnData); } TRACE_FLEAVE_RC("ttXlaOraDateToODBCTimeStamp",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaOraTimeStampToODBCTimeStamp( void *fromData, TIMESTAMP_STRUCT *returnData ) { SQLRETURN rc = SQL_SUCCESS; TRACE_FENTER("ttXlaOraTimeStampToODBCTimeStamp"); if ( DMGlobalData.directFuncs == NULL ) rc = SQL_ERROR; else { rc = (*((SQLRETURN (XLA_API *)( void *, TIMESTAMP_STRUCT *))(DMGlobalData.directFuncs->xlaFuncPtr[F_POS_XLA_ttXlaOraTimeStampToODBCTimeStamp])))(fromData, returnData); } TRACE_FLEAVE_RC("ttXlaOraTimeStampToODBCTimeStamp",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaConvertCharType( ttXlaHandle_h handle, ttXlaColDesc_t *colinfo, void*tup, void*buf, size_t buflen ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla; TRACE_FENTER("ttXlaConvertCharType"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else { rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaColDesc_t *, void *, void *, size_t))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaConvertCharType])))(TThXla->hXla, colinfo, tup, buf, buflen); } } TRACE_FLEAVE_RC("ttXlaConvertCharType",rc); return rc; } /* * Legacy (non persistent) functions */ DLLEXPORT SQLRETURN XLA_API ttXlaOpenTimesTen( SQLHDBC hdbc, ttXlaHandle_h * handle ) { SQLRETURN rc = SQL_SUCCESS; TTSQLHDBC TThDbc = NULL; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaOpenTimesTen"); TRACE_HVAL("hdbc",hdbc); TRACE_HVAL("handle",handle); if ( (hdbc == NULL) || (handle == NULL) ) rc = SQL_INVALID_HANDLE; else { TThDbc = (TTSQLHDBC)hdbc; *handle = NULL; if ( (TThDbc->tag != TTDM_STRUCT_TAG) || (TThDbc->hDbc == SQL_NULL_HDBC) || (TThDbc->pFuncMap->libType != TT_LIB_DM_TYPE) /*not direct mode*/ ) rc = SQL_INVALID_HANDLE; else { MUTEX_LOCK(TThDbc->mutex); CLEAR_ERROR_STACK(TThDbc); TThXla = (TTXlaHandle_t *)malloc(sizeof(TTXlaHandle_t)); if ( TThXla == NULL ) pushError(&(TThDbc->errorStack), rc = SQL_INVALID_HANDLE, (SQLCHAR *)TT_DM_SQLSTATE_NOMEM, tt_ErrDMNoMemory, (SQLCHAR *)"TimesTen Driver Manager: " "ttXlaOpenTimesTen: " "Unable to allocate memory for XLA handle" ); else { TThXla->tag = TTDM_STRUCT_TAG; rc = (*((SQLRETURN (XLA_API *)(SQLHDBC, ttXlaHandle_h *))(TThDbc->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaOpenTimesTen])))(TThDbc->hDbc, &(TThXla->hXla)); TThDbc->TThXla = TThXla; TThXla->TThEnv = TThDbc->TThEnv; TThXla->TThDbc = TThDbc; TThXla->pFuncMap = TThDbc->pFuncMap; #if defined(ENABLE_THREAD_SAFETY) TThXla->pMutex = TThDbc->mutex; #endif /* ENABLE_THREAD_SAFETY */ *handle = (ttXlaHandle_h)TThXla; } MUTEX_UNLOCK(TThDbc->mutex); } } TRACE_FLEAVE_RC("ttXlaOpenTimesTen",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaConfigBuffer( ttXlaHandle_h handle, SQLUBIGINT * oldSize, SQLUBIGINT * newSize ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaConfigBuffer"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLUBIGINT *, SQLUBIGINT *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaConfigBuffer])))(TThXla->hXla, oldSize, newSize); } TRACE_FLEAVE_RC("ttXlaConfigBuffer",rc); return rc; } /* * Undocumented public functions */ DLLEXPORT SQLRETURN XLA_API ttXlaEpilog2( ttXlaHandle_h handle ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaEpilog2"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaEpilog2])))(TThXla->hXla); } TRACE_FLEAVE_RC("ttXlaEpilog2",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaInvalidateTbl2( ttXlaHandle_h handle, SQLUBIGINT sysTableID, SQLUBIGINT userTableID ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaInvalidateTbl2"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, SQLUBIGINT, SQLUBIGINT))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaInvalidateTbl2])))(TThXla->hXla, sysTableID, userTableID); } TRACE_FLEAVE_RC("ttXlaConfigBuffer",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaGenerateSQL2( ttXlaHandle_h handle, ttXlaUpdateDesc_t * record, char * buffer, SQLINTEGER maxlen, SQLINTEGER * actuallen, char * valptr[], char * valbuf, SQLINTEGER vmaxlen, SQLINTEGER * vactLen, SQLINTEGER ind[], SQLINTEGER maxColLen[], SQLINTEGER * valCount ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaGenerateSQL2"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, ttXlaUpdateDesc_t *, char *, SQLINTEGER, SQLINTEGER *, char *[], char *, SQLINTEGER, SQLINTEGER *, SQLINTEGER[], SQLINTEGER[], SQLINTEGER *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaGenerateSQL2])))(TThXla->hXla, record, buffer, maxlen, actuallen, valptr, valbuf, vmaxlen, vactLen, ind, maxColLen, valCount); } TRACE_FLEAVE_RC("ttXlaGenerateSQL2",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaTranslate( ttXlaHandle_h handle, void * record ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaTranslate"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, void *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaTranslate])))(TThXla->hXla, record); } TRACE_FLEAVE_RC("ttXlaTranslate",rc); return rc; } DLLEXPORT SQLRETURN XLA_API ttXlaSqlOption( ttXlaHandle_h handle, const char * option ) { SQLRETURN rc = SQL_SUCCESS; TTXlaHandle_t * TThXla = NULL; TRACE_FENTER("ttXlaSqlOption"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = SQL_INVALID_HANDLE; else { TThXla = (TTXlaHandle_t *)handle; if ( (TThXla->tag != TTDM_STRUCT_TAG) || (TThXla->hXla == NULL) ) rc = SQL_INVALID_HANDLE; else rc = (*((SQLRETURN (XLA_API *)(ttXlaHandle_h, const char *))(TThXla->pFuncMap->xlaFuncPtr[F_POS_XLA_ttXlaSqlOption])))(TThXla->hXla, option); } TRACE_FLEAVE_RC("ttXlaSqlOption",rc); return rc; } #endif /* ENABLE_XLA_DIRECT */ #if defined(ENABLE_UTIL_LIB) /* ======================================================================== Public functions - Utility Library Analogues ======================================================================== */ /* * The TT utllity library has a dependency on the direct mode library. * We need to be sure we do not unload the direct mode library while the * utility library is loaded and in use. The easiest way to enforce this * is to allocate a global, direct mode, ODBC environment and keep this * allocated while the Utility library is in use. We will deallocate this * environment when the last Utility environment is freed and this will * trigger the unloading of the Utility libary in SQLFreeEnv. */ DLLEXPORT int UTIL_API ttUtilAllocEnv( ttUtilHandle* handle_ptr, char* errBuff, unsigned int buffLen, unsigned int* errLen ) { SQLRETURN sqlrc = SQL_SUCCESS; int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttUtilAllocEnv"); TRACE_HVAL("handle_ptr",handle_ptr); if ( handle_ptr == NULL ) rc = TTUTIL_INVALID_HANDLE; else { *handle_ptr = NULL; MUTEX_LOCK(DMGlobalData.utilMutex); if ( DMGlobalData.utilEnv == NULL ) { /* first call */ sqlrc = SQLAllocEnv((void *)&(DMGlobalData.utilEnv)); if ( sqlrc != SQL_SUCCESS ) { postUtilEnvError(TT_DM_UTIL_ENV1ERR,errBuff,buffLen,errLen); rc = TTUTIL_ERROR; } else if ( DMGlobalData.utilFuncs == NULL ) { /* utility library not loaded - maybe not present */ postUtilEnvError(TT_DM_UTIL_LIBERR,errBuff,buffLen,errLen); rc = TTUTIL_ERROR; SQLFreeEnv(DMGlobalData.utilEnv); DMGlobalData.utilEnv = NULL; } else { TThUtil = (TTUtilHandle)malloc(sizeof(TTUtilHandle_t)); if ( TThUtil == NULL ) { postUtilEnvError(TT_DM_UTIL_MEMERR,errBuff, buffLen,errLen); rc = TTUTIL_ERROR; SQLFreeEnv(DMGlobalData.utilEnv); DMGlobalData.utilEnv = NULL; } else { TThUtil->tag = TTDM_STRUCT_TAG; rc = (*((int (UTIL_API *)(ttUtilHandle *, char *, unsigned int, unsigned int *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttUtilAllocEnv])))(&(TThUtil->hUtil), errBuff, buffLen, errLen); #if defined(ENABLE_THREAD_SAFETY) if ( rc == TTUTIL_SUCCESS ) { MUTEX_CREATE(TThUtil->mutex); if ( TThUtil->mutex == NULL ) { postUtilEnvError(TT_DM_UTIL_MEMERR,errBuff, buffLen,errLen); rc = TTUTIL_ERROR; } } #endif /* ENABLE_THREAD_SAFETY */ if ( rc != TTUTIL_SUCCESS ) { free( (void *)TThUtil); SQLFreeEnv(DMGlobalData.utilEnv); DMGlobalData.utilEnv = NULL; } else { /* link it into global list */ if ( DMGlobalData.UThead == NULL ) { DMGlobalData.UThead = DMGlobalData.UTtail = TThUtil; TThUtil->prev = TThUtil->next = NULL; } else { DMGlobalData.UTtail->next = (void *)TThUtil; TThUtil->prev = DMGlobalData.UTtail; TThUtil->next = NULL; DMGlobalData.UTtail = TThUtil; } *handle_ptr = (void *)TThUtil; } } } } MUTEX_UNLOCK(DMGlobalData.utilMutex); } TRACE_FLEAVE_RC("ttUtilAllocEnv",rc); return rc; } DLLEXPORT int UTIL_API ttUtilFreeEnv( ttUtilHandle handle, char* errBuff, unsigned int buffLen, unsigned int* errLen ) { int rc = TTUTIL_SUCCESS; SQLRETURN sqlrc = SQL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttUtilFreeEnv"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else { MUTEX_LOCK(DMGlobalData.utilMutex); MUTEX_LOCK(TThUtil->mutex); rc = (*((int (UTIL_API *)(ttUtilHandle, char *, unsigned int, unsigned int *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttUtilFreeEnv])))(TThUtil->hUtil, errBuff, buffLen, errLen); if ( rc == TTUTIL_SUCCESS ) { /* mark invalid */ TThUtil->tag = 0; /* unlink from master list and free */ if ( DMGlobalData.UThead == DMGlobalData.UTtail ) { /* Only entry in list */ DMGlobalData.UThead = DMGlobalData.UTtail = NULL; } else if ( TThUtil == DMGlobalData.UThead ) { /* First entry in list */ DMGlobalData.UThead = DMGlobalData.UThead->next; DMGlobalData.UThead->prev = NULL; } else if ( TThUtil == DMGlobalData.UTtail ) { /* Last entry in list */ DMGlobalData.UTtail = DMGlobalData.UTtail->prev; DMGlobalData.UTtail->next = NULL; } else { /* somewhere else in list */ TThUtil->prev->next = TThUtil->next; TThUtil->next->prev = TThUtil->prev; } TThUtil->hUtil = NULL; TThUtil->next = TThUtil->prev = NULL; MUTEX_UNLOCK(TThUtil->mutex); MUTEX_DESTROY(TThUtil->mutex); free( (void *)TThUtil ); /* check if we should free environment and so unload library */ if ( DMGlobalData.UThead == NULL ) { sqlrc = SQLFreeEnv(DMGlobalData.utilEnv); if ( sqlrc == SQL_SUCCESS ) DMGlobalData.utilEnv = NULL; else { postUtilEnvError(TT_DM_UTIL_ENV2ERR,errBuff, buffLen,errLen); rc = TTUTIL_ERROR; } } } else MUTEX_UNLOCK(TThUtil->mutex); MUTEX_UNLOCK(DMGlobalData.utilMutex); } } TRACE_FLEAVE_RC("ttUtilFreeEnv",rc); return rc; } DLLEXPORT int UTIL_API ttUtilGetErrorCount( ttUtilHandle handle, unsigned int* errCount ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttUtilGetErrorCount"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, unsigned int *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttUtilGetErrorCount])))(TThUtil->hUtil, errCount); } TRACE_FLEAVE_RC("ttUtilGetErrorCount",rc); return rc; } DLLEXPORT int UTIL_API ttUtilGetError( ttUtilHandle handle, unsigned int errIndex, unsigned int* retCode, ttUtilErrType* retType, char* errBuff, unsigned int buffLen, unsigned int* errLen ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttUtilGetError"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, unsigned int, unsigned int *, ttUtilErrType *, char *, unsigned int, unsigned int *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttUtilGetError])))(TThUtil->hUtil, errIndex, retCode, retType, errBuff, buffLen, errLen); } TRACE_FLEAVE_RC("ttUtilGetError",rc); return rc; } DLLEXPORT int UTIL_API ttBackup( ttUtilHandle handle, const char* connStr, ttBackupType type, ttBooleanType atomic, const char* backupDir, const char* baseName, ttUtFileHandle stream ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttBackup"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, ttBackupType, ttBooleanType, const char *, const char *, ttUtFileHandle))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttBackup])))(TThUtil->hUtil, connStr, type, atomic, backupDir, baseName, stream); } TRACE_FLEAVE_RC("ttBackup",rc); return rc; } DLLEXPORT int UTIL_API ttDestroyDataStore( ttUtilHandle handle, const char* connStr, unsigned int timeout ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttDestroyDataStore"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, unsigned int))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttDestroyDataStore])))(TThUtil->hUtil, connStr, timeout); } TRACE_FLEAVE_RC("ttDestroyDataStore",rc); return rc; } DLLEXPORT int UTIL_API ttDestroyDataStoreForce( ttUtilHandle handle, const char* connStr, unsigned int timeout ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttDestroyDataStoreForce"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, unsigned int))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttDestroyDataStoreForce])))(TThUtil->hUtil, connStr, timeout); } TRACE_FLEAVE_RC("ttDestroyDataStoreForce",rc); return rc; } DLLEXPORT int UTIL_API ttRamGrace( ttUtilHandle handle, const char* connStr, unsigned int seconds ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRamGrace"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, unsigned int))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRamGrace])))(TThUtil->hUtil, connStr, seconds); } TRACE_FLEAVE_RC("ttRamGrace",rc); return rc; } DLLEXPORT int UTIL_API ttRamLoad( ttUtilHandle handle, const char* connStr ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRamLoad"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRamLoad])))(TThUtil->hUtil, connStr); } TRACE_FLEAVE_RC("ttRamLoad",rc); return rc; } DLLEXPORT int UTIL_API ttRamPolicy( ttUtilHandle handle, const char* connStr, ttRamPolicyType policy ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRamPolicy"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, ttRamPolicyType))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRamPolicy])))(TThUtil->hUtil, connStr, policy); } TRACE_FLEAVE_RC("ttRamPolicy",rc); return rc; } DLLEXPORT int UTIL_API ttRamUnload( ttUtilHandle handle, const char* connStr ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRamUnload"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRamUnload])))(TThUtil->hUtil, connStr); } TRACE_FLEAVE_RC("ttRamUnload",rc); return rc; } DLLEXPORT int UTIL_API ttRepDuplicateEx( ttUtilHandle handle, const char *destConnStr, const char *srcDatastore, const char *remoteHost, ttRepDuplicateExArg *arg ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRepDuplicateEx"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, const char *, const char *, ttRepDuplicateExArg *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRepDuplicateEx])))(TThUtil->hUtil, destConnStr, srcDatastore, remoteHost, arg); } TRACE_FLEAVE_RC("ttRepDuplicateEx",rc); return rc; } DLLEXPORT int UTIL_API ttRestore( ttUtilHandle handle, const char* connStr, ttRestoreType type, const char* backupDir, const char* baseName, ttUtFileHandle stream, unsigned int flags ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttRestore"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, ttRestoreType, const char *, const char *, ttUtFileHandle, unsigned int))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttRestore])))(TThUtil->hUtil, connStr, type, backupDir, baseName, stream, flags); } TRACE_FLEAVE_RC("ttRestore",rc); return rc; } DLLEXPORT int UTIL_API ttXactIdRollback( ttUtilHandle handle, const char* connStr, const char* xactId ) { int rc = TTUTIL_SUCCESS; TTUtilHandle TThUtil = NULL; TRACE_FENTER("ttXactIdRollback"); TRACE_HVAL("handle",handle); if ( handle == NULL ) rc = TTUTIL_INVALID_HANDLE; else { TThUtil = (TTUtilHandle)handle; if ( (TThUtil->tag != TTDM_STRUCT_TAG) || (TThUtil->hUtil == NULL) ) rc = TTUTIL_INVALID_HANDLE; else rc = (*((int (UTIL_API *)(ttUtilHandle, const char *, const char *))(DMGlobalData.utilFuncs->utilFuncPtr[F_POS_UTIL_ttXactIdRollback])))(TThUtil->hUtil, connStr, xactId); } TRACE_FLEAVE_RC("ttXactIdRollback",rc); return rc; } #endif /* ENABLE_UTIL_LIB */ /**************************************************************************/