4static SQLRETURN _SQLDriverConnect(SQLHDBC hdbc,
 
    6    ODBC_CHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
 
    7    ODBC_CHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
 
    8    SQLUSMALLINT fDriverCompletion, 
int wide);
 
   10SQLRETURN ODBC_PUBLIC ODBC_API SQLDriverConnectW(
 
   13    SQLWCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
 
   14    SQLWCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
 
   15    SQLUSMALLINT fDriverCompletion)
 
   17    if (TDS_UNLIKELY(tds_write_dump)) {
 
   19        tdsdump_log(TDS_DBG_FUNC, 
"SQLDriverConnectW(%p, %p, %ls, %d, %p, %d, %p, %u)\n",
 
   22            SQLWSTR(szConnStrIn), (
int) cbConnStrIn,
 
   23            szConnStrOut, (
int) cbConnStrOutMax, pcbConnStrOut,
 
   24            (
unsigned int) fDriverCompletion);
 
   27    return _SQLDriverConnect(hdbc,
 
   29        (ODBC_CHAR*) szConnStrIn, cbConnStrIn,
 
   30        (ODBC_CHAR*) szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
 
   31        fDriverCompletion, 1);
 
   35SQLRETURN ODBC_PUBLIC ODBC_API SQLDriverConnect(
 
   38    SQLCHAR * szConnStrIn, SQLSMALLINT cbConnStrIn,
 
   39    SQLCHAR * szConnStrOut, SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR* pcbConnStrOut,
 
   40    SQLUSMALLINT fDriverCompletion)
 
   42    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLDriverConnect(%p, %p, %s, %d, %p, %d, %p, %u)\n",
 
   45            (
const char*) szConnStrIn, (
int) cbConnStrIn,
 
   46            szConnStrOut, (
int) cbConnStrOutMax, pcbConnStrOut,
 
   47            (
unsigned int) fDriverCompletion);
 
   48#ifdef ENABLE_ODBC_WIDE 
   49    return _SQLDriverConnect(hdbc,
 
   51        (ODBC_CHAR*) szConnStrIn, cbConnStrIn,
 
   52        (ODBC_CHAR*) szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
 
   53        fDriverCompletion, 0);
 
   55    return _SQLDriverConnect(hdbc,
 
   57        szConnStrIn, cbConnStrIn,
 
   58        szConnStrOut, cbConnStrOutMax, pcbConnStrOut,
 
   63#ifdef ENABLE_ODBC_WIDE 
   64static SQLRETURN _SQLColumnPrivileges(SQLHSTMT hstmt,
 
   65    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
   66    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
   67    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName,
 
   68    ODBC_CHAR * szColumnName, SQLSMALLINT cbColumnName, 
int wide);
 
   70SQLRETURN ODBC_PUBLIC ODBC_API SQLColumnPrivilegesW(
 
   72    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
   73    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
   74    SQLWCHAR * szTableName, SQLSMALLINT cbTableName,
 
   75    SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
   77    if (TDS_UNLIKELY(tds_write_dump)) {
 
   79        tdsdump_log(TDS_DBG_FUNC, 
"SQLColumnPrivilegesW(%p, %ls, %d, %ls, %d, %ls, %d, %ls, %d)\n",
 
   81            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
   82            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
   83            SQLWSTR(szTableName), (
int) cbTableName,
 
   84            SQLWSTR(szColumnName), (
int) cbColumnName);
 
   87    return _SQLColumnPrivileges(hstmt,
 
   88        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
   89        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
   90        (ODBC_CHAR*) szTableName, cbTableName,
 
   91        (ODBC_CHAR*) szColumnName, cbColumnName, 1);
 
   95SQLRETURN ODBC_PUBLIC ODBC_API SQLColumnPrivileges(
 
   97    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
   98    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
   99    SQLCHAR * szTableName, SQLSMALLINT cbTableName,
 
  100    SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
  102    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLColumnPrivileges(%p, %s, %d, %s, %d, %s, %d, %s, %d)\n",
 
  104            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  105            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  106            (
const char*) szTableName, (
int) cbTableName,
 
  107            (
const char*) szColumnName, (
int) cbColumnName);
 
  108#ifdef ENABLE_ODBC_WIDE 
  109    return _SQLColumnPrivileges(hstmt,
 
  110        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  111        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  112        (ODBC_CHAR*) szTableName, cbTableName,
 
  113        (ODBC_CHAR*) szColumnName, cbColumnName, 0);
 
  115    return _SQLColumnPrivileges(hstmt,
 
  116        szCatalogName, cbCatalogName,
 
  117        szSchemaName, cbSchemaName,
 
  118        szTableName, cbTableName,
 
  119        szColumnName, cbColumnName);
 
  123#ifdef ENABLE_ODBC_WIDE 
  124static SQLRETURN _SQLForeignKeys(SQLHSTMT hstmt,
 
  125    ODBC_CHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName,
 
  126    ODBC_CHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName,
 
  127    ODBC_CHAR * szPkTableName, SQLSMALLINT cbPkTableName,
 
  128    ODBC_CHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName,
 
  129    ODBC_CHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName,
 
  130    ODBC_CHAR * szFkTableName, SQLSMALLINT cbFkTableName, 
int wide);
 
  132SQLRETURN ODBC_PUBLIC ODBC_API SQLForeignKeysW(
 
  134    SQLWCHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName,
 
  135    SQLWCHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName,
 
  136    SQLWCHAR * szPkTableName, SQLSMALLINT cbPkTableName,
 
  137    SQLWCHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName,
 
  138    SQLWCHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName,
 
  139    SQLWCHAR * szFkTableName, SQLSMALLINT cbFkTableName)
 
  141    if (TDS_UNLIKELY(tds_write_dump)) {
 
  143        tdsdump_log(TDS_DBG_FUNC, 
"SQLForeignKeysW(%p, %ls, %d, %ls, %d, %ls, %d, %ls, %d, %ls, %d, %ls, %d)\n",
 
  145            SQLWSTR(szPkCatalogName), (
int) cbPkCatalogName,
 
  146            SQLWSTR(szPkSchemaName), (
int) cbPkSchemaName,
 
  147            SQLWSTR(szPkTableName), (
int) cbPkTableName,
 
  148            SQLWSTR(szFkCatalogName), (
int) cbFkCatalogName,
 
  149            SQLWSTR(szFkSchemaName), (
int) cbFkSchemaName,
 
  150            SQLWSTR(szFkTableName), (
int) cbFkTableName);
 
  153    return _SQLForeignKeys(hstmt,
 
  154        (ODBC_CHAR*) szPkCatalogName, cbPkCatalogName,
 
  155        (ODBC_CHAR*) szPkSchemaName, cbPkSchemaName,
 
  156        (ODBC_CHAR*) szPkTableName, cbPkTableName,
 
  157        (ODBC_CHAR*) szFkCatalogName, cbFkCatalogName,
 
  158        (ODBC_CHAR*) szFkSchemaName, cbFkSchemaName,
 
  159        (ODBC_CHAR*) szFkTableName, cbFkTableName, 1);
 
  163SQLRETURN ODBC_PUBLIC ODBC_API SQLForeignKeys(
 
  165    SQLCHAR * szPkCatalogName, SQLSMALLINT cbPkCatalogName,
 
  166    SQLCHAR * szPkSchemaName, SQLSMALLINT cbPkSchemaName,
 
  167    SQLCHAR * szPkTableName, SQLSMALLINT cbPkTableName,
 
  168    SQLCHAR * szFkCatalogName, SQLSMALLINT cbFkCatalogName,
 
  169    SQLCHAR * szFkSchemaName, SQLSMALLINT cbFkSchemaName,
 
  170    SQLCHAR * szFkTableName, SQLSMALLINT cbFkTableName)
 
  172    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLForeignKeys(%p, %s, %d, %s, %d, %s, %d, %s, %d, %s, %d, %s, %d)\n",
 
  174            (
const char*) szPkCatalogName, (
int) cbPkCatalogName,
 
  175            (
const char*) szPkSchemaName, (
int) cbPkSchemaName,
 
  176            (
const char*) szPkTableName, (
int) cbPkTableName,
 
  177            (
const char*) szFkCatalogName, (
int) cbFkCatalogName,
 
  178            (
const char*) szFkSchemaName, (
int) cbFkSchemaName,
 
  179            (
const char*) szFkTableName, (
int) cbFkTableName);
 
  180#ifdef ENABLE_ODBC_WIDE 
  181    return _SQLForeignKeys(hstmt,
 
  182        (ODBC_CHAR*) szPkCatalogName, cbPkCatalogName,
 
  183        (ODBC_CHAR*) szPkSchemaName, cbPkSchemaName,
 
  184        (ODBC_CHAR*) szPkTableName, cbPkTableName,
 
  185        (ODBC_CHAR*) szFkCatalogName, cbFkCatalogName,
 
  186        (ODBC_CHAR*) szFkSchemaName, cbFkSchemaName,
 
  187        (ODBC_CHAR*) szFkTableName, cbFkTableName, 0);
 
  189    return _SQLForeignKeys(hstmt,
 
  190        szPkCatalogName, cbPkCatalogName,
 
  191        szPkSchemaName, cbPkSchemaName,
 
  192        szPkTableName, cbPkTableName,
 
  193        szFkCatalogName, cbFkCatalogName,
 
  194        szFkSchemaName, cbFkSchemaName,
 
  195        szFkTableName, cbFkTableName);
 
  199#ifdef ENABLE_ODBC_WIDE 
  200static SQLRETURN _SQLNativeSql(SQLHDBC hdbc,
 
  201    ODBC_CHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
 
  202    ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr, 
int wide);
 
  204SQLRETURN ODBC_PUBLIC ODBC_API SQLNativeSqlW(
 
  206    SQLWCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
 
  207    SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr)
 
  209    if (TDS_UNLIKELY(tds_write_dump)) {
 
  211        tdsdump_log(TDS_DBG_FUNC, 
"SQLNativeSqlW(%p, %ls, %d, %p, %d, %p)\n",
 
  213            SQLWSTR(szSqlStrIn), (
int) cbSqlStrIn,
 
  214            szSqlStr, (
int) cbSqlStrMax, pcbSqlStr);
 
  217    return _SQLNativeSql(hdbc,
 
  218        (ODBC_CHAR*) szSqlStrIn, cbSqlStrIn,
 
  219        (ODBC_CHAR*) szSqlStr, cbSqlStrMax, pcbSqlStr, 1);
 
  223SQLRETURN ODBC_PUBLIC ODBC_API SQLNativeSql(
 
  225    SQLCHAR * szSqlStrIn, SQLINTEGER cbSqlStrIn,
 
  226    SQLCHAR * szSqlStr, SQLINTEGER cbSqlStrMax, SQLINTEGER FAR* pcbSqlStr)
 
  228    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLNativeSql(%p, %s, %d, %p, %d, %p)\n",
 
  230            (
const char*) szSqlStrIn, (
int) cbSqlStrIn,
 
  231            szSqlStr, (
int) cbSqlStrMax, pcbSqlStr);
 
  232#ifdef ENABLE_ODBC_WIDE 
  233    return _SQLNativeSql(hdbc,
 
  234        (ODBC_CHAR*) szSqlStrIn, cbSqlStrIn,
 
  235        (ODBC_CHAR*) szSqlStr, cbSqlStrMax, pcbSqlStr, 0);
 
  237    return _SQLNativeSql(hdbc,
 
  238        szSqlStrIn, cbSqlStrIn,
 
  239        szSqlStr, cbSqlStrMax, pcbSqlStr);
 
  243#ifdef ENABLE_ODBC_WIDE 
  244static SQLRETURN _SQLPrimaryKeys(SQLHSTMT hstmt,
 
  245    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  246    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  247    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName, 
int wide);
 
  249SQLRETURN ODBC_PUBLIC ODBC_API SQLPrimaryKeysW(
 
  251    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  252    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  253    SQLWCHAR * szTableName, SQLSMALLINT cbTableName)
 
  255    if (TDS_UNLIKELY(tds_write_dump)) {
 
  257        tdsdump_log(TDS_DBG_FUNC, 
"SQLPrimaryKeysW(%p, %ls, %d, %ls, %d, %ls, %d)\n",
 
  259            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
  260            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
  261            SQLWSTR(szTableName), (
int) cbTableName);
 
  264    return _SQLPrimaryKeys(hstmt,
 
  265        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  266        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  267        (ODBC_CHAR*) szTableName, cbTableName, 1);
 
  271SQLRETURN ODBC_PUBLIC ODBC_API SQLPrimaryKeys(
 
  273    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  274    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  275    SQLCHAR * szTableName, SQLSMALLINT cbTableName)
 
  277    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLPrimaryKeys(%p, %s, %d, %s, %d, %s, %d)\n",
 
  279            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  280            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  281            (
const char*) szTableName, (
int) cbTableName);
 
  282#ifdef ENABLE_ODBC_WIDE 
  283    return _SQLPrimaryKeys(hstmt,
 
  284        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  285        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  286        (ODBC_CHAR*) szTableName, cbTableName, 0);
 
  288    return _SQLPrimaryKeys(hstmt,
 
  289        szCatalogName, cbCatalogName,
 
  290        szSchemaName, cbSchemaName,
 
  291        szTableName, cbTableName);
 
  295#ifdef ENABLE_ODBC_WIDE 
  296static SQLRETURN _SQLProcedureColumns(SQLHSTMT hstmt,
 
  297    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  298    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  299    ODBC_CHAR * szProcName, SQLSMALLINT cbProcName,
 
  300    ODBC_CHAR * szColumnName, SQLSMALLINT cbColumnName, 
int wide);
 
  302SQLRETURN ODBC_PUBLIC ODBC_API SQLProcedureColumnsW(
 
  304    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  305    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  306    SQLWCHAR * szProcName, SQLSMALLINT cbProcName,
 
  307    SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
  309    if (TDS_UNLIKELY(tds_write_dump)) {
 
  311        tdsdump_log(TDS_DBG_FUNC, 
"SQLProcedureColumnsW(%p, %ls, %d, %ls, %d, %ls, %d, %ls, %d)\n",
 
  313            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
  314            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
  315            SQLWSTR(szProcName), (
int) cbProcName,
 
  316            SQLWSTR(szColumnName), (
int) cbColumnName);
 
  319    return _SQLProcedureColumns(hstmt,
 
  320        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  321        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  322        (ODBC_CHAR*) szProcName, cbProcName,
 
  323        (ODBC_CHAR*) szColumnName, cbColumnName, 1);
 
  327SQLRETURN ODBC_PUBLIC ODBC_API SQLProcedureColumns(
 
  329    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  330    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  331    SQLCHAR * szProcName, SQLSMALLINT cbProcName,
 
  332    SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
  334    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLProcedureColumns(%p, %s, %d, %s, %d, %s, %d, %s, %d)\n",
 
  336            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  337            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  338            (
const char*) szProcName, (
int) cbProcName,
 
  339            (
const char*) szColumnName, (
int) cbColumnName);
 
  340#ifdef ENABLE_ODBC_WIDE 
  341    return _SQLProcedureColumns(hstmt,
 
  342        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  343        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  344        (ODBC_CHAR*) szProcName, cbProcName,
 
  345        (ODBC_CHAR*) szColumnName, cbColumnName, 0);
 
  347    return _SQLProcedureColumns(hstmt,
 
  348        szCatalogName, cbCatalogName,
 
  349        szSchemaName, cbSchemaName,
 
  350        szProcName, cbProcName,
 
  351        szColumnName, cbColumnName);
 
  355#ifdef ENABLE_ODBC_WIDE 
  356static SQLRETURN _SQLProcedures(SQLHSTMT hstmt,
 
  357    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  358    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  359    ODBC_CHAR * szProcName, SQLSMALLINT cbProcName, 
int wide);
 
  361SQLRETURN ODBC_PUBLIC ODBC_API SQLProceduresW(
 
  363    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  364    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  365    SQLWCHAR * szProcName, SQLSMALLINT cbProcName)
 
  367    if (TDS_UNLIKELY(tds_write_dump)) {
 
  369        tdsdump_log(TDS_DBG_FUNC, 
"SQLProceduresW(%p, %ls, %d, %ls, %d, %ls, %d)\n",
 
  371            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
  372            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
  373            SQLWSTR(szProcName), (
int) cbProcName);
 
  376    return _SQLProcedures(hstmt,
 
  377        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  378        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  379        (ODBC_CHAR*) szProcName, cbProcName, 1);
 
  383SQLRETURN ODBC_PUBLIC ODBC_API SQLProcedures(
 
  385    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  386    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  387    SQLCHAR * szProcName, SQLSMALLINT cbProcName)
 
  389    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLProcedures(%p, %s, %d, %s, %d, %s, %d)\n",
 
  391            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  392            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  393            (
const char*) szProcName, (
int) cbProcName);
 
  394#ifdef ENABLE_ODBC_WIDE 
  395    return _SQLProcedures(hstmt,
 
  396        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  397        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  398        (ODBC_CHAR*) szProcName, cbProcName, 0);
 
  400    return _SQLProcedures(hstmt,
 
  401        szCatalogName, cbCatalogName,
 
  402        szSchemaName, cbSchemaName,
 
  403        szProcName, cbProcName);
 
  407#ifdef ENABLE_ODBC_WIDE 
  408static SQLRETURN _SQLTablePrivileges(SQLHSTMT hstmt,
 
  409    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  410    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  411    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName, 
int wide);
 
  413SQLRETURN ODBC_PUBLIC ODBC_API SQLTablePrivilegesW(
 
  415    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  416    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  417    SQLWCHAR * szTableName, SQLSMALLINT cbTableName)
 
  419    if (TDS_UNLIKELY(tds_write_dump)) {
 
  421        tdsdump_log(TDS_DBG_FUNC, 
"SQLTablePrivilegesW(%p, %ls, %d, %ls, %d, %ls, %d)\n",
 
  423            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
  424            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
  425            SQLWSTR(szTableName), (
int) cbTableName);
 
  428    return _SQLTablePrivileges(hstmt,
 
  429        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  430        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  431        (ODBC_CHAR*) szTableName, cbTableName, 1);
 
  435SQLRETURN ODBC_PUBLIC ODBC_API SQLTablePrivileges(
 
  437    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  438    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  439    SQLCHAR * szTableName, SQLSMALLINT cbTableName)
 
  441    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLTablePrivileges(%p, %s, %d, %s, %d, %s, %d)\n",
 
  443            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  444            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  445            (
const char*) szTableName, (
int) cbTableName);
 
  446#ifdef ENABLE_ODBC_WIDE 
  447    return _SQLTablePrivileges(hstmt,
 
  448        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  449        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  450        (ODBC_CHAR*) szTableName, cbTableName, 0);
 
  452    return _SQLTablePrivileges(hstmt,
 
  453        szCatalogName, cbCatalogName,
 
  454        szSchemaName, cbSchemaName,
 
  455        szTableName, cbTableName);
 
  459#ifdef ENABLE_ODBC_WIDE 
  460static SQLRETURN _SQLConnect(SQLHDBC hdbc,
 
  461    ODBC_CHAR * szDSN, SQLSMALLINT cbDSN,
 
  462    ODBC_CHAR * szUID, SQLSMALLINT cbUID,
 
  463    ODBC_CHAR * szAuthStr, SQLSMALLINT cbAuthStr, 
int wide);
 
  465SQLRETURN ODBC_PUBLIC ODBC_API SQLConnectW(
 
  467    SQLWCHAR * szDSN, SQLSMALLINT cbDSN,
 
  468    SQLWCHAR * szUID, SQLSMALLINT cbUID,
 
  469    SQLWCHAR * szAuthStr, SQLSMALLINT cbAuthStr)
 
  471    if (TDS_UNLIKELY(tds_write_dump)) {
 
  473        tdsdump_log(TDS_DBG_FUNC, 
"SQLConnectW(%p, %ls, %d, %ls, %d, %ls, %d)\n",
 
  475            SQLWSTR(szDSN), (
int) cbDSN,
 
  476            SQLWSTR(szUID), (
int) cbUID,
 
  477            SQLWSTR(szAuthStr), (
int) cbAuthStr);
 
  480    return _SQLConnect(hdbc,
 
  481        (ODBC_CHAR*) szDSN, cbDSN,
 
  482        (ODBC_CHAR*) szUID, cbUID,
 
  483        (ODBC_CHAR*) szAuthStr, cbAuthStr, 1);
 
  487SQLRETURN ODBC_PUBLIC ODBC_API SQLConnect(
 
  489    SQLCHAR * szDSN, SQLSMALLINT cbDSN,
 
  490    SQLCHAR * szUID, SQLSMALLINT cbUID,
 
  491    SQLCHAR * szAuthStr, SQLSMALLINT cbAuthStr)
 
  493    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLConnect(%p, %s, %d, %s, %d, %s, %d)\n",
 
  495            (
const char*) szDSN, (
int) cbDSN,
 
  496            (
const char*) szUID, (
int) cbUID,
 
  497            (
const char*) szAuthStr, (
int) cbAuthStr);
 
  498#ifdef ENABLE_ODBC_WIDE 
  499    return _SQLConnect(hdbc,
 
  500        (ODBC_CHAR*) szDSN, cbDSN,
 
  501        (ODBC_CHAR*) szUID, cbUID,
 
  502        (ODBC_CHAR*) szAuthStr, cbAuthStr, 0);
 
  504    return _SQLConnect(hdbc,
 
  507        szAuthStr, cbAuthStr);
 
  511#ifdef ENABLE_ODBC_WIDE 
  512static SQLRETURN _SQLDescribeCol(SQLHSTMT hstmt,
 
  514    ODBC_CHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
 
  515    SQLSMALLINT * pfSqlType,
 
  517    SQLSMALLINT * pibScale,
 
  518    SQLSMALLINT * pfNullable, 
int wide);
 
  520SQLRETURN ODBC_PUBLIC ODBC_API SQLDescribeColW(
 
  523    SQLWCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
 
  524    SQLSMALLINT * pfSqlType,
 
  526    SQLSMALLINT * pibScale,
 
  527    SQLSMALLINT * pfNullable)
 
  529    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLDescribeColW(%p, %u, %p, %d, %p, %p, %p, %p, %p)\n",
 
  532            szColName, (
int) cbColNameMax, pcbColName,
 
  537    return _SQLDescribeCol(hstmt,
 
  539        (ODBC_CHAR*) szColName, cbColNameMax, pcbColName,
 
  547SQLRETURN ODBC_PUBLIC ODBC_API SQLDescribeCol(
 
  550    SQLCHAR * szColName, SQLSMALLINT cbColNameMax, SQLSMALLINT FAR* pcbColName,
 
  551    SQLSMALLINT * pfSqlType,
 
  553    SQLSMALLINT * pibScale,
 
  554    SQLSMALLINT * pfNullable)
 
  556    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLDescribeCol(%p, %u, %p, %d, %p, %p, %p, %p, %p)\n",
 
  559            szColName, (
int) cbColNameMax, pcbColName,
 
  564#ifdef ENABLE_ODBC_WIDE 
  565    return _SQLDescribeCol(hstmt,
 
  567        (ODBC_CHAR*) szColName, cbColNameMax, pcbColName,
 
  573    return _SQLDescribeCol(hstmt,
 
  575        szColName, cbColNameMax, pcbColName,
 
  583#ifdef ENABLE_ODBC_WIDE 
  584static SQLRETURN _SQLGetDescRec(SQLHDESC hdesc,
 
  585    SQLSMALLINT RecordNumber,
 
  586    ODBC_CHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
 
  588    SQLSMALLINT * SubType,
 
  590    SQLSMALLINT * Precision,
 
  592    SQLSMALLINT * Nullable, 
int wide);
 
  594SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescRecW(
 
  596    SQLSMALLINT RecordNumber,
 
  597    SQLWCHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
 
  599    SQLSMALLINT * SubType,
 
  601    SQLSMALLINT * Precision,
 
  603    SQLSMALLINT * Nullable)
 
  605    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetDescRecW(%p, %d, %p, %d, %p, %p, %p, %p, %p, %p, %p)\n",
 
  608            szName, (
int) cbNameMax, pcbName,
 
  615    return _SQLGetDescRec(hdesc,
 
  617        (ODBC_CHAR*) szName, cbNameMax, pcbName,
 
  627SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescRec(
 
  629    SQLSMALLINT RecordNumber,
 
  630    SQLCHAR * szName, SQLSMALLINT cbNameMax, SQLSMALLINT FAR* pcbName,
 
  632    SQLSMALLINT * SubType,
 
  634    SQLSMALLINT * Precision,
 
  636    SQLSMALLINT * Nullable)
 
  638    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetDescRec(%p, %d, %p, %d, %p, %p, %p, %p, %p, %p, %p)\n",
 
  641            szName, (
int) cbNameMax, pcbName,
 
  648#ifdef ENABLE_ODBC_WIDE 
  649    return _SQLGetDescRec(hdesc,
 
  651        (ODBC_CHAR*) szName, cbNameMax, pcbName,
 
  659    return _SQLGetDescRec(hdesc,
 
  661        szName, cbNameMax, pcbName,
 
  671#ifdef ENABLE_ODBC_WIDE 
  672static SQLRETURN _SQLGetDescField(SQLHDESC hdesc,
 
  674    SQLSMALLINT fDescType,
 
  676    SQLINTEGER BufferLength,
 
  677    SQLINTEGER * StringLength, 
int wide);
 
  679SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescFieldW(
 
  682    SQLSMALLINT fDescType,
 
  684    SQLINTEGER BufferLength,
 
  685    SQLINTEGER * StringLength)
 
  687    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetDescFieldW(%p, %d, %d, %p, %d, %p)\n",
 
  694    return _SQLGetDescField(hdesc,
 
  703SQLRETURN ODBC_PUBLIC ODBC_API SQLGetDescField(
 
  706    SQLSMALLINT fDescType,
 
  708    SQLINTEGER BufferLength,
 
  709    SQLINTEGER * StringLength)
 
  711    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetDescField(%p, %d, %d, %p, %d, %p)\n",
 
  718#ifdef ENABLE_ODBC_WIDE 
  719    return _SQLGetDescField(hdesc,
 
  726    return _SQLGetDescField(hdesc,
 
  735#ifdef ENABLE_ODBC_WIDE 
  736static SQLRETURN _SQLSetDescField(SQLHDESC hdesc,
 
  738    SQLSMALLINT fDescType,
 
  740    SQLINTEGER BufferLength, 
int wide);
 
  742SQLRETURN ODBC_PUBLIC ODBC_API SQLSetDescFieldW(
 
  745    SQLSMALLINT fDescType,
 
  747    SQLINTEGER BufferLength)
 
  749    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSetDescFieldW(%p, %d, %d, %p, %d)\n",
 
  755    return _SQLSetDescField(hdesc,
 
  763SQLRETURN ODBC_PUBLIC ODBC_API SQLSetDescField(
 
  766    SQLSMALLINT fDescType,
 
  768    SQLINTEGER BufferLength)
 
  770    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSetDescField(%p, %d, %d, %p, %d)\n",
 
  776#ifdef ENABLE_ODBC_WIDE 
  777    return _SQLSetDescField(hdesc,
 
  783    return _SQLSetDescField(hdesc,
 
  791#ifdef ENABLE_ODBC_WIDE 
  792static SQLRETURN _SQLExecDirect(SQLHSTMT hstmt,
 
  793    ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStr, 
int wide);
 
  795SQLRETURN ODBC_PUBLIC ODBC_API SQLExecDirectW(
 
  797    SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)
 
  799    if (TDS_UNLIKELY(tds_write_dump)) {
 
  801        tdsdump_log(TDS_DBG_FUNC, 
"SQLExecDirectW(%p, %ls, %d)\n",
 
  803            SQLWSTR(szSqlStr), (
int) cbSqlStr);
 
  806    return _SQLExecDirect(hstmt,
 
  807        (ODBC_CHAR*) szSqlStr, cbSqlStr, 1);
 
  811SQLRETURN ODBC_PUBLIC ODBC_API SQLExecDirect(
 
  813    SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)
 
  815    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLExecDirect(%p, %s, %d)\n",
 
  817            (
const char*) szSqlStr, (
int) cbSqlStr);
 
  818#ifdef ENABLE_ODBC_WIDE 
  819    return _SQLExecDirect(hstmt,
 
  820        (ODBC_CHAR*) szSqlStr, cbSqlStr, 0);
 
  822    return _SQLExecDirect(hstmt,
 
  827#ifdef ENABLE_ODBC_WIDE 
  828static SQLRETURN _SQLPrepare(SQLHSTMT hstmt,
 
  829    ODBC_CHAR * szSqlStr, SQLINTEGER cbSqlStr, 
int wide);
 
  831SQLRETURN ODBC_PUBLIC ODBC_API SQLPrepareW(
 
  833    SQLWCHAR * szSqlStr, SQLINTEGER cbSqlStr)
 
  835    if (TDS_UNLIKELY(tds_write_dump)) {
 
  837        tdsdump_log(TDS_DBG_FUNC, 
"SQLPrepareW(%p, %ls, %d)\n",
 
  839            SQLWSTR(szSqlStr), (
int) cbSqlStr);
 
  842    return _SQLPrepare(hstmt,
 
  843        (ODBC_CHAR*) szSqlStr, cbSqlStr, 1);
 
  847SQLRETURN ODBC_PUBLIC ODBC_API SQLPrepare(
 
  849    SQLCHAR * szSqlStr, SQLINTEGER cbSqlStr)
 
  851    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLPrepare(%p, %s, %d)\n",
 
  853            (
const char*) szSqlStr, (
int) cbSqlStr);
 
  854#ifdef ENABLE_ODBC_WIDE 
  855    return _SQLPrepare(hstmt,
 
  856        (ODBC_CHAR*) szSqlStr, cbSqlStr, 0);
 
  858    return _SQLPrepare(hstmt,
 
  863#ifdef ENABLE_ODBC_WIDE 
  864static SQLRETURN _SQLSetCursorName(SQLHSTMT hstmt,
 
  865    ODBC_CHAR * szCursor, SQLSMALLINT cbCursor, 
int wide);
 
  867SQLRETURN ODBC_PUBLIC ODBC_API SQLSetCursorNameW(
 
  869    SQLWCHAR * szCursor, SQLSMALLINT cbCursor)
 
  871    if (TDS_UNLIKELY(tds_write_dump)) {
 
  873        tdsdump_log(TDS_DBG_FUNC, 
"SQLSetCursorNameW(%p, %ls, %d)\n",
 
  875            SQLWSTR(szCursor), (
int) cbCursor);
 
  878    return _SQLSetCursorName(hstmt,
 
  879        (ODBC_CHAR*) szCursor, cbCursor, 1);
 
  883SQLRETURN ODBC_PUBLIC ODBC_API SQLSetCursorName(
 
  885    SQLCHAR * szCursor, SQLSMALLINT cbCursor)
 
  887    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSetCursorName(%p, %s, %d)\n",
 
  889            (
const char*) szCursor, (
int) cbCursor);
 
  890#ifdef ENABLE_ODBC_WIDE 
  891    return _SQLSetCursorName(hstmt,
 
  892        (ODBC_CHAR*) szCursor, cbCursor, 0);
 
  894    return _SQLSetCursorName(hstmt,
 
  899#ifdef ENABLE_ODBC_WIDE 
  900static SQLRETURN _SQLGetCursorName(SQLHSTMT hstmt,
 
  901    ODBC_CHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor, 
int wide);
 
  903SQLRETURN ODBC_PUBLIC ODBC_API SQLGetCursorNameW(
 
  905    SQLWCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor)
 
  907    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetCursorNameW(%p, %p, %d, %p)\n",
 
  909            szCursor, (
int) cbCursorMax, pcbCursor);
 
  910    return _SQLGetCursorName(hstmt,
 
  911        (ODBC_CHAR*) szCursor, cbCursorMax, pcbCursor, 1);
 
  915SQLRETURN ODBC_PUBLIC ODBC_API SQLGetCursorName(
 
  917    SQLCHAR * szCursor, SQLSMALLINT cbCursorMax, SQLSMALLINT FAR* pcbCursor)
 
  919    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetCursorName(%p, %p, %d, %p)\n",
 
  921            szCursor, (
int) cbCursorMax, pcbCursor);
 
  922#ifdef ENABLE_ODBC_WIDE 
  923    return _SQLGetCursorName(hstmt,
 
  924        (ODBC_CHAR*) szCursor, cbCursorMax, pcbCursor, 0);
 
  926    return _SQLGetCursorName(hstmt,
 
  927        szCursor, cbCursorMax, pcbCursor);
 
  931#ifdef ENABLE_ODBC_WIDE 
  932static SQLRETURN _SQLColumns(SQLHSTMT hstmt,
 
  933    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  934    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  935    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName,
 
  936    ODBC_CHAR * szColumnName, SQLSMALLINT cbColumnName, 
int wide);
 
  938SQLRETURN ODBC_PUBLIC ODBC_API SQLColumnsW(
 
  940    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  941    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  942    SQLWCHAR * szTableName, SQLSMALLINT cbTableName,
 
  943    SQLWCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
  945    if (TDS_UNLIKELY(tds_write_dump)) {
 
  947        tdsdump_log(TDS_DBG_FUNC, 
"SQLColumnsW(%p, %ls, %d, %ls, %d, %ls, %d, %ls, %d)\n",
 
  949            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
  950            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
  951            SQLWSTR(szTableName), (
int) cbTableName,
 
  952            SQLWSTR(szColumnName), (
int) cbColumnName);
 
  955    return _SQLColumns(hstmt,
 
  956        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  957        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  958        (ODBC_CHAR*) szTableName, cbTableName,
 
  959        (ODBC_CHAR*) szColumnName, cbColumnName, 1);
 
  963SQLRETURN ODBC_PUBLIC ODBC_API SQLColumns(
 
  965    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
  966    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
  967    SQLCHAR * szTableName, SQLSMALLINT cbTableName,
 
  968    SQLCHAR * szColumnName, SQLSMALLINT cbColumnName)
 
  970    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLColumns(%p, %s, %d, %s, %d, %s, %d, %s, %d)\n",
 
  972            (
const char*) szCatalogName, (
int) cbCatalogName,
 
  973            (
const char*) szSchemaName, (
int) cbSchemaName,
 
  974            (
const char*) szTableName, (
int) cbTableName,
 
  975            (
const char*) szColumnName, (
int) cbColumnName);
 
  976#ifdef ENABLE_ODBC_WIDE 
  977    return _SQLColumns(hstmt,
 
  978        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
  979        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
  980        (ODBC_CHAR*) szTableName, cbTableName,
 
  981        (ODBC_CHAR*) szColumnName, cbColumnName, 0);
 
  983    return _SQLColumns(hstmt,
 
  984        szCatalogName, cbCatalogName,
 
  985        szSchemaName, cbSchemaName,
 
  986        szTableName, cbTableName,
 
  987        szColumnName, cbColumnName);
 
  991#ifdef ENABLE_ODBC_WIDE 
  992static SQLRETURN _SQLGetConnectAttr(SQLHDBC hdbc,
 
  993    SQLINTEGER Attribute,
 
  995    SQLINTEGER BufferLength,
 
  996    SQLINTEGER * StringLength, 
int wide);
 
  998SQLRETURN ODBC_PUBLIC ODBC_API SQLGetConnectAttrW(
 
 1000    SQLINTEGER Attribute,
 
 1002    SQLINTEGER BufferLength,
 
 1003    SQLINTEGER * StringLength)
 
 1005    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetConnectAttrW(%p, %d, %p, %d, %p)\n",
 
 1011    return _SQLGetConnectAttr(hdbc,
 
 1019SQLRETURN ODBC_PUBLIC ODBC_API SQLGetConnectAttr(
 
 1021    SQLINTEGER Attribute,
 
 1023    SQLINTEGER BufferLength,
 
 1024    SQLINTEGER * StringLength)
 
 1026    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLGetConnectAttr(%p, %d, %p, %d, %p)\n",
 
 1032#ifdef ENABLE_ODBC_WIDE 
 1033    return _SQLGetConnectAttr(hdbc,
 
 1039    return _SQLGetConnectAttr(hdbc,
 
 1047#ifdef ENABLE_ODBC_WIDE 
 1048static SQLRETURN _SQLSetConnectAttr(SQLHDBC hdbc,
 
 1049    SQLINTEGER Attribute,
 
 1050    SQLPOINTER ValuePtr,
 
 1051    SQLINTEGER StringLength, 
int wide);
 
 1053SQLRETURN ODBC_PUBLIC ODBC_API SQLSetConnectAttrW(
 
 1055    SQLINTEGER Attribute,
 
 1056    SQLPOINTER ValuePtr,
 
 1057    SQLINTEGER StringLength)
 
 1059    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSetConnectAttrW(%p, %d, %p, %d)\n",
 
 1063            (
int) StringLength);
 
 1064    return _SQLSetConnectAttr(hdbc,
 
 1071SQLRETURN ODBC_PUBLIC ODBC_API SQLSetConnectAttr(
 
 1073    SQLINTEGER Attribute,
 
 1074    SQLPOINTER ValuePtr,
 
 1075    SQLINTEGER StringLength)
 
 1077    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSetConnectAttr(%p, %d, %p, %d)\n",
 
 1081            (
int) StringLength);
 
 1082#ifdef ENABLE_ODBC_WIDE 
 1083    return _SQLSetConnectAttr(hdbc,
 
 1088    return _SQLSetConnectAttr(hdbc,
 
 1095#ifdef ENABLE_ODBC_WIDE 
 1096static SQLRETURN _SQLSpecialColumns(SQLHSTMT hstmt,
 
 1097    SQLUSMALLINT fColType,
 
 1098    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1099    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1100    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName,
 
 1101    SQLUSMALLINT fScope,
 
 1102    SQLUSMALLINT fNullable, 
int wide);
 
 1104SQLRETURN ODBC_PUBLIC ODBC_API SQLSpecialColumnsW(
 
 1106    SQLUSMALLINT fColType,
 
 1107    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1108    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1109    SQLWCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1110    SQLUSMALLINT fScope,
 
 1111    SQLUSMALLINT fNullable)
 
 1113    if (TDS_UNLIKELY(tds_write_dump)) {
 
 1115        tdsdump_log(TDS_DBG_FUNC, 
"SQLSpecialColumnsW(%p, %u, %ls, %d, %ls, %d, %ls, %d, %u, %u)\n",
 
 1117            (
unsigned int) fColType,
 
 1118            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
 1119            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
 1120            SQLWSTR(szTableName), (
int) cbTableName,
 
 1121            (
unsigned int) fScope,
 
 1122            (
unsigned int) fNullable);
 
 1125    return _SQLSpecialColumns(hstmt,
 
 1127        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1128        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1129        (ODBC_CHAR*) szTableName, cbTableName,
 
 1135SQLRETURN ODBC_PUBLIC ODBC_API SQLSpecialColumns(
 
 1137    SQLUSMALLINT fColType,
 
 1138    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1139    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1140    SQLCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1141    SQLUSMALLINT fScope,
 
 1142    SQLUSMALLINT fNullable)
 
 1144    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLSpecialColumns(%p, %u, %s, %d, %s, %d, %s, %d, %u, %u)\n",
 
 1146            (
unsigned int) fColType,
 
 1147            (
const char*) szCatalogName, (
int) cbCatalogName,
 
 1148            (
const char*) szSchemaName, (
int) cbSchemaName,
 
 1149            (
const char*) szTableName, (
int) cbTableName,
 
 1150            (
unsigned int) fScope,
 
 1151            (
unsigned int) fNullable);
 
 1152#ifdef ENABLE_ODBC_WIDE 
 1153    return _SQLSpecialColumns(hstmt,
 
 1155        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1156        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1157        (ODBC_CHAR*) szTableName, cbTableName,
 
 1161    return _SQLSpecialColumns(hstmt,
 
 1163        szCatalogName, cbCatalogName,
 
 1164        szSchemaName, cbSchemaName,
 
 1165        szTableName, cbTableName,
 
 1171#ifdef ENABLE_ODBC_WIDE 
 1172static SQLRETURN _SQLStatistics(SQLHSTMT hstmt,
 
 1173    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1174    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1175    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName,
 
 1176    SQLUSMALLINT fUnique,
 
 1177    SQLUSMALLINT fAccuracy, 
int wide);
 
 1179SQLRETURN ODBC_PUBLIC ODBC_API SQLStatisticsW(
 
 1181    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1182    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1183    SQLWCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1184    SQLUSMALLINT fUnique,
 
 1185    SQLUSMALLINT fAccuracy)
 
 1187    if (TDS_UNLIKELY(tds_write_dump)) {
 
 1189        tdsdump_log(TDS_DBG_FUNC, 
"SQLStatisticsW(%p, %ls, %d, %ls, %d, %ls, %d, %u, %u)\n",
 
 1191            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
 1192            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
 1193            SQLWSTR(szTableName), (
int) cbTableName,
 
 1194            (
unsigned int) fUnique,
 
 1195            (
unsigned int) fAccuracy);
 
 1198    return _SQLStatistics(hstmt,
 
 1199        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1200        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1201        (ODBC_CHAR*) szTableName, cbTableName,
 
 1207SQLRETURN ODBC_PUBLIC ODBC_API SQLStatistics(
 
 1209    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1210    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1211    SQLCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1212    SQLUSMALLINT fUnique,
 
 1213    SQLUSMALLINT fAccuracy)
 
 1215    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLStatistics(%p, %s, %d, %s, %d, %s, %d, %u, %u)\n",
 
 1217            (
const char*) szCatalogName, (
int) cbCatalogName,
 
 1218            (
const char*) szSchemaName, (
int) cbSchemaName,
 
 1219            (
const char*) szTableName, (
int) cbTableName,
 
 1220            (
unsigned int) fUnique,
 
 1221            (
unsigned int) fAccuracy);
 
 1222#ifdef ENABLE_ODBC_WIDE 
 1223    return _SQLStatistics(hstmt,
 
 1224        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1225        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1226        (ODBC_CHAR*) szTableName, cbTableName,
 
 1230    return _SQLStatistics(hstmt,
 
 1231        szCatalogName, cbCatalogName,
 
 1232        szSchemaName, cbSchemaName,
 
 1233        szTableName, cbTableName,
 
 1239#ifdef ENABLE_ODBC_WIDE 
 1240static SQLRETURN _SQLTables(SQLHSTMT hstmt,
 
 1241    ODBC_CHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1242    ODBC_CHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1243    ODBC_CHAR * szTableName, SQLSMALLINT cbTableName,
 
 1244    ODBC_CHAR * szTableType, SQLSMALLINT cbTableType, 
int wide);
 
 1246SQLRETURN ODBC_PUBLIC ODBC_API SQLTablesW(
 
 1248    SQLWCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1249    SQLWCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1250    SQLWCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1251    SQLWCHAR * szTableType, SQLSMALLINT cbTableType)
 
 1253    if (TDS_UNLIKELY(tds_write_dump)) {
 
 1255        tdsdump_log(TDS_DBG_FUNC, 
"SQLTablesW(%p, %ls, %d, %ls, %d, %ls, %d, %ls, %d)\n",
 
 1257            SQLWSTR(szCatalogName), (
int) cbCatalogName,
 
 1258            SQLWSTR(szSchemaName), (
int) cbSchemaName,
 
 1259            SQLWSTR(szTableName), (
int) cbTableName,
 
 1260            SQLWSTR(szTableType), (
int) cbTableType);
 
 1263    return _SQLTables(hstmt,
 
 1264        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1265        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1266        (ODBC_CHAR*) szTableName, cbTableName,
 
 1267        (ODBC_CHAR*) szTableType, cbTableType, 1);
 
 1271SQLRETURN ODBC_PUBLIC ODBC_API SQLTables(
 
 1273    SQLCHAR * szCatalogName, SQLSMALLINT cbCatalogName,
 
 1274    SQLCHAR * szSchemaName, SQLSMALLINT cbSchemaName,
 
 1275    SQLCHAR * szTableName, SQLSMALLINT cbTableName,
 
 1276    SQLCHAR * szTableType, SQLSMALLINT cbTableType)
 
 1278    TDSDUMP_LOG_FAST(TDS_DBG_FUNC, 
"SQLTables(%p, %s, %d, %s, %d, %s, %d, %s, %d)\n",
 
 1280            (
const char*) szCatalogName, (
int) cbCatalogName,
 
 1281            (
const char*) szSchemaName, (
int) cbSchemaName,
 
 1282            (
const char*) szTableName, (
int) cbTableName,
 
 1283            (
const char*) szTableType, (
int) cbTableType);
 
 1284#ifdef ENABLE_ODBC_WIDE 
 1285    return _SQLTables(hstmt,
 
 1286        (ODBC_CHAR*) szCatalogName, cbCatalogName,
 
 1287        (ODBC_CHAR*) szSchemaName, cbSchemaName,
 
 1288        (ODBC_CHAR*) szTableName, cbTableName,
 
 1289        (ODBC_CHAR*) szTableType, cbTableType, 0);
 
 1291    return _SQLTables(hstmt,
 
 1292        szCatalogName, cbCatalogName,
 
 1293        szSchemaName, cbSchemaName,
 
 1294        szTableName, cbTableName,
 
 1295        szTableType, cbTableType);
 
 1299#define tdsdump_log TDSDUMP_LOG_FAST