reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-11-29 06:30:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e62e88f488
wine/dlls/odbc32/proxyodbc.c
Bill Medland e62e88f488 During startup of the connection to an external ODBC provider 
(e.g. unixODBC) replicate that provider's driver and DSN data to the
registry so that Windows programs that actually query the registry
rather than the ODBC will find at least some information.
2004-10-18 22:47:14 +00:00

2090 lines
71 KiB
C
Raw Blame History

/*
* Win32 ODBC functions
*
* Copyright 1999 Xiang Li, Corel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* NOTES:
* Proxy ODBC driver manager. This manager delegates all ODBC
* calls to a real ODBC driver manager named by the environment
* variable LIB_ODBC_DRIVER_MANAGER, or to libodbc.so if the
* variable is not set.
*
*/
#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "wine/debug.h"
#include "wine/library.h"
#include "sql.h"
#include "sqltypes.h"
#include "sqlext.h"
#include "proxyodbc.h"
static BOOL ODBC_LoadDriverManager(void);
static BOOL ODBC_LoadDMFunctions(void);
WINE_DEFAULT_DEBUG_CHANNEL(odbc);
static const DM_FUNC template_func[] =
{
/* 00 */ { SQL_API_SQLALLOCCONNECT, "SQLAllocConnect", SQLAllocConnect, NULL },
/* 01 */ { SQL_API_SQLALLOCENV, "SQLAllocEnv", SQLAllocEnv, NULL },
/* 02 */ { SQL_API_SQLALLOCHANDLE, "SQLAllocHandle", SQLAllocHandle, NULL },
/* 03 */ { SQL_API_SQLALLOCSTMT, "SQLAllocStmt", SQLAllocStmt, NULL },
/* 04 */ { SQL_API_SQLALLOCHANDLESTD, "SQLAllocHandleStd", SQLAllocHandleStd, NULL },
/* 05 */ { SQL_API_SQLBINDCOL, "SQLBindCol", SQLBindCol, NULL },
/* 06 */ { SQL_API_SQLBINDPARAM, "SQLBindParam", SQLBindParam, NULL },
/* 07 */ { SQL_API_SQLBINDPARAMETER, "SQLBindParameter", SQLBindParameter, NULL },
/* 08 */ { SQL_API_SQLBROWSECONNECT, "SQLBrowseConnect", SQLBrowseConnect, NULL },
/* 09 */ { SQL_API_SQLBULKOPERATIONS, "SQLBulkOperations", SQLBulkOperations, NULL },
/* 10 */ { SQL_API_SQLCANCEL, "SQLCancel", SQLCancel, NULL },
/* 11 */ { SQL_API_SQLCLOSECURSOR, "SQLCloseCursor", SQLCloseCursor, NULL },
/* 12 */ { SQL_API_SQLCOLATTRIBUTE, "SQLColAttribute", SQLColAttribute, NULL },
/* 13 */ { SQL_API_SQLCOLATTRIBUTES, "SQLColAttributes", SQLColAttributes, NULL },
/* 14 */ { SQL_API_SQLCOLUMNPRIVILEGES, "SQLColumnPrivileges", SQLColumnPrivileges, NULL },
/* 15 */ { SQL_API_SQLCOLUMNS, "SQLColumns", SQLColumns, NULL },
/* 16 */ { SQL_API_SQLCONNECT, "SQLConnect", SQLConnect, NULL },
/* 17 */ { SQL_API_SQLCOPYDESC, "SQLCopyDesc", SQLCopyDesc, NULL },
/* 18 */ { SQL_API_SQLDATASOURCES, "SQLDataSources", SQLDataSources, NULL },
/* 19 */ { SQL_API_SQLDESCRIBECOL, "SQLDescribeCol", SQLDescribeCol, NULL },
/* 20 */ { SQL_API_SQLDESCRIBEPARAM, "SQLDescribeParam", SQLDescribeParam, NULL },
/* 21 */ { SQL_API_SQLDISCONNECT, "SQLDisconnect", SQLDisconnect, NULL },
/* 22 */ { SQL_API_SQLDRIVERCONNECT, "SQLDriverConnect", SQLDriverConnect, NULL },
/* 23 */ { SQL_API_SQLDRIVERS, "SQLDrivers", SQLDrivers, NULL },
/* 24 */ { SQL_API_SQLENDTRAN, "SQLEndTran", SQLEndTran, NULL },
/* 25 */ { SQL_API_SQLERROR, "SQLError", SQLError, NULL },
/* 26 */ { SQL_API_SQLEXECDIRECT, "SQLExecDirect", SQLExecDirect, NULL },
/* 27 */ { SQL_API_SQLEXECUTE, "SQLExecute", SQLExecute, NULL },
/* 28 */ { SQL_API_SQLEXTENDEDFETCH, "SQLExtendedFetch", SQLExtendedFetch, NULL },
/* 29 */ { SQL_API_SQLFETCH, "SQLFetch", SQLFetch, NULL },
/* 30 */ { SQL_API_SQLFETCHSCROLL, "SQLFetchScroll", SQLFetchScroll, NULL },
/* 31 */ { SQL_API_SQLFOREIGNKEYS, "SQLForeignKeys", SQLForeignKeys, NULL },
/* 32 */ { SQL_API_SQLFREEENV, "SQLFreeEnv", SQLFreeEnv, NULL },
/* 33 */ { SQL_API_SQLFREEHANDLE, "SQLFreeHandle", SQLFreeHandle, NULL },
/* 34 */ { SQL_API_SQLFREESTMT, "SQLFreeStmt", SQLFreeStmt, NULL },
/* 35 */ { SQL_API_SQLFREECONNECT, "SQLFreeConnect", SQLFreeConnect, NULL },
/* 36 */ { SQL_API_SQLGETCONNECTATTR, "SQLGetConnectAttr", SQLGetConnectAttr, NULL },
/* 37 */ { SQL_API_SQLGETCONNECTOPTION, "SQLGetConnectOption", SQLGetConnectOption, NULL },
/* 38 */ { SQL_API_SQLGETCURSORNAME, "SQLGetCursorName", SQLGetCursorName, NULL },
/* 39 */ { SQL_API_SQLGETDATA, "SQLGetData", SQLGetData, NULL },
/* 40 */ { SQL_API_SQLGETDESCFIELD, "SQLGetDescField", SQLGetDescField, NULL },
/* 41 */ { SQL_API_SQLGETDESCREC, "SQLGetDescRec", SQLGetDescRec, NULL },
/* 42 */ { SQL_API_SQLGETDIAGFIELD, "SQLGetDiagField", SQLGetDiagField, NULL },
/* 43 */ { SQL_API_SQLGETENVATTR, "SQLGetEnvAttr", SQLGetEnvAttr, NULL },
/* 44 */ { SQL_API_SQLGETFUNCTIONS, "SQLGetFunctions", SQLGetFunctions, NULL },
/* 45 */ { SQL_API_SQLGETINFO, "SQLGetInfo", SQLGetInfo, NULL },
/* 46 */ { SQL_API_SQLGETSTMTATTR, "SQLGetStmtAttr", SQLGetStmtAttr, NULL },
/* 47 */ { SQL_API_SQLGETSTMTOPTION, "SQLGetStmtOption", SQLGetStmtOption, NULL },
/* 48 */ { SQL_API_SQLGETTYPEINFO, "SQLGetTypeInfo", SQLGetTypeInfo, NULL },
/* 49 */ { SQL_API_SQLMORERESULTS, "SQLMoreResults", SQLMoreResults, NULL },
/* 50 */ { SQL_API_SQLNATIVESQL, "SQLNativeSql", SQLNativeSql, NULL },
/* 51 */ { SQL_API_SQLNUMPARAMS, "SQLNumParams", SQLNumParams, NULL },
/* 52 */ { SQL_API_SQLNUMRESULTCOLS, "SQLNumResultCols", SQLNumResultCols, NULL },
/* 53 */ { SQL_API_SQLPARAMDATA, "SQLParamData", SQLParamData, NULL },
/* 54 */ { SQL_API_SQLPARAMOPTIONS, "SQLParamOptions", SQLParamOptions, NULL },
/* 55 */ { SQL_API_SQLPREPARE, "SQLPrepare", SQLPrepare, NULL },
/* 56 */ { SQL_API_SQLPRIMARYKEYS, "SQLPrimaryKeys", SQLPrimaryKeys, NULL },
/* 57 */ { SQL_API_SQLPROCEDURECOLUMNS, "SQLProcedureColumns", SQLProcedureColumns, NULL },
/* 58 */ { SQL_API_SQLPROCEDURES, "SQLProcedures", SQLProcedures, NULL },
/* 59 */ { SQL_API_SQLPUTDATA, "SQLPutData", SQLPutData, NULL },
/* 60 */ { SQL_API_SQLROWCOUNT, "SQLRowCount", SQLRowCount, NULL },
/* 61 */ { SQL_API_SQLSETCONNECTATTR, "SQLSetConnectAttr", SQLSetConnectAttr, NULL },
/* 62 */ { SQL_API_SQLSETCONNECTOPTION, "SQLSetConnectOption", SQLSetConnectOption, NULL },
/* 63 */ { SQL_API_SQLSETCURSORNAME, "SQLSetCursorName", SQLSetCursorName, NULL },
/* 64 */ { SQL_API_SQLSETDESCFIELD, "SQLSetDescField", SQLSetDescField, NULL },
/* 65 */ { SQL_API_SQLSETDESCREC, "SQLSetDescRec", SQLSetDescRec, NULL },
/* 66 */ { SQL_API_SQLSETENVATTR, "SQLSetEnvAttr", SQLSetEnvAttr, NULL },
/* 67 */ { SQL_API_SQLSETPARAM, "SQLSetParam", SQLSetParam, NULL },
/* 68 */ { SQL_API_SQLSETPOS, "SQLSetPos", SQLSetPos, NULL },
/* 69 */ { SQL_API_SQLSETSCROLLOPTIONS, "SQLSetScrollOptions", SQLSetScrollOptions, NULL },
/* 70 */ { SQL_API_SQLSETSTMTATTR, "SQLSetStmtAttr", SQLSetStmtAttr, NULL },
/* 71 */ { SQL_API_SQLSETSTMTOPTION, "SQLSetStmtOption", SQLSetStmtOption, NULL },
/* 72 */ { SQL_API_SQLSPECIALCOLUMNS, "SQLSpecialColumns", SQLSpecialColumns, NULL },
/* 73 */ { SQL_API_SQLSTATISTICS, "SQLStatistics", SQLStatistics, NULL },
/* 74 */ { SQL_API_SQLTABLEPRIVILEGES, "SQLTablePrivileges", SQLTablePrivileges, NULL },
/* 75 */ { SQL_API_SQLTABLES, "SQLTables", SQLTables, NULL },
/* 76 */ { SQL_API_SQLTRANSACT, "SQLTransact", SQLTransact, NULL },
/* 77 */ { SQL_API_SQLGETDIAGREC, "SQLGetDiagRec", SQLGetDiagRec, NULL },
};
static PROXYHANDLE gProxyHandle;
/* What is the difference between these two (dmHandle cf READY_AND_dmHandle)? When does one use one and when the other? */
#define CHECK_dmHandle() \
{ \
if (gProxyHandle.dmHandle == NULL) \
{ \
TRACE ("Not ready\n"); \
return SQL_ERROR; \
} \
}
#define CHECK_READY_AND_dmHandle() \
{ \
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL) \
{ \
TRACE ("Not ready\n"); \
return SQL_ERROR; \
} \
}
SQLRETURN SQLDummyFunc()
{
TRACE("SQLDummyFunc: \n");
return SQL_SUCCESS;
}
/***********************************************************************
* ODBC_ReplicateODBCInstToRegistry
*
* PARAMS
*
* RETURNS
*
* Utility to ODBC_ReplicateToRegistry to replicate the drivers of the
* ODBCINST.INI settings
*
* The driver settings are not replicated to the registry. If we were to
* replicate them we would need to decide whether to replicate all settings
* or to do some translation; whether to remove any entries present only in
* the windows registry, etc.
*/
static void ODBC_ReplicateODBCInstToRegistry (SQLHENV hEnv)
{
HKEY hODBCInst;
LONG reg_ret;
int success;
success = 0;
TRACE ("Driver settings are not currently replicated to the registry\n");
if ((reg_ret = RegCreateKeyExA (HKEY_LOCAL_MACHINE,
"Software\\ODBC\\ODBCINST.INI", 0, NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS /* a couple more than we need */, NULL,
&hODBCInst, NULL)) == ERROR_SUCCESS)
{
HKEY hDrivers;
if ((reg_ret = RegCreateKeyExA (hODBCInst, "ODBC Drivers", 0,
NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS /* overkill */, NULL, &hDrivers, NULL))
== ERROR_SUCCESS)
{
SQLRETURN sql_ret;
SQLUSMALLINT dirn;
SQLCHAR desc [256];
SQLSMALLINT sizedesc;
success = 1;
dirn = SQL_FETCH_FIRST;
while ((sql_ret = SQLDrivers (hEnv, dirn, desc, sizeof(desc),
&sizedesc, NULL, 0, NULL)) == SQL_SUCCESS ||
sql_ret == SQL_SUCCESS_WITH_INFO)
{
/* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
dirn = SQL_FETCH_NEXT;
if (sizedesc == strlen(desc))
{
HKEY hThis;
if ((reg_ret = RegQueryValueExA (hDrivers, desc, NULL,
NULL, NULL, NULL)) == ERROR_FILE_NOT_FOUND)
{
if ((reg_ret = RegSetValueExA (hDrivers, desc, 0,
REG_SZ, "Installed", 10)) != ERROR_SUCCESS)
{
TRACE ("Error %ld replicating driver %s\n",
reg_ret, desc);
success = 0;
}
}
else if (reg_ret != ERROR_SUCCESS)
{
TRACE ("Error %ld checking for %s in drivers\n",
reg_ret, desc);
success = 0;
}
if ((reg_ret = RegCreateKeyExA (hODBCInst, desc, 0,
NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS, NULL, &hThis, NULL))
== ERROR_SUCCESS)
{
/* FIXME This is where the settings go.
* I suggest that if the disposition says it
* exists then we leave it alone. Alternatively
* include an extra value to flag that it is
* a replication of the unixODBC/iODBC/...
*/
if ((reg_ret = RegCloseKey (hThis)) !=
ERROR_SUCCESS)
TRACE ("Error %ld closing %s key\n", reg_ret,
desc);
}
else
{
TRACE ("Error %ld ensuring driver key %s\n",
reg_ret, desc);
success = 0;
}
}
else
{
WARN ("Unusually long driver name %s not replicated\n",
desc);
success = 0;
}
}
if (sql_ret != SQL_NO_DATA)
{
TRACE ("Error %d enumerating drivers\n", (int)sql_ret);
success = 0;
}
if ((reg_ret = RegCloseKey (hDrivers)) != ERROR_SUCCESS)
{
TRACE ("Error %ld closing hDrivers\n", reg_ret);
}
}
else
{
TRACE ("Error %ld opening HKLM\\S\\O\\OI\\Drivers\n", reg_ret);
}
if ((reg_ret = RegCloseKey (hODBCInst)) != ERROR_SUCCESS)
{
TRACE ("Error %ld closing HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
}
}
else
{
TRACE ("Error %ld opening HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
}
if (!success)
{
WARN ("May not have replicated all ODBC drivers to the registry\n");
}
}
/***********************************************************************
* ODBC_ReplicateODBCToRegistry
*
* PARAMS
*
* RETURNS
*
* Utility to ODBC_ReplicateToRegistry to replicate either the USER or
* SYSTEM dsns
*
* For now simply place the "Driver description" (as returned by SQLDataSources)
* into the registry as the driver. This is enough to satisfy Crystal's
* requirement that there be a driver entry. (It doesn't seem to care what
* the setting is).
* A slightly more accurate setting would be to access the registry to find
* the actual driver library for the given description (which appears to map
* to one of the HKLM/Software/ODBC/ODBCINST.INI keys). (If you do this note
* that this will add a requirement that this function be called after
* ODBC_ReplicateODBCInstToRegistry)
*/
static void ODBC_ReplicateODBCToRegistry (int is_user, SQLHENV hEnv)
{
HKEY hODBC;
LONG reg_ret;
SQLRETURN sql_ret;
SQLUSMALLINT dirn;
SQLCHAR dsn [SQL_MAX_DSN_LENGTH + 1];
SQLSMALLINT sizedsn;
SQLCHAR desc [256];
SQLSMALLINT sizedesc;
int success;
const char *which = is_user ? "user" : "system";
success = 0;
if ((reg_ret = RegCreateKeyExA (
is_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
"Software\\ODBC\\ODBC.INI", 0, NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS /* a couple more than we need */, NULL, &hODBC,
NULL)) == ERROR_SUCCESS)
{
success = 1;
dirn = is_user ? SQL_FETCH_FIRST_USER : SQL_FETCH_FIRST_SYSTEM;
while ((sql_ret = SQLDataSources (hEnv, dirn,
dsn, sizeof(dsn), &sizedsn,
desc, sizeof(desc), &sizedesc)) == SQL_SUCCESS
|| sql_ret == SQL_SUCCESS_WITH_INFO)
{
/* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
dirn = SQL_FETCH_NEXT;
if (sizedsn == strlen(dsn) && sizedesc == strlen(desc))
{
HKEY hDSN;
if ((reg_ret = RegCreateKeyExA (hODBC, dsn, 0,
NULL, REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS, NULL, &hDSN, NULL))
== ERROR_SUCCESS)
{
static const char *DRIVERKEY = "Driver";
if ((reg_ret = RegQueryValueExA (hDSN, DRIVERKEY,
NULL, NULL, NULL, NULL))
== ERROR_FILE_NOT_FOUND)
{
if ((reg_ret = RegSetValueExA (hDSN, DRIVERKEY, 0,
REG_SZ, desc, sizedesc)) != ERROR_SUCCESS)
{
TRACE ("Error %ld replicating description of "
"%s(%s)\n", reg_ret, dsn, desc);
success = 0;
}
}
else if (reg_ret != ERROR_SUCCESS)
{
TRACE ("Error %ld checking for description of %s\n",
reg_ret, dsn);
success = 0;
}
if ((reg_ret = RegCloseKey (hDSN)) != ERROR_SUCCESS)
{
TRACE ("Error %ld closing %s DSN key %s\n",
reg_ret, which, dsn);
}
}
else
{
TRACE ("Error %ld opening %s DSN key %s\n",
reg_ret, which, dsn);
success = 0;
}
}
else
{
WARN ("Unusually long %s data source name %s (%s) not "
"replicated\n", which, dsn, desc);
success = 0;
}
}
if (sql_ret != SQL_NO_DATA)
{
TRACE ("Error %d enumerating %s datasources\n",
(int)sql_ret, which);
success = 0;
}
if ((reg_ret = RegCloseKey (hODBC)) != ERROR_SUCCESS)
{
TRACE ("Error %ld closing %s ODBC.INI registry key\n", reg_ret,
which);
}
}
else
{
TRACE ("Error %ld creating/opening %s ODBC.INI registry key\n",
reg_ret, which);
}
if (!success)
{
WARN ("May not have replicated all %s ODBC DSNs to the registry\n",
which);
}
}
/***********************************************************************
* ODBC_ReplicateToRegistry
*
* PARAMS
*
* RETURNS
*
* Unfortunately some of the functions that Windows documents as being part
* of the ODBC API it implements directly during compilation or something
* in terms of registry access functions.
* e.g. SQLGetInstalledDrivers queries the list at
* HKEY_LOCAL_MACHINE\Software\ODBC\ODBCINST.INI\ODBC Drivers
*
* This function is called when the driver manager is loaded and is used
* to replicate the appropriate details into the Wine registry
*/
static void ODBC_ReplicateToRegistry (void)
{
SQLRETURN sql_ret;
SQLHENV hEnv;
if ((sql_ret = SQLAllocEnv (&hEnv)) == SQL_SUCCESS)
{
ODBC_ReplicateODBCInstToRegistry (hEnv);
ODBC_ReplicateODBCToRegistry (0 /* system dsns */, hEnv);
ODBC_ReplicateODBCToRegistry (1 /* user dsns */, hEnv);
if ((sql_ret = SQLFreeEnv (hEnv)) != SQL_SUCCESS)
{
TRACE ("Error %d freeing the SQL environment.\n", (int)sql_ret);
}
}
else
{
TRACE ("Error %d opening an SQL environment.\n", (int)sql_ret);
WARN ("The external ODBC settings have not been replicated to the"
" Wine registry\n");
}
}
/***********************************************************************
* DllMain [Internal] Initializes the internal 'ODBC32.DLL'.
*
* PARAMS
* hinstDLL [I] handle to the DLL's instance
* fdwReason [I]
* lpvReserved [I] reserved, must be NULL
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
int i;
TRACE("Initializing or Finalizing proxy ODBC: %p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved);
if (fdwReason == DLL_PROCESS_ATTACH)
{
TRACE("Loading ODBC...\n");
DisableThreadLibraryCalls(hinstDLL);
if (ODBC_LoadDriverManager())
{
ODBC_LoadDMFunctions();
ODBC_ReplicateToRegistry();
}
}
else if (fdwReason == DLL_PROCESS_DETACH)
{
TRACE("Unloading ODBC...\n");
if (gProxyHandle.bFunctionReady)
{
for ( i = 0; i < NUM_SQLFUNC; i ++ )
{
gProxyHandle.functions[i].func = SQLDummyFunc;
}
}
if (gProxyHandle.dmHandle)
{
wine_dlclose(gProxyHandle.dmHandle,NULL,0);
gProxyHandle.dmHandle = NULL;
}
}
return TRUE;
}
/***********************************************************************
* ODBC_LoadDriverManager [Internal] Load ODBC library.
*
* PARAMS
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
static BOOL ODBC_LoadDriverManager(void)
{
const char *s = getenv("LIB_ODBC_DRIVER_MANAGER");
char error[256];
TRACE("\n");
gProxyHandle.bFunctionReady = FALSE;
gProxyHandle.nErrorType = ERROR_LIBRARY_NOT_FOUND;
if (s!= NULL && strlen (s) >= sizeof(gProxyHandle.dmLibName))
{
ERR("Driver name too long (%s)\n",s);
return FALSE;
}
if (s == NULL || strlen(s) == 0)
s = "libodbc.so";
strcpy(gProxyHandle.dmLibName, s);
gProxyHandle.dmHandle = wine_dlopen(gProxyHandle.dmLibName, RTLD_LAZY | RTLD_GLOBAL, error, sizeof(error));
if (gProxyHandle.dmHandle == NULL) /* fail to load unixODBC driver manager */
{
WARN("failed to open library %s: %s\n", gProxyHandle.dmLibName, error);
gProxyHandle.dmLibName[0] = '\0';
gProxyHandle.nErrorType = ERROR_LIBRARY_NOT_FOUND;
return FALSE;
}
else
{
gProxyHandle.nErrorType = ERROR_FREE;
return TRUE;
}
}
/***********************************************************************
* ODBC_LoadDMFunctions [Internal] Populate function table.
*
* PARAMS
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
static BOOL ODBC_LoadDMFunctions(void)
{
int i;
char error[256];
if (gProxyHandle.dmHandle == NULL)
return FALSE;
for ( i = 0; i < NUM_SQLFUNC; i ++ )
{
gProxyHandle.functions[i] = template_func[i];
gProxyHandle.functions[i].func = wine_dlsym(gProxyHandle.dmHandle,
gProxyHandle.functions[i].name, error, sizeof(error));
if (error[0])
{
ERR("Failed to load function %s\n",gProxyHandle.functions[i].name);
gProxyHandle.functions[i].func = SQLDummyFunc;
}
}
gProxyHandle.bFunctionReady = TRUE;
return TRUE;
}
/*************************************************************************
* SQLAllocConnect [ODBC32.001]
*/
SQLRETURN WINAPI SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle)
{
SQLRETURN ret;
TRACE("Env=%lx\n",EnvironmentHandle);
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
*ConnectionHandle = SQL_NULL_HDBC;
TRACE("Not ready\n");
return SQL_ERROR;
}
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCCONNECT].func)
(EnvironmentHandle, ConnectionHandle);
TRACE("Returns ret=%d, Handle %lx\n",ret, *ConnectionHandle);
return ret;
}
/*************************************************************************
* SQLAllocEnv [ODBC32.002]
*/
SQLRETURN WINAPI SQLAllocEnv(SQLHENV *EnvironmentHandle)
{
SQLRETURN ret;
TRACE("\n");
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
*EnvironmentHandle = SQL_NULL_HENV;
TRACE("Not ready\n");
return SQL_ERROR;
}
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCENV].func) (EnvironmentHandle);
TRACE("Returns ret=%d, Env=%lx\n",ret, *EnvironmentHandle);
return ret;
}
/*************************************************************************
* SQLAllocHandle [ODBC32.024]
*/
SQLRETURN WINAPI SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
{
SQLRETURN ret;
TRACE("(Type=%d, Handle=%lx)\n",HandleType,InputHandle);
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND)
WARN("ProxyODBC: Can not load ODBC driver manager library.\n");
if (HandleType == SQL_HANDLE_ENV)
*OutputHandle = SQL_NULL_HENV;
else if (HandleType == SQL_HANDLE_DBC)
*OutputHandle = SQL_NULL_HDBC;
else if (HandleType == SQL_HANDLE_STMT)
*OutputHandle = SQL_NULL_HSTMT;
else if (HandleType == SQL_HANDLE_DESC)
*OutputHandle = SQL_NULL_HDESC;
TRACE ("Not ready\n");
return SQL_ERROR;
}
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLE].func)
(HandleType, InputHandle, OutputHandle);
TRACE("Returns ret=%d, Handle=%lx\n",ret, *OutputHandle);
return ret;
}
/*************************************************************************
* SQLAllocStmt [ODBC32.003]
*/
SQLRETURN WINAPI SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle)
{
SQLRETURN ret;
TRACE("(Connection=%lx)\n",ConnectionHandle);
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
*StatementHandle = SQL_NULL_HSTMT;
TRACE ("Not ready\n");
return SQL_ERROR;
}
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCSTMT].func)
(ConnectionHandle, StatementHandle);
TRACE ("Returns ret=%d, Handle=%lx\n", ret, *StatementHandle);
return ret;
}
/*************************************************************************
* SQLAllocHandleStd [ODBC32.077]
*/
SQLRETURN WINAPI SQLAllocHandleStd( SQLSMALLINT HandleType,
SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
{
TRACE("ProxyODBC: SQLAllocHandelStd.\n");
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
if (gProxyHandle.nErrorType == ERROR_LIBRARY_NOT_FOUND)
WARN("ProxyODBC: Can not load ODBC driver manager library.\n");
if (HandleType == SQL_HANDLE_ENV)
*OutputHandle = SQL_NULL_HENV;
else if (HandleType == SQL_HANDLE_DBC)
*OutputHandle = SQL_NULL_HDBC;
else if (HandleType == SQL_HANDLE_STMT)
*OutputHandle = SQL_NULL_HSTMT;
else if (HandleType == SQL_HANDLE_DESC)
*OutputHandle = SQL_NULL_HDESC;
return SQL_ERROR;
}
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLALLOCHANDLESTD].func)
(HandleType, InputHandle, OutputHandle);
}
/*************************************************************************
* SQLBindCol [ODBC32.004]
*/
SQLRETURN WINAPI SQLBindCol(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
SQLPOINTER TargetValue, SQLINTEGER BufferLength,
SQLINTEGER *StrLen_or_Ind)
{
TRACE("\n");
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
TRACE ("Not ready\n");
return SQL_ERROR;
}
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDCOL].func)
(StatementHandle, ColumnNumber, TargetType,
TargetValue, BufferLength, StrLen_or_Ind);
}
/*************************************************************************
* SQLBindParam [ODBC32.025]
*/
SQLRETURN WINAPI SQLBindParam(SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
SQLINTEGER *StrLen_or_Ind)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAM].func)
(StatementHandle, ParameterNumber, ValueType,
ParameterScale, ParameterValue, StrLen_or_Ind);
}
/*************************************************************************
* SQLCancel [ODBC32.005]
*/
SQLRETURN WINAPI SQLCancel(SQLHSTMT StatementHandle)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCANCEL].func) (StatementHandle);
}
/*************************************************************************
* SQLCloseCursor [ODBC32.026]
*/
SQLRETURN WINAPI SQLCloseCursor(SQLHSTMT StatementHandle)
{
SQLRETURN ret;
TRACE("(Handle=%lx)\n",StatementHandle);
CHECK_READY_AND_dmHandle();
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCLOSECURSOR].func) (StatementHandle);
TRACE("returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLColAttribute [ODBC32.027]
*/
SQLRETURN WINAPI SQLColAttribute (SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttribute, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength, SQLPOINTER NumericAttribute)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTE].func)
(StatementHandle, ColumnNumber, FieldIdentifier,
CharacterAttribute, BufferLength, StringLength, NumericAttribute);
}
/*************************************************************************
* SQLColumns [ODBC32.040]
*/
SQLRETURN WINAPI SQLColumns(SQLHSTMT StatementHandle,
SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
SQLCHAR *TableName, SQLSMALLINT NameLength3,
SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNS].func)
(StatementHandle, CatalogName, NameLength1,
SchemaName, NameLength2, TableName, NameLength3, ColumnName, NameLength4);
}
/*************************************************************************
* SQLConnect [ODBC32.007]
*/
SQLRETURN WINAPI SQLConnect(SQLHDBC ConnectionHandle,
SQLCHAR *ServerName, SQLSMALLINT NameLength1,
SQLCHAR *UserName, SQLSMALLINT NameLength2,
SQLCHAR *Authentication, SQLSMALLINT NameLength3)
{
SQLRETURN ret;
TRACE("(Server=%.*s)\n",NameLength1, ServerName);
CHECK_READY_AND_dmHandle();
strcpy(gProxyHandle.ServerName, ServerName);
strcpy(gProxyHandle.UserName, UserName);
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLCONNECT].func)
(ConnectionHandle, ServerName, NameLength1,
UserName, NameLength2, Authentication, NameLength3);
TRACE("returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLCopyDesc [ODBC32.028]
*/
SQLRETURN WINAPI SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOPYDESC].func)
(SourceDescHandle, TargetDescHandle);
}
/*************************************************************************
* SQLDataSources [ODBC32.057]
*/
SQLRETURN WINAPI SQLDataSources(SQLHENV EnvironmentHandle,
SQLUSMALLINT Direction, SQLCHAR *ServerName,
SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1,
SQLCHAR *Description, SQLSMALLINT BufferLength2,
SQLSMALLINT *NameLength2)
{
SQLRETURN ret;
TRACE("EnvironmentHandle = %p\n", (LPVOID)EnvironmentHandle);
if (!gProxyHandle.bFunctionReady || gProxyHandle.dmHandle == NULL)
{
ERR("Error: empty dm handle (gProxyHandle.dmHandle == NULL)\n");
return SQL_ERROR;
}
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func);
ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDATASOURCES].func)
(EnvironmentHandle, Direction, ServerName,
BufferLength1, NameLength1, Description, BufferLength2, NameLength2);
if (TRACE_ON(odbc))
{
TRACE("returns: %d \t", ret);
if (*NameLength1 > 0)
TRACE("DataSource = %s,", ServerName);
if (*NameLength2 > 0)
TRACE(" Description = %s", Description);
TRACE("\n");
}
return ret;
}
/*************************************************************************
* SQLDescribeCol [ODBC32.008]
*/
SQLRETURN WINAPI SQLDescribeCol(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
SQLSMALLINT BufferLength, SQLSMALLINT *NameLength,
SQLSMALLINT *DataType, SQLUINTEGER *ColumnSize,
SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBECOL].func)
(StatementHandle, ColumnNumber, ColumnName,
BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
}
/*************************************************************************
* SQLDisconnect [ODBC32.009]
*/
SQLRETURN WINAPI SQLDisconnect(SQLHDBC ConnectionHandle)
{
SQLRETURN ret;
TRACE("(Handle=%lx)\n", ConnectionHandle);
CHECK_READY_AND_dmHandle();
gProxyHandle.ServerName[0] = '\0';
gProxyHandle.UserName[0] = '\0';
assert(gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func);
ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLDISCONNECT].func) (ConnectionHandle);
TRACE("returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLEndTran [ODBC32.029]
*/
SQLRETURN WINAPI SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLENDTRAN].func) (HandleType, Handle, CompletionType);
}
/*************************************************************************
* SQLError [ODBC32.010]
*/
SQLRETURN WINAPI SQLError(SQLHENV EnvironmentHandle,
SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
SQLCHAR *Sqlstate, SQLINTEGER *NativeError,
SQLCHAR *MessageText, SQLSMALLINT BufferLength,
SQLSMALLINT *TextLength)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLERROR].func)
(EnvironmentHandle, ConnectionHandle, StatementHandle,
Sqlstate, NativeError, MessageText, BufferLength, TextLength);
}
/*************************************************************************
* SQLExecDirect [ODBC32.011]
*/
SQLRETURN WINAPI SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECDIRECT].func)
(StatementHandle, StatementText, TextLength);
}
/*************************************************************************
* SQLExecute [ODBC32.012]
*/
SQLRETURN WINAPI SQLExecute(SQLHSTMT StatementHandle)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXECUTE].func) (StatementHandle);
}
/*************************************************************************
* SQLFetch [ODBC32.013]
*/
SQLRETURN WINAPI SQLFetch(SQLHSTMT StatementHandle)
{
TRACE("\n");
CHECK_READY_AND_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCH].func) (StatementHandle);
}
/*************************************************************************
* SQLFetchScroll [ODBC32.030]
*/
SQLRETURN WINAPI SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLINTEGER FetchOffset)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLFETCHSCROLL].func)
(StatementHandle, FetchOrientation, FetchOffset);
}
/*************************************************************************
* SQLFreeConnect [ODBC32.014]
*/
SQLRETURN WINAPI SQLFreeConnect(SQLHDBC ConnectionHandle)
{
SQLRETURN ret;
TRACE("(Handle=%lx)\n",ConnectionHandle);
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREECONNECT].func) (ConnectionHandle);
TRACE("Returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLFreeEnv [ODBC32.015]
*/
SQLRETURN WINAPI SQLFreeEnv(SQLHENV EnvironmentHandle)
{
SQLRETURN ret;
TRACE("(Env=%lx)\n",EnvironmentHandle);
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func);
ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEENV].func) (EnvironmentHandle);
TRACE("Returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLFreeHandle [ODBC32.031]
*/
SQLRETURN WINAPI SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
{
SQLRETURN ret;
TRACE("(Type=%d, Handle=%lx)\n",HandleType,Handle);
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func);
ret = (gProxyHandle.functions[SQLAPI_INDEX_SQLFREEHANDLE].func)
(HandleType, Handle);
TRACE ("Returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLFreeStmt [ODBC32.016]
*/
SQLRETURN WINAPI SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option)
{
SQLRETURN ret;
TRACE("(Handle %lx, Option=%d)\n",StatementHandle, Option);
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func);
ret=(gProxyHandle.functions[SQLAPI_INDEX_SQLFREESTMT].func)
(StatementHandle, Option);
TRACE("Returns %d\n",ret);
return ret;
}
/*************************************************************************
* SQLGetConnectAttr [ODBC32.032]
*/
SQLRETURN WINAPI SQLGetConnectAttr(SQLHDBC ConnectionHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTATTR].func)
(ConnectionHandle, Attribute, Value,
BufferLength, StringLength);
}
/*************************************************************************
* SQLGetConnectOption [ODBC32.042]
*/
SQLRETURN WINAPI SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCONNECTOPTION].func)
(ConnectionHandle, Option, Value);
}
/*************************************************************************
* SQLGetCursorName [ODBC32.017]
*/
SQLRETURN WINAPI SQLGetCursorName(SQLHSTMT StatementHandle,
SQLCHAR *CursorName, SQLSMALLINT BufferLength,
SQLSMALLINT *NameLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETCURSORNAME].func)
(StatementHandle, CursorName, BufferLength, NameLength);
}
/*************************************************************************
* SQLGetData [ODBC32.043]
*/
SQLRETURN WINAPI SQLGetData(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
SQLPOINTER TargetValue, SQLINTEGER BufferLength,
SQLINTEGER *StrLen_or_Ind)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDATA].func)
(StatementHandle, ColumnNumber, TargetType,
TargetValue, BufferLength, StrLen_or_Ind);
}
/*************************************************************************
* SQLGetDescField [ODBC32.033]
*/
SQLRETURN WINAPI SQLGetDescField(SQLHDESC DescriptorHandle,
SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
SQLPOINTER Value, SQLINTEGER BufferLength,
SQLINTEGER *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCFIELD].func)
(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength, StringLength);
}
/*************************************************************************
* SQLGetDescRec [ODBC32.034]
*/
SQLRETURN WINAPI SQLGetDescRec(SQLHDESC DescriptorHandle,
SQLSMALLINT RecNumber, SQLCHAR *Name,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
SQLSMALLINT *Type, SQLSMALLINT *SubType,
SQLINTEGER *Length, SQLSMALLINT *Precision,
SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDESCREC].func)
(DescriptorHandle, RecNumber, Name, BufferLength,
StringLength, Type, SubType, Length, Precision, Scale, Nullable);
}
/*************************************************************************
* SQLGetDiagField [ODBC32.035]
*/
SQLRETURN WINAPI SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier,
SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGFIELD].func)
(HandleType, Handle, RecNumber, DiagIdentifier,
DiagInfo, BufferLength, StringLength);
}
/*************************************************************************
* SQLGetDiagRec [ODBC32.036]
*/
SQLRETURN WINAPI SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT RecNumber, SQLCHAR *Sqlstate,
SQLINTEGER *NativeError, SQLCHAR *MessageText,
SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETDIAGREC].func)
(HandleType, Handle, RecNumber, Sqlstate, NativeError,
MessageText, BufferLength, TextLength);
}
/*************************************************************************
* SQLGetEnvAttr [ODBC32.037]
*/
SQLRETURN WINAPI SQLGetEnvAttr(SQLHENV EnvironmentHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETENVATTR].func)
(EnvironmentHandle, Attribute, Value, BufferLength, StringLength);
}
/*************************************************************************
* SQLGetFunctions [ODBC32.044]
*/
SQLRETURN WINAPI SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETFUNCTIONS].func)
(ConnectionHandle, FunctionId, Supported);
}
/*************************************************************************
* SQLGetInfo [ODBC32.045]
*/
SQLRETURN WINAPI SQLGetInfo(SQLHDBC ConnectionHandle,
SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETINFO].func)
(ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength);
}
/*************************************************************************
* SQLGetStmtAttr [ODBC32.038]
*/
SQLRETURN WINAPI SQLGetStmtAttr(SQLHSTMT StatementHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTATTR].func)
(StatementHandle, Attribute, Value, BufferLength, StringLength);
}
/*************************************************************************
* SQLGetStmtOption [ODBC32.046]
*/
SQLRETURN WINAPI SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETSTMTOPTION].func)
(StatementHandle, Option, Value);
}
/*************************************************************************
* SQLGetTypeInfo [ODBC32.047]
*/
SQLRETURN WINAPI SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLGETTYPEINFO].func)
(StatementHandle, DataType);
}
/*************************************************************************
* SQLNumResultCols [ODBC32.018]
*/
SQLRETURN WINAPI SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMRESULTCOLS].func)
(StatementHandle, ColumnCount);
}
/*************************************************************************
* SQLParamData [ODBC32.048]
*/
SQLRETURN WINAPI SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMDATA].func)
(StatementHandle, Value);
}
/*************************************************************************
* SQLPrepare [ODBC32.019]
*/
SQLRETURN WINAPI SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPREPARE].func)
(StatementHandle, StatementText, TextLength);
}
/*************************************************************************
* SQLPutData [ODBC32.049]
*/
SQLRETURN WINAPI SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLINTEGER StrLen_or_Ind)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPUTDATA].func)
(StatementHandle, Data, StrLen_or_Ind);
}
/*************************************************************************
* SQLRowCount [ODBC32.020]
*/
SQLRETURN WINAPI SQLRowCount(SQLHSTMT StatementHandle, SQLINTEGER *RowCount)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLROWCOUNT].func)
(StatementHandle, RowCount);
}
/*************************************************************************
* SQLSetConnectAttr [ODBC32.039]
*/
SQLRETURN WINAPI SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute,
SQLPOINTER Value, SQLINTEGER StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTATTR].func)
(ConnectionHandle, Attribute, Value, StringLength);
}
/*************************************************************************
* SQLSetConnectOption [ODBC32.050]
*/
SQLRETURN WINAPI SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLUINTEGER Value)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCONNECTOPTION].func)
(ConnectionHandle, Option, Value);
}
/*************************************************************************
* SQLSetCursorName [ODBC32.021]
*/
SQLRETURN WINAPI SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETCURSORNAME].func)
(StatementHandle, CursorName, NameLength);
}
/*************************************************************************
* SQLSetDescField [ODBC32.073]
*/
SQLRETURN WINAPI SQLSetDescField(SQLHDESC DescriptorHandle,
SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
SQLPOINTER Value, SQLINTEGER BufferLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCFIELD].func)
(DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
}
/*************************************************************************
* SQLSetDescRec [ODBC32.074]
*/
SQLRETURN WINAPI SQLSetDescRec(SQLHDESC DescriptorHandle,
SQLSMALLINT RecNumber, SQLSMALLINT Type,
SQLSMALLINT SubType, SQLINTEGER Length,
SQLSMALLINT Precision, SQLSMALLINT Scale,
SQLPOINTER Data, SQLINTEGER *StringLength,
SQLINTEGER *Indicator)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETDESCREC].func)
(DescriptorHandle, RecNumber, Type, SubType, Length,
Precision, Scale, Data, StringLength, Indicator);
}
/*************************************************************************
* SQLSetEnvAttr [ODBC32.075]
*/
SQLRETURN WINAPI SQLSetEnvAttr(SQLHENV EnvironmentHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETENVATTR].func)
(EnvironmentHandle, Attribute, Value, StringLength);
}
/*************************************************************************
* SQLSetParam [ODBC32.022]
*/
SQLRETURN WINAPI SQLSetParam(SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
SQLSMALLINT ParameterType, SQLUINTEGER LengthPrecision,
SQLSMALLINT ParameterScale, SQLPOINTER ParameterValue,
SQLINTEGER *StrLen_or_Ind)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPARAM].func)
(StatementHandle, ParameterNumber, ValueType, ParameterType, LengthPrecision,
ParameterScale, ParameterValue, StrLen_or_Ind);
}
/*************************************************************************
* SQLSetStmtAttr [ODBC32.076]
*/
SQLRETURN WINAPI SQLSetStmtAttr(SQLHSTMT StatementHandle,
SQLINTEGER Attribute, SQLPOINTER Value,
SQLINTEGER StringLength)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTATTR].func)
(StatementHandle, Attribute, Value, StringLength);
}
/*************************************************************************
* SQLSetStmtOption [ODBC32.051]
*/
SQLRETURN WINAPI SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLUINTEGER Value)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSTMTOPTION].func)
(StatementHandle, Option, Value);
}
/*************************************************************************
* SQLSpecialColumns [ODBC32.052]
*/
SQLRETURN WINAPI SQLSpecialColumns(SQLHSTMT StatementHandle,
SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
SQLSMALLINT NameLength2, SQLCHAR *TableName,
SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
SQLUSMALLINT Nullable)
{
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSPECIALCOLUMNS].func)
(StatementHandle, IdentifierType, CatalogName, NameLength1, SchemaName,
NameLength2, TableName, NameLength3, Scope, Nullable);
}
/*************************************************************************
* SQLStatistics [ODBC32.053]
*/
SQLRETURN WINAPI SQLStatistics(SQLHSTMT StatementHandle,
SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
SQLCHAR *TableName, SQLSMALLINT NameLength3,
SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSTATISTICS].func)
(StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
TableName, NameLength3, Unique, Reserved);
}
/*************************************************************************
* SQLTables [ODBC32.054]
*/
SQLRETURN WINAPI SQLTables(SQLHSTMT StatementHandle,
SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
SQLCHAR *TableName, SQLSMALLINT NameLength3,
SQLCHAR *TableType, SQLSMALLINT NameLength4)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLES].func)
(StatementHandle, CatalogName, NameLength1,
SchemaName, NameLength2, TableName, NameLength3, TableType, NameLength4);
}
/*************************************************************************
* SQLTransact [ODBC32.023]
*/
SQLRETURN WINAPI SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle,
SQLUSMALLINT CompletionType)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLTRANSACT].func)
(EnvironmentHandle, ConnectionHandle, CompletionType);
}
/*************************************************************************
* SQLBrowseConnect [ODBC32.055]
*/
SQLRETURN WINAPI SQLBrowseConnect(
SQLHDBC hdbc,
SQLCHAR *szConnStrIn,
SQLSMALLINT cbConnStrIn,
SQLCHAR *szConnStrOut,
SQLSMALLINT cbConnStrOutMax,
SQLSMALLINT *pcbConnStrOut)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLBROWSECONNECT].func)
(hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
}
/*************************************************************************
* SQLBulkOperations [ODBC32.078]
*/
SQLRETURN WINAPI SQLBulkOperations(
SQLHSTMT StatementHandle,
SQLSMALLINT Operation)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLBULKOPERATIONS].func)
(StatementHandle, Operation);
}
/*************************************************************************
* SQLColAttributes [ODBC32.006]
*/
SQLRETURN WINAPI SQLColAttributes(
SQLHSTMT hstmt,
SQLUSMALLINT icol,
SQLUSMALLINT fDescType,
SQLPOINTER rgbDesc,
SQLSMALLINT cbDescMax,
SQLSMALLINT *pcbDesc,
SQLINTEGER *pfDesc)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLATTRIBUTES].func)
(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
}
/*************************************************************************
* SQLColumnPrivileges [ODBC32.056]
*/
SQLRETURN WINAPI SQLColumnPrivileges(
SQLHSTMT hstmt,
SQLCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLCHAR *szTableName,
SQLSMALLINT cbTableName,
SQLCHAR *szColumnName,
SQLSMALLINT cbColumnName)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLCOLUMNPRIVILEGES].func)
(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
szTableName, cbTableName, szColumnName, cbColumnName);
}
/*************************************************************************
* SQLDescribeParam [ODBC32.058]
*/
SQLRETURN WINAPI SQLDescribeParam(
SQLHSTMT hstmt,
SQLUSMALLINT ipar,
SQLSMALLINT *pfSqlType,
SQLUINTEGER *pcbParamDef,
SQLSMALLINT *pibScale,
SQLSMALLINT *pfNullable)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLDESCRIBEPARAM].func)
(hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
}
/*************************************************************************
* SQLExtendedFetch [ODBC32.059]
*/
SQLRETURN WINAPI SQLExtendedFetch(
SQLHSTMT hstmt,
SQLUSMALLINT fFetchType,
SQLINTEGER irow,
SQLUINTEGER *pcrow,
SQLUSMALLINT *rgfRowStatus)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLEXTENDEDFETCH].func)
(hstmt, fFetchType, irow, pcrow, rgfRowStatus);
}
/*************************************************************************
* SQLForeignKeys [ODBC32.060]
*/
SQLRETURN WINAPI 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)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLFOREIGNKEYS].func)
(hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName, cbPkSchemaName,
szPkTableName, cbPkTableName, szFkCatalogName, cbFkCatalogName, szFkSchemaName,
cbFkSchemaName, szFkTableName, cbFkTableName);
}
/*************************************************************************
* SQLMoreResults [ODBC32.061]
*/
SQLRETURN WINAPI SQLMoreResults(SQLHSTMT hstmt)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLMORERESULTS].func) (hstmt);
}
/*************************************************************************
* SQLNativeSql [ODBC32.062]
*/
SQLRETURN WINAPI SQLNativeSql(
SQLHDBC hdbc,
SQLCHAR *szSqlStrIn,
SQLINTEGER cbSqlStrIn,
SQLCHAR *szSqlStr,
SQLINTEGER cbSqlStrMax,
SQLINTEGER *pcbSqlStr)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLNATIVESQL].func)
(hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
}
/*************************************************************************
* SQLNumParams [ODBC32.063]
*/
SQLRETURN WINAPI SQLNumParams(
SQLHSTMT hstmt,
SQLSMALLINT *pcpar)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLNUMPARAMS].func) (hstmt, pcpar);
}
/*************************************************************************
* SQLParamOptions [ODBC32.064]
*/
SQLRETURN WINAPI SQLParamOptions(
SQLHSTMT hstmt,
SQLUINTEGER crow,
SQLUINTEGER *pirow)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPARAMOPTIONS].func) (hstmt, crow, pirow);
}
/*************************************************************************
* SQLPrimaryKeys [ODBC32.065]
*/
SQLRETURN WINAPI SQLPrimaryKeys(
SQLHSTMT hstmt,
SQLCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLCHAR *szTableName,
SQLSMALLINT cbTableName)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPRIMARYKEYS].func)
(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
szTableName, cbTableName);
}
/*************************************************************************
* SQLProcedureColumns [ODBC32.066]
*/
SQLRETURN WINAPI SQLProcedureColumns(
SQLHSTMT hstmt,
SQLCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLCHAR *szProcName,
SQLSMALLINT cbProcName,
SQLCHAR *szColumnName,
SQLSMALLINT cbColumnName)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURECOLUMNS].func)
(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
szProcName, cbProcName, szColumnName, cbColumnName);
}
/*************************************************************************
* SQLProcedures [ODBC32.067]
*/
SQLRETURN WINAPI SQLProcedures(
SQLHSTMT hstmt,
SQLCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLCHAR *szProcName,
SQLSMALLINT cbProcName)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLPROCEDURES].func)
(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
szProcName, cbProcName);
}
/*************************************************************************
* SQLSetPos [ODBC32.068]
*/
SQLRETURN WINAPI SQLSetPos(
SQLHSTMT hstmt,
SQLUSMALLINT irow,
SQLUSMALLINT fOption,
SQLUSMALLINT fLock)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETPOS].func)
(hstmt, irow, fOption, fLock);
}
/*************************************************************************
* SQLTablePrivileges [ODBC32.070]
*/
SQLRETURN WINAPI SQLTablePrivileges(
SQLHSTMT hstmt,
SQLCHAR *szCatalogName,
SQLSMALLINT cbCatalogName,
SQLCHAR *szSchemaName,
SQLSMALLINT cbSchemaName,
SQLCHAR *szTableName,
SQLSMALLINT cbTableName)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLTABLEPRIVILEGES].func)
(hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName,
szTableName, cbTableName);
}
/*************************************************************************
* SQLDrivers [ODBC32.071]
*/
SQLRETURN WINAPI SQLDrivers(
SQLHENV henv,
SQLUSMALLINT fDirection,
SQLCHAR *szDriverDesc,
SQLSMALLINT cbDriverDescMax,
SQLSMALLINT *pcbDriverDesc,
SQLCHAR *szDriverAttributes,
SQLSMALLINT cbDriverAttrMax,
SQLSMALLINT *pcbDriverAttr)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERS].func)
(henv, fDirection, szDriverDesc, cbDriverDescMax, pcbDriverDesc,
szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
}
/*************************************************************************
* SQLBindParameter [ODBC32.072]
*/
SQLRETURN WINAPI SQLBindParameter(
SQLHSTMT hstmt,
SQLUSMALLINT ipar,
SQLSMALLINT fParamType,
SQLSMALLINT fCType,
SQLSMALLINT fSqlType,
SQLUINTEGER cbColDef,
SQLSMALLINT ibScale,
SQLPOINTER rgbValue,
SQLINTEGER cbValueMax,
SQLINTEGER *pcbValue)
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLBINDPARAMETER].func)
(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale,
rgbValue, cbValueMax, pcbValue);
}
/*************************************************************************
* SQLDriverConnect [ODBC32.041]
*/
SQLRETURN WINAPI SQLDriverConnect(
SQLHDBC hdbc,
SQLHWND hwnd,
SQLCHAR *conn_str_in,
SQLSMALLINT len_conn_str_in,
SQLCHAR *conn_str_out,
SQLSMALLINT conn_str_out_max,
SQLSMALLINT *ptr_conn_str_out,
SQLUSMALLINT driver_completion )
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLDRIVERCONNECT].func)
(hdbc, hwnd, conn_str_in, len_conn_str_in, conn_str_out,
conn_str_out_max, ptr_conn_str_out, driver_completion);
}
/*************************************************************************
* SQLSetScrollOptions [ODBC32.069]
*/
SQLRETURN WINAPI SQLSetScrollOptions(
SQLHSTMT statement_handle,
SQLUSMALLINT f_concurrency,
SQLINTEGER crow_keyset,
SQLUSMALLINT crow_rowset )
{
TRACE("\n");
CHECK_dmHandle();
assert (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func);
return (gProxyHandle.functions[SQLAPI_INDEX_SQLSETSCROLLOPTIONS].func)
(statement_handle, f_concurrency, crow_keyset, crow_rowset);
}
/* End of file */
Reference in New Issue View Git Blame Copy Permalink