dlls/odbc32/proxyodbc.c

   1 /*
   2  * Win32 ODBC functions
   3  *
   4  * Copyright 1999 Xiang Li, Corel Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * NOTES:
  21  *   Proxy ODBC driver manager.  This manager delegates all ODBC
  22  *   calls to a real ODBC driver manager named by the environment
  23  *   variable LIB_ODBC_DRIVER_MANAGER, or to libodbc.so if the
  24  *   variable is not set.
  25  *
  26  */
  27
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <assert.h>
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winternl.h"
  37 #include "winreg.h"
  38 #include "wine/debug.h"
  39
  40 #include "sql.h"
  41 #include "sqltypes.h"
  42 #include "sqlext.h"
  43 #include "unixlib.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(odbc);
  46 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  47
  48 static unixlib_handle_t odbc_handle;
  49
  50 #define ODBC_CALL( func, params ) __wine_unix_call( odbc_handle, unix_ ## func, params )
  51
  52 /***********************************************************************
  53  * ODBC_ReplicateODBCInstToRegistry
  54  *
  55  * PARAMS
  56  *
  57  * RETURNS
  58  *
  59  * Utility to ODBC_ReplicateToRegistry to replicate the drivers of the
  60  * ODBCINST.INI settings
  61  *
  62  * The driver settings are not replicated to the registry.  If we were to
  63  * replicate them we would need to decide whether to replicate all settings
  64  * or to do some translation; whether to remove any entries present only in
  65  * the windows registry, etc.
  66  */
  67
  68 static void ODBC_ReplicateODBCInstToRegistry (SQLHENV hEnv)
  69 {
  70     HKEY hODBCInst;
  71     LONG reg_ret;
  72     BOOL success;
  73
  74     success = FALSE;
  75     TRACE ("Driver settings are not currently replicated to the registry\n");
  76     if ((reg_ret = RegCreateKeyExA (HKEY_LOCAL_MACHINE,
  77             "Software\\ODBC\\ODBCINST.INI", 0, NULL,
  78             REG_OPTION_NON_VOLATILE,
  79             KEY_ALL_ACCESS /* a couple more than we need */, NULL,
  80             &hODBCInst, NULL)) == ERROR_SUCCESS)
  81     {
  82         HKEY hDrivers;
  83         if ((reg_ret = RegCreateKeyExA (hODBCInst, "ODBC Drivers", 0,
  84                 NULL, REG_OPTION_NON_VOLATILE,
  85                 KEY_ALL_ACCESS /* overkill */, NULL, &hDrivers, NULL))
  86                 == ERROR_SUCCESS)
  87         {
  88             SQLRETURN sql_ret;
  89             SQLUSMALLINT dirn;
  90             CHAR desc [256];
  91             SQLSMALLINT sizedesc;
  92
  93             success = TRUE;
  94             dirn = SQL_FETCH_FIRST;
  95             while ((sql_ret = SQLDrivers (hEnv, dirn, (SQLCHAR*)desc, sizeof(desc),
  96                     &sizedesc, NULL, 0, NULL)) == SQL_SUCCESS ||
  97                     sql_ret == SQL_SUCCESS_WITH_INFO)
  98             {
  99                 /* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
 100                 dirn = SQL_FETCH_NEXT;
 101                 if (sizedesc == lstrlenA(desc))
 102                 {
 103                     HKEY hThis;
 104                     if ((reg_ret = RegQueryValueExA (hDrivers, desc, NULL,
 105                             NULL, NULL, NULL)) == ERROR_FILE_NOT_FOUND)
 106                     {
 107                         if ((reg_ret = RegSetValueExA (hDrivers, desc, 0,
 108                                 REG_SZ, (const BYTE *)"Installed", 10)) != ERROR_SUCCESS)
 109                         {
 110                             TRACE ("Error %d replicating driver %s\n",
 111                                     reg_ret, desc);
 112                             success = FALSE;
 113                         }
 114                     }
 115                     else if (reg_ret != ERROR_SUCCESS)
 116                     {
 117                         TRACE ("Error %d checking for %s in drivers\n",
 118                                 reg_ret, desc);
 119                         success = FALSE;
 120                     }
 121                     if ((reg_ret = RegCreateKeyExA (hODBCInst, desc, 0,
 122                             NULL, REG_OPTION_NON_VOLATILE,
 123                             KEY_ALL_ACCESS, NULL, &hThis, NULL))
 124                             == ERROR_SUCCESS)
 125                     {
 126                         /* FIXME This is where the settings go.
 127                          * I suggest that if the disposition says it
 128                          * exists then we leave it alone.  Alternatively
 129                          * include an extra value to flag that it is
 130                          * a replication of the unixODBC/iODBC/...
 131                          */
 132                         if ((reg_ret = RegCloseKey (hThis)) !=
 133                                 ERROR_SUCCESS)
 134                             TRACE ("Error %d closing %s key\n", reg_ret,
 135                                     desc);
 136                     }
 137                     else
 138                     {
 139                         TRACE ("Error %d ensuring driver key %s\n",
 140                                 reg_ret, desc);
 141                         success = FALSE;
 142                     }
 143                 }
 144                 else
 145                 {
 146                     WARN ("Unusually long driver name %s not replicated\n",
 147                             desc);
 148                     success = FALSE;
 149                 }
 150             }
 151             if (sql_ret != SQL_NO_DATA)
 152             {
 153                 TRACE ("Error %d enumerating drivers\n", (int)sql_ret);
 154                 success = FALSE;
 155             }
 156             if ((reg_ret = RegCloseKey (hDrivers)) != ERROR_SUCCESS)
 157             {
 158                 TRACE ("Error %d closing hDrivers\n", reg_ret);
 159             }
 160         }
 161         else
 162         {
 163             TRACE ("Error %d opening HKLM\\S\\O\\OI\\Drivers\n", reg_ret);
 164         }
 165         if ((reg_ret = RegCloseKey (hODBCInst)) != ERROR_SUCCESS)
 166         {
 167             TRACE ("Error %d closing HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
 168         }
 169     }
 170     else
 171     {
 172         TRACE ("Error %d opening HKLM\\S\\O\\ODBCINST.INI\n", reg_ret);
 173     }
 174     if (!success)
 175     {
 176         WARN ("May not have replicated all ODBC drivers to the registry\n");
 177     }
 178 }
 179
 180 /***********************************************************************
 181  * ODBC_ReplicateODBCToRegistry
 182  *
 183  * PARAMS
 184  *
 185  * RETURNS
 186  *
 187  * Utility to ODBC_ReplicateToRegistry to replicate either the USER or
 188  * SYSTEM dsns
 189  *
 190  * For now simply place the "Driver description" (as returned by SQLDataSources)
 191  * into the registry as the driver.  This is enough to satisfy Crystal's
 192  * requirement that there be a driver entry.  (It doesn't seem to care what
 193  * the setting is).
 194  * A slightly more accurate setting would be to access the registry to find
 195  * the actual driver library for the given description (which appears to map
 196  * to one of the HKLM/Software/ODBC/ODBCINST.INI keys).  (If you do this note
 197  * that this will add a requirement that this function be called after
 198  * ODBC_ReplicateODBCInstToRegistry)
 199  */
 200 static void ODBC_ReplicateODBCToRegistry (BOOL is_user, SQLHENV hEnv)
 201 {
 202     HKEY hODBC;
 203     LONG reg_ret;
 204     SQLRETURN sql_ret;
 205     SQLUSMALLINT dirn;
 206     CHAR dsn [SQL_MAX_DSN_LENGTH + 1];
 207     SQLSMALLINT sizedsn;
 208     CHAR desc [256];
 209     SQLSMALLINT sizedesc;
 210     BOOL success;
 211     const char *which = is_user ? "user" : "system";
 212
 213     success = FALSE;
 214     if ((reg_ret = RegCreateKeyExA (
 215             is_user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
 216             "Software\\ODBC\\ODBC.INI", 0, NULL, REG_OPTION_NON_VOLATILE,
 217             KEY_ALL_ACCESS /* a couple more than we need */, NULL, &hODBC,
 218             NULL)) == ERROR_SUCCESS)
 219     {
 220         success = TRUE;
 221         dirn = is_user ? SQL_FETCH_FIRST_USER : SQL_FETCH_FIRST_SYSTEM;
 222         while ((sql_ret = SQLDataSources (hEnv, dirn,
 223                 (SQLCHAR*)dsn, sizeof(dsn), &sizedsn,
 224                 (SQLCHAR*)desc, sizeof(desc), &sizedesc)) == SQL_SUCCESS
 225                 || sql_ret == SQL_SUCCESS_WITH_INFO)
 226         {
 227             /* FIXME Do some proper handling of the SUCCESS_WITH_INFO */
 228             dirn = SQL_FETCH_NEXT;
 229             if (sizedsn == lstrlenA(dsn) && sizedesc == lstrlenA(desc))
 230             {
 231                 HKEY hDSN;
 232                 if ((reg_ret = RegCreateKeyExA (hODBC, dsn, 0,
 233                         NULL, REG_OPTION_NON_VOLATILE,
 234                         KEY_ALL_ACCESS, NULL, &hDSN, NULL))
 235                         == ERROR_SUCCESS)
 236                 {
 237                     static const char DRIVERKEY[] = "Driver";
 238                     if ((reg_ret = RegQueryValueExA (hDSN, DRIVERKEY,
 239                             NULL, NULL, NULL, NULL))
 240                             == ERROR_FILE_NOT_FOUND)
 241                     {
 242                         if ((reg_ret = RegSetValueExA (hDSN, DRIVERKEY, 0,
 243                                 REG_SZ, (LPBYTE)desc, sizedesc)) != ERROR_SUCCESS)
 244                         {
 245                             TRACE ("Error %d replicating description of "
 246                                     "%s(%s)\n", reg_ret, dsn, desc);
 247                             success = FALSE;
 248                         }
 249                     }
 250                     else if (reg_ret != ERROR_SUCCESS)
 251                     {
 252                         TRACE ("Error %d checking for description of %s\n",
 253                                 reg_ret, dsn);
 254                         success = FALSE;
 255                     }
 256                     if ((reg_ret = RegCloseKey (hDSN)) != ERROR_SUCCESS)
 257                     {
 258                         TRACE ("Error %d closing %s DSN key %s\n",
 259                                 reg_ret, which, dsn);
 260                     }
 261                 }
 262                 else
 263                 {
 264                     TRACE ("Error %d opening %s DSN key %s\n",
 265                             reg_ret, which, dsn);
 266                     success = FALSE;
 267                 }
 268             }
 269             else
 270             {
 271                 WARN ("Unusually long %s data source name %s (%s) not "
 272                         "replicated\n", which, dsn, desc);
 273                 success = FALSE;
 274             }
 275         }
 276         if (sql_ret != SQL_NO_DATA)
 277         {
 278             TRACE ("Error %d enumerating %s datasources\n",
 279                     (int)sql_ret, which);
 280             success = FALSE;
 281         }
 282         if ((reg_ret = RegCloseKey (hODBC)) != ERROR_SUCCESS)
 283         {
 284             TRACE ("Error %d closing %s ODBC.INI registry key\n", reg_ret,
 285                     which);
 286         }
 287     }
 288     else
 289     {
 290         TRACE ("Error %d creating/opening %s ODBC.INI registry key\n",
 291                 reg_ret, which);
 292     }
 293     if (!success)
 294     {
 295         WARN ("May not have replicated all %s ODBC DSNs to the registry\n",
 296                 which);
 297     }
 298 }
 299
 300 /***********************************************************************
 301  * ODBC_ReplicateToRegistry
 302  *
 303  * PARAMS
 304  *
 305  * RETURNS
 306  *
 307  * Unfortunately some of the functions that Windows documents as being part
 308  * of the ODBC API it implements directly during compilation or something
 309  * in terms of registry access functions.
 310  * e.g. SQLGetInstalledDrivers queries the list at
 311  * HKEY_LOCAL_MACHINE\Software\ODBC\ODBCINST.INI\ODBC Drivers
 312  *
 313  * This function is called when the driver manager is loaded and is used
 314  * to replicate the appropriate details into the Wine registry
 315  */
 316
 317 static void ODBC_ReplicateToRegistry (void)
 318 {
 319     SQLRETURN sql_ret;
 320     SQLHENV hEnv;
 321
 322     if ((sql_ret = SQLAllocEnv(&hEnv)) == SQL_SUCCESS)
 323     {
 324         ODBC_ReplicateODBCInstToRegistry (hEnv);
 325         ODBC_ReplicateODBCToRegistry (FALSE /* system dsns */, hEnv);
 326         ODBC_ReplicateODBCToRegistry (TRUE /* user dsns */, hEnv);
 327
 328         if ((sql_ret = SQLFreeEnv(hEnv)) != SQL_SUCCESS)
 329         {
 330             TRACE ("Error %d freeing the SQL environment.\n", (int)sql_ret);
 331         }
 332     }
 333     else
 334     {
 335         TRACE ("Error %d opening an SQL environment.\n", (int)sql_ret);
 336         WARN ("The external ODBC settings have not been replicated to the"
 337                 " Wine registry\n");
 338     }
 339 }
 340
 341 /*************************************************************************
 342  *                              SQLAllocConnect           [ODBC32.001]
 343  */
 344 SQLRETURN WINAPI SQLAllocConnect(SQLHENV EnvironmentHandle, SQLHDBC *ConnectionHandle)
 345 {
 346     struct SQLAllocConnect_params params = { EnvironmentHandle, ConnectionHandle };
 347     SQLRETURN ret;
 348
 349     TRACE("(EnvironmentHandle %p, ConnectionHandle %p)\n", EnvironmentHandle, ConnectionHandle);
 350
 351     *ConnectionHandle = SQL_NULL_HDBC;
 352     ret = ODBC_CALL( SQLAllocConnect, &params );
 353     TRACE("Returning %d, ConnectionHandle %p\n", ret, *ConnectionHandle);
 354     return ret;
 355 }
 356
 357 /*************************************************************************
 358  *                              SQLAllocEnv           [ODBC32.002]
 359  */
 360 SQLRETURN WINAPI SQLAllocEnv(SQLHENV *EnvironmentHandle)
 361 {
 362     struct SQLAllocEnv_params params = { EnvironmentHandle };
 363     SQLRETURN ret;
 364
 365     TRACE("(EnvironmentHandle %p)\n", EnvironmentHandle);
 366
 367     *EnvironmentHandle = SQL_NULL_HENV;
 368     ret = ODBC_CALL( SQLAllocEnv, &params );
 369     TRACE("Returning %d, EnvironmentHandle %p\n", ret, *EnvironmentHandle);
 370     return ret;
 371 }
 372
 373 /*************************************************************************
 374  *                              SQLAllocHandle           [ODBC32.024]
 375  */
 376 SQLRETURN WINAPI SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 377 {
 378     struct SQLAllocHandle_params params = { HandleType, InputHandle, OutputHandle };
 379     SQLRETURN ret;
 380
 381     TRACE("(HandleType %d, InputHandle %p, OutputHandle %p)\n", HandleType, InputHandle, OutputHandle);
 382
 383     *OutputHandle = 0;
 384     ret = ODBC_CALL( SQLAllocHandle, &params );
 385     TRACE("Returning %d, Handle %p\n", ret, *OutputHandle);
 386     return ret;
 387 }
 388
 389 /*************************************************************************
 390  *                              SQLAllocStmt           [ODBC32.003]
 391  */
 392 SQLRETURN WINAPI SQLAllocStmt(SQLHDBC ConnectionHandle, SQLHSTMT *StatementHandle)
 393 {
 394     struct SQLAllocStmt_params params = { ConnectionHandle, StatementHandle };
 395     SQLRETURN ret;
 396
 397     TRACE("(ConnectionHandle %p, StatementHandle %p)\n", ConnectionHandle, StatementHandle);
 398
 399     *StatementHandle = SQL_NULL_HSTMT;
 400     ret = ODBC_CALL( SQLAllocStmt, &params );
 401     TRACE ("Returning %d, StatementHandle %p\n", ret, *StatementHandle);
 402     return ret;
 403 }
 404
 405 /*************************************************************************
 406  *                              SQLAllocHandleStd           [ODBC32.077]
 407  */
 408 SQLRETURN WINAPI SQLAllocHandleStd(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE *OutputHandle)
 409 {
 410     struct SQLAllocHandleStd_params params = { HandleType, InputHandle, OutputHandle };
 411     SQLRETURN ret;
 412
 413     TRACE("(HandleType %d, InputHandle %p, OutputHandle %p)\n", HandleType, InputHandle, OutputHandle);
 414
 415     *OutputHandle = 0;
 416     ret = ODBC_CALL( SQLAllocHandleStd, &params );
 417     TRACE ("Returning %d, OutputHandle %p\n", ret, *OutputHandle);
 418     return ret;
 419 }
 420
 421 static const char *debugstr_sqllen( SQLLEN len )
 422 {
 423 #ifdef _WIN64
 424     return wine_dbg_sprintf( "%ld", len );
 425 #else
 426     return wine_dbg_sprintf( "%d", len );
 427 #endif
 428 }
 429
 430 /*************************************************************************
 431  *                              SQLBindCol           [ODBC32.004]
 432  */
 433 SQLRETURN WINAPI SQLBindCol(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 434                             SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrLen_or_Ind)
 435 {
 436     struct SQLBindCol_params params = { StatementHandle, ColumnNumber, TargetType, TargetValue,
 437                                         BufferLength, StrLen_or_Ind };
 438     SQLRETURN ret;
 439
 440     TRACE("(StatementHandle %p, ColumnNumber %d, TargetType %d, TargetValue %p, BufferLength %s, StrLen_or_Ind %p)\n",
 441           StatementHandle, ColumnNumber, TargetType, TargetValue, debugstr_sqllen(BufferLength), StrLen_or_Ind);
 442
 443     ret = ODBC_CALL( SQLBindCol, &params );
 444     TRACE ("Returning %d\n", ret);
 445     return ret;
 446 }
 447
 448 static const char *debugstr_sqlulen( SQLULEN len )
 449 {
 450 #ifdef _WIN64
 451     return wine_dbg_sprintf( "%lu", len );
 452 #else
 453     return wine_dbg_sprintf( "%u", len );
 454 #endif
 455 }
 456
 457 /*************************************************************************
 458  *                              SQLBindParam           [ODBC32.025]
 459  */
 460 SQLRETURN WINAPI SQLBindParam(SQLHSTMT StatementHandle, SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
 461                               SQLSMALLINT ParameterType, SQLULEN LengthPrecision, SQLSMALLINT ParameterScale,
 462                               SQLPOINTER ParameterValue, SQLLEN *StrLen_or_Ind)
 463 {
 464     struct SQLBindParam_params params = { StatementHandle, ParameterNumber, ValueType, ParameterType,
 465                                           LengthPrecision, ParameterScale, ParameterValue, StrLen_or_Ind };
 466     SQLRETURN ret;
 467
 468     TRACE("(StatementHandle %p, ParameterNumber %d, ValueType %d, ParameterType %d, LengthPrecision %s,"
 469           " ParameterScale %d, ParameterValue %p, StrLen_or_Ind %p)\n", StatementHandle, ParameterNumber, ValueType,
 470           ParameterType, debugstr_sqlulen(LengthPrecision), ParameterScale, ParameterValue, StrLen_or_Ind);
 471
 472     ret = ODBC_CALL( SQLBindParam, &params );
 473     TRACE ("Returning %d\n", ret);
 474     return ret;
 475 }
 476
 477 /*************************************************************************
 478  *                              SQLCancel           [ODBC32.005]
 479  */
 480 SQLRETURN WINAPI SQLCancel(SQLHSTMT StatementHandle)
 481 {
 482     struct SQLCancel_params params = { StatementHandle };
 483     SQLRETURN ret;
 484
 485     TRACE("(StatementHandle %p)\n", StatementHandle);
 486
 487     ret = ODBC_CALL( SQLCancel, &params );
 488     TRACE("Returning %d\n", ret);
 489     return ret;
 490 }
 491
 492 /*************************************************************************
 493  *                              SQLCloseCursor           [ODBC32.026]
 494  */
 495 SQLRETURN WINAPI SQLCloseCursor(SQLHSTMT StatementHandle)
 496 {
 497     struct SQLCloseCursor_params params = { StatementHandle };
 498     SQLRETURN ret;
 499
 500     TRACE("(StatementHandle %p)\n", StatementHandle);
 501
 502     ret = ODBC_CALL( SQLCloseCursor, &params );
 503     TRACE("Returning %d\n", ret);
 504     return ret;
 505 }
 506
 507 /*************************************************************************
 508  *                              SQLColAttribute           [ODBC32.027]
 509  */
 510 SQLRETURN WINAPI SQLColAttribute(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber,
 511                                  SQLUSMALLINT FieldIdentifier, SQLPOINTER CharacterAttribute,
 512                                  SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
 513                                  SQLLEN *NumericAttribute)
 514 {
 515     struct SQLColAttribute_params params = { StatementHandle, ColumnNumber, FieldIdentifier,
 516                                              CharacterAttribute, BufferLength, StringLength, NumericAttribute };
 517     SQLRETURN ret;
 518
 519     TRACE("(StatementHandle %p, ColumnNumber %d, FieldIdentifier %d, CharacterAttribute %p, BufferLength %d,"
 520           " StringLength %p, NumericAttribute %p)\n", StatementHandle, ColumnNumber, FieldIdentifier,
 521           CharacterAttribute, BufferLength, StringLength, NumericAttribute);
 522
 523     ret = ODBC_CALL( SQLColAttribute, &params );
 524     TRACE("Returning %d\n", ret);
 525     return ret;
 526 }
 527
 528 /*************************************************************************
 529  *                              SQLColumns           [ODBC32.040]
 530  */
 531 SQLRETURN WINAPI SQLColumns(SQLHSTMT StatementHandle, SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
 532                             SQLCHAR *SchemaName, SQLSMALLINT NameLength2, SQLCHAR *TableName,
 533                             SQLSMALLINT NameLength3, SQLCHAR *ColumnName, SQLSMALLINT NameLength4)
 534 {
 535     struct SQLColumns_params params = { StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
 536                                         TableName, NameLength3, ColumnName, NameLength4 };
 537     SQLRETURN ret;
 538
 539     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d, TableName %s,"
 540           " NameLength3 %d, ColumnName %s, NameLength4 %d)\n", StatementHandle,
 541           debugstr_an((const char *)CatalogName, NameLength1), NameLength1,
 542           debugstr_an((const char *)SchemaName, NameLength2), NameLength2,
 543           debugstr_an((const char *)TableName, NameLength3), NameLength3,
 544           debugstr_an((const char *)ColumnName, NameLength4), NameLength4);
 545
 546     ret = ODBC_CALL( SQLColumns, &params );
 547     TRACE("Returning %d\n", ret);
 548     return ret;
 549 }
 550
 551 /*************************************************************************
 552  *                              SQLConnect           [ODBC32.007]
 553  */
 554 SQLRETURN WINAPI SQLConnect(SQLHDBC ConnectionHandle, SQLCHAR *ServerName, SQLSMALLINT NameLength1,
 555                             SQLCHAR *UserName, SQLSMALLINT NameLength2, SQLCHAR *Authentication,
 556                             SQLSMALLINT NameLength3)
 557 {
 558     struct SQLConnect_params params = { ConnectionHandle, ServerName, NameLength1, UserName, NameLength2,
 559                                         Authentication, NameLength3 };
 560     SQLRETURN ret;
 561
 562     TRACE("(ConnectionHandle %p, ServerName %s, NameLength1 %d, UserName %s, NameLength2 %d, Authentication %s,"
 563           " NameLength3 %d)\n", ConnectionHandle,
 564           debugstr_an((const char *)ServerName, NameLength1), NameLength1,
 565           debugstr_an((const char *)UserName, NameLength2), NameLength2,
 566           debugstr_an((const char *)Authentication, NameLength3), NameLength3);
 567
 568     ret = ODBC_CALL( SQLConnect, &params );
 569     TRACE("Returning %d\n", ret);
 570     return ret;
 571 }
 572
 573 /*************************************************************************
 574  *                              SQLCopyDesc           [ODBC32.028]
 575  */
 576 SQLRETURN WINAPI SQLCopyDesc(SQLHDESC SourceDescHandle, SQLHDESC TargetDescHandle)
 577 {
 578     struct SQLCopyDesc_params params = { SourceDescHandle, TargetDescHandle };
 579     SQLRETURN ret;
 580
 581     TRACE("(SourceDescHandle %p, TargetDescHandle %p)\n", SourceDescHandle, TargetDescHandle);
 582
 583     ret = ODBC_CALL( SQLCopyDesc, &params );
 584     TRACE("Returning %d\n", ret);
 585     return ret;
 586 }
 587
 588 /*************************************************************************
 589  *                              SQLDataSources           [ODBC32.057]
 590  */
 591 SQLRETURN WINAPI SQLDataSources(SQLHENV EnvironmentHandle, SQLUSMALLINT Direction, SQLCHAR *ServerName,
 592                                 SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1, SQLCHAR *Description,
 593                                 SQLSMALLINT BufferLength2, SQLSMALLINT *NameLength2)
 594 {
 595     struct SQLDataSources_params params = { EnvironmentHandle, Direction, ServerName, BufferLength1,
 596                                             NameLength1, Description, BufferLength2, NameLength2 };
 597     SQLRETURN ret;
 598
 599     TRACE("(EnvironmentHandle %p, Direction %d, ServerName %p, BufferLength1 %d, NameLength1 %p, Description %p,"
 600           " BufferLength2 %d, NameLength2 %p)\n", EnvironmentHandle, Direction, ServerName, BufferLength1,
 601           NameLength1, Description, BufferLength2, NameLength2);
 602
 603     ret = ODBC_CALL( SQLDataSources, &params );
 604     if (ret >= 0 && TRACE_ON(odbc))
 605     {
 606         if (ServerName && NameLength1 && *NameLength1 > 0)
 607             TRACE(" DataSource %s", debugstr_an((const char *)ServerName, *NameLength1));
 608         if (Description && NameLength2 && *NameLength2 > 0)
 609             TRACE(" Description %s", debugstr_an((const char *)Description, *NameLength2));
 610         TRACE("\n");
 611     }
 612
 613     TRACE("Returning %d\n", ret);
 614     return ret;
 615 }
 616
 617 SQLRETURN WINAPI SQLDataSourcesA(SQLHENV EnvironmentHandle, SQLUSMALLINT Direction, SQLCHAR *ServerName,
 618                                  SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1, SQLCHAR *Description,
 619                                  SQLSMALLINT BufferLength2, SQLSMALLINT *NameLength2)
 620 {
 621     struct SQLDataSourcesA_params params = { EnvironmentHandle, Direction, ServerName, BufferLength1,
 622                                              NameLength1, Description, BufferLength2, NameLength2 };
 623     SQLRETURN ret;
 624
 625     TRACE("(EnvironmentHandle %p, Direction %d, ServerName %p, BufferLength1 %d, NameLength1 %p, Description %p,"
 626           " BufferLength2 %d, NameLength2 %p)\n", EnvironmentHandle, Direction, ServerName, BufferLength1,
 627           NameLength1, Description, BufferLength2, NameLength2);
 628
 629     ret = ODBC_CALL( SQLDataSourcesA, &params );
 630     if (TRACE_ON(odbc))
 631     {
 632        if (ServerName && NameLength1 && *NameLength1 > 0)
 633             TRACE(" DataSource %s", debugstr_an((const char *)ServerName, *NameLength1));
 634        if (Description && NameLength2 && *NameLength2 > 0)
 635             TRACE(" Description %s", debugstr_an((const char *)Description, *NameLength2));
 636        TRACE("\n");
 637     }
 638
 639     TRACE("Returning %d\n", ret);
 640     return ret;
 641 }
 642
 643 /*************************************************************************
 644  *                              SQLDescribeCol           [ODBC32.008]
 645  */
 646 SQLRETURN WINAPI SQLDescribeCol(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLCHAR *ColumnName,
 647                                 SQLSMALLINT BufferLength, SQLSMALLINT *NameLength, SQLSMALLINT *DataType,
 648                                 SQLULEN *ColumnSize, SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
 649 {
 650     struct SQLDescribeCol_params params = { StatementHandle, ColumnNumber, ColumnName, BufferLength,
 651                                             NameLength, DataType, ColumnSize, DecimalDigits, Nullable };
 652     SQLSMALLINT dummy;
 653     SQLRETURN ret;
 654
 655     TRACE("(StatementHandle %p, ColumnNumber %d, ColumnName %p, BufferLength %d, NameLength %p, DataType %p,"
 656           " ColumnSize %p, DecimalDigits %p, Nullable %p)\n", StatementHandle, ColumnNumber, ColumnName,
 657           BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
 658
 659     if (!params.NameLength) params.NameLength = &dummy; /* workaround for drivers that don't accept NULL NameLength */
 660
 661     ret = ODBC_CALL( SQLDescribeCol, &params );
 662     if (ret >= 0)
 663     {
 664         if (ColumnName && NameLength) TRACE(" ColumnName %s\n", debugstr_an((const char *)ColumnName, *NameLength));
 665         if (DataType) TRACE(" DataType %d\n", *DataType);
 666         if (ColumnSize) TRACE(" ColumnSize %s\n", debugstr_sqlulen(*ColumnSize));
 667         if (DecimalDigits) TRACE(" DecimalDigits %d\n", *DecimalDigits);
 668         if (Nullable) TRACE(" Nullable %d\n", *Nullable);
 669     }
 670
 671     TRACE("Returning %d\n", ret);
 672     return ret;
 673 }
 674
 675 /*************************************************************************
 676  *                              SQLDisconnect           [ODBC32.009]
 677  */
 678 SQLRETURN WINAPI SQLDisconnect(SQLHDBC ConnectionHandle)
 679 {
 680     struct SQLDisconnect_params params = { ConnectionHandle };
 681     SQLRETURN ret;
 682
 683     TRACE("(ConnectionHandle %p)\n", ConnectionHandle);
 684
 685     ret = ODBC_CALL( SQLDisconnect, &params );
 686     TRACE("Returning %d\n", ret);
 687     return ret;
 688 }
 689
 690 /*************************************************************************
 691  *                              SQLEndTran           [ODBC32.029]
 692  */
 693 SQLRETURN WINAPI SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType)
 694 {
 695     struct SQLEndTran_params params = { HandleType, Handle, CompletionType };
 696     SQLRETURN ret;
 697
 698     TRACE("(HandleType %d, Handle %p, CompletionType %d)\n", HandleType, Handle, CompletionType);
 699
 700     ret = ODBC_CALL( SQLEndTran, &params );
 701     TRACE("Returning %d\n", ret);
 702     return ret;
 703 }
 704
 705 /*************************************************************************
 706  *                              SQLError           [ODBC32.010]
 707  */
 708 SQLRETURN WINAPI SQLError(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
 709                           SQLCHAR *Sqlstate, SQLINTEGER *NativeError, SQLCHAR *MessageText,
 710                           SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
 711 {
 712     struct SQLError_params params = { EnvironmentHandle, ConnectionHandle, StatementHandle, Sqlstate,
 713                                       NativeError, MessageText, BufferLength, TextLength };
 714     SQLRETURN ret;
 715
 716     TRACE("(EnvironmentHandle %p, ConnectionHandle %p, StatementHandle %p, Sqlstate %p, NativeError %p,"
 717           " MessageText %p, BufferLength %d, TextLength %p)\n", EnvironmentHandle, ConnectionHandle,
 718           StatementHandle, Sqlstate, NativeError, MessageText, BufferLength, TextLength);
 719
 720     ret = ODBC_CALL( SQLError, &params );
 721
 722     if (ret == SQL_SUCCESS)
 723     {
 724         TRACE(" SQLState %s\n", debugstr_an((const char *)Sqlstate, 5));
 725         TRACE(" Error %d\n", *NativeError);
 726         TRACE(" MessageText %s\n", debugstr_an((const char *)MessageText, *TextLength));
 727     }
 728
 729     TRACE("Returning %d\n", ret);
 730     return ret;
 731 }
 732
 733 /*************************************************************************
 734  *                              SQLExecDirect           [ODBC32.011]
 735  */
 736 SQLRETURN WINAPI SQLExecDirect(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
 737 {
 738     struct SQLExecDirect_params params = { StatementHandle, StatementText, TextLength };
 739     SQLRETURN ret;
 740
 741     TRACE("(StatementHandle %p, StatementText %s, TextLength %d)\n", StatementHandle,
 742           debugstr_an((const char *)StatementText, TextLength), TextLength);
 743
 744     ret = ODBC_CALL( SQLExecDirect, &params );
 745     TRACE("Returning %d\n", ret);
 746     return ret;
 747 }
 748
 749 /*************************************************************************
 750  *                              SQLExecute           [ODBC32.012]
 751  */
 752 SQLRETURN WINAPI SQLExecute(SQLHSTMT StatementHandle)
 753 {
 754     struct SQLExecute_params params = { StatementHandle };
 755     SQLRETURN ret;
 756
 757     TRACE("(StatementHandle %p)\n", StatementHandle);
 758
 759     ret = ODBC_CALL( SQLExecute, &params );
 760     TRACE("Returning %d\n", ret);
 761     return ret;
 762 }
 763
 764 /*************************************************************************
 765  *                              SQLFetch           [ODBC32.013]
 766  */
 767 SQLRETURN WINAPI SQLFetch(SQLHSTMT StatementHandle)
 768 {
 769     struct SQLFetch_params params = { StatementHandle };
 770     SQLRETURN ret;
 771
 772     TRACE("(StatementHandle %p)\n", StatementHandle);
 773
 774     ret = ODBC_CALL( SQLFetch, &params );
 775     TRACE("Returning %d\n", ret);
 776     return ret;
 777 }
 778
 779 /*************************************************************************
 780  *                              SQLFetchScroll          [ODBC32.030]
 781  */
 782 SQLRETURN WINAPI SQLFetchScroll(SQLHSTMT StatementHandle, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
 783 {
 784     struct SQLFetchScroll_params params = { StatementHandle, FetchOrientation, FetchOffset };
 785     SQLRETURN ret;
 786
 787     TRACE("(StatementHandle %p, FetchOrientation %d, FetchOffset %s)\n", StatementHandle, FetchOrientation,
 788           debugstr_sqllen(FetchOffset));
 789
 790     ret = ODBC_CALL( SQLFetchScroll, &params );
 791     TRACE("Returning %d\n", ret);
 792     return ret;
 793 }
 794
 795 /*************************************************************************
 796  *                              SQLFreeConnect           [ODBC32.014]
 797  */
 798 SQLRETURN WINAPI SQLFreeConnect(SQLHDBC ConnectionHandle)
 799 {
 800     struct SQLFreeConnect_params params = { ConnectionHandle };
 801     SQLRETURN ret;
 802
 803     TRACE("(ConnectionHandle %p)\n", ConnectionHandle);
 804
 805     ret = ODBC_CALL( SQLFreeConnect, &params );
 806     TRACE("Returning %d\n", ret);
 807     return ret;
 808 }
 809
 810 /*************************************************************************
 811  *                              SQLFreeEnv           [ODBC32.015]
 812  */
 813 SQLRETURN WINAPI SQLFreeEnv(SQLHENV EnvironmentHandle)
 814 {
 815     struct SQLFreeEnv_params params = { EnvironmentHandle };
 816     SQLRETURN ret;
 817
 818     TRACE("(EnvironmentHandle %p)\n", EnvironmentHandle);
 819
 820     ret = ODBC_CALL( SQLFreeEnv, &params );
 821     TRACE("Returning %d\n", ret);
 822     return ret;
 823 }
 824
 825 /*************************************************************************
 826  *                              SQLFreeHandle           [ODBC32.031]
 827  */
 828 SQLRETURN WINAPI SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
 829 {
 830     struct SQLFreeHandle_params params = { HandleType, Handle };
 831     SQLRETURN ret;
 832
 833     TRACE("(HandleType %d, Handle %p)\n", HandleType, Handle);
 834
 835     ret = ODBC_CALL( SQLFreeHandle, &params );
 836     TRACE ("Returning %d\n", ret);
 837     return ret;
 838 }
 839
 840 /*************************************************************************
 841  *                              SQLFreeStmt           [ODBC32.016]
 842  */
 843 SQLRETURN WINAPI SQLFreeStmt(SQLHSTMT StatementHandle, SQLUSMALLINT Option)
 844 {
 845     struct SQLFreeStmt_params params = { StatementHandle, Option };
 846     SQLRETURN ret;
 847
 848     TRACE("(StatementHandle %p, Option %d)\n", StatementHandle, Option);
 849
 850     ret = ODBC_CALL( SQLFreeStmt, &params );
 851     TRACE("Returning %d\n", ret);
 852     return ret;
 853 }
 854
 855 /*************************************************************************
 856  *                              SQLGetConnectAttr           [ODBC32.032]
 857  */
 858 SQLRETURN WINAPI SQLGetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, SQLPOINTER Value,
 859                                    SQLINTEGER BufferLength, SQLINTEGER *StringLength)
 860 {
 861     struct SQLGetConnectAttr_params params = { ConnectionHandle, Attribute, Value, BufferLength, StringLength };
 862     SQLRETURN ret;
 863
 864     TRACE("(ConnectionHandle %p, Attribute %d, Value %p, BufferLength %d, StringLength %p)\n", ConnectionHandle,
 865           Attribute, Value, BufferLength, StringLength);
 866
 867     ret = ODBC_CALL( SQLGetConnectAttr, &params );
 868     TRACE("Returning %d\n", ret);
 869     return ret;
 870 }
 871
 872 /*************************************************************************
 873  *                              SQLGetConnectOption       [ODBC32.042]
 874  */
 875 SQLRETURN WINAPI SQLGetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
 876 {
 877     struct SQLGetConnectOption_params params = { ConnectionHandle, Option, Value };
 878     SQLRETURN ret;
 879
 880     TRACE("(ConnectionHandle %p, Option %d, Value %p)\n", ConnectionHandle, Option, Value);
 881
 882     ret = ODBC_CALL( SQLGetConnectOption, &params );
 883     TRACE("Returning %d\n", ret);
 884     return ret;
 885 }
 886
 887 /*************************************************************************
 888  *                              SQLGetCursorName           [ODBC32.017]
 889  */
 890 SQLRETURN WINAPI SQLGetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT BufferLength,
 891                                   SQLSMALLINT *NameLength)
 892 {
 893     struct SQLGetCursorName_params params = { StatementHandle, CursorName, BufferLength, NameLength };
 894     SQLRETURN ret;
 895
 896     TRACE("(StatementHandle %p, CursorName %p, BufferLength %d, NameLength %p)\n", StatementHandle, CursorName,
 897           BufferLength, NameLength);
 898
 899     ret = ODBC_CALL( SQLGetCursorName, &params );
 900     TRACE("Returning %d\n", ret);
 901     return ret;
 902 }
 903
 904 /*************************************************************************
 905  *                              SQLGetData           [ODBC32.043]
 906  */
 907 SQLRETURN WINAPI SQLGetData(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
 908                             SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN *StrLen_or_Ind)
 909 {
 910     struct SQLGetData_params params = { StatementHandle, ColumnNumber, TargetType, TargetValue,
 911                                         BufferLength, StrLen_or_Ind };
 912     SQLRETURN ret;
 913
 914     TRACE("(StatementHandle %p, ColumnNumber %d, TargetType %d, TargetValue %p, BufferLength %s, StrLen_or_Ind %p)\n",
 915           StatementHandle, ColumnNumber, TargetType, TargetValue, debugstr_sqllen(BufferLength), StrLen_or_Ind);
 916
 917     ret = ODBC_CALL( SQLGetData, &params );
 918     TRACE("Returning %d\n", ret);
 919     return ret;
 920 }
 921
 922 /*************************************************************************
 923  *                              SQLGetDescField           [ODBC32.033]
 924  */
 925 SQLRETURN WINAPI SQLGetDescField(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
 926                                  SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER *StringLength)
 927 {
 928     struct SQLGetDescField_params params = { DescriptorHandle, RecNumber, FieldIdentifier, Value,
 929                                              BufferLength, StringLength };
 930     SQLRETURN ret;
 931
 932     TRACE("(DescriptorHandle %p, RecNumber %d, FieldIdentifier %d, Value %p, BufferLength %d, StringLength %p)\n",
 933           DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength, StringLength);
 934
 935     ret = ODBC_CALL( SQLGetDescField, &params );
 936     TRACE("Returning %d\n", ret);
 937     return ret;
 938 }
 939
 940 /*************************************************************************
 941  *                              SQLGetDescRec           [ODBC32.034]
 942  */
 943 SQLRETURN WINAPI SQLGetDescRec(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLCHAR *Name,
 944                                SQLSMALLINT BufferLength, SQLSMALLINT *StringLength, SQLSMALLINT *Type,
 945                                SQLSMALLINT *SubType, SQLLEN *Length, SQLSMALLINT *Precision,
 946                                SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
 947 {
 948     struct SQLGetDescRec_params params = { DescriptorHandle, RecNumber, Name, BufferLength, StringLength,
 949                                            Type, SubType, Length, Precision, Scale, Nullable };
 950     SQLRETURN ret;
 951
 952     TRACE("(DescriptorHandle %p, RecNumber %d, Name %p, BufferLength %d, StringLength %p, Type %p, SubType %p,"
 953           " Length %p, Precision %p, Scale %p, Nullable %p)\n", DescriptorHandle, RecNumber, Name, BufferLength,
 954           StringLength, Type, SubType, Length, Precision, Scale, Nullable);
 955
 956     ret = ODBC_CALL( SQLGetDescRec, &params );
 957     TRACE("Returning %d\n", ret);
 958     return ret;
 959 }
 960
 961 /*************************************************************************
 962  *                              SQLGetDiagField           [ODBC32.035]
 963  */
 964 SQLRETURN WINAPI SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber,
 965                                  SQLSMALLINT DiagIdentifier, SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
 966                                  SQLSMALLINT *StringLength)
 967 {
 968     struct SQLGetDiagField_params params = { HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo,
 969                                              BufferLength, StringLength };
 970     SQLRETURN ret;
 971
 972     TRACE("(HandleType %d, Handle %p, RecNumber %d, DiagIdentifier %d, DiagInfo %p, BufferLength %d,"
 973           " StringLength %p)\n", HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength, StringLength);
 974
 975     ret = ODBC_CALL( SQLGetDiagField, &params );
 976     TRACE("Returning %d\n", ret);
 977     return ret;
 978 }
 979
 980 /*************************************************************************
 981  *                              SQLGetDiagRec           [ODBC32.036]
 982  */
 983 SQLRETURN WINAPI SQLGetDiagRec(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber,
 984                                SQLCHAR *Sqlstate, SQLINTEGER *NativeError, SQLCHAR *MessageText,
 985                                SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
 986 {
 987     struct SQLGetDiagRec_params params = { HandleType, Handle, RecNumber, Sqlstate, NativeError,
 988                                            MessageText, BufferLength, TextLength };
 989     SQLRETURN ret;
 990
 991     TRACE("(HandleType %d, Handle %p, RecNumber %d, Sqlstate %p, NativeError %p, MessageText %p, BufferLength %d,"
 992           " TextLength %p)\n", HandleType, Handle, RecNumber, Sqlstate, NativeError, MessageText, BufferLength,
 993           TextLength);
 994
 995     ret = ODBC_CALL( SQLGetDiagRec, &params );
 996     TRACE("Returning %d\n", ret);
 997     return ret;
 998 }
 999
1000 /*************************************************************************
1001  *                              SQLGetEnvAttr           [ODBC32.037]
1002  */
1003 SQLRETURN WINAPI SQLGetEnvAttr(SQLHENV EnvironmentHandle, SQLINTEGER Attribute, SQLPOINTER Value,
1004                                SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1005 {
1006     struct SQLGetEnvAttr_params params = { EnvironmentHandle, Attribute, Value, BufferLength, StringLength };
1007     SQLRETURN ret;
1008
1009     TRACE("(EnvironmentHandle %p, Attribute %d, Value %p, BufferLength %d, StringLength %p)\n",
1010           EnvironmentHandle, Attribute, Value, BufferLength, StringLength);
1011
1012     ret = ODBC_CALL( SQLGetEnvAttr, &params );
1013     TRACE("Returning %d\n", ret);
1014     return ret;
1015 }
1016
1017 /*************************************************************************
1018  *                              SQLGetFunctions           [ODBC32.044]
1019  */
1020 SQLRETURN WINAPI SQLGetFunctions(SQLHDBC ConnectionHandle, SQLUSMALLINT FunctionId, SQLUSMALLINT *Supported)
1021 {
1022     struct SQLGetFunctions_params params = { ConnectionHandle, FunctionId, Supported };
1023     SQLRETURN ret;
1024
1025     TRACE("(ConnectionHandle %p, FunctionId %d, Supported %p)\n", ConnectionHandle, FunctionId, Supported);
1026
1027     ret = ODBC_CALL( SQLGetFunctions, &params );
1028     TRACE("Returning %d\n", ret);
1029     return ret;
1030 }
1031
1032 /*************************************************************************
1033  *                              SQLGetInfo           [ODBC32.045]
1034  */
1035 SQLRETURN WINAPI SQLGetInfo(SQLHDBC ConnectionHandle, SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
1036                             SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
1037 {
1038     struct SQLGetInfo_params params = { ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength };
1039     SQLRETURN ret;
1040
1041     TRACE("(ConnectionHandle, %p, InfoType %d, InfoValue %p, BufferLength %d, StringLength %p)\n", ConnectionHandle,
1042           InfoType, InfoValue, BufferLength, StringLength);
1043
1044     if (!InfoValue)
1045     {
1046         WARN("Unexpected NULL InfoValue address\n");
1047         return SQL_ERROR;
1048     }
1049
1050     ret = ODBC_CALL( SQLGetInfo, &params );
1051     TRACE("Returning %d\n", ret);
1052     return ret;
1053 }
1054
1055 /*************************************************************************
1056  *                              SQLGetStmtAttr           [ODBC32.038]
1057  */
1058 SQLRETURN WINAPI SQLGetStmtAttr(SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER Value,
1059                                 SQLINTEGER BufferLength, SQLINTEGER *StringLength)
1060 {
1061     struct SQLGetStmtAttr_params params = { StatementHandle, Attribute, Value, BufferLength, StringLength };
1062     SQLRETURN ret;
1063
1064     TRACE("(StatementHandle %p, Attribute %d, Value %p, BufferLength %d, StringLength %p)\n", StatementHandle,
1065           Attribute, Value, BufferLength, StringLength);
1066
1067     if (!Value)
1068     {
1069         WARN("Unexpected NULL Value return address\n");
1070         return SQL_ERROR;
1071     }
1072
1073     ret = ODBC_CALL( SQLGetStmtAttr, &params );
1074     TRACE("Returning %d\n", ret);
1075     return ret;
1076 }
1077
1078 /*************************************************************************
1079  *                              SQLGetStmtOption           [ODBC32.046]
1080  */
1081 SQLRETURN WINAPI SQLGetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLPOINTER Value)
1082 {
1083     struct SQLGetStmtOption_params params = { StatementHandle, Option, Value };
1084     SQLRETURN ret;
1085
1086     TRACE("(StatementHandle %p, Option %d, Value %p)\n", StatementHandle, Option, Value);
1087
1088     ret = ODBC_CALL( SQLGetStmtOption, &params );
1089     TRACE("Returning %d\n", ret);
1090     return ret;
1091 }
1092
1093 /*************************************************************************
1094  *                              SQLGetTypeInfo           [ODBC32.047]
1095  */
1096 SQLRETURN WINAPI SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
1097 {
1098     struct SQLGetTypeInfo_params params = { StatementHandle, DataType };
1099     SQLRETURN ret;
1100
1101     TRACE("(StatementHandle %p, DataType %d)\n", StatementHandle, DataType);
1102
1103     ret = ODBC_CALL( SQLGetTypeInfo, &params );
1104     TRACE("Returning %d\n", ret);
1105     return ret;
1106 }
1107
1108 /*************************************************************************
1109  *                              SQLNumResultCols           [ODBC32.018]
1110  */
1111 SQLRETURN WINAPI SQLNumResultCols(SQLHSTMT StatementHandle, SQLSMALLINT *ColumnCount)
1112 {
1113     struct SQLNumResultCols_params params = { StatementHandle, ColumnCount };
1114     SQLRETURN ret;
1115
1116     TRACE("(StatementHandle %p, ColumnCount %p)\n", StatementHandle, ColumnCount);
1117
1118     ret = ODBC_CALL( SQLNumResultCols, &params );
1119     TRACE("Returning %d ColumnCount %d\n", ret, *ColumnCount);
1120     return ret;
1121 }
1122
1123 /*************************************************************************
1124  *                              SQLParamData           [ODBC32.048]
1125  */
1126 SQLRETURN WINAPI SQLParamData(SQLHSTMT StatementHandle, SQLPOINTER *Value)
1127 {
1128     struct SQLParamData_params params = { StatementHandle, Value };
1129     SQLRETURN ret;
1130
1131     TRACE("(StatementHandle %p, Value %p)\n", StatementHandle, Value);
1132
1133     ret = ODBC_CALL( SQLParamData, &params );
1134     TRACE("Returning %d\n", ret);
1135     return ret;
1136 }
1137
1138 /*************************************************************************
1139  *                              SQLPrepare           [ODBC32.019]
1140  */
1141 SQLRETURN WINAPI SQLPrepare(SQLHSTMT StatementHandle, SQLCHAR *StatementText, SQLINTEGER TextLength)
1142 {
1143     struct SQLPrepare_params params = { StatementHandle, StatementText, TextLength };
1144     SQLRETURN ret;
1145
1146     TRACE("(StatementHandle %p, StatementText %s, TextLength %d)\n", StatementHandle,
1147           debugstr_an((const char *)StatementText, TextLength), TextLength);
1148
1149     ret = ODBC_CALL( SQLPrepare, &params );
1150     TRACE("Returning %d\n", ret);
1151     return ret;
1152 }
1153
1154 /*************************************************************************
1155  *                              SQLPutData           [ODBC32.049]
1156  */
1157 SQLRETURN WINAPI SQLPutData(SQLHSTMT StatementHandle, SQLPOINTER Data, SQLLEN StrLen_or_Ind)
1158 {
1159     struct SQLPutData_params params = { StatementHandle, Data, StrLen_or_Ind };
1160     SQLRETURN ret;
1161
1162     TRACE("(StatementHandle %p, Data %p, StrLen_or_Ind %s)\n", StatementHandle, Data, debugstr_sqllen(StrLen_or_Ind));
1163
1164     ret = ODBC_CALL( SQLPutData, &params );
1165     TRACE("Returning %d\n", ret);
1166     return ret;
1167 }
1168
1169 /*************************************************************************
1170  *                              SQLRowCount           [ODBC32.020]
1171  */
1172 SQLRETURN WINAPI SQLRowCount(SQLHSTMT StatementHandle, SQLLEN *RowCount)
1173 {
1174     struct SQLRowCount_params params = { StatementHandle, RowCount };
1175     SQLRETURN ret;
1176
1177     TRACE("(StatementHandle %p, RowCount %p)\n", StatementHandle, RowCount);
1178
1179     ret = ODBC_CALL( SQLRowCount, &params );
1180     if (ret == SQL_SUCCESS && RowCount) TRACE(" RowCount %s\n", debugstr_sqllen(*RowCount));
1181     TRACE("Returning %d\n", ret);
1182     return ret;
1183 }
1184
1185 /*************************************************************************
1186  *                              SQLSetConnectAttr           [ODBC32.039]
1187  */
1188 SQLRETURN WINAPI SQLSetConnectAttr(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, SQLPOINTER Value,
1189                                    SQLINTEGER StringLength)
1190 {
1191     struct SQLSetConnectAttr_params params = { ConnectionHandle, Attribute, Value, StringLength };
1192     SQLRETURN ret;
1193
1194     TRACE("(ConnectionHandle %p, Attribute %d, Value %p, StringLength %d)\n", ConnectionHandle, Attribute, Value,
1195           StringLength);
1196
1197     ret = ODBC_CALL( SQLSetConnectAttr, &params );
1198     TRACE("Returning %d\n", ret);
1199     return ret;
1200 }
1201
1202 /*************************************************************************
1203  *                              SQLSetConnectOption           [ODBC32.050]
1204  */
1205 SQLRETURN WINAPI SQLSetConnectOption(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLULEN Value)
1206 {
1207     struct SQLSetConnectOption_params params = { ConnectionHandle, Option, Value };
1208     SQLRETURN ret;
1209
1210     TRACE("(ConnectionHandle %p, Option %d, Value %s)\n", ConnectionHandle, Option, debugstr_sqlulen(Value));
1211
1212     ret = ODBC_CALL( SQLSetConnectOption, &params );
1213     TRACE("Returning %d\n", ret);
1214     return ret;
1215 }
1216
1217 /*************************************************************************
1218  *                              SQLSetCursorName           [ODBC32.021]
1219  */
1220 SQLRETURN WINAPI SQLSetCursorName(SQLHSTMT StatementHandle, SQLCHAR *CursorName, SQLSMALLINT NameLength)
1221 {
1222     struct SQLSetCursorName_params params = { StatementHandle, CursorName, NameLength };
1223     SQLRETURN ret;
1224
1225     TRACE("(StatementHandle %p, CursorName %s, NameLength %d)\n", StatementHandle,
1226           debugstr_an((const char *)CursorName, NameLength), NameLength);
1227
1228     ret = ODBC_CALL( SQLSetCursorName, &params );
1229     TRACE("Returning %d\n", ret);
1230     return ret;
1231 }
1232
1233 /*************************************************************************
1234  *                              SQLSetDescField           [ODBC32.073]
1235  */
1236 SQLRETURN WINAPI SQLSetDescField(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
1237                                  SQLPOINTER Value, SQLINTEGER BufferLength)
1238 {
1239     struct SQLSetDescField_params params = { DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength };
1240     SQLRETURN ret;
1241
1242     TRACE("(DescriptorHandle %p, RecNumber %d, FieldIdentifier %d, Value %p, BufferLength %d)\n", DescriptorHandle,
1243           RecNumber, FieldIdentifier, Value, BufferLength);
1244
1245     ret = ODBC_CALL( SQLSetDescField, &params );
1246     TRACE("Returning %d\n", ret);
1247     return ret;
1248 }
1249
1250 /*************************************************************************
1251  *                              SQLSetDescRec           [ODBC32.074]
1252  */
1253 SQLRETURN WINAPI SQLSetDescRec(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT Type,
1254                                SQLSMALLINT SubType, SQLLEN Length, SQLSMALLINT Precision, SQLSMALLINT Scale,
1255                                SQLPOINTER Data, SQLLEN *StringLength, SQLLEN *Indicator)
1256 {
1257     struct SQLSetDescRec_params params = { DescriptorHandle, RecNumber, Type, SubType, Length, Precision, Scale, Data, StringLength, Indicator };
1258     SQLRETURN ret;
1259
1260     TRACE("(DescriptorHandle %p, RecNumber %d, Type %d, SubType %d, Length %s, Precision %d, Scale %d, Data %p,"
1261           " StringLength %p, Indicator %p)\n", DescriptorHandle, RecNumber, Type, SubType, debugstr_sqllen(Length),
1262           Precision, Scale, Data, StringLength, Indicator);
1263
1264     ret = ODBC_CALL( SQLSetDescRec, &params );
1265     TRACE("Returning %d\n", ret);
1266     return ret;
1267 }
1268
1269 /*************************************************************************
1270  *                              SQLSetEnvAttr           [ODBC32.075]
1271  */
1272 SQLRETURN WINAPI SQLSetEnvAttr(SQLHENV EnvironmentHandle, SQLINTEGER Attribute, SQLPOINTER Value,
1273                                SQLINTEGER StringLength)
1274 {
1275     struct SQLSetEnvAttr_params params = { EnvironmentHandle, Attribute, Value, StringLength };
1276     SQLRETURN ret;
1277
1278     TRACE("(EnvironmentHandle %p, Attribute %d, Value %p, StringLength %d)\n", EnvironmentHandle, Attribute, Value,
1279           StringLength);
1280
1281     ret = ODBC_CALL( SQLSetEnvAttr, &params );
1282     TRACE("Returning %d\n", ret);
1283     return ret;
1284 }
1285
1286 /*************************************************************************
1287  *                              SQLSetParam           [ODBC32.022]
1288  */
1289 SQLRETURN WINAPI SQLSetParam(SQLHSTMT StatementHandle, SQLUSMALLINT ParameterNumber, SQLSMALLINT ValueType,
1290                              SQLSMALLINT ParameterType, SQLULEN LengthPrecision, SQLSMALLINT ParameterScale,
1291                              SQLPOINTER ParameterValue, SQLLEN *StrLen_or_Ind)
1292 {
1293     struct SQLSetParam_params params = { StatementHandle, ParameterNumber, ValueType, ParameterType,
1294                                          LengthPrecision, ParameterScale, ParameterValue, StrLen_or_Ind };
1295     SQLRETURN ret;
1296
1297     TRACE("(StatementHandle %p, ParameterNumber %d, ValueType %d, ParameterType %d, LengthPrecision %s,"
1298           " ParameterScale %d, ParameterValue %p, StrLen_or_Ind %p)\n", StatementHandle, ParameterNumber, ValueType,
1299           ParameterType, debugstr_sqlulen(LengthPrecision), ParameterScale, ParameterValue, StrLen_or_Ind);
1300
1301     ret = ODBC_CALL( SQLSetParam, &params );
1302     TRACE("Returning %d\n", ret);
1303     return ret;
1304 }
1305
1306 /*************************************************************************
1307  *                              SQLSetStmtAttr           [ODBC32.076]
1308  */
1309 SQLRETURN WINAPI SQLSetStmtAttr(SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER Value,
1310                                 SQLINTEGER StringLength)
1311 {
1312     struct SQLSetStmtAttr_params params = { StatementHandle, Attribute, Value, StringLength };
1313     SQLRETURN ret;
1314
1315     TRACE("(StatementHandle %p, Attribute %d, Value %p, StringLength %d)\n", StatementHandle, Attribute, Value,
1316           StringLength);
1317
1318     ret = ODBC_CALL( SQLSetStmtAttr, &params );
1319     TRACE("Returning %d\n", ret);
1320     return ret;
1321 }
1322
1323 /*************************************************************************
1324  *                              SQLSetStmtOption           [ODBC32.051]
1325  */
1326 SQLRETURN WINAPI SQLSetStmtOption(SQLHSTMT StatementHandle, SQLUSMALLINT Option, SQLULEN Value)
1327 {
1328     struct SQLSetStmtOption_params params = { StatementHandle, Option, Value };
1329     SQLRETURN ret;
1330
1331     TRACE("(StatementHandle %p, Option %d, Value %s)\n", StatementHandle, Option, debugstr_sqlulen(Value));
1332
1333     ret = ODBC_CALL( SQLSetStmtOption, &params );
1334     TRACE("Returning %d\n", ret);
1335     return ret;
1336 }
1337
1338 /*************************************************************************
1339  *                              SQLSpecialColumns           [ODBC32.052]
1340  */
1341 SQLRETURN WINAPI SQLSpecialColumns(SQLHSTMT StatementHandle, SQLUSMALLINT IdentifierType, SQLCHAR *CatalogName,
1342                                    SQLSMALLINT NameLength1, SQLCHAR *SchemaName, SQLSMALLINT NameLength2,
1343                                    SQLCHAR *TableName, SQLSMALLINT NameLength3, SQLUSMALLINT Scope,
1344                                    SQLUSMALLINT Nullable)
1345 {
1346     struct SQLSpecialColumns_params params = { StatementHandle, IdentifierType, CatalogName, NameLength1,
1347                                                SchemaName, NameLength2, TableName, NameLength3, Scope, Nullable };
1348     SQLRETURN ret;
1349
1350     TRACE("(StatementHandle %p, IdentifierType %d, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d,"
1351           " TableName %s, NameLength3 %d, Scope %d, Nullable %d)\n", StatementHandle, IdentifierType,
1352           debugstr_an((const char *)CatalogName, NameLength1), NameLength1,
1353           debugstr_an((const char *)SchemaName, NameLength2), NameLength2,
1354           debugstr_an((const char *)TableName, NameLength3), NameLength3, Scope, Nullable);
1355
1356     ret = ODBC_CALL( SQLSpecialColumns, &params );
1357     TRACE("Returning %d\n", ret);
1358     return ret;
1359 }
1360
1361 /*************************************************************************
1362  *                              SQLStatistics           [ODBC32.053]
1363  */
1364 SQLRETURN WINAPI SQLStatistics(SQLHSTMT StatementHandle, SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1365                                SQLCHAR *SchemaName, SQLSMALLINT NameLength2, SQLCHAR *TableName,
1366                                SQLSMALLINT NameLength3, SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
1367 {
1368     struct SQLStatistics_params params = { StatementHandle, CatalogName, NameLength1, SchemaName,
1369                                            NameLength2, TableName, NameLength3, Unique, Reserved };
1370     SQLRETURN ret;
1371
1372     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d SchemaName %s, NameLength2 %d, TableName %s"
1373           " NameLength3 %d, Unique %d, Reserved %d)\n", StatementHandle,
1374           debugstr_an((const char *)CatalogName, NameLength1), NameLength1,
1375           debugstr_an((const char *)SchemaName, NameLength2), NameLength2,
1376           debugstr_an((const char *)TableName, NameLength3), NameLength3, Unique, Reserved);
1377
1378     ret = ODBC_CALL( SQLStatistics, &params );
1379     TRACE("Returning %d\n", ret);
1380     return ret;
1381 }
1382
1383 /*************************************************************************
1384  *                              SQLTables           [ODBC32.054]
1385  */
1386 SQLRETURN WINAPI SQLTables(SQLHSTMT StatementHandle, SQLCHAR *CatalogName, SQLSMALLINT NameLength1,
1387                            SQLCHAR *SchemaName, SQLSMALLINT NameLength2, SQLCHAR *TableName,
1388                            SQLSMALLINT NameLength3, SQLCHAR *TableType, SQLSMALLINT NameLength4)
1389 {
1390     struct SQLTables_params params = { StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
1391                                        TableName, NameLength3, TableType, NameLength4 };
1392     SQLRETURN ret;
1393
1394     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d, TableName %s,"
1395           " NameLength3 %d, TableType %s, NameLength4 %d)\n", StatementHandle,
1396           debugstr_an((const char *)CatalogName, NameLength1), NameLength1,
1397           debugstr_an((const char *)SchemaName, NameLength2), NameLength2,
1398           debugstr_an((const char *)TableName, NameLength3), NameLength3,
1399           debugstr_an((const char *)TableType, NameLength4), NameLength4);
1400
1401     ret = ODBC_CALL( SQLTables, &params );
1402     TRACE("Returning %d\n", ret);
1403     return ret;
1404 }
1405
1406 /*************************************************************************
1407  *                              SQLTransact           [ODBC32.023]
1408  */
1409 SQLRETURN WINAPI SQLTransact(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle, SQLUSMALLINT CompletionType)
1410 {
1411     struct SQLTransact_params params = { EnvironmentHandle, ConnectionHandle, CompletionType };
1412     SQLRETURN ret;
1413
1414     TRACE("(EnvironmentHandle %p, ConnectionHandle %p, CompletionType %d)\n", EnvironmentHandle, ConnectionHandle,
1415           CompletionType);
1416
1417     ret = ODBC_CALL( SQLTransact, &params );
1418     TRACE("Returning %d\n", ret);
1419     return ret;
1420 }
1421
1422 /*************************************************************************
1423  *                              SQLBrowseConnect           [ODBC32.055]
1424  */
1425 SQLRETURN WINAPI SQLBrowseConnect(SQLHDBC hdbc, SQLCHAR *szConnStrIn, SQLSMALLINT cbConnStrIn,
1426                                   SQLCHAR *szConnStrOut, SQLSMALLINT cbConnStrOutMax,
1427                                   SQLSMALLINT *pcbConnStrOut)
1428 {
1429     struct SQLBrowseConnect_params params = { hdbc, szConnStrIn, cbConnStrIn, szConnStrOut,
1430                                               cbConnStrOutMax, pcbConnStrOut };
1431     SQLRETURN ret;
1432
1433     TRACE("(hdbc %p, szConnStrIn %s, cbConnStrIn %d, szConnStrOut %p, cbConnStrOutMax %d, pcbConnStrOut %p)\n",
1434           hdbc, debugstr_an((const char *)szConnStrIn, cbConnStrIn), cbConnStrIn, szConnStrOut, cbConnStrOutMax,
1435           pcbConnStrOut);
1436
1437     ret = ODBC_CALL( SQLBrowseConnect, &params );
1438     TRACE("Returning %d\n", ret);
1439     return ret;
1440 }
1441
1442 /*************************************************************************
1443  *                              SQLBulkOperations           [ODBC32.078]
1444  */
1445 SQLRETURN WINAPI SQLBulkOperations(SQLHSTMT StatementHandle, SQLSMALLINT Operation)
1446 {
1447     struct SQLBulkOperations_params params = { StatementHandle, Operation };
1448     SQLRETURN ret;
1449
1450     TRACE("(StatementHandle %p, Operation %d)\n", StatementHandle, Operation);
1451
1452     ret = ODBC_CALL( SQLBulkOperations, &params );
1453     TRACE("Returning %d\n", ret);
1454     return ret;
1455 }
1456
1457 /*************************************************************************
1458  *                              SQLColAttributes           [ODBC32.006]
1459  */
1460 SQLRETURN WINAPI SQLColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
1461                                   SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT *pcbDesc,
1462                                   SQLLEN *pfDesc)
1463 {
1464     struct SQLColAttributes_params params = { hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc };
1465     SQLRETURN ret;
1466
1467     TRACE("(hstmt %p, icol %d, fDescType %d, rgbDesc %p, cbDescMax %d, pcbDesc %p, pfDesc %p)\n", hstmt, icol,
1468           fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
1469
1470     ret = ODBC_CALL( SQLColAttributes, &params );
1471     TRACE("Returning %d\n", ret);
1472     return ret;
1473 }
1474
1475 /*************************************************************************
1476  *                              SQLColumnPrivileges           [ODBC32.056]
1477  */
1478 SQLRETURN WINAPI SQLColumnPrivileges(SQLHSTMT hstmt, SQLCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
1479                                      SQLCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR *szTableName,
1480                                      SQLSMALLINT cbTableName, SQLCHAR *szColumnName, SQLSMALLINT cbColumnName)
1481 {
1482     struct SQLColumnPrivileges_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
1483                                                  cbSchemaName, szTableName, cbTableName, szColumnName, cbColumnName };
1484     SQLRETURN ret;
1485
1486     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
1487           " cbTableName %d, szColumnName %s, cbColumnName %d)\n", hstmt,
1488           debugstr_an((const char *)szCatalogName, cbCatalogName), cbCatalogName,
1489           debugstr_an((const char *)szSchemaName, cbSchemaName), cbSchemaName,
1490           debugstr_an((const char *)szTableName, cbTableName), cbTableName,
1491           debugstr_an((const char *)szColumnName, cbColumnName), cbColumnName);
1492
1493     ret = ODBC_CALL( SQLColumnPrivileges, &params );
1494     TRACE("Returning %d\n", ret);
1495     return ret;
1496 }
1497
1498 /*************************************************************************
1499  *                              SQLDescribeParam          [ODBC32.058]
1500  */
1501 SQLRETURN WINAPI SQLDescribeParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT *pfSqlType,
1502                                   SQLULEN *pcbParamDef, SQLSMALLINT *pibScale, SQLSMALLINT *pfNullable)
1503 {
1504     struct SQLDescribeParam_params params = { hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable };
1505     SQLRETURN ret;
1506
1507     TRACE("(hstmt %p, ipar %d, pfSqlType %p, pcbParamDef %p, pibScale %p, pfNullable %p)\n", hstmt, ipar,
1508           pfSqlType, pcbParamDef, pibScale, pfNullable);
1509
1510     ret = ODBC_CALL( SQLDescribeParam, &params );
1511     TRACE("Returning %d\n", ret);
1512     return ret;
1513 }
1514
1515 /*************************************************************************
1516  *                              SQLExtendedFetch           [ODBC32.059]
1517  */
1518 SQLRETURN WINAPI SQLExtendedFetch(SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLLEN irow, SQLULEN *pcrow,
1519                                   SQLUSMALLINT *rgfRowStatus)
1520 {
1521     struct SQLExtendedFetch_params params = { hstmt, fFetchType, irow, pcrow, rgfRowStatus };
1522     SQLRETURN ret;
1523
1524     TRACE("(hstmt %p, fFetchType %d, irow %s, pcrow %p, rgfRowStatus %p)\n", hstmt, fFetchType, debugstr_sqllen(irow),
1525           pcrow, rgfRowStatus);
1526
1527     ret = ODBC_CALL( SQLExtendedFetch, &params );
1528     TRACE("Returning %d\n", ret);
1529     return ret;
1530 }
1531
1532 /*************************************************************************
1533  *                              SQLForeignKeys           [ODBC32.060]
1534  */
1535 SQLRETURN WINAPI SQLForeignKeys(SQLHSTMT hstmt, SQLCHAR *szPkCatalogName, SQLSMALLINT cbPkCatalogName,
1536                                 SQLCHAR *szPkSchemaName, SQLSMALLINT cbPkSchemaName, SQLCHAR *szPkTableName,
1537                                 SQLSMALLINT cbPkTableName, SQLCHAR *szFkCatalogName,
1538                                 SQLSMALLINT cbFkCatalogName, SQLCHAR *szFkSchemaName,
1539                                 SQLSMALLINT cbFkSchemaName, SQLCHAR *szFkTableName, SQLSMALLINT cbFkTableName)
1540 {
1541     struct SQLForeignKeys_params params = { hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName,
1542                                             cbPkSchemaName, szPkTableName, cbPkTableName, szFkCatalogName,
1543                                             cbFkCatalogName, szFkSchemaName, cbFkSchemaName,
1544                                             szFkTableName, cbFkTableName };
1545     SQLRETURN ret;
1546
1547     TRACE("(hstmt %p, szPkCatalogName %s, cbPkCatalogName %d, szPkSchemaName %s, cbPkSchemaName %d,"
1548           " szPkTableName %s, cbPkTableName %d, szFkCatalogName %s, cbFkCatalogName %d, szFkSchemaName %s,"
1549           " cbFkSchemaName %d, szFkTableName %s, cbFkTableName %d)\n", hstmt,
1550           debugstr_an((const char *)szPkCatalogName, cbPkCatalogName), cbPkCatalogName,
1551           debugstr_an((const char *)szPkSchemaName, cbPkSchemaName), cbPkSchemaName,
1552           debugstr_an((const char *)szPkTableName, cbPkTableName), cbPkTableName,
1553           debugstr_an((const char *)szFkCatalogName, cbFkCatalogName), cbFkCatalogName,
1554           debugstr_an((const char *)szFkSchemaName, cbFkSchemaName), cbFkSchemaName,
1555           debugstr_an((const char *)szFkTableName, cbFkTableName), cbFkTableName);
1556
1557     ret = ODBC_CALL( SQLForeignKeys, &params );
1558     TRACE("Returning %d\n", ret);
1559     return ret;
1560 }
1561
1562 /*************************************************************************
1563  *                              SQLMoreResults           [ODBC32.061]
1564  */
1565 SQLRETURN WINAPI SQLMoreResults(SQLHSTMT StatementHandle)
1566 {
1567     struct SQLMoreResults_params params = { StatementHandle };
1568     SQLRETURN ret;
1569
1570     TRACE("(%p)\n", StatementHandle);
1571
1572     ret = ODBC_CALL( SQLMoreResults, &params );
1573     TRACE("Returning %d\n", ret);
1574     return ret;
1575 }
1576
1577 /*************************************************************************
1578  *                              SQLNativeSql           [ODBC32.062]
1579  */
1580 SQLRETURN WINAPI SQLNativeSql(SQLHDBC hdbc, SQLCHAR *szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLCHAR *szSqlStr,
1581                               SQLINTEGER cbSqlStrMax, SQLINTEGER *pcbSqlStr)
1582 {
1583     struct SQLNativeSql_params params = { hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr };
1584     SQLRETURN ret;
1585
1586     TRACE("(hdbc %p, szSqlStrIn %s, cbSqlStrIn %d, szSqlStr %p, cbSqlStrMax %d, pcbSqlStr %p)\n", hdbc,
1587           debugstr_an((const char *)szSqlStrIn, cbSqlStrIn), cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
1588
1589     ret = ODBC_CALL( SQLNativeSql, &params );
1590     TRACE("Returning %d\n", ret);
1591     return ret;
1592 }
1593
1594 /*************************************************************************
1595  *                              SQLNumParams           [ODBC32.063]
1596  */
1597 SQLRETURN WINAPI SQLNumParams(SQLHSTMT hstmt, SQLSMALLINT *pcpar)
1598 {
1599     struct SQLNumParams_params params = { hstmt, pcpar };
1600     SQLRETURN ret;
1601
1602     TRACE("(hstmt %p, pcpar %p)\n", hstmt, pcpar);
1603
1604     ret = ODBC_CALL( SQLNumParams, &params );
1605     TRACE("Returning %d\n", ret);
1606     return ret;
1607 }
1608
1609 /*************************************************************************
1610  *                              SQLParamOptions           [ODBC32.064]
1611  */
1612 SQLRETURN WINAPI SQLParamOptions(SQLHSTMT hstmt, SQLULEN crow, SQLULEN *pirow)
1613 {
1614     struct SQLParamOptions_params params = { hstmt, crow, pirow };
1615     SQLRETURN ret;
1616
1617     TRACE("(hstmt %p, crow %s, pirow %p)\n", hstmt, debugstr_sqlulen(crow), pirow);
1618
1619     ret = ODBC_CALL( SQLParamOptions, &params );
1620     TRACE("Returning %d\n", ret);
1621     return ret;
1622 }
1623
1624 /*************************************************************************
1625  *                              SQLPrimaryKeys           [ODBC32.065]
1626  */
1627 SQLRETURN WINAPI SQLPrimaryKeys(SQLHSTMT hstmt, SQLCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
1628                                 SQLCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR *szTableName,
1629                                 SQLSMALLINT cbTableName)
1630 {
1631     struct SQLPrimaryKeys_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
1632                                             cbSchemaName, szTableName, cbTableName };
1633     SQLRETURN ret;
1634
1635     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
1636           " cbTableName %d)\n", hstmt,
1637           debugstr_an((const char *)szCatalogName, cbCatalogName), cbCatalogName,
1638           debugstr_an((const char *)szSchemaName, cbSchemaName), cbSchemaName,
1639           debugstr_an((const char *)szTableName, cbTableName), cbTableName);
1640
1641     ret = ODBC_CALL( SQLPrimaryKeys, &params );
1642     TRACE("Returning %d\n", ret);
1643     return ret;
1644 }
1645
1646 /*************************************************************************
1647  *                              SQLProcedureColumns           [ODBC32.066]
1648  */
1649 SQLRETURN WINAPI SQLProcedureColumns(SQLHSTMT hstmt, SQLCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
1650                                      SQLCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR *szProcName,
1651                                      SQLSMALLINT cbProcName, SQLCHAR *szColumnName, SQLSMALLINT cbColumnName)
1652 {
1653     struct SQLProcedureColumns_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
1654                                                  cbSchemaName, szProcName, cbProcName,
1655                                                  szColumnName, cbColumnName };
1656     SQLRETURN ret;
1657
1658     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szProcName %s,"
1659           " cbProcName %d, szColumnName %s, cbColumnName %d)\n", hstmt,
1660           debugstr_an((const char *)szCatalogName, cbCatalogName), cbCatalogName,
1661           debugstr_an((const char *)szSchemaName, cbSchemaName), cbSchemaName,
1662           debugstr_an((const char *)szProcName, cbProcName), cbProcName,
1663           debugstr_an((const char *)szColumnName, cbColumnName), cbColumnName);
1664
1665     ret = ODBC_CALL( SQLProcedureColumns, &params );
1666     TRACE("Returning %d\n", ret);
1667     return ret;
1668 }
1669
1670 /*************************************************************************
1671  *                              SQLProcedures           [ODBC32.067]
1672  */
1673 SQLRETURN WINAPI SQLProcedures(SQLHSTMT hstmt, SQLCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
1674                                SQLCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR *szProcName,
1675                                SQLSMALLINT cbProcName)
1676 {
1677     struct SQLProcedures_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
1678                                            cbSchemaName, szProcName, cbProcName };
1679     SQLRETURN ret;
1680
1681     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szProcName %s,"
1682           " cbProcName %d)\n", hstmt,
1683           debugstr_an((const char *)szCatalogName, cbCatalogName), cbCatalogName,
1684           debugstr_an((const char *)szSchemaName, cbSchemaName), cbSchemaName,
1685           debugstr_an((const char *)szProcName, cbProcName), cbProcName);
1686
1687     ret = ODBC_CALL( SQLProcedures, &params );
1688     TRACE("Returning %d\n", ret);
1689     return ret;
1690 }
1691
1692 /*************************************************************************
1693  *                              SQLSetPos           [ODBC32.068]
1694  */
1695 SQLRETURN WINAPI SQLSetPos(SQLHSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock)
1696 {
1697     struct SQLSetPos_params params = { hstmt, irow, fOption, fLock };
1698     SQLRETURN ret;
1699
1700     TRACE("(hstmt %p, irow %s, fOption %d, fLock %d)\n", hstmt, debugstr_sqlulen(irow), fOption, fLock);
1701
1702     ret = ODBC_CALL( SQLSetPos, &params );
1703     TRACE("Returning %d\n", ret);
1704     return ret;
1705 }
1706
1707 /*************************************************************************
1708  *                              SQLTablePrivileges           [ODBC32.070]
1709  */
1710 SQLRETURN WINAPI SQLTablePrivileges(SQLHSTMT hstmt, SQLCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
1711                                     SQLCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLCHAR *szTableName,
1712                                     SQLSMALLINT cbTableName)
1713 {
1714     struct SQLTablePrivileges_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
1715                                                 cbSchemaName, szTableName, cbTableName };
1716     SQLRETURN ret;
1717
1718     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
1719           " cbTableName %d)\n", hstmt,
1720           debugstr_an((const char *)szCatalogName, cbCatalogName), cbCatalogName,
1721           debugstr_an((const char *)szSchemaName, cbSchemaName), cbSchemaName,
1722           debugstr_an((const char *)szTableName, cbTableName), cbTableName);
1723
1724     ret = ODBC_CALL( SQLTablePrivileges, &params );
1725     TRACE("Returning %d\n", ret);
1726     return ret;
1727 }
1728
1729 /*************************************************************************
1730  *                              SQLDrivers           [ODBC32.071]
1731  */
1732 SQLRETURN WINAPI SQLDrivers(SQLHENV EnvironmentHandle, SQLUSMALLINT fDirection, SQLCHAR *szDriverDesc,
1733                             SQLSMALLINT cbDriverDescMax, SQLSMALLINT *pcbDriverDesc,
1734                             SQLCHAR *szDriverAttributes, SQLSMALLINT cbDriverAttrMax,
1735                             SQLSMALLINT *pcbDriverAttr)
1736 {
1737     struct SQLDrivers_params params = { EnvironmentHandle, fDirection, szDriverDesc, cbDriverDescMax,
1738                                         pcbDriverDesc, szDriverAttributes, cbDriverAttrMax, pcbDriverAttr };
1739     SQLRETURN ret;
1740
1741     TRACE("(EnvironmentHandle %p, Direction %d, szDriverDesc %p, cbDriverDescMax %d, pcbDriverDesc %p,"
1742           " DriverAttributes %p, cbDriverAttrMax %d, pcbDriverAttr %p)\n", EnvironmentHandle, fDirection,
1743           szDriverDesc, cbDriverDescMax, pcbDriverDesc, szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
1744
1745     ret = ODBC_CALL( SQLDrivers, &params );
1746
1747     if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
1748         ERR_(winediag)("No ODBC drivers could be found. Check the settings for your libodbc provider.\n");
1749
1750     TRACE("Returning %d\n", ret);
1751     return ret;
1752 }
1753
1754 /*************************************************************************
1755  *                              SQLBindParameter           [ODBC32.072]
1756  */
1757 SQLRETURN WINAPI SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType,
1758                                   SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef,
1759                                   SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax,
1760                                   SQLLEN *pcbValue)
1761 {
1762     struct SQLBindParameter_params params = { hstmt, ipar, fParamType, fCType, fSqlType, cbColDef,
1763                                               ibScale, rgbValue, cbValueMax, pcbValue };
1764     SQLRETURN ret;
1765
1766     TRACE("(hstmt %p, ipar %d, fParamType %d, fCType %d, fSqlType %d, cbColDef %s, ibScale %d, rgbValue %p,"
1767           " cbValueMax %s, pcbValue %p)\n", hstmt, ipar, fParamType, fCType, fSqlType, debugstr_sqlulen(cbColDef),
1768           ibScale, rgbValue, debugstr_sqllen(cbValueMax), pcbValue);
1769
1770     ret = ODBC_CALL( SQLBindParameter, &params );
1771     TRACE("Returning %d\n", ret);
1772     return ret;
1773 }
1774
1775 /*************************************************************************
1776  *                              SQLDriverConnect           [ODBC32.041]
1777  */
1778 SQLRETURN WINAPI SQLDriverConnect(SQLHDBC hdbc, SQLHWND hwnd, SQLCHAR *ConnectionString, SQLSMALLINT Length,
1779                                   SQLCHAR *conn_str_out, SQLSMALLINT conn_str_out_max,
1780                                   SQLSMALLINT *ptr_conn_str_out, SQLUSMALLINT driver_completion)
1781 {
1782     struct SQLDriverConnect_params params = { hdbc, hwnd, ConnectionString, Length, conn_str_out,
1783                                               conn_str_out_max, ptr_conn_str_out, driver_completion };
1784     SQLRETURN ret;
1785
1786     TRACE("(hdbc %p, hwnd %p, ConnectionString %s, Length %d, conn_str_out %p, conn_str_out_max %d,"
1787           " ptr_conn_str_out %p, driver_completion %d)\n", hdbc, hwnd,
1788           debugstr_an((const char *)ConnectionString, Length), Length, conn_str_out, conn_str_out_max,
1789           ptr_conn_str_out, driver_completion);
1790
1791     ret = ODBC_CALL( SQLDriverConnect, &params );
1792     TRACE("Returning %d\n", ret);
1793     return ret;
1794 }
1795
1796 /*************************************************************************
1797  *                              SQLSetScrollOptions           [ODBC32.069]
1798  */
1799 SQLRETURN WINAPI SQLSetScrollOptions(SQLHSTMT statement_handle, SQLUSMALLINT f_concurrency, SQLLEN crow_keyset,
1800                                      SQLUSMALLINT crow_rowset)
1801 {
1802     struct SQLSetScrollOptions_params params = { statement_handle, f_concurrency, crow_keyset, crow_rowset };
1803     SQLRETURN ret;
1804
1805     TRACE("(statement_handle %p, f_concurrency %d, crow_keyset %s, crow_rowset %d)\n", statement_handle,
1806           f_concurrency, debugstr_sqllen(crow_keyset), crow_rowset);
1807
1808     ret = ODBC_CALL( SQLSetScrollOptions, &params );
1809     TRACE("Returning %d\n", ret);
1810     return ret;
1811 }
1812
1813 static BOOL SQLColAttributes_KnownStringAttribute(SQLUSMALLINT fDescType)
1814 {
1815     static const SQLUSMALLINT attrList[] =
1816     {
1817         SQL_COLUMN_OWNER_NAME,
1818         SQL_COLUMN_QUALIFIER_NAME,
1819         SQL_COLUMN_LABEL,
1820         SQL_COLUMN_NAME,
1821         SQL_COLUMN_TABLE_NAME,
1822         SQL_COLUMN_TYPE_NAME,
1823         SQL_DESC_BASE_COLUMN_NAME,
1824         SQL_DESC_BASE_TABLE_NAME,
1825         SQL_DESC_CATALOG_NAME,
1826         SQL_DESC_LABEL,
1827         SQL_DESC_LITERAL_PREFIX,
1828         SQL_DESC_LITERAL_SUFFIX,
1829         SQL_DESC_LOCAL_TYPE_NAME,
1830         SQL_DESC_NAME,
1831         SQL_DESC_SCHEMA_NAME,
1832         SQL_DESC_TABLE_NAME,
1833         SQL_DESC_TYPE_NAME,
1834     };
1835     unsigned int i;
1836
1837     for (i = 0; i < ARRAY_SIZE(attrList); i++) {
1838         if (attrList[i] == fDescType) return TRUE;
1839     }
1840     return FALSE;
1841 }
1842
1843 /*************************************************************************
1844  *                              SQLColAttributesW          [ODBC32.106]
1845  */
1846 SQLRETURN WINAPI SQLColAttributesW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
1847                                    SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT *pcbDesc,
1848                                    SQLLEN *pfDesc)
1849 {
1850     struct SQLColAttributesW_params params = { hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc };
1851     SQLRETURN ret;
1852
1853     TRACE("(hstmt %p, icol %d, fDescType %d, rgbDesc %p, cbDescMax %d, pcbDesc %p, pfDesc %p)\n", hstmt, icol,
1854           fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
1855
1856     ret = ODBC_CALL( SQLColAttributesW, &params );
1857
1858     if (ret == SQL_SUCCESS && SQLColAttributes_KnownStringAttribute(fDescType) && rgbDesc && pcbDesc &&
1859         *pcbDesc != lstrlenW(rgbDesc) * 2)
1860     {
1861         TRACE("CHEAT: resetting name length for ADO\n");
1862         *pcbDesc = lstrlenW(rgbDesc) * 2;
1863     }
1864
1865     TRACE("Returning %d\n", ret);
1866     return ret;
1867 }
1868
1869 /*************************************************************************
1870  *                              SQLConnectW          [ODBC32.107]
1871  */
1872 SQLRETURN WINAPI SQLConnectW(SQLHDBC ConnectionHandle, WCHAR *ServerName, SQLSMALLINT NameLength1,
1873                              WCHAR *UserName, SQLSMALLINT NameLength2, WCHAR *Authentication,
1874                              SQLSMALLINT NameLength3)
1875 {
1876     struct SQLConnectW_params params = { ConnectionHandle, ServerName, NameLength1, UserName, NameLength2,
1877                                          Authentication, NameLength3 };
1878     SQLRETURN ret;
1879
1880     TRACE("(ConnectionHandle %p, ServerName %s, NameLength1 %d, UserName %s, NameLength2 %d, Authentication %s,"
1881           " NameLength3 %d)\n", ConnectionHandle, debugstr_wn(ServerName, NameLength1), NameLength1,
1882           debugstr_wn(UserName, NameLength2), NameLength2, debugstr_wn(Authentication, NameLength3), NameLength3);
1883
1884     ret = ODBC_CALL( SQLConnectW, &params );
1885     TRACE("Returning %d\n", ret);
1886     return ret;
1887 }
1888
1889 /*************************************************************************
1890  *                              SQLDescribeColW          [ODBC32.108]
1891  */
1892 SQLRETURN WINAPI SQLDescribeColW(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, WCHAR *ColumnName,
1893                                  SQLSMALLINT BufferLength, SQLSMALLINT *NameLength, SQLSMALLINT *DataType,
1894                                  SQLULEN *ColumnSize, SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
1895 {
1896     struct SQLDescribeColW_params params = { StatementHandle, ColumnNumber, ColumnName, BufferLength,
1897                                              NameLength, DataType, ColumnSize, DecimalDigits, Nullable };
1898     SQLSMALLINT dummy;
1899     SQLRETURN ret;
1900
1901     TRACE("(StatementHandle %p, ColumnNumber %d, ColumnName %p, BufferLength %d, NameLength %p, DataType %p,"
1902           " ColumnSize %p, DecimalDigits %p, Nullable %p)\n", StatementHandle, ColumnNumber, ColumnName,
1903           BufferLength, NameLength, DataType, ColumnSize, DecimalDigits, Nullable);
1904
1905     if (!NameLength) NameLength = &dummy; /* workaround for drivers that don't accept NULL NameLength */
1906
1907     ret = ODBC_CALL( SQLDescribeColW, &params );
1908     if (ret >= 0)
1909     {
1910         if (ColumnName && NameLength) TRACE("ColumnName %s\n", debugstr_wn(ColumnName, *NameLength));
1911         if (DataType) TRACE("DataType %d\n", *DataType);
1912         if (ColumnSize) TRACE("ColumnSize %s\n", debugstr_sqlulen(*ColumnSize));
1913         if (DecimalDigits) TRACE("DecimalDigits %d\n", *DecimalDigits);
1914         if (Nullable) TRACE("Nullable %d\n", *Nullable);
1915     }
1916
1917     TRACE("Returning %d\n", ret);
1918     return ret;
1919 }
1920
1921 /*************************************************************************
1922  *                              SQLErrorW          [ODBC32.110]
1923  */
1924 SQLRETURN WINAPI SQLErrorW(SQLHENV EnvironmentHandle, SQLHDBC ConnectionHandle, SQLHSTMT StatementHandle,
1925                            WCHAR *Sqlstate, SQLINTEGER *NativeError, WCHAR *MessageText,
1926                            SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
1927 {
1928     struct SQLErrorW_params params = { EnvironmentHandle, ConnectionHandle, StatementHandle, Sqlstate,
1929                                        NativeError, MessageText, BufferLength, TextLength };
1930     SQLRETURN ret;
1931
1932     TRACE("(EnvironmentHandle %p, ConnectionHandle %p, StatementHandle %p, Sqlstate %p, NativeError %p,"
1933           " MessageText %p, BufferLength %d, TextLength %p)\n", EnvironmentHandle, ConnectionHandle,
1934           StatementHandle, Sqlstate, NativeError, MessageText, BufferLength, TextLength);
1935
1936     ret = ODBC_CALL( SQLErrorW, &params );
1937
1938     if (ret == SQL_SUCCESS)
1939     {
1940         TRACE(" SQLState %s\n", debugstr_wn(Sqlstate, 5));
1941         TRACE(" Error %d\n", *NativeError);
1942         TRACE(" MessageText %s\n", debugstr_wn(MessageText, *TextLength));
1943     }
1944
1945     TRACE("Returning %d\n", ret);
1946     return ret;
1947 }
1948
1949 /*************************************************************************
1950  *                              SQLExecDirectW          [ODBC32.111]
1951  */
1952 SQLRETURN WINAPI SQLExecDirectW(SQLHSTMT StatementHandle, WCHAR *StatementText, SQLINTEGER TextLength)
1953 {
1954     struct SQLExecDirectW_params params = { StatementHandle, StatementText, TextLength };
1955     SQLRETURN ret;
1956
1957     TRACE("(StatementHandle %p, StatementText %s, TextLength %d)\n", StatementHandle,
1958           debugstr_wn(StatementText, TextLength), TextLength);
1959
1960     ret = ODBC_CALL( SQLExecDirectW, &params );
1961     TRACE("Returning %d\n", ret);
1962     return ret;
1963 }
1964
1965 /*************************************************************************
1966  *                              SQLGetCursorNameW          [ODBC32.117]
1967  */
1968 SQLRETURN WINAPI SQLGetCursorNameW(SQLHSTMT StatementHandle, WCHAR *CursorName, SQLSMALLINT BufferLength,
1969                                    SQLSMALLINT *NameLength)
1970 {
1971     struct SQLGetCursorNameW_params params = { StatementHandle, CursorName, BufferLength, NameLength };
1972     SQLRETURN ret;
1973
1974     TRACE("(StatementHandle %p, CursorName %p, BufferLength %d, NameLength %p)\n", StatementHandle, CursorName,
1975           BufferLength, NameLength);
1976
1977     ret = ODBC_CALL( SQLGetCursorNameW, &params );
1978     TRACE("Returning %d\n", ret);
1979     return ret;
1980 }
1981
1982 /*************************************************************************
1983  *                              SQLPrepareW          [ODBC32.119]
1984  */
1985 SQLRETURN WINAPI SQLPrepareW(SQLHSTMT StatementHandle, WCHAR *StatementText, SQLINTEGER TextLength)
1986 {
1987     struct SQLPrepareW_params params = { StatementHandle, StatementText, TextLength };
1988     SQLRETURN ret;
1989
1990     TRACE("(StatementHandle %p, StatementText %s, TextLength %d)\n", StatementHandle,
1991           debugstr_wn(StatementText, TextLength), TextLength);
1992
1993     ret = ODBC_CALL( SQLPrepareW, &params );
1994     TRACE("Returning %d\n", ret);
1995     return ret;
1996 }
1997
1998 /*************************************************************************
1999  *                              SQLSetCursorNameW          [ODBC32.121]
2000  */
2001 SQLRETURN WINAPI SQLSetCursorNameW(SQLHSTMT StatementHandle, WCHAR *CursorName, SQLSMALLINT NameLength)
2002 {
2003     struct SQLSetCursorNameW_params params = { StatementHandle, CursorName, NameLength };
2004     SQLRETURN ret;
2005
2006     TRACE("(StatementHandle %p, CursorName %s, NameLength %d)\n", StatementHandle,
2007           debugstr_wn(CursorName, NameLength), NameLength);
2008
2009     ret = ODBC_CALL( SQLSetCursorNameW, &params );
2010     TRACE("Returning %d\n", ret);
2011     return ret;
2012 }
2013
2014 /*************************************************************************
2015  *                              SQLColAttributeW          [ODBC32.127]
2016  */
2017 SQLRETURN WINAPI SQLColAttributeW(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber,
2018                                   SQLUSMALLINT FieldIdentifier, SQLPOINTER CharacterAttribute,
2019                                   SQLSMALLINT BufferLength, SQLSMALLINT *StringLength,
2020                                   SQLLEN *NumericAttribute)
2021 {
2022     struct SQLColAttributeW_params params = { StatementHandle, ColumnNumber, FieldIdentifier,
2023                                               CharacterAttribute, BufferLength, StringLength,
2024                                               NumericAttribute };
2025     SQLRETURN ret;
2026
2027     TRACE("StatementHandle %p ColumnNumber %d FieldIdentifier %d CharacterAttribute %p BufferLength %d"
2028           " StringLength %p NumericAttribute %p\n", StatementHandle, ColumnNumber, FieldIdentifier,
2029           CharacterAttribute, BufferLength, StringLength, NumericAttribute);
2030
2031     ret = ODBC_CALL( SQLColAttributeW, &params );
2032
2033     if (ret == SQL_SUCCESS && CharacterAttribute != NULL && SQLColAttributes_KnownStringAttribute(FieldIdentifier) &&
2034         StringLength && *StringLength != lstrlenW(CharacterAttribute) * 2)
2035     {
2036         TRACE("CHEAT: resetting name length for ADO\n");
2037         *StringLength = lstrlenW(CharacterAttribute) * 2;
2038     }
2039
2040     TRACE("Returning %d\n", ret);
2041     return ret;
2042 }
2043
2044 /*************************************************************************
2045  *                              SQLGetConnectAttrW          [ODBC32.132]
2046  */
2047 SQLRETURN WINAPI SQLGetConnectAttrW(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, SQLPOINTER Value,
2048                                     SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2049 {
2050     struct SQLGetConnectAttrW_params params = { ConnectionHandle, Attribute, Value,
2051                                                 BufferLength, StringLength };
2052     SQLRETURN ret;
2053
2054     TRACE("(ConnectionHandle %p, Attribute %d, Value %p, BufferLength %d, StringLength %p)\n", ConnectionHandle,
2055           Attribute, Value, BufferLength, StringLength);
2056
2057     ret = ODBC_CALL( SQLGetConnectAttrW, &params );
2058     TRACE("Returning %d\n", ret);
2059     return ret;
2060 }
2061
2062 /*************************************************************************
2063  *                              SQLGetDescFieldW          [ODBC32.133]
2064  */
2065 SQLRETURN WINAPI SQLGetDescFieldW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2066                                   SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2067 {
2068     struct SQLGetDescFieldW_params params = { DescriptorHandle, RecNumber, FieldIdentifier, Value,
2069                                               BufferLength, StringLength };
2070     SQLRETURN ret;
2071
2072     TRACE("(DescriptorHandle %p, RecNumber %d, FieldIdentifier %d, Value %p, BufferLength %d, StringLength %p)\n",
2073           DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength, StringLength);
2074
2075     ret = ODBC_CALL( SQLGetDescFieldW, &params );
2076     TRACE("Returning %d\n", ret);
2077     return ret;
2078 }
2079
2080 /*************************************************************************
2081  *                              SQLGetDescRecW          [ODBC32.134]
2082  */
2083 SQLRETURN WINAPI SQLGetDescRecW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, WCHAR *Name,
2084                                 SQLSMALLINT BufferLength, SQLSMALLINT *StringLength, SQLSMALLINT *Type,
2085                                 SQLSMALLINT *SubType, SQLLEN *Length, SQLSMALLINT *Precision,
2086                                 SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
2087 {
2088     struct SQLGetDescRecW_params params = { DescriptorHandle, RecNumber, Name, BufferLength, StringLength,
2089                                             Type, SubType, Length, Precision, Scale, Nullable };
2090     SQLRETURN ret;
2091
2092     TRACE("(DescriptorHandle %p, RecNumber %d, Name %p, BufferLength %d, StringLength %p, Type %p, SubType %p,"
2093           " Length %p, Precision %p, Scale %p, Nullable %p)\n", DescriptorHandle, RecNumber, Name, BufferLength,
2094           StringLength, Type, SubType, Length, Precision, Scale, Nullable);
2095
2096     ret = ODBC_CALL( SQLGetDescRecW, &params );
2097     TRACE("Returning %d\n", ret);
2098     return ret;
2099 }
2100
2101 /*************************************************************************
2102  *                              SQLGetDiagFieldW          [ODBC32.135]
2103  */
2104 SQLRETURN WINAPI SQLGetDiagFieldW(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber,
2105                                   SQLSMALLINT DiagIdentifier, SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
2106                                   SQLSMALLINT *StringLength)
2107 {
2108     struct SQLGetDiagFieldW_params params = { HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo,
2109                                               BufferLength, StringLength };
2110     SQLRETURN ret;
2111
2112     TRACE("(HandleType %d, Handle %p, RecNumber %d, DiagIdentifier %d, DiagInfo %p, BufferLength %d,"
2113           " StringLength %p)\n", HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength, StringLength);
2114
2115     ret = ODBC_CALL( SQLGetDiagFieldW, &params );
2116     TRACE("Returning %d\n", ret);
2117     return ret;
2118 }
2119
2120 /*************************************************************************
2121  *                              SQLGetDiagRecW           [ODBC32.136]
2122  */
2123 SQLRETURN WINAPI SQLGetDiagRecW(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber,
2124                                 WCHAR *Sqlstate, SQLINTEGER *NativeError, WCHAR *MessageText,
2125                                 SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
2126 {
2127     struct SQLGetDiagRecW_params params = { HandleType, Handle, RecNumber, Sqlstate, NativeError,
2128                                             MessageText, BufferLength, TextLength };
2129     SQLRETURN ret;
2130
2131     TRACE("(HandleType %d, Handle %p, RecNumber %d, Sqlstate %p, NativeError %p, MessageText %p, BufferLength %d,"
2132           " TextLength %p)\n", HandleType, Handle, RecNumber, Sqlstate, NativeError, MessageText, BufferLength,
2133           TextLength);
2134
2135     ret = ODBC_CALL( SQLGetDiagRecW, &params );
2136     TRACE("Returning %d\n", ret);
2137     return ret;
2138 }
2139
2140 /*************************************************************************
2141  *                              SQLGetStmtAttrW          [ODBC32.138]
2142  */
2143 SQLRETURN WINAPI SQLGetStmtAttrW(SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER Value,
2144                                  SQLINTEGER BufferLength, SQLINTEGER *StringLength)
2145 {
2146     struct SQLGetStmtAttrW_params params = { StatementHandle, Attribute, Value, BufferLength, StringLength };
2147     SQLRETURN ret;
2148
2149     TRACE("(StatementHandle %p, Attribute %d, Value %p, BufferLength %d, StringLength %p)\n", StatementHandle,
2150           Attribute, Value, BufferLength, StringLength);
2151
2152     if (!Value)
2153     {
2154         WARN("Unexpected NULL Value return address\n");
2155         return SQL_ERROR;
2156     }
2157
2158     ret = ODBC_CALL( SQLGetStmtAttrW, &params );
2159     TRACE("Returning %d\n", ret);
2160     return ret;
2161 }
2162
2163 /*************************************************************************
2164  *                              SQLSetConnectAttrW          [ODBC32.139]
2165  */
2166 SQLRETURN WINAPI SQLSetConnectAttrW(SQLHDBC ConnectionHandle, SQLINTEGER Attribute, SQLPOINTER Value,
2167                                     SQLINTEGER StringLength)
2168 {
2169     struct SQLSetConnectAttrW_params params = { ConnectionHandle, Attribute, Value, StringLength };
2170     SQLRETURN ret;
2171
2172     TRACE("(ConnectionHandle %p, Attribute %d, Value %p, StringLength %d)\n", ConnectionHandle, Attribute, Value,
2173           StringLength);
2174
2175     ret = ODBC_CALL( SQLSetConnectAttrW, &params );
2176     TRACE("Returning %d\n", ret);
2177     return ret;
2178 }
2179
2180 /*************************************************************************
2181  *                              SQLColumnsW          [ODBC32.140]
2182  */
2183 SQLRETURN WINAPI SQLColumnsW(SQLHSTMT StatementHandle, WCHAR *CatalogName, SQLSMALLINT NameLength1,
2184                              WCHAR *SchemaName, SQLSMALLINT NameLength2, WCHAR *TableName,
2185                              SQLSMALLINT NameLength3, WCHAR *ColumnName, SQLSMALLINT NameLength4)
2186 {
2187     struct SQLColumnsW_params params = { StatementHandle, CatalogName, NameLength1, SchemaName,
2188                                          NameLength2, TableName, NameLength3, ColumnName, NameLength4 };
2189     SQLRETURN ret;
2190
2191     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d, TableName %s,"
2192           " NameLength3 %d, ColumnName %s, NameLength4 %d)\n", StatementHandle,
2193           debugstr_wn(CatalogName, NameLength1), NameLength1, debugstr_wn(SchemaName, NameLength2), NameLength2,
2194           debugstr_wn(TableName, NameLength3), NameLength3, debugstr_wn(ColumnName, NameLength4), NameLength4);
2195
2196     ret = ODBC_CALL( SQLColumnsW, &params );
2197     TRACE("Returning %d\n", ret);
2198     return ret;
2199 }
2200
2201 /*************************************************************************
2202  *                              SQLDriverConnectW          [ODBC32.141]
2203  */
2204 SQLRETURN WINAPI SQLDriverConnectW(SQLHDBC ConnectionHandle, SQLHWND WindowHandle, WCHAR *InConnectionString,
2205                                    SQLSMALLINT Length, WCHAR *OutConnectionString, SQLSMALLINT BufferLength,
2206                                    SQLSMALLINT *Length2, SQLUSMALLINT DriverCompletion)
2207 {
2208     struct SQLDriverConnectW_params params = { ConnectionHandle, WindowHandle, InConnectionString, Length,
2209                                                OutConnectionString, BufferLength, Length2, DriverCompletion };
2210     SQLRETURN ret;
2211
2212     TRACE("(ConnectionHandle %p, WindowHandle %p, InConnectionString %s, Length %d, OutConnectionString %p,"
2213           " BufferLength %d, Length2 %p, DriverCompletion %d)\n", ConnectionHandle, WindowHandle,
2214           debugstr_wn(InConnectionString, Length), Length, OutConnectionString, BufferLength, Length2,
2215           DriverCompletion);
2216
2217     ret = ODBC_CALL( SQLDriverConnectW, &params );
2218     TRACE("Returning %d\n", ret);
2219     return ret;
2220 }
2221
2222 /*************************************************************************
2223  *                              SQLGetConnectOptionW      [ODBC32.142]
2224  */
2225 SQLRETURN WINAPI SQLGetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLPOINTER Value)
2226 {
2227     struct SQLGetConnectOptionW_params params = { ConnectionHandle, Option, Value };
2228     SQLRETURN ret;
2229
2230     TRACE("(ConnectionHandle %p, Option %d, Value %p)\n", ConnectionHandle, Option, Value);
2231
2232     ret = ODBC_CALL( SQLGetConnectOptionW, &params );
2233     TRACE("Returning %d\n", ret);
2234     return ret;
2235 }
2236
2237 /*************************************************************************
2238  *                              SQLGetInfoW          [ODBC32.145]
2239  */
2240 SQLRETURN WINAPI SQLGetInfoW(SQLHDBC ConnectionHandle, SQLUSMALLINT InfoType, SQLPOINTER InfoValue,
2241                              SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
2242 {
2243     struct SQLGetInfoW_params params = { ConnectionHandle, InfoType, InfoValue, BufferLength, StringLength };
2244     SQLRETURN ret;
2245
2246     TRACE("(ConnectionHandle, %p, InfoType %d, InfoValue %p, BufferLength %d, StringLength %p)\n", ConnectionHandle,
2247           InfoType, InfoValue, BufferLength, StringLength);
2248
2249     if (!InfoValue)
2250     {
2251         WARN("Unexpected NULL InfoValue address\n");
2252         return SQL_ERROR;
2253     }
2254
2255     ret = ODBC_CALL( SQLGetInfoW, &params );
2256     TRACE("Returning %d\n", ret);
2257     return ret;
2258 }
2259
2260 /*************************************************************************
2261  *                              SQLGetTypeInfoW          [ODBC32.147]
2262  */
2263 SQLRETURN WINAPI SQLGetTypeInfoW(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
2264 {
2265     struct SQLGetTypeInfoW_params params = { StatementHandle, DataType };
2266     SQLRETURN ret;
2267
2268     TRACE("(StatementHandle %p, DataType %d)\n", StatementHandle, DataType);
2269
2270     ret = ODBC_CALL( SQLGetTypeInfoW, &params );
2271     TRACE("Returning %d\n", ret);
2272     return ret;
2273 }
2274
2275 /*************************************************************************
2276  *                              SQLSetConnectOptionW          [ODBC32.150]
2277  */
2278 SQLRETURN WINAPI SQLSetConnectOptionW(SQLHDBC ConnectionHandle, SQLUSMALLINT Option, SQLLEN Value)
2279 {
2280     struct SQLSetConnectOptionW_params params = { ConnectionHandle, Option, Value };
2281     SQLRETURN ret;
2282
2283     TRACE("(ConnectionHandle %p, Option %d, Value %s)\n", ConnectionHandle, Option, debugstr_sqllen(Value));
2284
2285     ret = ODBC_CALL( SQLSetConnectOptionW, &params );
2286     TRACE("Returning %d\n", ret);
2287     return ret;
2288 }
2289
2290 /*************************************************************************
2291  *                              SQLSpecialColumnsW          [ODBC32.152]
2292  */
2293 SQLRETURN WINAPI SQLSpecialColumnsW(SQLHSTMT StatementHandle, SQLUSMALLINT IdentifierType,
2294                                     SQLWCHAR *CatalogName, SQLSMALLINT NameLength1, SQLWCHAR *SchemaName,
2295                                     SQLSMALLINT NameLength2, SQLWCHAR *TableName, SQLSMALLINT NameLength3,
2296                                     SQLUSMALLINT Scope, SQLUSMALLINT Nullable)
2297 {
2298     struct SQLSpecialColumnsW_params params = { StatementHandle, IdentifierType, CatalogName, NameLength1,
2299                                                 SchemaName, NameLength2, TableName, NameLength3, Scope, Nullable };
2300     SQLRETURN ret;
2301
2302     TRACE("(StatementHandle %p, IdentifierType %d, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d,"
2303           " TableName %s, NameLength3 %d, Scope %d, Nullable %d)\n", StatementHandle, IdentifierType,
2304           debugstr_wn(CatalogName, NameLength1), NameLength1, debugstr_wn(SchemaName, NameLength2), NameLength2,
2305           debugstr_wn(TableName, NameLength3), NameLength3, Scope, Nullable);
2306
2307     ret = ODBC_CALL( SQLSpecialColumnsW, &params );
2308     TRACE("Returning %d\n", ret);
2309     return ret;
2310 }
2311
2312 /*************************************************************************
2313  *                              SQLStatisticsW          [ODBC32.153]
2314  */
2315 SQLRETURN WINAPI SQLStatisticsW(SQLHSTMT StatementHandle, SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2316                                 SQLWCHAR *SchemaName, SQLSMALLINT NameLength2, SQLWCHAR *TableName,
2317                                 SQLSMALLINT NameLength3, SQLUSMALLINT Unique, SQLUSMALLINT Reserved)
2318 {
2319     struct SQLStatisticsW_params params = { StatementHandle, CatalogName, NameLength1, SchemaName,
2320                                             NameLength2, TableName, NameLength3, Unique, Reserved };
2321     SQLRETURN ret;
2322
2323     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d SchemaName %s, NameLength2 %d, TableName %s"
2324           " NameLength3 %d, Unique %d, Reserved %d)\n", StatementHandle,
2325           debugstr_wn(CatalogName, NameLength1), NameLength1, debugstr_wn(SchemaName, NameLength2), NameLength2,
2326           debugstr_wn(TableName, NameLength3), NameLength3, Unique, Reserved);
2327
2328     ret = ODBC_CALL( SQLStatisticsW, &params );
2329     TRACE("Returning %d\n", ret);
2330     return ret;
2331 }
2332
2333 /*************************************************************************
2334  *                              SQLTablesW          [ODBC32.154]
2335  */
2336 SQLRETURN WINAPI SQLTablesW(SQLHSTMT StatementHandle, SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
2337                             SQLWCHAR *SchemaName, SQLSMALLINT NameLength2, SQLWCHAR *TableName,
2338                             SQLSMALLINT NameLength3, SQLWCHAR *TableType, SQLSMALLINT NameLength4)
2339 {
2340     struct SQLTablesW_params params = { StatementHandle, CatalogName, NameLength1, SchemaName, NameLength2,
2341                                         TableName, NameLength3, TableType, NameLength4 };
2342     SQLRETURN ret;
2343
2344     TRACE("(StatementHandle %p, CatalogName %s, NameLength1 %d, SchemaName %s, NameLength2 %d, TableName %s,"
2345           " NameLength3 %d, TableType %s, NameLength4 %d)\n", StatementHandle,
2346           debugstr_wn(CatalogName, NameLength1), NameLength1, debugstr_wn(SchemaName, NameLength2), NameLength2,
2347           debugstr_wn(TableName, NameLength3), NameLength3, debugstr_wn(TableType, NameLength4), NameLength4);
2348
2349     ret = ODBC_CALL( SQLTablesW, &params );
2350     TRACE("Returning %d\n", ret);
2351     return ret;
2352 }
2353
2354 /*************************************************************************
2355  *                              SQLBrowseConnectW          [ODBC32.155]
2356  */
2357 SQLRETURN WINAPI SQLBrowseConnectW(SQLHDBC hdbc, SQLWCHAR *szConnStrIn, SQLSMALLINT cbConnStrIn,
2358                                    SQLWCHAR *szConnStrOut, SQLSMALLINT cbConnStrOutMax,
2359                                    SQLSMALLINT *pcbConnStrOut)
2360 {
2361     struct SQLBrowseConnectW_params params = { hdbc, szConnStrIn, cbConnStrIn, szConnStrOut,
2362                                                cbConnStrOutMax, pcbConnStrOut };
2363     SQLRETURN ret;
2364
2365     TRACE("(hdbc %p, szConnStrIn %s, cbConnStrIn %d, szConnStrOut %p, cbConnStrOutMax %d, pcbConnStrOut %p)\n",
2366           hdbc, debugstr_wn(szConnStrIn, cbConnStrIn), cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
2367
2368     ret = ODBC_CALL( SQLBrowseConnectW, &params );
2369     TRACE("Returning %d\n", ret);
2370     return ret;
2371 }
2372
2373 /*************************************************************************
2374  *                              SQLColumnPrivilegesW          [ODBC32.156]
2375  */
2376 SQLRETURN WINAPI SQLColumnPrivilegesW(SQLHSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
2377                                       SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szTableName,
2378                                       SQLSMALLINT cbTableName, SQLWCHAR *szColumnName, SQLSMALLINT cbColumnName)
2379 {
2380     struct SQLColumnPrivilegesW_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
2381                                                   cbSchemaName, szTableName, cbTableName, szColumnName,
2382                                                   cbColumnName };
2383     SQLRETURN ret;
2384
2385     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
2386           " cbTableName %d, szColumnName %s, cbColumnName %d)\n", hstmt,
2387           debugstr_wn(szCatalogName, cbCatalogName), cbCatalogName,
2388           debugstr_wn(szSchemaName, cbSchemaName), cbSchemaName,
2389           debugstr_wn(szTableName, cbTableName), cbTableName,
2390           debugstr_wn(szColumnName, cbColumnName), cbColumnName);
2391
2392     ret = ODBC_CALL( SQLColumnPrivilegesW, &params );
2393     TRACE("Returning %d\n", ret);
2394     return ret;
2395 }
2396
2397 /*************************************************************************
2398  *                              SQLDataSourcesW          [ODBC32.157]
2399  */
2400 SQLRETURN WINAPI SQLDataSourcesW(SQLHENV EnvironmentHandle, SQLUSMALLINT Direction, WCHAR *ServerName,
2401                                  SQLSMALLINT BufferLength1, SQLSMALLINT *NameLength1, WCHAR *Description,
2402                                  SQLSMALLINT BufferLength2, SQLSMALLINT *NameLength2)
2403 {
2404     struct SQLDataSourcesW_params params = { EnvironmentHandle, Direction, ServerName, BufferLength1,
2405                                              NameLength1, Description, BufferLength2, NameLength2 };
2406     SQLRETURN ret;
2407
2408     TRACE("(EnvironmentHandle %p, Direction %d, ServerName %p, BufferLength1 %d, NameLength1 %p, Description %p,"
2409           " BufferLength2 %d, NameLength2 %p)\n", EnvironmentHandle, Direction, ServerName, BufferLength1,
2410           NameLength1, Description, BufferLength2, NameLength2);
2411
2412     ret = ODBC_CALL( SQLDataSourcesW, &params );
2413
2414     if (ret >= 0 && TRACE_ON(odbc))
2415     {
2416         if (ServerName && NameLength1 && *NameLength1 > 0)
2417             TRACE(" DataSource %s", debugstr_wn(ServerName, *NameLength1));
2418         if (Description && NameLength2 && *NameLength2 > 0)
2419             TRACE(" Description %s", debugstr_wn(Description, *NameLength2));
2420         TRACE("\n");
2421     }
2422
2423     TRACE("Returning %d\n", ret);
2424     return ret;
2425 }
2426
2427 /*************************************************************************
2428  *                              SQLForeignKeysW          [ODBC32.160]
2429  */
2430 SQLRETURN WINAPI SQLForeignKeysW(SQLHSTMT hstmt, SQLWCHAR *szPkCatalogName, SQLSMALLINT cbPkCatalogName,
2431                                  SQLWCHAR *szPkSchemaName, SQLSMALLINT cbPkSchemaName, SQLWCHAR *szPkTableName,
2432                                  SQLSMALLINT cbPkTableName, SQLWCHAR *szFkCatalogName,
2433                                  SQLSMALLINT cbFkCatalogName, SQLWCHAR *szFkSchemaName,
2434                                  SQLSMALLINT cbFkSchemaName, SQLWCHAR *szFkTableName, SQLSMALLINT cbFkTableName)
2435 {
2436     struct SQLForeignKeysW_params params = { hstmt, szPkCatalogName, cbPkCatalogName, szPkSchemaName,
2437                                              cbPkSchemaName, szPkTableName, cbPkTableName, szFkCatalogName,
2438                                              cbFkCatalogName, szFkSchemaName, cbFkSchemaName, szFkTableName,
2439                                              cbFkTableName };
2440     SQLRETURN ret;
2441
2442     TRACE("(hstmt %p, szPkCatalogName %s, cbPkCatalogName %d, szPkSchemaName %s, cbPkSchemaName %d,"
2443           " szPkTableName %s, cbPkTableName %d, szFkCatalogName %s, cbFkCatalogName %d, szFkSchemaName %s,"
2444           " cbFkSchemaName %d, szFkTableName %s, cbFkTableName %d)\n", hstmt,
2445           debugstr_wn(szPkCatalogName, cbPkCatalogName), cbPkCatalogName,
2446           debugstr_wn(szPkSchemaName, cbPkSchemaName), cbPkSchemaName,
2447           debugstr_wn(szPkTableName, cbPkTableName), cbPkTableName,
2448           debugstr_wn(szFkCatalogName, cbFkCatalogName), cbFkCatalogName,
2449           debugstr_wn(szFkSchemaName, cbFkSchemaName), cbFkSchemaName,
2450           debugstr_wn(szFkTableName, cbFkTableName), cbFkTableName);
2451
2452     ret = ODBC_CALL( SQLForeignKeysW, &params );
2453     TRACE("Returning %d\n", ret);
2454     return ret;
2455 }
2456
2457 /*************************************************************************
2458  *                              SQLNativeSqlW          [ODBC32.162]
2459  */
2460 SQLRETURN WINAPI SQLNativeSqlW(SQLHDBC hdbc, SQLWCHAR *szSqlStrIn, SQLINTEGER cbSqlStrIn, SQLWCHAR *szSqlStr,
2461                                SQLINTEGER cbSqlStrMax, SQLINTEGER *pcbSqlStr)
2462 {
2463     struct SQLNativeSqlW_params params = { hdbc, szSqlStrIn, cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr };
2464     SQLRETURN ret;
2465
2466     TRACE("(hdbc %p, szSqlStrIn %s, cbSqlStrIn %d, szSqlStr %p, cbSqlStrMax %d, pcbSqlStr %p)\n", hdbc,
2467           debugstr_wn(szSqlStrIn, cbSqlStrIn), cbSqlStrIn, szSqlStr, cbSqlStrMax, pcbSqlStr);
2468
2469     ret = ODBC_CALL( SQLNativeSqlW, &params );
2470     TRACE("Returning %d\n", ret);
2471     return ret;
2472 }
2473
2474 /*************************************************************************
2475  *                              SQLPrimaryKeysW          [ODBC32.165]
2476  */
2477 SQLRETURN WINAPI SQLPrimaryKeysW(SQLHSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
2478                                  SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szTableName,
2479                                  SQLSMALLINT cbTableName)
2480 {
2481     struct SQLPrimaryKeysW_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
2482                                              cbSchemaName, szTableName, cbTableName };
2483     SQLRETURN ret;
2484
2485     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
2486           " cbTableName %d)\n", hstmt,
2487           debugstr_wn(szCatalogName, cbCatalogName), cbCatalogName,
2488           debugstr_wn(szSchemaName, cbSchemaName), cbSchemaName,
2489           debugstr_wn(szTableName, cbTableName), cbTableName);
2490
2491     ret = ODBC_CALL( SQLPrimaryKeysW, &params );
2492     TRACE("Returning %d\n", ret);
2493     return ret;
2494 }
2495
2496 /*************************************************************************
2497  *                              SQLProcedureColumnsW          [ODBC32.166]
2498  */
2499 SQLRETURN WINAPI SQLProcedureColumnsW(SQLHSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
2500                                       SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szProcName,
2501                                       SQLSMALLINT cbProcName, SQLWCHAR *szColumnName, SQLSMALLINT cbColumnName)
2502 {
2503     struct SQLProcedureColumnsW_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
2504                                                   cbSchemaName, szProcName, cbProcName,
2505                                                   szColumnName, cbColumnName };
2506     SQLRETURN ret;
2507
2508     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szProcName %s,"
2509           " cbProcName %d, szColumnName %s, cbColumnName %d)\n", hstmt,
2510           debugstr_wn(szCatalogName, cbCatalogName), cbCatalogName,
2511           debugstr_wn(szSchemaName, cbSchemaName), cbSchemaName,
2512           debugstr_wn(szProcName, cbProcName), cbProcName,
2513           debugstr_wn(szColumnName, cbColumnName), cbColumnName);
2514
2515     ret = ODBC_CALL( SQLProcedureColumnsW, &params );
2516     TRACE("Returning %d\n", ret);
2517     return ret;
2518 }
2519
2520 /*************************************************************************
2521  *                              SQLProceduresW          [ODBC32.167]
2522  */
2523 SQLRETURN WINAPI SQLProceduresW(SQLHSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
2524                                 SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szProcName,
2525                                 SQLSMALLINT cbProcName)
2526 {
2527     struct SQLProceduresW_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
2528                                             cbSchemaName, szProcName, cbProcName };
2529     SQLRETURN ret;
2530
2531     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szProcName %s,"
2532           " cbProcName %d)\n", hstmt, debugstr_wn(szCatalogName, cbCatalogName), cbCatalogName,
2533           debugstr_wn(szSchemaName, cbSchemaName), cbSchemaName, debugstr_wn(szProcName, cbProcName), cbProcName);
2534
2535     ret = ODBC_CALL( SQLProceduresW, &params );
2536     TRACE("Returning %d\n", ret);
2537     return ret;
2538 }
2539
2540 /*************************************************************************
2541  *                              SQLTablePrivilegesW          [ODBC32.170]
2542  */
2543 SQLRETURN WINAPI SQLTablePrivilegesW(SQLHSTMT hstmt, SQLWCHAR *szCatalogName, SQLSMALLINT cbCatalogName,
2544                                      SQLWCHAR *szSchemaName, SQLSMALLINT cbSchemaName, SQLWCHAR *szTableName,
2545                                      SQLSMALLINT cbTableName)
2546 {
2547     struct SQLTablePrivilegesW_params params = { hstmt, szCatalogName, cbCatalogName, szSchemaName,
2548                                                  cbSchemaName, szTableName, cbTableName };
2549     SQLRETURN ret;
2550
2551     TRACE("(hstmt %p, szCatalogName %s, cbCatalogName %d, szSchemaName %s, cbSchemaName %d, szTableName %s,"
2552           " cbTableName %d)\n", hstmt, debugstr_wn(szCatalogName, cbCatalogName), cbCatalogName,
2553           debugstr_wn(szSchemaName, cbSchemaName), cbSchemaName, debugstr_wn(szTableName, cbTableName), cbTableName);
2554
2555     ret = ODBC_CALL( SQLTablePrivilegesW, &params );
2556     TRACE("Returning %d\n", ret);
2557     return ret;
2558 }
2559
2560 /*************************************************************************
2561  *                              SQLDriversW          [ODBC32.171]
2562  */
2563 SQLRETURN WINAPI SQLDriversW(SQLHENV EnvironmentHandle, SQLUSMALLINT fDirection, SQLWCHAR *szDriverDesc,
2564                              SQLSMALLINT cbDriverDescMax, SQLSMALLINT *pcbDriverDesc,
2565                              SQLWCHAR *szDriverAttributes, SQLSMALLINT cbDriverAttrMax,
2566                              SQLSMALLINT *pcbDriverAttr)
2567 {
2568     struct SQLDriversW_params params = { EnvironmentHandle, fDirection, szDriverDesc, cbDriverDescMax,
2569                                          pcbDriverDesc, szDriverAttributes, cbDriverAttrMax, pcbDriverAttr };
2570     SQLRETURN ret;
2571
2572     TRACE("(EnvironmentHandle %p, Direction %d, szDriverDesc %p, cbDriverDescMax %d, pcbDriverDesc %p,"
2573           " DriverAttributes %p, cbDriverAttrMax %d, pcbDriverAttr %p)\n", EnvironmentHandle, fDirection,
2574           szDriverDesc, cbDriverDescMax, pcbDriverDesc, szDriverAttributes, cbDriverAttrMax, pcbDriverAttr);
2575
2576     ret = ODBC_CALL( SQLDriversW, &params );
2577
2578     if (ret == SQL_NO_DATA && fDirection == SQL_FETCH_FIRST)
2579         ERR_(winediag)("No ODBC drivers could be found. Check the settings for your libodbc provider.\n");
2580
2581     TRACE("Returning %d\n", ret);
2582     return ret;
2583 }
2584
2585 /*************************************************************************
2586  *                              SQLSetDescFieldW          [ODBC32.173]
2587  */
2588 SQLRETURN WINAPI SQLSetDescFieldW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier,
2589                                   SQLPOINTER Value, SQLINTEGER BufferLength)
2590 {
2591     struct SQLSetDescFieldW_params params = { DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength };
2592     SQLRETURN ret;
2593
2594     TRACE("(DescriptorHandle %p, RecNumber %d, FieldIdentifier %d, Value %p, BufferLength %d)\n", DescriptorHandle,
2595           RecNumber, FieldIdentifier, Value, BufferLength);
2596
2597     ret = ODBC_CALL( SQLSetDescFieldW, &params );
2598     TRACE("Returning %d\n", ret);
2599     return ret;
2600 }
2601
2602 /*************************************************************************
2603  *                              SQLSetStmtAttrW          [ODBC32.176]
2604  */
2605 SQLRETURN WINAPI SQLSetStmtAttrW(SQLHSTMT StatementHandle, SQLINTEGER Attribute, SQLPOINTER Value,
2606                                  SQLINTEGER StringLength)
2607 {
2608     struct SQLSetStmtAttrW_params params = { StatementHandle, Attribute, Value, StringLength };
2609     SQLRETURN ret;
2610
2611     TRACE("(StatementHandle %p, Attribute %d, Value %p, StringLength %d)\n", StatementHandle, Attribute, Value,
2612           StringLength);
2613
2614     ret = ODBC_CALL( SQLSetStmtAttrW, &params );
2615     if (ret == SQL_ERROR && (Attribute == SQL_ROWSET_SIZE || Attribute == SQL_ATTR_ROW_ARRAY_SIZE))
2616     {
2617         TRACE("CHEAT: returning SQL_SUCCESS to ADO\n");
2618         return SQL_SUCCESS;
2619     }
2620
2621     TRACE("Returning %d\n", ret);
2622     return ret;
2623 }
2624
2625 /*************************************************************************
2626  *                              SQLGetDiagRecA           [ODBC32.236]
2627  */
2628 SQLRETURN WINAPI SQLGetDiagRecA(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber,
2629                                 SQLCHAR *Sqlstate, SQLINTEGER *NativeError, SQLCHAR *MessageText,
2630                                 SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
2631 {
2632     struct SQLGetDiagRecA_params params = { HandleType, Handle, RecNumber, Sqlstate, NativeError,
2633                                             MessageText, BufferLength, TextLength };
2634     SQLRETURN ret;
2635
2636     TRACE("(HandleType %d, Handle %p, RecNumber %d, Sqlstate %p, NativeError %p, MessageText %p, BufferLength %d,"
2637           " TextLength %p)\n", HandleType, Handle, RecNumber, Sqlstate, NativeError, MessageText, BufferLength,
2638           TextLength);
2639
2640     ret = ODBC_CALL( SQLGetDiagRecA, &params );
2641     TRACE("Returning %d\n", ret);
2642     return ret;
2643 }
2644
2645
2646 /***********************************************************************
2647  * DllMain [Internal] Initializes the internal 'ODBC32.DLL'.
2648  */
2649 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
2650 {
2651     TRACE("proxy ODBC: %p,%x,%p\n", hinstDLL, reason, reserved);
2652
2653     switch (reason)
2654     {
2655     case DLL_PROCESS_ATTACH:
2656        DisableThreadLibraryCalls(hinstDLL);
2657         if (!NtQueryVirtualMemory( GetCurrentProcess(), hinstDLL, MemoryWineUnixFuncs,
2658                                    &odbc_handle, sizeof(odbc_handle), NULL ) &&
2659             !__wine_unix_call( odbc_handle, process_attach, NULL))
2660         {
2661             ODBC_ReplicateToRegistry();
2662         }
2663        break;
2664
2665     case DLL_PROCESS_DETACH:
2666       if (reserved) break;
2667       __wine_unix_call( odbc_handle, process_detach, NULL );
2668     }
2669
2670     return TRUE;
2671 }