LCOV - code coverage report
Current view: top level - src/odbc - odbc.c (source / functions) Hit Total Coverage
Test: FreeTDS coverage Lines: 2267 3995 56.7 %
Date: 2024-03-23 09:12:27 Functions: 62 73 84.9 %

          Line data    Source code
       1             : /* FreeTDS - Library of routines accessing Sybase and Microsoft databases
       2             :  * Copyright (C) 1998, 1999, 2000, 2001  Brian Bruns
       3             :  * Copyright (C) 2002-2012  Frediano Ziglio
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or
       6             :  * modify it under the terms of the GNU Library General Public
       7             :  * License as published by the Free Software Foundation; either
       8             :  * version 2 of the License, or (at your option) any later version.
       9             :  *
      10             :  * This library is distributed in the hope that it will be useful,
      11             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      13             :  * Library General Public License for more details.
      14             :  *
      15             :  * You should have received a copy of the GNU Library General Public
      16             :  * License along with this library; if not, write to the
      17             :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      18             :  * Boston, MA 02111-1307, USA.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : 
      23             : #include <stdarg.h>
      24             : #include <stdio.h>
      25             : 
      26             : #if HAVE_STDLIB_H
      27             : #include <stdlib.h>
      28             : #endif /* HAVE_STDLIB_H */
      29             : 
      30             : #if HAVE_STRING_H
      31             : #include <string.h>
      32             : #endif /* HAVE_STRING_H */
      33             : 
      34             : #include <assert.h>
      35             : #include <ctype.h>
      36             : 
      37             : #include <freetds/utils.h>
      38             : #include <freetds/odbc.h>
      39             : #include <freetds/iconv.h>
      40             : #include <freetds/utils/string.h>
      41             : #include <freetds/convert.h>
      42             : #include <freetds/encodings.h>
      43             : #include <freetds/replacements.h>
      44             : #include "sqlwparams.h"
      45             : 
      46             : /* Include odbcss.h with all bcp functions */
      47             : /* The define trick is to make inline functions calls internal
      48             :  * _SQLSetConnectAttr instead of SQLSetConnectAttr */
      49             : ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,ValuePtr), P(SQLINTEGER,StringLength) WIDE));
      50             : #define TDSODBC_BCP
      51             : #undef SQLSetConnectAttr
      52             : #define SQLSetConnectAttr(h, n, p, t) _SQLSetConnectAttr(h, n, p, t _wide0)
      53             : #include <odbcss.h>
      54             : #undef SQLSetConnectAttr
      55             : 
      56             : static SQLRETURN _SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc);
      57             : static SQLRETURN _SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version);
      58             : static SQLRETURN _SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt);
      59             : static SQLRETURN _SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc);
      60             : static SQLRETURN _SQLFreeConnect(SQLHDBC hdbc);
      61             : static SQLRETURN _SQLFreeEnv(SQLHENV henv);
      62             : static SQLRETURN _SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force);
      63             : static SQLRETURN _SQLFreeDesc(SQLHDESC hdesc);
      64             : static SQLRETURN _SQLExecute(TDS_STMT * stmt);
      65             : static SQLRETURN _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength WIDE);
      66             : static SQLRETURN _SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength,
      67             :                                          SQLINTEGER * StringLength WIDE);
      68             : static SQLRETURN _SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc,
      69             :                                           SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE);
      70             : static SQLRETURN _SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset);
      71             : static SQLRETURN odbc_populate_ird(TDS_STMT * stmt);
      72             : static int odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg);
      73             : static void odbc_log_unimplemented_type(const char function_name[], int fType);
      74             : static void odbc_upper_column_names(TDS_STMT * stmt);
      75             : static void odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name);
      76             : static SQLRETURN odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...);
      77             : static SQLRETURN odbc_free_dynamic(TDS_STMT * stmt);
      78             : static SQLRETURN odbc_free_cursor(TDS_STMT * stmt);
      79             : static SQLRETURN odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs);
      80             : static SQLRETURN odbc_prepare(TDS_STMT *stmt);
      81             : static SQLSMALLINT odbc_swap_datetime_sql_type(SQLSMALLINT sql_type, int version);
      82             : static int odbc_process_tokens(TDS_STMT * stmt, unsigned flag);
      83             : static int odbc_lock_statement(TDS_STMT* stmt);
      84             : static void odbc_unlock_statement(TDS_STMT* stmt);
      85             : 
      86             : #if ENABLE_EXTRA_CHECKS
      87             : static void odbc_ird_check(TDS_STMT * stmt);
      88             : 
      89             : #define IRD_CHECK odbc_ird_check(stmt)
      90             : #else
      91             : #define IRD_CHECK
      92             : #endif
      93             : 
      94             : /**
      95             :  * \defgroup odbc_api ODBC API
      96             :  * Functions callable by \c ODBC client programs
      97             :  */
      98             : 
      99             : 
     100             : /* utils to check handles */
     101             : #define INIT_HANDLE(t, n) \
     102             :         TDS_##t *n = (TDS_##t*)h##n; \
     103             :         if (SQL_NULL_H##t  == h##n || (n)->htype != SQL_HANDLE_##t) return SQL_INVALID_HANDLE; \
     104             :         tds_mutex_lock(&n->mtx); \
     105             :         CHECK_##t##_EXTRA(n); \
     106             :         odbc_errs_reset(&n->errs);
     107             : 
     108             : #define ODBC_ENTER_HSTMT INIT_HANDLE(STMT, stmt)
     109             : #define ODBC_ENTER_HDBC  INIT_HANDLE(DBC,  dbc)
     110             : #define ODBC_ENTER_HENV  INIT_HANDLE(ENV,  env)
     111             : #define ODBC_ENTER_HDESC INIT_HANDLE(DESC, desc)
     112             : 
     113             : #define IS_VALID_LEN(len) ((len) >= 0 || (len) == SQL_NTS || (len) == SQL_NULL_DATA)
     114             : 
     115             : #define ODBC_SAFE_ERROR(stmt) \
     116             :         do { \
     117             :                 if (!stmt->errs.num_errors) \
     118             :                         odbc_errs_add(&stmt->errs, "HY000", "Unknown error"); \
     119             :         } while(0)
     120             : 
     121             : #define DEFAULT_QUERY_TIMEOUT (~((SQLUINTEGER) 0))
     122             : 
     123             : /*
     124             :  * Note: I *HATE* hungarian notation, it has to be the most idiotic thing
     125             :  * I've ever seen. So, you will note it is avoided other than in the function
     126             :  * declarations. "Gee, let's make our code totally hard to read and they'll
     127             :  * beg for GUI tools"
     128             :  * Bah!
     129             :  */
     130             : 
     131             : static const char *
     132           0 : odbc_prret(SQLRETURN ret, char *unknown, size_t unknown_size)
     133             : {
     134           0 :         switch (ret) {
     135             :         case SQL_ERROR:                 return "SQL_ERROR";
     136           0 :         case SQL_INVALID_HANDLE:        return "SQL_INVALID_HANDLE";
     137           0 :         case SQL_SUCCESS:               return "SQL_SUCCESS";
     138           0 :         case SQL_SUCCESS_WITH_INFO:     return "SQL_SUCCESS_WITH_INFO";
     139             : #if ODBCVER >= 0x0300
     140           0 :         case SQL_NO_DATA:               return "SQL_NO_DATA";
     141             : #endif
     142           0 :         case SQL_STILL_EXECUTING:       return "SQL_STILL_EXECUTING";
     143           0 :         case SQL_NEED_DATA:             return "SQL_NEED_DATA";
     144             :         }
     145             :         
     146           0 :         snprintf(unknown, unknown_size, "unknown: %d", (int)ret);
     147             : 
     148           0 :         return unknown;
     149             : }
     150             : #define ODBC_PRRET_BUF  char unknown_prret_buf[24]
     151             : #define odbc_prret(ret) odbc_prret(ret, unknown_prret_buf, sizeof(unknown_prret_buf))
     152             : 
     153             : static void
     154         418 : odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name)
     155             : {
     156             : #if ENABLE_EXTRA_CHECKS
     157             :         TDSRESULTINFO *resinfo;
     158             : #endif
     159             : 
     160         418 :         IRD_CHECK;
     161             : 
     162             : #if ENABLE_EXTRA_CHECKS
     163         418 :         if (colpos > 0 && stmt->tds != NULL && (resinfo = stmt->tds->current_results) != NULL) {
     164         418 :                 if (colpos <= resinfo->num_cols) {
     165             :                         /* no overflow possible, name is always shorter */
     166         418 :                         if (!tds_dstr_copy(&resinfo->columns[colpos - 1]->column_name, name))
     167           0 :                                 odbc_errs_add(&stmt->errs, "HY001", NULL);
     168         418 :                         tds_dstr_empty(&resinfo->columns[colpos - 1]->table_column_name);
     169             :                 }
     170             :         }
     171             : #endif
     172             : 
     173         418 :         if (colpos > 0 && colpos <= stmt->ird->header.sql_desc_count) {
     174         418 :                 --colpos;
     175         418 :                 if (!tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_label, name)
     176         418 :                     || !tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_name, name))
     177           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
     178             :         }
     179         418 : }
     180             : 
     181             : /* spinellia@acm.org : copied shamelessly from change_database */
     182             : static SQLRETURN
     183         207 : change_autocommit(TDS_DBC * dbc, int state)
     184             : {
     185         207 :         TDSSOCKET *tds = dbc->tds_socket;
     186             :         TDSRET ret;
     187             : 
     188         207 :         tds_mutex_check_owned(&dbc->mtx);
     189         207 :         if (dbc->attr.autocommit == state)
     190             :                 return SQL_SUCCESS;
     191             : 
     192             :         /*
     193             :          * We may not be connected yet and dbc->tds_socket
     194             :          * may not initialized.
     195             :          */
     196         185 :         if (tds) {
     197             :                 /* TODO better idle check, not thread safe */
     198         151 :                 if (tds->state == TDS_IDLE)
     199         151 :                         tds->query_timeout = dbc->default_query_timeout;
     200             : 
     201         151 :                 if (state == SQL_AUTOCOMMIT_ON)
     202          46 :                         ret = tds_submit_rollback(tds, 0);
     203             :                 else
     204         105 :                         ret = tds_submit_begin_tran(tds);
     205             : 
     206         151 :                 if (TDS_FAILED(ret)) {
     207           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
     208           0 :                         return SQL_ERROR;
     209             :                 }
     210         151 :                 if (TDS_FAILED(tds_process_simple_query(tds))) {
     211           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
     212           0 :                         return SQL_ERROR;
     213             :                 }
     214         151 :                 dbc->attr.autocommit = state;
     215             :         } else {
     216             :                 /* if not connected we will change auto-commit after login */
     217          34 :                 dbc->attr.autocommit = state;
     218             :         }
     219         185 :         ODBC_RETURN_(dbc);
     220             : }
     221             : 
     222             : static SQLRETURN
     223          48 : change_database(TDS_DBC * dbc, const char *database, int database_len)
     224             : {
     225          48 :         TDSSOCKET *tds = dbc->tds_socket;
     226          48 :         tds_mutex_check_owned(&dbc->mtx);
     227             : 
     228             :         /* 
     229             :          * We may not be connected yet and dbc->tds_socket
     230             :          * may not initialized.
     231             :          */
     232          48 :         if (tds) {
     233             :                 /* build query */
     234          16 :                 char *query = tds_new(char, 6 + tds_quote_id(tds, NULL, database, database_len));
     235             : 
     236          16 :                 if (!query) {
     237           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     238           0 :                         return SQL_ERROR;
     239             :                 }
     240          16 :                 strcpy(query, "USE ");
     241          16 :                 tds_quote_id(tds, query + 4, database, database_len);
     242             : 
     243             : 
     244          16 :                 tdsdump_log(TDS_DBG_INFO1, "change_database: executing %s\n", query);
     245             : 
     246             :                 /* TODO better idle check, not thread safe */
     247          16 :                 if (tds->state == TDS_IDLE)
     248          16 :                         tds->query_timeout = dbc->default_query_timeout;
     249          16 :                 if (TDS_FAILED(tds_submit_query(tds, query))) {
     250           0 :                         free(query);
     251           0 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
     252           0 :                         return SQL_ERROR;
     253             :                 }
     254          16 :                 free(query);
     255          16 :                 if (TDS_FAILED(tds_process_simple_query(tds))) {
     256           8 :                         odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
     257           8 :                         return SQL_ERROR;
     258             :                 }
     259             :         } else {
     260          32 :                 if (!tds_dstr_copyn(&dbc->attr.current_catalog, database, database_len)) {
     261           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     262           0 :                         return SQL_ERROR;
     263             :                 }
     264             :         }
     265          40 :         ODBC_RETURN_(dbc);
     266             : }
     267             : 
     268             : static SQLRETURN
     269         100 : change_txn(TDS_DBC * dbc, SQLUINTEGER txn_isolation)
     270             : {
     271             :         char query[64];
     272             :         const char *level;
     273         100 :         TDSSOCKET *tds = dbc->tds_socket;
     274         100 :         tds_mutex_check_owned(&dbc->mtx);
     275             : 
     276         100 :         switch (txn_isolation) {
     277             :         case SQL_TXN_READ_COMMITTED:
     278             :                 level = "READ COMMITTED";
     279             :                 break;
     280          24 :         case SQL_TXN_READ_UNCOMMITTED:
     281          24 :                 level = "READ UNCOMMITTED";
     282          24 :                 break;
     283          36 :         case SQL_TXN_REPEATABLE_READ:
     284          36 :                 level = "REPEATABLE READ";
     285          36 :                 break;
     286          24 :         case SQL_TXN_SERIALIZABLE:
     287          24 :                 level = "SERIALIZABLE";
     288          24 :                 break;
     289           8 :         default:
     290           8 :                 odbc_errs_add(&dbc->errs, "HY024", NULL);
     291           8 :                 return SQL_ERROR;
     292             :         }
     293             : 
     294             :         /* if not connected return success, will be set after connection */
     295          92 :         if (!tds)
     296             :                 return SQL_SUCCESS;
     297             : 
     298          66 :         if (tds->state != TDS_IDLE) {
     299           8 :                 odbc_errs_add(&dbc->errs, "HY011", NULL);
     300           8 :                 return SQL_ERROR;
     301             :         }
     302             : 
     303          58 :         tds->query_timeout = dbc->default_query_timeout;
     304          58 :         sprintf(query, "SET TRANSACTION ISOLATION LEVEL %s", level);
     305          58 :         if (TDS_FAILED(tds_submit_query(tds, query))) {
     306           0 :                 ODBC_SAFE_ERROR(dbc);
     307             :                 return SQL_ERROR;
     308             :         }
     309          58 :         if (TDS_FAILED(tds_process_simple_query(tds))) {
     310           0 :                 ODBC_SAFE_ERROR(dbc);
     311             :                 return SQL_ERROR;
     312             :         }
     313             : 
     314             :         return SQL_SUCCESS;
     315             : }
     316             : 
     317             : static TDS_DBC*
     318        7923 : odbc_get_dbc(TDSSOCKET *tds)
     319             : {
     320        7923 :         TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
     321        7923 :         if (!chk)
     322             :                 return NULL;
     323        7923 :         if (chk->htype == SQL_HANDLE_DBC)
     324             :                 return (TDS_DBC *) chk;
     325        3063 :         assert(chk->htype == SQL_HANDLE_STMT);
     326        3063 :         return ((TDS_STMT *) chk)->dbc;
     327             : }
     328             : 
     329             : static TDS_STMT*
     330             : odbc_get_stmt(TDSSOCKET *tds)
     331             : {
     332        4410 :         TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
     333        4410 :         if (!chk || chk->htype != SQL_HANDLE_STMT)
     334             :                 return NULL;
     335             :         return (TDS_STMT *) chk;
     336             : }
     337             : 
     338             : 
     339             : static void
     340        3673 : odbc_env_change(TDSSOCKET * tds, int type, char *oldval, char *newval)
     341             : {
     342             :         TDS_DBC *dbc;
     343             : 
     344        3673 :         assert(tds);
     345             : 
     346        3673 :         dbc = odbc_get_dbc(tds);
     347        3673 :         if (!dbc)
     348             :                 return;
     349             : 
     350        3673 :         switch (type) {
     351        1921 :         case TDS_ENV_DATABASE:
     352        1921 :                 tds_dstr_copy(&dbc->attr.current_catalog, newval);
     353        1921 :                 break;
     354         876 :         case TDS_ENV_PACKSIZE:
     355         876 :                 dbc->attr.packet_size = atoi(newval);
     356         876 :                 break;
     357             :         }
     358             : }
     359             : 
     360             : static SQLRETURN
     361         884 : odbc_connect(TDS_DBC * dbc, TDSLOGIN * login)
     362             : {
     363         884 :         TDS_ENV *env = dbc->env;
     364         884 :         tds_mutex_check_owned(&dbc->mtx);
     365             : 
     366             : #ifdef ENABLE_ODBC_WIDE
     367         884 :         dbc->mb_conv = NULL;
     368             : #endif
     369         884 :         dbc->tds_socket = tds_alloc_socket(env->tds_ctx, 512);
     370         884 :         if (!dbc->tds_socket)
     371             :                 goto memory_error;
     372             : 
     373         884 :         dbc->tds_socket->conn->use_iconv = 0;
     374         884 :         tds_set_parent(dbc->tds_socket, (void *) dbc);
     375             : 
     376             :         /* Set up our environment change hook */
     377         884 :         dbc->tds_socket->env_chg_func = odbc_env_change;
     378             : 
     379         884 :         tds_fix_login(login);
     380             : 
     381             :         /* use connection timeout if set */
     382         884 :         if (dbc->attr.connection_timeout)
     383           8 :                 login->connect_timeout = dbc->attr.connection_timeout;
     384             : 
     385             :         /* but override with login timeout, if set */
     386         884 :         if (dbc->attr.login_timeout)
     387           8 :                 login->connect_timeout = dbc->attr.login_timeout;
     388             : 
     389         884 :         if (dbc->attr.mars_enabled != SQL_MARS_ENABLED_NO)
     390         411 :                 login->mars = 1;
     391         884 :         if (dbc->attr.bulk_enabled != SQL_BCP_OFF)
     392           8 :                 tds_set_bulk(login, true);
     393             : 
     394             : #ifdef ENABLE_ODBC_WIDE
     395             :         /* force utf-8 in order to support wide characters */
     396        1768 :         dbc->original_charset_num = tds_canonical_charset(tds_dstr_cstr(&login->client_charset));
     397         884 :         if (dbc->original_charset_num < 0) {
     398             :                 char *msg;
     399             : 
     400           0 :                 tds_free_socket(dbc->tds_socket);
     401           0 :                 dbc->tds_socket = NULL;
     402             : 
     403           0 :                 if (asprintf(&msg, "Invalid \"%s\" character set specified", tds_dstr_cstr(&login->client_charset)) > 0) {
     404           0 :                         odbc_errs_add(&dbc->errs, "HY024", msg);
     405           0 :                         free(msg);
     406             :                 } else {
     407           0 :                         odbc_errs_add(&dbc->errs, "HY024", "Invalid character set specified");
     408             :                 }
     409           0 :                 ODBC_RETURN_(dbc);
     410             :         }
     411         884 :         if (!tds_dstr_copy(&login->client_charset, "UTF-8"))
     412             :                 goto memory_error;
     413             : #endif
     414             : 
     415             :         /* replace password with old one */
     416         884 :         if (dbc->use_oldpwd) {
     417           0 :                 if (!tds_dstr_dup(&login->new_password, &login->password)
     418           0 :                     || !tds_dstr_dup(&login->password, &dbc->oldpwd))
     419             :                         goto memory_error;
     420           0 :                 login->use_new_password = 1;
     421             :         }
     422             : 
     423         884 :         if (TDS_FAILED(tds_connect_and_login(dbc->tds_socket, login))) {
     424           8 :                 tds_free_socket(dbc->tds_socket);
     425           8 :                 dbc->tds_socket = NULL;
     426           8 :                 odbc_errs_add(&dbc->errs, "08001", NULL);
     427           8 :                 return SQL_ERROR;
     428             :         }
     429             : #ifdef ENABLE_ODBC_WIDE
     430         876 :         dbc->mb_conv = tds_iconv_get_info(dbc->tds_socket->conn, dbc->original_charset_num, TDS_CHARSET_UTF_8);
     431             : #endif
     432             : 
     433         876 :         dbc->default_query_timeout = dbc->tds_socket->query_timeout;
     434             : 
     435         876 :         if (IS_TDS7_PLUS(dbc->tds_socket->conn))
     436         662 :                 dbc->cursor_support = 1;
     437             : 
     438             : #if ENABLE_ODBC_MARS
     439             :         /* check if mars is enabled */
     440         438 :         if (!IS_TDS72_PLUS(dbc->tds_socket->conn) || !dbc->tds_socket->conn->mars)
     441         335 :                 dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
     442             : #else
     443         438 :         dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
     444             : #endif
     445             : 
     446         876 :         if (dbc->attr.txn_isolation != SQL_TXN_READ_COMMITTED) {
     447          26 :                 if (!SQL_SUCCEEDED(change_txn(dbc, dbc->attr.txn_isolation)))
     448           0 :                         ODBC_RETURN_(dbc);
     449             :         }
     450             : 
     451         876 :         if (dbc->attr.autocommit != SQL_AUTOCOMMIT_ON) {
     452          34 :                 dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
     453          34 :                 if (!SQL_SUCCEEDED(change_autocommit(dbc, SQL_AUTOCOMMIT_OFF)))
     454           0 :                         ODBC_RETURN_(dbc);
     455             :         }
     456             : 
     457             :         /* this overwrite any error arrived (wanted behavior, Sybase return error for conversion errors) */
     458         876 :         ODBC_RETURN(dbc, SQL_SUCCESS);
     459             : 
     460           0 : memory_error:
     461           0 :         tds_free_socket(dbc->tds_socket);
     462           0 :         dbc->tds_socket = NULL;
     463           0 :         odbc_errs_add(&dbc->errs, "HY001", NULL);
     464           0 :         ODBC_RETURN_(dbc);
     465             : }
     466             : 
     467             : /**
     468             :  * Update IRD information.
     469             :  * This is needed if the IRD is not updated as requires query to be prepared.
     470             :  * For instance calling SQLNumResultCols after SQLPrepare we need to
     471             :  * know how many rows the query could return.
     472             :  */
     473             : static SQLRETURN
     474          56 : odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs)
     475             : {
     476             :         SQLRETURN res;
     477             : 
     478          56 :         if (!stmt->need_reprepare || stmt->prepared_query_is_rpc
     479          50 :             || !stmt->dbc || !IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
     480           8 :                 stmt->need_reprepare = 0;
     481             :                 return SQL_SUCCESS;
     482             :         }
     483             : 
     484             :         /* FIXME where error are put ?? on stmt... */
     485          48 :         if (!odbc_lock_statement(stmt))
     486           0 :                 ODBC_RETURN_(stmt);
     487             : 
     488             :         /* FIXME error */
     489          48 :         res = start_parse_prepared_query(stmt, false);
     490          48 :         if (res != SQL_SUCCESS) {
     491             :                 /* prepare with dummy parameters just to fill IRD */
     492           6 :                 tds_free_param_results(stmt->params);
     493           6 :                 stmt->params = NULL;
     494           6 :                 stmt->param_num = 0;
     495             :                 /*
     496             :                  * TODO
     497             :                  * we need to prepare again with parameters but need_reprepare
     498             :                  * flag is reset by odbc_prepare... perhaps should be checked
     499             :                  * later, not calling describeCol or similar
     500             :                  * we need prepare to get dynamic and cause we change parameters
     501             :                  */
     502             :         }
     503             : 
     504          48 :         return odbc_prepare(stmt);
     505             : }
     506             : 
     507             : static SQLRETURN
     508         340 : odbc_prepare(TDS_STMT *stmt)
     509             : {
     510         340 :         TDSSOCKET *tds = stmt->tds;
     511         340 :         int in_row = 0;
     512             : 
     513         680 :         if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
     514          16 :                 ODBC_SAFE_ERROR(stmt);
     515             :                 return SQL_ERROR;
     516             :         }
     517             : 
     518             :         /* try to go to the next recordset */
     519             :         /* TODO merge with similar code */
     520         324 :         desc_free_records(stmt->ird);
     521         324 :         stmt->row_status = PRE_NORMAL_ROW;
     522             :         for (;;) {
     523             :                 TDS_INT result_type;
     524             :                 int done_flags;
     525             : 
     526         716 :                 switch (tds_process_tokens(tds, &result_type, &done_flags, TDS_RETURN_ROWFMT|TDS_RETURN_DONE)) {
     527         392 :                 case TDS_SUCCESS:
     528         392 :                         switch (result_type) {
     529         316 :                         case TDS_DONE_RESULT:
     530             :                         case TDS_DONEPROC_RESULT:
     531             :                         case TDS_DONEINPROC_RESULT:
     532         316 :                                 stmt->row_count = tds->rows_affected;
     533         316 :                                 if (done_flags & TDS_DONE_ERROR && !stmt->dyn->emulated)
     534           2 :                                         stmt->errs.lastrc = SQL_ERROR;
     535             :                                 /* FIXME this row is used only as a flag for update binding, should be cleared if binding/result changed */
     536         316 :                                 stmt->row = 0;
     537         316 :                                 break;
     538             : 
     539          76 :                         case TDS_ROWFMT_RESULT:
     540             :                                 /* store first row informations */
     541          76 :                                 if (!in_row)
     542          64 :                                         odbc_populate_ird(stmt);
     543          76 :                                 stmt->row = 0;
     544          76 :                                 stmt->row_count = TDS_NO_COUNT;
     545          76 :                                 stmt->row_status = PRE_NORMAL_ROW;
     546          76 :                                 in_row = 1;
     547          76 :                                 break;
     548             :                         }
     549         392 :                         continue;
     550             :                 case TDS_NO_MORE_RESULTS:
     551             :                         break;
     552           0 :                 case TDS_CANCELLED:
     553           0 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
     554           8 :                 default:
     555           8 :                         stmt->errs.lastrc = SQL_ERROR;
     556           8 :                         break;
     557             :                 }
     558         324 :                 break;
     559             :         }
     560             : 
     561         324 :         if (stmt->errs.lastrc == SQL_ERROR && !stmt->dyn->emulated) {
     562          10 :                 tds_release_dynamic(&stmt->dyn);
     563             :         }
     564         324 :         odbc_unlock_statement(stmt);
     565         324 :         stmt->need_reprepare = 0;
     566         324 :         ODBC_RETURN_(stmt);
     567             : }
     568             : 
     569          94 : ODBC_FUNC(SQLDriverConnect, (P(SQLHDBC,hdbc), P(SQLHWND,hwnd), PCHARIN(ConnStrIn,SQLSMALLINT),
     570             :         PCHAROUT(ConnStrOut,SQLSMALLINT), P(SQLUSMALLINT,fDriverCompletion) WIDE))
     571             : {
     572             :         TDSLOGIN *login;
     573             :         TDS_PARSED_PARAM params[ODBC_PARAM_SIZE];
     574          94 :         DSTR conn_str = DSTR_INITIALIZER;
     575             : 
     576          94 :         ODBC_ENTER_HDBC;
     577             : 
     578             : #ifdef TDS_NO_DM
     579             :         /* Check string length */
     580          94 :         if (!IS_VALID_LEN(cbConnStrIn) || cbConnStrIn == 0) {
     581           0 :                 odbc_errs_add(&dbc->errs, "HY090", NULL);
     582           0 :                 ODBC_EXIT_(dbc);
     583             :         }
     584             : 
     585             :         /* Check completion param */
     586          94 :         switch (fDriverCompletion) {
     587             :         case SQL_DRIVER_NOPROMPT:
     588             :         case SQL_DRIVER_COMPLETE:
     589             :         case SQL_DRIVER_PROMPT:
     590             :         case SQL_DRIVER_COMPLETE_REQUIRED:
     591             :                 break;
     592           0 :         default:
     593           0 :                 odbc_errs_add(&dbc->errs, "HY110", NULL);
     594           0 :                 ODBC_EXIT_(dbc);
     595             :         }
     596             : #endif
     597             : 
     598          94 :         if (!odbc_dstr_copy(dbc, &conn_str, cbConnStrIn, szConnStrIn)) {
     599           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
     600           0 :                 ODBC_EXIT_(dbc);
     601             :         }
     602             : 
     603          94 :         login = tds_alloc_login(0);
     604          94 :         if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale)) {
     605           0 :                 tds_free_login(login);
     606           0 :                 tds_dstr_free(&conn_str);
     607           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
     608           0 :                 ODBC_EXIT_(dbc);
     609             :         }
     610             : 
     611         188 :         if (!tds_dstr_isempty(&dbc->attr.current_catalog))
     612          16 :                 if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog)) {
     613           0 :                         tds_free_login(login);
     614           0 :                         tds_dstr_free(&conn_str);
     615           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
     616           0 :                         ODBC_EXIT_(dbc);
     617             :                 }
     618             : 
     619             :         /* parse the DSN string */
     620         282 :         if (!odbc_parse_connect_string(&dbc->errs, tds_dstr_buf(&conn_str), tds_dstr_buf(&conn_str) + tds_dstr_len(&conn_str),
     621             :                                        login, params)) {
     622           0 :                 tds_dstr_free(&conn_str);
     623           0 :                 ODBC_EXIT_(dbc);
     624             :         }
     625             : 
     626         282 :         odbc_set_dstr(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, &conn_str);
     627          94 :         tds_dstr_free(&conn_str);
     628             : 
     629             :         /* add login info */
     630          94 :         if (hwnd && fDriverCompletion != SQL_DRIVER_NOPROMPT
     631           0 :             && (fDriverCompletion == SQL_DRIVER_PROMPT || (!params[ODBC_PARAM_UID].p && !params[ODBC_PARAM_Trusted_Connection].p)
     632           0 :                 || tds_dstr_isempty(&login->server_name))) {
     633             : #ifdef _WIN32
     634             :                 char *out = NULL;
     635             : 
     636             :                 /* prompt for login information */
     637             :                 if (!get_login_info(hwnd, login)) {
     638             :                         tds_free_login(login);
     639             :                         odbc_errs_add(&dbc->errs, "08001", "User canceled login");
     640             :                         ODBC_EXIT_(dbc);
     641             :                 }
     642             :                 if (tds_dstr_isempty(&login->user_name)) {
     643             :                         params[ODBC_PARAM_UID].p = NULL;
     644             :                         params[ODBC_PARAM_PWD].p = NULL;
     645             :                         params[ODBC_PARAM_Trusted_Connection].p = "Yes";
     646             :                         params[ODBC_PARAM_Trusted_Connection].len = 3;
     647             :                 } else {
     648             :                         params[ODBC_PARAM_UID].p   = tds_dstr_cstr(&login->user_name);
     649             :                         params[ODBC_PARAM_UID].len = tds_dstr_len(&login->user_name);
     650             :                         params[ODBC_PARAM_PWD].p   = tds_dstr_cstr(&login->password);
     651             :                         params[ODBC_PARAM_PWD].len = tds_dstr_len(&login->password);
     652             :                         params[ODBC_PARAM_Trusted_Connection].p = NULL;
     653             :                 }
     654             :                 if (!odbc_build_connect_string(&dbc->errs, params, &out))
     655             :                         ODBC_EXIT_(dbc);
     656             : 
     657             :                 odbc_set_string(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, out, -1);
     658             :                 tdsdump_log(TDS_DBG_INFO1, "connection string is now: %s\n", out);
     659             :                 free(out);
     660             : #else
     661             :                 /* we dont support a dialog box */
     662           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
     663             : #endif
     664             :         }
     665             : 
     666         188 :         if (tds_dstr_isempty(&login->server_name)) {
     667           0 :                 tds_free_login(login);
     668           0 :                 odbc_errs_add(&dbc->errs, "IM007", "Could not find Servername or server parameter");
     669           0 :                 ODBC_EXIT_(dbc);
     670             :         }
     671             : 
     672          94 :         odbc_connect(dbc, login);
     673             : 
     674          94 :         tds_free_login(login);
     675          94 :         ODBC_EXIT_(dbc);
     676             : }
     677             : 
     678             : #if 0
     679             : SQLRETURN ODBC_API
     680             : SQLBrowseConnect(SQLHDBC hdbc, SQLCHAR FAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR FAR * szConnStrOut,
     681             :                  SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR * pcbConnStrOut)
     682             : {
     683             :         tdsdump_log(TDS_DBG_FUNC, "SQLBrowseConnect(%p, %s, %d, %p, %d, %p)\n", 
     684             :                         hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
     685             :         ODBC_ENTER_HDBC;
     686             :         odbc_errs_add(&dbc->errs, "HYC00", "SQLBrowseConnect: function not implemented");
     687             :         ODBC_EXIT_(dbc);
     688             : }
     689             : #endif
     690             : 
     691             : 
     692           0 : ODBC_FUNC(SQLColumnPrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT), PCHARIN(SchemaName,SQLSMALLINT),
     693             :         PCHARIN(TableName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
     694             : {
     695             :         int retcode;
     696             : 
     697           0 :         ODBC_ENTER_HSTMT;
     698             : 
     699           0 :         retcode =
     700           0 :                 odbc_stat_execute(stmt _wide, "sp_column_privileges", 4, "O@table_qualifier", szCatalogName, cbCatalogName,
     701             :                                   "O@table_owner", szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName,
     702             :                                   "P@column_name", szColumnName, cbColumnName);
     703           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
     704           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
     705           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
     706             :         }
     707           0 :         ODBC_EXIT_(stmt);
     708             : }
     709             : 
     710             : #if 0
     711             : SQLRETURN ODBC_API
     712             : SQLDescribeParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT FAR * pfSqlType, SQLUINTEGER FAR * pcbParamDef,
     713             :                  SQLSMALLINT FAR * pibScale, SQLSMALLINT FAR * pfNullable)
     714             : {
     715             :         tdsdump_log(TDS_DBG_FUNC, "SQLDescribeParam(%p, %d, %p, %p, %p, %p)\n", 
     716             :                         hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
     717             :         ODBC_ENTER_HSTMT;
     718             :         odbc_errs_add(&stmt->errs, "HYC00", "SQLDescribeParam: function not implemented");
     719             :         ODBC_EXIT_(stmt);
     720             : }
     721             : #endif
     722             : 
     723             : 
     724             : SQLRETURN ODBC_PUBLIC ODBC_API
     725             : SQLExtendedFetch(SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLROWOFFSET irow, SQLROWSETSIZE FAR * pcrow, SQLUSMALLINT FAR * rgfRowStatus)
     726             : {
     727             :         SQLRETURN ret;
     728             :         SQLULEN * tmp_rows;
     729             :         SQLUSMALLINT * tmp_status;
     730             :         SQLULEN tmp_size;
     731             :         SQLLEN * tmp_offset;
     732             :         SQLPOINTER tmp_bookmark;
     733             :         SQLULEN bookmark;
     734          14 :         SQLULEN out_len = 0;
     735             : 
     736          14 :         ODBC_ENTER_HSTMT;
     737             : 
     738          14 :         tdsdump_log(TDS_DBG_FUNC, "SQLExtendedFetch(%p, %d, %d, %p, %p)\n", 
     739             :                         hstmt, fFetchType, (int)irow, pcrow, rgfRowStatus);
     740             : 
     741          14 :         if (fFetchType != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
     742           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
     743           0 :                 ODBC_EXIT_(stmt);
     744             :         }
     745             : 
     746             :         /* save and change IRD/ARD state */
     747          14 :         tmp_rows = stmt->ird->header.sql_desc_rows_processed_ptr;
     748          14 :         stmt->ird->header.sql_desc_rows_processed_ptr = &out_len;
     749          14 :         tmp_status = stmt->ird->header.sql_desc_array_status_ptr;
     750          14 :         stmt->ird->header.sql_desc_array_status_ptr = rgfRowStatus;
     751          14 :         tmp_size = stmt->ard->header.sql_desc_array_size;
     752          14 :         stmt->ard->header.sql_desc_array_size = stmt->sql_rowset_size;
     753          14 :         tmp_offset = stmt->ard->header.sql_desc_bind_offset_ptr;
     754          14 :         stmt->ard->header.sql_desc_bind_offset_ptr = NULL;
     755          14 :         tmp_bookmark = stmt->attr.fetch_bookmark_ptr;
     756             : 
     757             :         /* SQL_FETCH_BOOKMARK different */
     758          14 :         if (fFetchType == SQL_FETCH_BOOKMARK) {
     759           0 :                 bookmark = irow;
     760           0 :                 irow = 0;
     761           0 :                 stmt->attr.fetch_bookmark_ptr = &bookmark;
     762             :         }
     763             :         
     764             :         /* TODO errors are sligthly different ... perhaps it's better to leave DM do this job ?? */
     765             :         /* TODO check fFetchType can be converted to USMALLINT */
     766          14 :         ret = _SQLFetch(stmt, fFetchType, irow);
     767             : 
     768             :         /* restore IRD/ARD */
     769          14 :         stmt->ird->header.sql_desc_rows_processed_ptr = tmp_rows;
     770          14 :         if (pcrow)
     771          14 :                 *pcrow = out_len;
     772          14 :         stmt->ird->header.sql_desc_array_status_ptr = tmp_status;
     773          14 :         stmt->ard->header.sql_desc_array_size = tmp_size;
     774          14 :         stmt->ard->header.sql_desc_bind_offset_ptr = tmp_offset;
     775          14 :         stmt->attr.fetch_bookmark_ptr = tmp_bookmark;
     776             : 
     777          14 :         ODBC_EXIT(stmt, ret);
     778             : }
     779             : 
     780           0 : ODBC_FUNC(SQLForeignKeys, (P(SQLHSTMT,hstmt), PCHARIN(PkCatalogName,SQLSMALLINT),
     781             :         PCHARIN(PkSchemaName,SQLSMALLINT), PCHARIN(PkTableName,SQLSMALLINT),
     782             :         PCHARIN(FkCatalogName,SQLSMALLINT), PCHARIN(FkSchemaName,SQLSMALLINT),
     783             :         PCHARIN(FkTableName,SQLSMALLINT) WIDE))
     784             : {
     785             :         int retcode;
     786             : 
     787           0 :         ODBC_ENTER_HSTMT;
     788             : 
     789           0 :         retcode =
     790           0 :                 odbc_stat_execute(stmt _wide, "sp_fkeys", 6, "O@pktable_qualifier", szPkCatalogName, cbPkCatalogName, "O@pktable_owner",
     791             :                                   szPkSchemaName, cbPkSchemaName, "O@pktable_name", szPkTableName, cbPkTableName,
     792             :                                   "O@fktable_qualifier", szFkCatalogName, cbFkCatalogName, "O@fktable_owner", szFkSchemaName,
     793             :                                   cbFkSchemaName, "O@fktable_name", szFkTableName, cbFkTableName);
     794           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
     795           0 :                 odbc_col_setname(stmt, 1, "PKTABLE_CAT");
     796           0 :                 odbc_col_setname(stmt, 2, "PKTABLE_SCHEM");
     797           0 :                 odbc_col_setname(stmt, 5, "FKTABLE_CAT");
     798           0 :                 odbc_col_setname(stmt, 6, "FKTABLE_SCHEM");
     799             :         }
     800           0 :         ODBC_EXIT_(stmt);
     801             : }
     802             : 
     803             : static int
     804       52049 : odbc_lock_statement(TDS_STMT* stmt)
     805             : {
     806             : #if ENABLE_ODBC_MARS
     807       26093 :         TDSSOCKET *tds = stmt->tds;
     808             : 
     809             : 
     810             :         /* we already own a socket, just use it */
     811       26093 :         if (!tds) {
     812             :                 /* try with one saved into DBC */
     813       12590 :                 TDSSOCKET *dbc_tds = stmt->dbc->tds_socket;
     814       12590 :                 tds_mutex_lock(&stmt->dbc->mtx);
     815             : 
     816       12590 :                 if (stmt->dbc->current_statement == NULL
     817          42 :                     || stmt->dbc->current_statement == stmt) {
     818       12548 :                         tds = dbc_tds;
     819       12548 :                         stmt->dbc->current_statement = stmt;
     820             :                 }
     821             : 
     822             :                 /* try to grab current locked one */
     823       12590 :                 if (!tds && dbc_tds->state == TDS_IDLE) {
     824          31 :                         stmt->dbc->current_statement->tds = NULL;
     825          31 :                         tds = dbc_tds;
     826          31 :                         stmt->dbc->current_statement = stmt;
     827             :                 }
     828       12590 :                 tds_mutex_unlock(&stmt->dbc->mtx);
     829             : 
     830             :                 /* try with MARS */
     831       12590 :                 if (!tds)
     832          11 :                         tds = tds_alloc_additional_socket(dbc_tds->conn);
     833             :         }
     834       26093 :         if (tds) {
     835       52174 :                 tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
     836       26087 :                         stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
     837       26087 :                 tds_set_parent(tds, stmt);
     838       26087 :                 stmt->tds = tds;
     839       26087 :                 return 1;
     840             :         }
     841           6 :         odbc_errs_add(&stmt->errs, "24000", NULL);
     842           6 :         return 0;
     843             : #else
     844       25956 :         TDSSOCKET *tds = stmt->dbc->tds_socket;
     845             : 
     846       25956 :         tds_mutex_lock(&stmt->dbc->mtx);
     847       25956 :         if (stmt->dbc->current_statement != NULL
     848       13411 :             && stmt->dbc->current_statement != stmt) {
     849          39 :                 if (!tds || tds->state != TDS_IDLE) {
     850           8 :                         tds_mutex_unlock(&stmt->dbc->mtx);
     851           8 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
     852           8 :                         return 0;
     853             :                 }
     854          31 :                 stmt->dbc->current_statement->tds = NULL;
     855             :         }
     856       25948 :         stmt->dbc->current_statement = stmt;
     857       25948 :         if (tds) {
     858       51896 :                 tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
     859       25948 :                         stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
     860       25948 :                 tds_set_parent(tds, stmt);
     861       25948 :                 stmt->tds = tds;
     862             :         }
     863       25948 :         tds_mutex_unlock(&stmt->dbc->mtx);
     864       25948 :         return 1;
     865             : #endif
     866             : }
     867             : 
     868             : static void
     869       36327 : odbc_unlock_statement(TDS_STMT* stmt)
     870             : {
     871             :         TDSSOCKET * tds;
     872             : 
     873       36327 :         tds_mutex_lock(&stmt->dbc->mtx);
     874       36327 :         tds = stmt->tds;
     875       36327 :         if (stmt->dbc->current_statement == stmt) {
     876       24693 :                 assert(tds == stmt->dbc->tds_socket);
     877       24693 :                 if (tds->state == TDS_IDLE || tds->state == TDS_DEAD) {
     878       24693 :                         stmt->dbc->current_statement = NULL;
     879       24693 :                         tds_set_parent(tds, stmt->dbc);
     880       24693 :                         stmt->tds = NULL;
     881             :                 }
     882             : #if ENABLE_ODBC_MARS
     883        5820 :         } else if (tds) {
     884           5 :                 if (tds->state == TDS_IDLE || tds->state == TDS_DEAD) {
     885           5 :                         assert(tds != stmt->dbc->tds_socket);
     886           5 :                         tds_free_socket(tds);
     887           5 :                         stmt->tds = NULL;
     888             :                 }
     889             : #endif
     890             :         }
     891       36327 :         tds_mutex_unlock(&stmt->dbc->mtx);
     892       36327 : }
     893             : 
     894             : SQLRETURN ODBC_PUBLIC ODBC_API
     895             : SQLMoreResults(SQLHSTMT hstmt)
     896             : {
     897             :         TDSSOCKET *tds;
     898             :         TDS_INT result_type;
     899             :         TDSRET tdsret;
     900       39977 :         int in_row = 0;
     901             :         SQLUSMALLINT param_status;
     902             :         int token_flags;
     903             : 
     904       39977 :         ODBC_ENTER_HSTMT;
     905             : 
     906       39977 :         tdsdump_log(TDS_DBG_FUNC, "SQLMoreResults(%p)\n", hstmt);
     907             : 
     908       39977 :         tds = stmt->tds;
     909             : 
     910             :         /* We already read all results... */
     911       39977 :         if (!tds)
     912         568 :                 ODBC_EXIT(stmt, SQL_NO_DATA);
     913             : 
     914       39409 :         stmt->row_count = TDS_NO_COUNT;
     915       39409 :         stmt->special_row = ODBC_SPECIAL_NONE;
     916             : 
     917             :         /* TODO this code is TOO similar to _SQLExecute, merge it - freddy77 */
     918             :         /* try to go to the next recordset */
     919       39409 :         if (stmt->row_status == IN_COMPUTE_ROW) {
     920             :                 /* FIXME doesn't seem so fine ... - freddy77 */
     921          16 :                 tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
     922          16 :                 stmt->row_status = IN_COMPUTE_ROW;
     923          16 :                 in_row = 1;
     924             :         }
     925             : 
     926       39409 :         param_status = SQL_PARAM_SUCCESS;
     927       39409 :         token_flags = (TDS_TOKEN_RESULTS & (~TDS_STOPAT_COMPUTE)) | TDS_RETURN_COMPUTE;
     928       39409 :         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
     929       38164 :                 token_flags |= TDS_RETURN_MSG;
     930             :         for (;;) {
     931       39788 :                 result_type = odbc_process_tokens(stmt, token_flags);
     932       39788 :                 tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: result_type=%d, row_count=%" PRId64 ", lastrc=%d\n",
     933           0 :                                                 result_type, stmt->row_count, stmt->errs.lastrc);
     934       39788 :                 switch (result_type) {
     935        6643 :                 case TDS_CMD_DONE:
     936             : #if 1 /* !UNIXODBC */
     937        6643 :                         tds_free_all_results(tds);
     938             : #endif
     939        6643 :                         odbc_populate_ird(stmt);
     940        6643 :                         odbc_unlock_statement(stmt);
     941        6643 :                         if (stmt->row_count == TDS_NO_COUNT && !in_row) {
     942        6619 :                                 stmt->row_status = NOT_IN_ROW;
     943        6619 :                                 tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_status=%d\n", stmt->row_status);
     944             :                         }
     945        6643 :                         tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_count=%" PRId64 ", lastrc=%d\n", stmt->row_count, stmt->errs.lastrc);
     946        6643 :                         if (stmt->row_count == TDS_NO_COUNT) {
     947        6631 :                                 if (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
     948        6627 :                                         ODBC_EXIT(stmt, SQL_NO_DATA);
     949             :                         }
     950          16 :                         ODBC_EXIT_(stmt);
     951             : 
     952           0 :                 case TDS_CMD_FAIL:
     953           0 :                         ODBC_SAFE_ERROR(stmt);
     954           0 :                         ODBC_EXIT_(stmt);
     955             : 
     956          48 :                 case TDS_COMPUTE_RESULT:
     957          48 :                         switch (stmt->row_status) {
     958             :                         /* skip this recordset */
     959             :                         case IN_COMPUTE_ROW:
     960             :                                 /* TODO here we should set current_results to normal results */
     961             :                                 in_row = 1;
     962             :                                 /* fall through */
     963             :                         /* in normal row, put in compute status */
     964          48 :                         case AFTER_COMPUTE_ROW:
     965             :                         case IN_NORMAL_ROW:
     966             :                         case PRE_NORMAL_ROW:
     967          48 :                                 stmt->row_status = IN_COMPUTE_ROW;
     968          48 :                                 odbc_populate_ird(stmt);
     969          48 :                                 ODBC_EXIT_(stmt);
     970           0 :                         case NOT_IN_ROW:
     971             :                                 /* this should never happen, protocol error */
     972           0 :                                 ODBC_SAFE_ERROR(stmt);
     973           0 :                                 ODBC_EXIT_(stmt);
     974             :                                 break;
     975             :                         }
     976             :                         break;
     977             : 
     978         295 :                 case TDS_ROW_RESULT:
     979         295 :                         if (in_row || (stmt->row_status != IN_NORMAL_ROW && stmt->row_status != PRE_NORMAL_ROW)) {
     980         126 :                                 stmt->row_status = PRE_NORMAL_ROW;
     981         126 :                                 odbc_populate_ird(stmt);
     982         126 :                                 ODBC_EXIT_(stmt);
     983             :                         }
     984             :                         /* Skipping current result set's rows to access next resultset or proc's retval */
     985         169 :                         tdsret = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_STOPAT_COMPUTE);
     986             :                         /* TODO should we set in_row ?? */
     987         169 :                         switch (tdsret) {
     988           0 :                         case TDS_CANCELLED:
     989           0 :                                 odbc_errs_add(&stmt->errs, "HY008", NULL);
     990         169 :                         default:
     991         169 :                                 if (TDS_FAILED(tdsret)) {
     992           0 :                                         ODBC_SAFE_ERROR(stmt);
     993           0 :                                         ODBC_EXIT_(stmt);
     994             :                                 }
     995             :                         }
     996             :                         break;
     997             : 
     998       32530 :                 case TDS_DONE_RESULT:
     999             :                 case TDS_DONEPROC_RESULT:
    1000             :                         /* FIXME here ??? */
    1001       32530 :                         if (!in_row)
    1002       32508 :                                 tds_free_all_results(tds);
    1003       32530 :                         switch (stmt->errs.lastrc) {
    1004           0 :                         case SQL_ERROR:
    1005           0 :                                 param_status = SQL_PARAM_ERROR;
    1006           0 :                                 break;
    1007          14 :                         case SQL_SUCCESS_WITH_INFO:
    1008          14 :                                 param_status = SQL_PARAM_SUCCESS_WITH_INFO;
    1009          14 :                                 break;
    1010             :                         }
    1011       32530 :                         if (stmt->curr_param_row < stmt->num_param_rows) {
    1012           0 :                                 if (stmt->ipd->header.sql_desc_array_status_ptr)
    1013           0 :                                         stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    1014           0 :                                 ++stmt->curr_param_row;
    1015           0 :                                 if (stmt->ipd->header.sql_desc_rows_processed_ptr)
    1016           0 :                                         *stmt->ipd->header.sql_desc_rows_processed_ptr = stmt->curr_param_row;
    1017             :                         }
    1018       32530 :                         if (stmt->curr_param_row < stmt->num_param_rows) {
    1019             : #if 0
    1020             :                                 if (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
    1021             :                                         found_info = 1;
    1022             :                                 if (stmt->errs.lastrc == SQL_ERROR)
    1023             :                                         found_error = 1;
    1024             : #endif
    1025           0 :                                 stmt->errs.lastrc = SQL_SUCCESS;
    1026           0 :                                 param_status = SQL_PARAM_SUCCESS;
    1027           0 :                                 break;
    1028             :                         }
    1029       32530 :                         odbc_populate_ird(stmt);
    1030       32530 :                         ODBC_EXIT_(stmt);
    1031             :                         break;
    1032             : 
    1033             :                         /*
    1034             :                          * TODO test flags ? check error and change result ? 
    1035             :                          * see also other DONEINPROC handle (below)
    1036             :                          */
    1037          64 :                 case TDS_DONEINPROC_RESULT:
    1038          64 :                         if (in_row) {
    1039          52 :                                 odbc_populate_ird(stmt);
    1040          52 :                                 ODBC_EXIT_(stmt);
    1041             :                         }
    1042             :                         /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
    1043          12 :                         tds_free_all_results(tds);
    1044          12 :                         odbc_populate_ird(stmt);
    1045          12 :                         break;
    1046             : 
    1047             :                         /* do not stop at metadata, an error can follow... */
    1048         152 :                 case TDS_ROWFMT_RESULT:
    1049         152 :                         if (in_row) {
    1050          10 :                                 odbc_populate_ird(stmt);
    1051          10 :                                 ODBC_EXIT_(stmt);
    1052             :                         }
    1053         142 :                         stmt->row = 0;
    1054         142 :                         stmt->row_count = TDS_NO_COUNT;
    1055             :                         /* we expect a row */
    1056         142 :                         stmt->row_status = PRE_NORMAL_ROW;
    1057         142 :                         in_row = 1;
    1058         142 :                         break;
    1059             : 
    1060          56 :                 case TDS_MSG_RESULT:
    1061          56 :                         if (!in_row) {
    1062          56 :                                 tds_free_all_results(tds);
    1063          56 :                                 odbc_populate_ird(stmt);
    1064             :                         }
    1065             :                         in_row = 1;
    1066             :                         break;
    1067             :                 }
    1068             :         }
    1069             :         ODBC_EXIT(stmt, SQL_ERROR);
    1070             : }
    1071             : 
    1072           0 : ODBC_FUNC(SQLNativeSql, (P(SQLHDBC,hdbc), PCHARIN(SqlStrIn,SQLINTEGER),
    1073             :         PCHAROUT(SqlStr,SQLINTEGER) WIDE))
    1074             : {
    1075           0 :         SQLRETURN ret = SQL_SUCCESS;
    1076           0 :         DSTR query = DSTR_INITIALIZER;
    1077             : 
    1078           0 :         ODBC_ENTER_HDBC;
    1079             : 
    1080             : #ifdef TDS_NO_DM
    1081           0 :         if (!szSqlStrIn || !IS_VALID_LEN(cbSqlStrIn)) {
    1082           0 :                 odbc_errs_add(&dbc->errs, "HY009", NULL);
    1083           0 :                 ODBC_EXIT_(dbc);
    1084             :         }
    1085             : #endif
    1086             : 
    1087           0 :         if (!odbc_dstr_copy(dbc, &query, cbSqlStrIn, szSqlStrIn)) {
    1088           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1089           0 :                 ODBC_EXIT_(dbc);
    1090             :         }
    1091             : 
    1092           0 :         native_sql(dbc, &query);
    1093             : 
    1094             :         /* FIXME if error set some kind of error */
    1095           0 :         ret = odbc_set_dstr(dbc, szSqlStr, cbSqlStrMax, pcbSqlStr, &query);
    1096             : 
    1097           0 :         tds_dstr_free(&query);
    1098             : 
    1099           0 :         ODBC_EXIT(dbc, ret);
    1100             : }
    1101             : 
    1102             : SQLRETURN ODBC_PUBLIC ODBC_API
    1103             : SQLNumParams(SQLHSTMT hstmt, SQLSMALLINT FAR * pcpar)
    1104             : {
    1105          32 :         ODBC_ENTER_HSTMT;
    1106          32 :         tdsdump_log(TDS_DBG_FUNC, "SQLNumParams(%p, %p)\n", hstmt, pcpar);
    1107          32 :         *pcpar = stmt->param_count;
    1108          32 :         ODBC_EXIT_(stmt);
    1109             : }
    1110             : 
    1111             : SQLRETURN ODBC_PUBLIC ODBC_API
    1112             : SQLParamOptions(SQLHSTMT hstmt, SQLULEN crow, SQLULEN FAR * pirow)
    1113             : {
    1114             :         SQLRETURN res;
    1115             : 
    1116          16 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamOptions(%p, %lu, %p)\n", hstmt, (unsigned long int)crow, pirow);
    1117             : 
    1118             :         /* emulate for ODBC 2 DM */
    1119          16 :         res = _SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, pirow, 0 _wide0);
    1120          16 :         if (res != SQL_SUCCESS)
    1121             :                 return res;
    1122          16 :         return _SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crow, 0 _wide0);
    1123             : }
    1124             : 
    1125           0 : ODBC_FUNC(SQLPrimaryKeys, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1126             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
    1127             : {
    1128             :         int retcode;
    1129             : 
    1130           0 :         ODBC_ENTER_HSTMT;
    1131             : 
    1132           0 :         retcode =
    1133           0 :                 odbc_stat_execute(stmt _wide, "sp_pkeys", 3, "O@table_qualifier", szCatalogName, cbCatalogName, "O@table_owner",
    1134             :                                   szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName);
    1135           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1136           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    1137           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    1138             :         }
    1139           0 :         ODBC_EXIT_(stmt);
    1140             : }
    1141             : 
    1142          16 : ODBC_FUNC(SQLProcedureColumns, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1143             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
    1144             : {
    1145             :         int retcode;
    1146             : 
    1147          16 :         ODBC_ENTER_HSTMT;
    1148             : 
    1149          16 :         retcode =
    1150          16 :                 odbc_stat_execute(stmt _wide, "sp_sproc_columns", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4,
    1151             :                                   "O@procedure_qualifier", szCatalogName, cbCatalogName,
    1152             :                                   "P@procedure_owner", szSchemaName, cbSchemaName, "P@procedure_name", szProcName, cbProcName,
    1153             :                                   "P@column_name", szColumnName, cbColumnName, "V@ODBCVer", (char*) NULL, 0);
    1154          16 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1155           8 :                 odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
    1156           8 :                 odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
    1157           8 :                 odbc_col_setname(stmt, 8, "COLUMN_SIZE");
    1158           8 :                 odbc_col_setname(stmt, 9, "BUFFER_LENGTH");
    1159           8 :                 odbc_col_setname(stmt, 10, "DECIMAL_DIGITS");
    1160           8 :                 odbc_col_setname(stmt, 11, "NUM_PREC_RADIX");
    1161           8 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    1162           2 :                         stmt->special_row = ODBC_SPECIAL_PROCEDURECOLUMNS;
    1163             :         }
    1164          16 :         ODBC_EXIT_(stmt);
    1165             : }
    1166             : 
    1167           0 : ODBC_FUNC(SQLProcedures, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1168             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT) WIDE))
    1169             : {
    1170             :         int retcode;
    1171             : 
    1172           0 :         ODBC_ENTER_HSTMT;
    1173             : 
    1174           0 :         retcode =
    1175           0 :                 odbc_stat_execute(stmt _wide, "..sp_stored_procedures", 3, "P@sp_name", szProcName, cbProcName, "P@sp_owner", szSchemaName,
    1176             :                                   cbSchemaName, "O@sp_qualifier", szCatalogName, cbCatalogName);
    1177           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1178           0 :                 odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
    1179           0 :                 odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
    1180             :         }
    1181           0 :         ODBC_EXIT_(stmt);
    1182             : }
    1183             : 
    1184             : static TDSPARAMINFO*
    1185          60 : odbc_build_update_params(TDS_STMT * stmt, unsigned int n_row)
    1186             : {
    1187             :         unsigned int n;
    1188          60 :         TDSPARAMINFO * params = NULL;
    1189             :         struct _drecord *drec_ird;
    1190             : 
    1191         180 :         for (n = 0; n < stmt->ird->header.sql_desc_count && n < stmt->ard->header.sql_desc_count; ++n) {
    1192             :                 TDSPARAMINFO *temp_params;
    1193             :                 TDSCOLUMN *curcol;
    1194             : 
    1195         120 :                 drec_ird = &stmt->ird->records[n];
    1196             : 
    1197         120 :                 if (drec_ird->sql_desc_updatable == SQL_FALSE)
    1198          12 :                         continue;
    1199             : 
    1200             :                 /* we have certainly a parameter */
    1201         108 :                 if (!(temp_params = tds_alloc_param_result(params)))
    1202             :                         goto memory_error;
    1203         108 :                 params = temp_params;
    1204             : 
    1205         108 :                 curcol = params->columns[params->num_cols - 1];
    1206         108 :                 if (!tds_dstr_dup(&curcol->column_name, &drec_ird->sql_desc_name))
    1207             :                         goto memory_error;
    1208             : 
    1209             :                 /* TODO use all infos... */
    1210         108 :                 if (!tds_dstr_dup(&curcol->table_name, &drec_ird->sql_desc_base_table_name))
    1211             :                         goto memory_error;
    1212             : 
    1213         108 :                 switch (odbc_sql2tds(stmt, drec_ird, &stmt->ard->records[n], curcol, true, stmt->ard, n_row)) {
    1214             :                 case SQL_NEED_DATA:
    1215             :                         goto memory_error;
    1216           0 :                 case SQL_ERROR:
    1217           0 :                         tds_free_param_results(params);
    1218           0 :                         return NULL;
    1219             :                 }
    1220             :         }
    1221             :         return params;
    1222             : 
    1223           0 : memory_error:
    1224           0 :         tds_free_param_results(params);
    1225           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1226           0 :         return NULL;
    1227             : }
    1228             : 
    1229             : SQLRETURN ODBC_PUBLIC ODBC_API
    1230             : SQLSetPos(SQLHSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock)
    1231             : {
    1232             :         TDSRET ret;
    1233             :         TDSSOCKET *tds;
    1234             :         TDS_CURSOR_OPERATION op;
    1235         240 :         TDSPARAMINFO *params = NULL;
    1236         240 :         ODBC_ENTER_HSTMT;
    1237             : 
    1238         240 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetPos(%p, %ld, %d, %d)\n", 
    1239             :                         hstmt, (long) irow, fOption, fLock);
    1240             : 
    1241         240 :         if (!stmt->dbc->cursor_support) {
    1242           0 :                 odbc_errs_add(&stmt->errs, "HYC00", "SQLSetPos: function not implemented");
    1243           0 :                 ODBC_EXIT_(stmt);
    1244             :         }
    1245             : 
    1246             :         /* TODO handle irow == 0 (all rows) */
    1247             : 
    1248         240 :         if (!stmt->cursor) {
    1249           0 :                 odbc_errs_add(&stmt->errs, "HY109", NULL);
    1250           0 :                 ODBC_EXIT_(stmt);
    1251             :         }
    1252             : 
    1253         240 :         switch (fOption) {
    1254             :         case SQL_POSITION:
    1255             :                 op = TDS_CURSOR_POSITION;
    1256             :                 break;
    1257             :         /* TODO cursor support */
    1258           0 :         case SQL_REFRESH:
    1259             :         default:
    1260           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    1261           0 :                 ODBC_EXIT_(stmt);
    1262             :                 break;
    1263          60 :         case SQL_UPDATE:
    1264          60 :                 op = TDS_CURSOR_UPDATE;
    1265             :                 /* prepare paremeters for update */
    1266             :                 /* scan all columns and build parameter list */
    1267          60 :                 params = odbc_build_update_params(stmt, irow >= 1 ? irow - 1 : 0);
    1268          60 :                 if (!params) {
    1269           0 :                         ODBC_SAFE_ERROR(stmt);
    1270           0 :                         ODBC_EXIT_(stmt);
    1271             :                 }
    1272             :                 break;
    1273          60 :         case SQL_DELETE:
    1274          60 :                 op = TDS_CURSOR_DELETE;
    1275          60 :                 break;
    1276           0 :         case SQL_ADD:
    1277           0 :                 op = TDS_CURSOR_INSERT;
    1278           0 :                 break;
    1279             :         }
    1280             : 
    1281         240 :         if (!odbc_lock_statement(stmt)) {
    1282           0 :                 tds_free_param_results(params);
    1283           0 :                 ODBC_EXIT_(stmt);
    1284             :         }
    1285             : 
    1286         240 :         tds = stmt->tds;
    1287             : 
    1288         240 :         if (TDS_FAILED(tds_cursor_update(tds, stmt->cursor, op, irow, params))) {
    1289           0 :                 tds_free_param_results(params);
    1290           0 :                 ODBC_SAFE_ERROR(stmt);
    1291           0 :                 ODBC_EXIT_(stmt);
    1292             :         }
    1293         240 :         tds_free_param_results(params);
    1294         240 :         params = NULL;
    1295             : 
    1296         240 :         ret = tds_process_simple_query(tds);
    1297         240 :         odbc_unlock_statement(stmt);
    1298         240 :         if (TDS_FAILED(ret)) {
    1299           0 :                 ODBC_SAFE_ERROR(stmt);
    1300           0 :                 ODBC_EXIT_(stmt);
    1301             :         }
    1302             : 
    1303         240 :         ODBC_EXIT_(stmt);
    1304             : }
    1305             : 
    1306           0 : ODBC_FUNC(SQLTablePrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    1307             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
    1308             : {
    1309             :         int retcode;
    1310             : 
    1311           0 :         ODBC_ENTER_HSTMT;
    1312             : 
    1313           0 :         retcode =
    1314           0 :                 odbc_stat_execute(stmt _wide, "sp_table_privileges", 3, "O@table_qualifier", szCatalogName, cbCatalogName,
    1315             :                                   "P@table_owner", szSchemaName, cbSchemaName, "P@table_name", szTableName, cbTableName);
    1316           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    1317           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    1318           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    1319             :         }
    1320           0 :         ODBC_EXIT_(stmt);
    1321             : }
    1322             : 
    1323             : #if (ODBCVER >= 0x0300)
    1324             : SQLRETURN ODBC_PUBLIC ODBC_API
    1325             : SQLSetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER StringLength)
    1326             : {
    1327         440 :         SQLINTEGER i_val = (SQLINTEGER) (TDS_INTPTR) Value;
    1328             : 
    1329         440 :         ODBC_ENTER_HENV;
    1330             : 
    1331         440 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetEnvAttr(%p, %d, %p, %d)\n", henv, (int)Attribute, Value, (int)StringLength);
    1332             : 
    1333         440 :         switch (Attribute) {
    1334           0 :         case SQL_ATTR_CONNECTION_POOLING:
    1335             :         case SQL_ATTR_CP_MATCH:
    1336           0 :                 odbc_errs_add(&env->errs, "HYC00", NULL);
    1337           0 :                 break;
    1338         440 :         case SQL_ATTR_ODBC_VERSION:
    1339         440 :                 switch (i_val) {
    1340         440 :                 case SQL_OV_ODBC3:
    1341             :                 case SQL_OV_ODBC2:
    1342         440 :                         env->attr.odbc_version = i_val;
    1343         440 :                         break;
    1344           0 :                 default:
    1345           0 :                         odbc_errs_add(&env->errs, "HY024", NULL);
    1346           0 :                         break;
    1347             :                 }
    1348             :                 break;
    1349           0 :         case SQL_ATTR_OUTPUT_NTS:
    1350             :                 /* TODO - Make this really work */
    1351             :                 /* env->attr.output_nts = i_val; */
    1352           0 :                 env->attr.output_nts = SQL_TRUE;
    1353           0 :                 break;
    1354           0 :         default:
    1355           0 :                 odbc_errs_add(&env->errs, "HY092", NULL);
    1356           0 :                 break;
    1357             :         }
    1358         440 :         ODBC_EXIT_(env);
    1359             : }
    1360             : 
    1361             : SQLRETURN ODBC_PUBLIC ODBC_API
    1362             : SQLGetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    1363             : {
    1364             :         size_t size;
    1365             :         void *src;
    1366             : 
    1367           0 :         ODBC_ENTER_HENV;
    1368             : 
    1369           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetEnvAttr(%p, %d, %p, %d, %p)\n", 
    1370             :                         henv, (int)Attribute, Value, (int)BufferLength, StringLength);
    1371             : 
    1372           0 :         switch (Attribute) {
    1373           0 :         case SQL_ATTR_CONNECTION_POOLING:
    1374           0 :                 src = &env->attr.connection_pooling;
    1375           0 :                 size = sizeof(env->attr.connection_pooling);
    1376           0 :                 break;
    1377           0 :         case SQL_ATTR_CP_MATCH:
    1378           0 :                 src = &env->attr.cp_match;
    1379           0 :                 size = sizeof(env->attr.cp_match);
    1380           0 :                 break;
    1381           0 :         case SQL_ATTR_ODBC_VERSION:
    1382           0 :                 src = &env->attr.odbc_version;
    1383           0 :                 size = sizeof(env->attr.odbc_version);
    1384           0 :                 break;
    1385           0 :         case SQL_ATTR_OUTPUT_NTS:
    1386             :                 /* TODO handle output_nts flags */
    1387           0 :                 env->attr.output_nts = SQL_TRUE;
    1388           0 :                 src = &env->attr.output_nts;
    1389           0 :                 size = sizeof(env->attr.output_nts);
    1390           0 :                 break;
    1391           0 :         default:
    1392           0 :                 odbc_errs_add(&env->errs, "HY092", NULL);
    1393           0 :                 ODBC_EXIT_(env);
    1394             :                 break;
    1395             :         }
    1396             : 
    1397           0 :         if (StringLength) {
    1398           0 :                 *StringLength = size;
    1399             :         }
    1400           0 :         memcpy(Value, src, size);
    1401             : 
    1402           0 :         ODBC_EXIT_(env);
    1403             : }
    1404             : 
    1405             : #endif
    1406             : 
    1407             : #define IRD_UPDATE(desc, errs, exit) \
    1408             :         do { \
    1409             :                 if (desc->type == DESC_IRD && ((TDS_STMT*)desc->parent)->need_reprepare && \
    1410             :                     odbc_update_ird((TDS_STMT*)desc->parent, errs) != SQL_SUCCESS) \
    1411             :                         exit; \
    1412             :         } while(0)
    1413             : 
    1414             : static SQLRETURN
    1415        9340 : _SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
    1416             :                   SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1417             : {
    1418             :         TDS_DESC *apd, *ipd;
    1419             :         struct _drecord *drec;
    1420             :         SQLSMALLINT orig_apd_size, orig_ipd_size;
    1421        9340 :         bool is_numeric = false;
    1422             : 
    1423        9340 :         ODBC_ENTER_HSTMT;
    1424             : 
    1425        9340 :         tdsdump_log(TDS_DBG_FUNC, "_SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n", 
    1426             :                         hstmt, (unsigned short)ipar, (int)fParamType, (int)fCType, (int)fSqlType, (unsigned int)cbColDef, 
    1427             :                         (int)ibScale, rgbValue, (int)cbValueMax, pcbValue);
    1428             : 
    1429             : #ifdef TDS_NO_DM
    1430             :         /* TODO - more error checking ...  XXX smurph */
    1431             : 
    1432             :         /* Check param type */
    1433             :         switch (fParamType) {
    1434             :         case SQL_PARAM_INPUT:
    1435             :         case SQL_PARAM_INPUT_OUTPUT:
    1436             :         case SQL_PARAM_OUTPUT:
    1437             :                 break;
    1438           0 :         default:
    1439           0 :                 odbc_errs_add(&stmt->errs, "HY105", NULL);
    1440           0 :                 ODBC_EXIT_(stmt);
    1441             :         }
    1442             : 
    1443             :         /* Check max buffer length */
    1444        9340 :         if (cbValueMax < 0 && cbValueMax != SQL_NTS) {
    1445           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    1446           0 :                 ODBC_EXIT_(stmt);
    1447             :         }
    1448             : #endif
    1449             : 
    1450             :         /* check cbColDef and ibScale */
    1451        9340 :         if (fSqlType == SQL_DECIMAL || fSqlType == SQL_NUMERIC) {
    1452         170 :                 is_numeric = true;
    1453         170 :                 if (cbColDef < 1 || cbColDef > 38) {
    1454           0 :                         odbc_errs_add(&stmt->errs, "HY104", "Invalid precision value");
    1455           0 :                         ODBC_EXIT_(stmt);
    1456             :                 }
    1457         170 :                 if (ibScale < 0 || ibScale > cbColDef) {
    1458           0 :                         odbc_errs_add(&stmt->errs, "HY104", "Invalid scale value");
    1459           0 :                         ODBC_EXIT_(stmt);
    1460             :                 }
    1461             :         }
    1462             : 
    1463             :         /* Check parameter number */
    1464        9340 :         if (ipar <= 0 || ipar > 4000) {
    1465           0 :                 odbc_errs_add(&stmt->errs, "07009", NULL);
    1466           0 :                 ODBC_EXIT_(stmt);
    1467             :         }
    1468             : 
    1469             :         /* special checks for table type */
    1470        9340 :         if (fSqlType == SQL_SS_TABLE) {
    1471             :                 /* Table types are strictly read-only */
    1472        2076 :                 if (fParamType != SQL_PARAM_INPUT) {
    1473           6 :                         odbc_errs_add(&stmt->errs, "HY105", NULL);
    1474           6 :                         ODBC_EXIT_(stmt);
    1475             :                 }
    1476             : 
    1477             :                 /* Only SQL_C_DEFAULT is accepted */
    1478        2070 :                 if (fCType != SQL_C_DEFAULT) {
    1479           2 :                         odbc_errs_add(&stmt->errs, "07006", NULL);
    1480           2 :                         ODBC_EXIT_(stmt);
    1481             :                 }
    1482             :                 fCType = SQL_C_BINARY;
    1483             :         }
    1484             : 
    1485        9332 :         apd = stmt->apd;
    1486        9332 :         ipd = stmt->ipd;
    1487             : 
    1488             :         /* If the parameter focus is set to 0, bind values as arguments */
    1489             :         /* Otherwise, bind values as the columns of a table-valued parameter */
    1490        9332 :         if (stmt->attr.param_focus != 0) {
    1491             :                 SQLTVP *tvp;
    1492             : 
    1493             :                 /* a table type cannot contain a table type */
    1494        2074 :                 if (fSqlType == SQL_SS_TABLE) {
    1495           4 :                         odbc_errs_add(&stmt->errs, "HY004", NULL);
    1496           4 :                         ODBC_EXIT_(stmt);
    1497             :                 }
    1498             : 
    1499             :                 /* Columns of table types are strictly read-only */
    1500        2070 :                 if (fParamType != SQL_PARAM_INPUT) {
    1501           0 :                         odbc_errs_add(&stmt->errs, "HY105", NULL);
    1502           0 :                         ODBC_EXIT_(stmt);
    1503             :                 }
    1504             : 
    1505             :                 /* check index */
    1506        2070 :                 if (stmt->attr.param_focus > ipd->header.sql_desc_count) {
    1507           0 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    1508           0 :                         ODBC_EXIT_(stmt);
    1509             :                 }
    1510             : 
    1511        2070 :                 drec = &ipd->records[stmt->attr.param_focus - 1];
    1512             : 
    1513             :                 /* check idp type */
    1514        2070 :                 if (drec->sql_desc_concise_type != SQL_SS_TABLE) {
    1515           0 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    1516           0 :                         ODBC_EXIT_(stmt);
    1517             :                 }
    1518             : 
    1519        2070 :                 tvp = (SQLTVP *) drec->sql_desc_data_ptr;
    1520        2070 :                 apd = tvp->apd;
    1521        2070 :                 ipd = tvp->ipd;
    1522             :         }
    1523             : 
    1524             :         /* fill APD related fields */
    1525        9328 :         orig_apd_size = apd->header.sql_desc_count;
    1526        9328 :         if (ipar > apd->header.sql_desc_count && desc_alloc_records(apd, ipar) != SQL_SUCCESS) {
    1527           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    1528           0 :                 ODBC_EXIT_(stmt);
    1529             :         }
    1530        9328 :         drec = &apd->records[ipar - 1];
    1531             : 
    1532        9328 :         if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
    1533          56 :                 desc_alloc_records(apd, orig_apd_size);
    1534          56 :                 odbc_errs_add(&stmt->errs, "HY004", NULL);
    1535          56 :                 ODBC_EXIT_(stmt);
    1536             :         }
    1537             : 
    1538        9272 :         stmt->need_reprepare = 1;
    1539             : 
    1540             :         /* TODO other types ?? handle SQL_C_DEFAULT */
    1541        9272 :         if (drec->sql_desc_type == SQL_C_CHAR || drec->sql_desc_type == SQL_C_WCHAR || drec->sql_desc_type == SQL_C_BINARY)
    1542        4588 :                 drec->sql_desc_octet_length = cbValueMax;
    1543        9272 :         drec->sql_desc_indicator_ptr = pcbValue;
    1544        9272 :         drec->sql_desc_octet_length_ptr = pcbValue;
    1545        9272 :         drec->sql_desc_data_ptr = (char *) rgbValue;
    1546             : 
    1547        9272 :         if (fSqlType == SQL_SS_TABLE)
    1548        2064 :                 drec->sql_desc_length = 1;
    1549             : 
    1550             :         /* field IPD related fields */
    1551        9272 :         orig_ipd_size = ipd->header.sql_desc_count;
    1552        9272 :         if (ipar > ipd->header.sql_desc_count && desc_alloc_records(ipd, ipar) != SQL_SUCCESS) {
    1553           0 :                 desc_alloc_records(apd, orig_apd_size);
    1554           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    1555           0 :                 ODBC_EXIT_(stmt);
    1556             :         }
    1557        9272 :         drec = &ipd->records[ipar - 1];
    1558             : 
    1559        9272 :         drec->sql_desc_parameter_type = fParamType;
    1560             : 
    1561        9272 :         if (odbc_set_concise_sql_type(fSqlType, drec, 0) != SQL_SUCCESS) {
    1562           0 :                 desc_alloc_records(ipd, orig_ipd_size);
    1563           0 :                 desc_alloc_records(apd, orig_apd_size);
    1564           0 :                 odbc_errs_add(&stmt->errs, "HY004", NULL);
    1565           0 :                 ODBC_EXIT_(stmt);
    1566             :         }
    1567        9272 :         if (is_numeric) {
    1568         170 :                 drec->sql_desc_precision = cbColDef;
    1569         170 :                 drec->sql_desc_scale = ibScale;
    1570             :         } else {
    1571        9102 :                 drec->sql_desc_length = cbColDef;
    1572             :         }
    1573             : 
    1574        9272 :         if (fSqlType == SQL_SS_TABLE) {
    1575             :                 SQLTVP *tvp;
    1576        2064 :                 int wide = 1;
    1577             : 
    1578        2064 :                 tvp = tvp_alloc(stmt);
    1579        2064 :                 if (tvp == NULL) {
    1580           0 :                         desc_alloc_records(ipd, orig_ipd_size);
    1581           0 :                         desc_alloc_records(apd, orig_apd_size);
    1582           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1583           0 :                         ODBC_EXIT_(stmt);
    1584             :                 }
    1585        2064 :                 tvp->apd->header.sql_desc_array_size = cbColDef;
    1586             : 
    1587        2064 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &tvp->type_name, cbValueMax, (ODBC_CHAR *) rgbValue)) {
    1588           0 :                         free(tvp);
    1589           0 :                         desc_alloc_records(ipd, orig_ipd_size);
    1590           0 :                         desc_alloc_records(apd, orig_apd_size);
    1591           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    1592           0 :                         ODBC_EXIT_(stmt);
    1593             :                 }
    1594             : 
    1595             :                 /* Use this the column type as a marker for us */
    1596             :                 /* to free up memory allocated with odbc_alloc_table() */
    1597        2064 :                 drec->sql_desc_type = drec->sql_desc_concise_type = SQL_SS_TABLE;
    1598             : 
    1599        2064 :                 drec->sql_desc_data_ptr = tvp;
    1600             : 
    1601        2064 :                 drec->sql_desc_length = 0;
    1602             :         }
    1603             : 
    1604        9272 :         ODBC_EXIT_(stmt);
    1605             : }
    1606             : 
    1607             : SQLRETURN ODBC_PUBLIC ODBC_API
    1608             : SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
    1609             :                  SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1610             : {
    1611        9340 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n", 
    1612             :                         hstmt, (unsigned)ipar, fParamType, fCType, (int)fSqlType, (unsigned)cbColDef, ibScale, rgbValue, (int)cbValueMax, pcbValue);
    1613        9340 :         return _SQLBindParameter(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue);
    1614             : }
    1615             : 
    1616             : 
    1617             : /* compatibility with X/Open */
    1618             : SQLRETURN ODBC_PUBLIC ODBC_API
    1619             : SQLBindParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale,
    1620             :              SQLPOINTER rgbValue, SQLLEN FAR * pcbValue)
    1621             : {
    1622           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindParam(%p, %d, %d, %d, %u, %d, %p, %p)\n", 
    1623             :                         hstmt, ipar, fCType, fSqlType, (unsigned)cbColDef, ibScale, rgbValue, pcbValue);
    1624           0 :         return _SQLBindParameter(hstmt, ipar, SQL_PARAM_INPUT, fCType, fSqlType, cbColDef, ibScale, rgbValue, 0, pcbValue);
    1625             : }
    1626             : 
    1627             : #if (ODBCVER >= 0x0300)
    1628             : SQLRETURN ODBC_PUBLIC ODBC_API
    1629             : SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
    1630             : {
    1631         974 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(%d, %p, %p)\n", HandleType, InputHandle, OutputHandle);
    1632             : 
    1633         974 :         switch (HandleType) {
    1634          94 :         case SQL_HANDLE_STMT:
    1635          94 :                 return _SQLAllocStmt(InputHandle, OutputHandle);
    1636             :                 break;
    1637         432 :         case SQL_HANDLE_DBC:
    1638         432 :                 return _SQLAllocConnect(InputHandle, OutputHandle);
    1639             :                 break;
    1640         432 :         case SQL_HANDLE_ENV:
    1641         432 :                 return _SQLAllocEnv(OutputHandle, SQL_OV_ODBC3);
    1642             :                 break;
    1643          16 :         case SQL_HANDLE_DESC:
    1644          16 :                 return _SQLAllocDesc(InputHandle, OutputHandle);
    1645             :                 break;
    1646             :         }
    1647             :         
    1648             :         /*
    1649             :          * As the documentation puts it, 
    1650             :          *      "There is no handle with which to associate additional diagnostic information."
    1651             :          *
    1652             :          * The DM must catch HY092 because the driver has no valid handle at this early stage in which 
    1653             :          * to store the error for later retrieval by the application.  
    1654             :          */
    1655           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(): invalid HandleType, error HY092: should be caught by DM\n");
    1656             :         return SQL_ERROR;
    1657             : }
    1658             : #endif
    1659             : 
    1660             : static SQLRETURN
    1661         900 : _SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
    1662             : {
    1663             :         TDS_DBC *dbc;
    1664             : 
    1665         900 :         ODBC_ENTER_HENV;
    1666             : 
    1667         900 :         tdsdump_log(TDS_DBG_FUNC, "_SQLAllocConnect(%p, %p)\n", henv, phdbc);
    1668             : 
    1669         900 :         dbc = tds_new0(TDS_DBC, 1);
    1670         900 :         if (!dbc) {
    1671           0 :                 odbc_errs_add(&env->errs, "HY001", NULL);
    1672           0 :                 ODBC_EXIT_(env);
    1673             :         }
    1674             : 
    1675         900 :         dbc->htype = SQL_HANDLE_DBC;
    1676         900 :         dbc->env = env;
    1677        1800 :         tds_dstr_init(&dbc->dsn);
    1678             : 
    1679         900 :         dbc->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    1680         900 :         dbc->attr.access_mode = SQL_MODE_READ_WRITE;
    1681         900 :         dbc->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    1682         900 :         dbc->attr.auto_ipd = SQL_FALSE;
    1683             :         /*
    1684             :          * spinellia@acm.org
    1685             :          * after login is enabled autocommit
    1686             :          */
    1687         900 :         dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
    1688         900 :         dbc->attr.connection_dead = SQL_CD_TRUE;     /* No connection yet */
    1689         900 :         dbc->attr.connection_timeout = 0;
    1690             :         /* This is set in the environment change function */
    1691        1800 :         tds_dstr_init(&dbc->attr.current_catalog);
    1692         900 :         dbc->attr.login_timeout = 0; /* TODO */
    1693         900 :         dbc->attr.metadata_id = SQL_FALSE;
    1694         900 :         dbc->attr.odbc_cursors = SQL_CUR_USE_IF_NEEDED;
    1695         900 :         dbc->attr.packet_size = 0;
    1696         900 :         dbc->attr.quite_mode = NULL; /* We don't support GUI dialogs yet */
    1697             : #ifdef TDS_NO_DM
    1698         900 :         dbc->attr.trace = SQL_OPT_TRACE_OFF;
    1699        1800 :         tds_dstr_init(&dbc->attr.tracefile);
    1700             : #endif
    1701        1800 :         tds_dstr_init(&dbc->attr.translate_lib);
    1702             : #ifdef ENABLE_ODBC_WIDE
    1703         900 :         dbc->original_charset_num = TDS_CHARSET_UTF_8;
    1704             : #endif
    1705        1800 :         tds_dstr_init(&dbc->oldpwd);
    1706         900 :         dbc->attr.translate_option = 0;
    1707         900 :         dbc->attr.txn_isolation = SQL_TXN_READ_COMMITTED;
    1708         900 :         dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
    1709         900 :         dbc->attr.bulk_enabled = SQL_BCP_OFF;
    1710             : 
    1711        1800 :         tds_mutex_init(&dbc->mtx);
    1712         900 :         *phdbc = (SQLHDBC) dbc;
    1713             : 
    1714         900 :         ODBC_EXIT_(env);
    1715             : }
    1716             : 
    1717             : SQLRETURN ODBC_PUBLIC ODBC_API
    1718             : SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
    1719             : {
    1720         468 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocConnect(%p, %p)\n", henv, phdbc);
    1721             : 
    1722         468 :         return _SQLAllocConnect(henv, phdbc);
    1723             : }
    1724             : 
    1725             : static SQLRETURN
    1726         900 : _SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version)
    1727             : {
    1728             :         TDS_ENV *env;
    1729             :         TDSCONTEXT *ctx;
    1730             : 
    1731         900 :         tdsdump_log(TDS_DBG_FUNC, "_SQLAllocEnv(%p, %d)\n",
    1732             :                         phenv, (int) odbc_version);
    1733             : 
    1734         900 :         env = tds_new0(TDS_ENV, 1);
    1735         900 :         if (!env)
    1736             :                 return SQL_ERROR;
    1737             : 
    1738         900 :         env->htype = SQL_HANDLE_ENV;
    1739         900 :         env->attr.odbc_version = odbc_version;
    1740             :         /* TODO use it */
    1741         900 :         env->attr.output_nts = SQL_TRUE;
    1742             : 
    1743         900 :         ctx = tds_alloc_context(env);
    1744         900 :         if (!ctx) {
    1745           0 :                 free(env);
    1746           0 :                 return SQL_ERROR;
    1747             :         }
    1748         900 :         env->tds_ctx = ctx;
    1749         900 :         ctx->msg_handler = odbc_errmsg_handler;
    1750         900 :         ctx->err_handler = odbc_errmsg_handler;
    1751             : 
    1752             :         /* ODBC has its own format */
    1753         900 :         free(ctx->locale->datetime_fmt);
    1754         900 :         ctx->locale->datetime_fmt = strdup("%Y-%m-%d %H:%M:%S.%z");
    1755         900 :         free(ctx->locale->date_fmt);
    1756         900 :         ctx->locale->date_fmt = strdup("%Y-%m-%d");
    1757         900 :         free(ctx->locale->time_fmt);
    1758         900 :         ctx->locale->time_fmt = strdup("%H:%M:%S.%z");
    1759             : 
    1760        1800 :         tds_mutex_init(&env->mtx);
    1761         900 :         *phenv = (SQLHENV) env;
    1762             : 
    1763         900 :         return SQL_SUCCESS;
    1764             : }
    1765             : 
    1766             : SQLRETURN ODBC_PUBLIC ODBC_API
    1767             : SQLAllocEnv(SQLHENV FAR * phenv)
    1768             : {
    1769         468 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocEnv(%p)\n", phenv);
    1770             : 
    1771         468 :         return _SQLAllocEnv(phenv, SQL_OV_ODBC2);
    1772             : }
    1773             : 
    1774             : static SQLRETURN
    1775          16 : _SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc)
    1776             : {
    1777             :         int i;
    1778             : 
    1779          16 :         ODBC_ENTER_HDBC;
    1780             : 
    1781          16 :         tdsdump_log(TDS_DBG_FUNC, "_SQLAllocDesc(%p, %p)\n", hdbc, phdesc);
    1782             : 
    1783          24 :         for (i = 0; ; ++i) {
    1784          32 :                 if (i >= TDS_MAX_APP_DESC) {
    1785           0 :                         odbc_errs_add(&dbc->errs, "HY014", NULL);
    1786           0 :                         break;
    1787             :                 }
    1788          24 :                 if (dbc->uad[i] == NULL) {
    1789          16 :                         TDS_DESC *desc = desc_alloc(dbc, DESC_ARD, SQL_DESC_ALLOC_USER);
    1790          16 :                         if (desc == NULL) {
    1791           0 :                                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1792           0 :                                 break;
    1793             :                         }
    1794          16 :                         dbc->uad[i] = desc;
    1795          16 :                         *phdesc = (SQLHDESC) desc;
    1796          16 :                         break;
    1797             :                 }
    1798             :         }
    1799          16 :         ODBC_EXIT_(dbc);
    1800             : }
    1801             : 
    1802             : static SQLRETURN
    1803       13217 : _SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
    1804             : {
    1805             :         TDS_STMT *stmt;
    1806             :         char *pstr;
    1807             : 
    1808       13217 :         ODBC_ENTER_HDBC;
    1809             : 
    1810       13217 :         tdsdump_log(TDS_DBG_FUNC, "_SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
    1811             : 
    1812       13217 :         stmt = tds_new0(TDS_STMT, 1);
    1813       13217 :         if (!stmt) {
    1814           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1815           0 :                 ODBC_EXIT_(dbc);
    1816             :         }
    1817       26434 :         tds_dstr_init(&stmt->cursor_name);
    1818       26434 :         tds_dstr_init(&stmt->query);
    1819             : 
    1820       13217 :         stmt->htype = SQL_HANDLE_STMT;
    1821       13217 :         stmt->dbc = dbc;
    1822       13217 :         stmt->num_param_rows = 1;
    1823       13217 :         pstr = NULL;
    1824             :         /* TODO test initial cursor ... */
    1825       13217 :         if (asprintf(&pstr, "SQL_CUR%lx", (unsigned long) stmt) < 0 || !tds_dstr_set(&stmt->cursor_name, pstr)) {
    1826           0 :                 free(stmt);
    1827           0 :                 free(pstr);
    1828           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1829           0 :                 ODBC_EXIT_(dbc);
    1830             :         }
    1831             :         /* do not free pstr tds_dstr_set do it if necessary */
    1832             : 
    1833             :         /* allocate descriptors */
    1834       13217 :         stmt->ird = desc_alloc(stmt, DESC_IRD, SQL_DESC_ALLOC_AUTO);
    1835       13217 :         stmt->ard = desc_alloc(stmt, DESC_ARD, SQL_DESC_ALLOC_AUTO);
    1836       13217 :         stmt->ipd = desc_alloc(stmt, DESC_IPD, SQL_DESC_ALLOC_AUTO);
    1837       13217 :         stmt->apd = desc_alloc(stmt, DESC_APD, SQL_DESC_ALLOC_AUTO);
    1838       13217 :         if (!stmt->ird || !stmt->ard || !stmt->ipd || !stmt->apd) {
    1839           0 :                 tds_dstr_free(&stmt->cursor_name);
    1840           0 :                 desc_free(stmt->ird);
    1841           0 :                 desc_free(stmt->ard);
    1842           0 :                 desc_free(stmt->ipd);
    1843           0 :                 desc_free(stmt->apd);
    1844           0 :                 free(stmt);
    1845           0 :                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    1846           0 :                 ODBC_EXIT_(dbc);
    1847             :         }
    1848             : 
    1849             :         /* save original ARD and APD */
    1850       13217 :         stmt->orig_apd = stmt->apd;
    1851       13217 :         stmt->orig_ard = stmt->ard;
    1852             : 
    1853             :         /* set the default statement attributes */
    1854             : /*      stmt->attr.app_param_desc = stmt->apd; */
    1855             : /*      stmt->attr.app_row_desc = stmt->ard; */
    1856       13217 :         stmt->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    1857       13217 :         stmt->attr.concurrency = SQL_CONCUR_READ_ONLY;
    1858       13217 :         stmt->attr.cursor_scrollable = SQL_NONSCROLLABLE;
    1859       13217 :         stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    1860       13217 :         stmt->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    1861             :         /* TODO ?? why two attributes */
    1862       13217 :         stmt->attr.enable_auto_ipd = dbc->attr.auto_ipd = SQL_FALSE;
    1863       13217 :         stmt->attr.fetch_bookmark_ptr = NULL;
    1864             : /*      stmt->attr.imp_param_desc = stmt->ipd; */
    1865             : /*      stmt->attr.imp_row_desc = stmt->ird; */
    1866       13217 :         stmt->attr.keyset_size = 0;
    1867       13217 :         stmt->attr.max_length = 0;
    1868       13217 :         stmt->attr.max_rows = 0;
    1869       13217 :         stmt->attr.metadata_id = dbc->attr.metadata_id;
    1870             :         /* TODO check this flag in prepare_call */
    1871       13217 :         stmt->attr.noscan = SQL_NOSCAN_OFF;
    1872       13217 :         assert(stmt->apd->header.sql_desc_bind_offset_ptr == NULL);
    1873       13217 :         assert(stmt->apd->header.sql_desc_bind_type == SQL_PARAM_BIND_BY_COLUMN);
    1874       13217 :         assert(stmt->apd->header.sql_desc_array_status_ptr == NULL);
    1875       13217 :         assert(stmt->ipd->header.sql_desc_array_status_ptr == NULL);
    1876       13217 :         assert(stmt->ipd->header.sql_desc_rows_processed_ptr == NULL);
    1877       13217 :         assert(stmt->apd->header.sql_desc_array_size == 1);
    1878       13217 :         stmt->attr.query_timeout = DEFAULT_QUERY_TIMEOUT;
    1879       13217 :         stmt->attr.retrieve_data = SQL_RD_ON;
    1880       13217 :         assert(stmt->ard->header.sql_desc_array_size == 1);
    1881       13217 :         assert(stmt->ard->header.sql_desc_bind_offset_ptr == NULL);
    1882       13217 :         assert(stmt->ard->header.sql_desc_bind_type == SQL_BIND_BY_COLUMN);
    1883       13217 :         stmt->attr.row_number = 0;
    1884       13217 :         assert(stmt->ard->header.sql_desc_array_status_ptr == NULL);
    1885       13217 :         assert(stmt->ird->header.sql_desc_array_status_ptr == NULL);
    1886       13217 :         assert(stmt->ird->header.sql_desc_rows_processed_ptr == NULL);
    1887       13217 :         stmt->attr.simulate_cursor = SQL_SC_NON_UNIQUE;
    1888       13217 :         stmt->attr.use_bookmarks = SQL_UB_OFF;
    1889       26434 :         tds_dstr_init(&stmt->attr.qn_msgtext);
    1890       26434 :         tds_dstr_init(&stmt->attr.qn_options);
    1891       13217 :         stmt->attr.qn_timeout = 432000;
    1892             : 
    1893       13217 :         stmt->sql_rowset_size = 1;
    1894             : 
    1895       13217 :         stmt->row_count = TDS_NO_COUNT;
    1896       13217 :         stmt->row_status = NOT_IN_ROW;
    1897             : 
    1898             :         /* insert into list */
    1899       13217 :         stmt->next = dbc->stmt_list;
    1900       13217 :         if (dbc->stmt_list)
    1901         243 :                 dbc->stmt_list->prev = stmt;
    1902       13217 :         dbc->stmt_list = stmt;
    1903             : 
    1904       26434 :         tds_mutex_init(&stmt->mtx);
    1905       13217 :         *phstmt = (SQLHSTMT) stmt;
    1906             : 
    1907       13217 :         if (dbc->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY)
    1908           0 :                 _SQLSetStmtAttr(stmt, SQL_CURSOR_TYPE, (SQLPOINTER) (TDS_INTPTR) dbc->attr.cursor_type, SQL_IS_INTEGER _wide0);
    1909             : 
    1910       13217 :         stmt->attr.param_focus = 0;
    1911             : 
    1912       13217 :         ODBC_EXIT_(dbc);
    1913             : }
    1914             : 
    1915             : SQLRETURN ODBC_PUBLIC ODBC_API
    1916             : SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
    1917             : {
    1918       13123 :         tdsdump_log(TDS_DBG_FUNC, "SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
    1919             : 
    1920       13123 :         return _SQLAllocStmt(hdbc, phstmt);
    1921             : }
    1922             : 
    1923             : SQLRETURN ODBC_PUBLIC ODBC_API
    1924             : SQLBindCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    1925             : {
    1926             :         TDS_DESC *ard;
    1927             :         struct _drecord *drec;
    1928             :         SQLSMALLINT orig_ard_size;
    1929             : 
    1930        4602 :         ODBC_ENTER_HSTMT;
    1931             : 
    1932        4602 :         tdsdump_log(TDS_DBG_FUNC, "SQLBindCol(%p, %d, %d, %p, %d, %p)\n", 
    1933             :                         hstmt, icol, fCType, rgbValue, (int)cbValueMax, pcbValue);
    1934             : 
    1935             :         /* TODO - More error checking XXX smurph */
    1936             : 
    1937             : #ifdef TDS_NO_DM
    1938             :         /* check conversion type */
    1939        4602 :         switch (fCType) {
    1940        2376 :         case SQL_C_CHAR:
    1941             :         case SQL_C_WCHAR:
    1942             :         case SQL_C_BINARY:
    1943             :         case SQL_C_DEFAULT:
    1944             :                 /* check max buffer length */
    1945        2376 :                 if (!IS_VALID_LEN(cbValueMax)) {
    1946           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    1947           0 :                         ODBC_EXIT_(stmt);
    1948             :                 }
    1949             :                 break;
    1950             :         }
    1951             : #endif
    1952             : 
    1953        4602 :         if (icol <= 0 || icol > 4000) {
    1954           0 :                 odbc_errs_add(&stmt->errs, "07009", NULL);
    1955           0 :                 ODBC_EXIT_(stmt);
    1956             :         }
    1957             : 
    1958        4602 :         ard = stmt->ard;
    1959        4602 :         orig_ard_size = ard->header.sql_desc_count;
    1960        4602 :         if (icol > ard->header.sql_desc_count && desc_alloc_records(ard, icol) != SQL_SUCCESS) {
    1961           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    1962           0 :                 ODBC_EXIT_(stmt);
    1963             :         }
    1964             : 
    1965        4602 :         drec = &ard->records[icol - 1];
    1966             : 
    1967        4602 :         if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
    1968           0 :                 desc_alloc_records(ard, orig_ard_size);
    1969           0 :                 odbc_errs_add(&stmt->errs, "HY003", NULL);
    1970           0 :                 ODBC_EXIT_(stmt);
    1971             :         }
    1972        4602 :         drec->sql_desc_octet_length = cbValueMax;
    1973        4602 :         drec->sql_desc_octet_length_ptr = pcbValue;
    1974        4602 :         drec->sql_desc_indicator_ptr = pcbValue;
    1975        4602 :         drec->sql_desc_data_ptr = rgbValue;
    1976             : 
    1977             :         /* force rebind */
    1978        4602 :         stmt->row = 0;
    1979             : 
    1980        4602 :         ODBC_EXIT_(stmt);
    1981             : }
    1982             : 
    1983             : SQLRETURN ODBC_PUBLIC ODBC_API
    1984             : SQLCancel(SQLHSTMT hstmt)
    1985             : {
    1986             :         TDSSOCKET *tds;
    1987             : 
    1988             :         /*
    1989             :          * FIXME this function can be called from other thread, do not free 
    1990             :          * errors for this function
    1991             :          * If function is called from another thread errors are not touched
    1992             :          */
    1993             :         /* TODO some tests required */
    1994          32 :         TDS_STMT *stmt = (TDS_STMT*)hstmt;
    1995          32 :         if (SQL_NULL_HSTMT == hstmt || !IS_HSTMT(hstmt))
    1996             :                 return SQL_INVALID_HANDLE;
    1997             : 
    1998          32 :         tdsdump_log(TDS_DBG_FUNC, "SQLCancel(%p)\n", hstmt);
    1999             : 
    2000          32 :         tds = stmt->tds;
    2001             : 
    2002             :         /* cancelling an inactive statement ?? */
    2003          32 :         if (!tds) {
    2004           0 :                 ODBC_SAFE_ERROR(stmt);
    2005           0 :                 ODBC_EXIT_(stmt);
    2006             :         }
    2007          32 :         if (tds_mutex_trylock(&stmt->mtx) == 0) {
    2008           0 :                 CHECK_STMT_EXTRA(stmt);
    2009           0 :                 odbc_errs_reset(&stmt->errs);
    2010             : 
    2011             :                 /* FIXME test current statement */
    2012             :                 /* FIXME here we are unlocked */
    2013             : 
    2014           0 :                 if (TDS_FAILED(tds_send_cancel(tds))) {
    2015           0 :                         ODBC_SAFE_ERROR(stmt);
    2016           0 :                         ODBC_EXIT_(stmt);
    2017             :                 }
    2018             : 
    2019           0 :                 if (TDS_FAILED(tds_process_cancel(tds))) {
    2020           0 :                         ODBC_SAFE_ERROR(stmt);
    2021           0 :                         ODBC_EXIT_(stmt);
    2022             :                 }
    2023             : 
    2024             :                 /* only if we processed cancel reset statement */
    2025           0 :                 if (tds->state == TDS_IDLE)
    2026           0 :                         odbc_unlock_statement(stmt);
    2027             : 
    2028           0 :                 ODBC_EXIT_(stmt);
    2029             :         }
    2030             : 
    2031             :         /* don't access error here, just return error */
    2032          32 :         if (TDS_FAILED(tds_send_cancel(tds)))
    2033             :                 return SQL_ERROR;
    2034          32 :         return SQL_SUCCESS;
    2035             : }
    2036             : 
    2037         790 : ODBC_FUNC(SQLConnect, (P(SQLHDBC,hdbc), PCHARIN(DSN,SQLSMALLINT), PCHARIN(UID,SQLSMALLINT),
    2038             :         PCHARIN(AuthStr,SQLSMALLINT) WIDE))
    2039             : {
    2040             :         TDSLOGIN *login;
    2041             :         DSTR *s;
    2042             : 
    2043         790 :         ODBC_ENTER_HDBC;
    2044             : 
    2045             : #ifdef TDS_NO_DM
    2046         790 :         if (szDSN && !IS_VALID_LEN(cbDSN)) {
    2047           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid DSN buffer length");
    2048           0 :                 ODBC_EXIT_(dbc);
    2049             :         }
    2050             : 
    2051         790 :         if (szUID && !IS_VALID_LEN(cbUID)) {
    2052           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid UID buffer length");
    2053           0 :                 ODBC_EXIT_(dbc);
    2054             :         }
    2055             : 
    2056         790 :         if (szAuthStr && !IS_VALID_LEN(cbAuthStr)) {
    2057           0 :                 odbc_errs_add(&dbc->errs, "HY090", "Invalid PWD buffer length");
    2058           0 :                 ODBC_EXIT_(dbc);
    2059             :         }
    2060             : #endif
    2061             : 
    2062         790 :         login = tds_alloc_login(0);
    2063         790 :         if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale))
    2064             :                 goto memory_error;
    2065             : 
    2066             :         /* data source name */
    2067         790 :         if (odbc_get_string_size(cbDSN, szDSN _wide))
    2068         790 :                 s = odbc_dstr_copy(dbc, &dbc->dsn, cbDSN, szDSN);
    2069             :         else
    2070           0 :                 s = tds_dstr_copy(&dbc->dsn, "DEFAULT");
    2071         790 :         if (!s)
    2072             :                 goto memory_error;
    2073             : 
    2074             : 
    2075        1580 :         if (!odbc_get_dsn_info(&dbc->errs, tds_dstr_cstr(&dbc->dsn), login)) {
    2076           0 :                 tds_free_login(login);
    2077           0 :                 ODBC_EXIT_(dbc);
    2078             :         }
    2079             : 
    2080        1580 :         if (!tds_dstr_isempty(&dbc->attr.current_catalog))
    2081          16 :                 if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog))
    2082             :                         goto memory_error;
    2083             : 
    2084             :         /*
    2085             :          * username/password are never saved to ini file,
    2086             :          * so you do not check in ini file
    2087             :          */
    2088             :         /* user id */
    2089         790 :         if (odbc_get_string_size(cbUID, szUID _wide)) {
    2090         790 :                 if (!odbc_dstr_copy(dbc, &login->user_name, cbUID, szUID))
    2091             :                         goto memory_error;
    2092             :         }
    2093             : 
    2094             :         /* password */
    2095        1580 :         if (szAuthStr && !tds_dstr_isempty(&login->user_name)) {
    2096         790 :                 if (!odbc_dstr_copy(dbc, &login->password, cbAuthStr, szAuthStr))
    2097             :                         goto memory_error;
    2098             :         }
    2099             : 
    2100             :         /* DO IT */
    2101         790 :         odbc_connect(dbc, login);
    2102             : 
    2103         790 :         tds_free_login(login);
    2104         790 :         ODBC_EXIT_(dbc);
    2105             : 
    2106           0 : memory_error:
    2107           0 :         tds_free_login(login);
    2108           0 :         odbc_errs_add(&dbc->errs, "HY001", NULL);
    2109           0 :         ODBC_EXIT_(dbc);
    2110             : }
    2111             : 
    2112        1838 : ODBC_FUNC(SQLDescribeCol, (P(SQLHSTMT,hstmt), P(SQLUSMALLINT,icol), PCHAROUT(ColName,SQLSMALLINT),
    2113             :         P(SQLSMALLINT FAR *,pfSqlType), P(SQLULEN FAR *,pcbColDef),
    2114             :         P(SQLSMALLINT FAR *,pibScale), P(SQLSMALLINT FAR *,pfNullable) WIDE))
    2115             : {
    2116             :         TDS_DESC *ird;
    2117             :         struct _drecord *drec;
    2118             :         SQLRETURN result;
    2119             : 
    2120        1838 :         ODBC_ENTER_HSTMT;
    2121             : 
    2122        1838 :         ird = stmt->ird;
    2123        1838 :         IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    2124             : 
    2125        1838 :         if (icol <= 0 || icol > ird->header.sql_desc_count) {
    2126           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    2127           0 :                 ODBC_EXIT_(stmt);
    2128             :         }
    2129             :         /* check name length */
    2130        1838 :         if (cbColNameMax < 0) {
    2131           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    2132           0 :                 ODBC_EXIT_(stmt);
    2133             :         }
    2134        1838 :         drec = &ird->records[icol - 1];
    2135             : 
    2136             :         /* cbColNameMax can be 0 (to retrieve name length) */
    2137        1838 :         if (szColName == NULL)
    2138         812 :                 cbColNameMax = 0;
    2139             : 
    2140             :         /* straight copy column name up to cbColNameMax */
    2141        5514 :         result = odbc_set_dstr(stmt->dbc, szColName, cbColNameMax, pcbColName, &drec->sql_desc_label);
    2142        1838 :         if (szColName && result == SQL_SUCCESS_WITH_INFO)
    2143          24 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    2144             : 
    2145        1838 :         if (pfSqlType) {
    2146             :                 /* TODO sure ? check documentation for date and intervals */
    2147        1838 :                 *pfSqlType = drec->sql_desc_concise_type;
    2148             :         }
    2149             : 
    2150        1838 :         if (pcbColDef) {
    2151         912 :                 if (drec->sql_desc_type == SQL_NUMERIC || drec->sql_desc_type == SQL_DECIMAL) {
    2152         144 :                         *pcbColDef = drec->sql_desc_precision;
    2153             :                 } else {
    2154         768 :                         *pcbColDef = drec->sql_desc_length;
    2155             :                 }
    2156             :         }
    2157        1838 :         if (pibScale) {
    2158         912 :                 *pibScale = drec->sql_desc_scale;
    2159             :         }
    2160        1838 :         if (pfNullable) {
    2161         912 :                 *pfNullable = drec->sql_desc_nullable;
    2162             :         }
    2163        1838 :         ODBC_EXIT_(stmt);
    2164             : }
    2165             : 
    2166             : static SQLRETURN
    2167        5194 : _SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax,
    2168             :                  SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE)
    2169             : {
    2170             :         TDS_DESC *ird;
    2171             :         struct _drecord *drec;
    2172        5194 :         SQLRETURN result = SQL_SUCCESS;
    2173             : 
    2174        5194 :         ODBC_ENTER_HSTMT;
    2175             : 
    2176        5194 :         tdsdump_log(TDS_DBG_FUNC, "_SQLColAttribute(%p, %u, %u, %p, %d, %p, %p)\n", 
    2177             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2178             : 
    2179        5194 :         ird = stmt->ird;
    2180             : 
    2181             : #define COUT(src) result = odbc_set_string_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, src ? src : "", -1);
    2182             : #define SOUT(src) result = odbc_set_dstr_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, &src);
    2183             : 
    2184             : /* SQLColAttribute returns always attributes using SQLINTEGER */
    2185             : #if ENABLE_EXTRA_CHECKS
    2186             : #define IOUT(type, src) do { \
    2187             :         /* trick warning if type wrong */ \
    2188             :         type *p_test = &src; p_test = p_test; \
    2189             :         *pfDesc = src; } while(0)
    2190             : #else
    2191             : #define IOUT(type, src) *pfDesc = src
    2192             : #endif
    2193             : 
    2194        5194 :         IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    2195             : 
    2196             :         /* dont check column index for these */
    2197        5194 :         switch (fDescType) {
    2198             : #if SQL_COLUMN_COUNT != SQL_DESC_COUNT
    2199           0 :         case SQL_COLUMN_COUNT:
    2200             : #endif
    2201             :         case SQL_DESC_COUNT:
    2202           0 :                 IOUT(SQLSMALLINT, ird->header.sql_desc_count);
    2203           0 :                 ODBC_EXIT(stmt, SQL_SUCCESS);
    2204             :                 break;
    2205             :         }
    2206             : 
    2207        5194 :         if (!ird->header.sql_desc_count) {
    2208           0 :                 odbc_errs_add(&stmt->errs, "07005", NULL);
    2209           0 :                 ODBC_EXIT_(stmt);
    2210             :         }
    2211             : 
    2212        5194 :         if (icol <= 0 || icol > ird->header.sql_desc_count) {
    2213           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    2214           0 :                 ODBC_EXIT_(stmt);
    2215             :         }
    2216        5194 :         drec = &ird->records[icol - 1];
    2217             : 
    2218        5194 :         tdsdump_log(TDS_DBG_INFO1, "SQLColAttribute: fDescType is %d\n", fDescType);
    2219             : 
    2220        5194 :         switch (fDescType) {
    2221           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    2222           0 :                 IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
    2223             :                 break;
    2224           0 :         case SQL_DESC_BASE_COLUMN_NAME:
    2225           0 :                 SOUT(drec->sql_desc_base_column_name);
    2226           0 :                 break;
    2227           0 :         case SQL_DESC_BASE_TABLE_NAME:
    2228           0 :                 SOUT(drec->sql_desc_base_table_name);
    2229           0 :                 break;
    2230           0 :         case SQL_DESC_CASE_SENSITIVE:
    2231           0 :                 IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
    2232             :                 break;
    2233           0 :         case SQL_DESC_CATALOG_NAME:
    2234           0 :                 SOUT(drec->sql_desc_catalog_name);
    2235           0 :                 break;
    2236             : #if SQL_COLUMN_TYPE != SQL_DESC_CONCISE_TYPE
    2237             :         case SQL_COLUMN_TYPE:
    2238             : #endif
    2239         108 :         case SQL_DESC_CONCISE_TYPE:
    2240             :                 /* special case, get ODBC 2 type, not ODBC 3 SQL_DESC_CONCISE_TYPE (different for datetime) */
    2241         108 :                 if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    2242          76 :                         IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
    2243             :                         break;
    2244             :                 }
    2245             : 
    2246             :                 /* get type and convert it to ODBC 2 type */
    2247             :                 {
    2248          32 :                         SQLSMALLINT type = drec->sql_desc_concise_type;
    2249             : 
    2250          32 :                         switch (type) {
    2251           0 :                         case SQL_TYPE_DATE:
    2252           0 :                                 type = SQL_DATE;
    2253           0 :                                 break;
    2254           0 :                         case SQL_TYPE_TIME:
    2255           0 :                                 type = SQL_TIME;
    2256           0 :                                 break;
    2257          16 :                         case SQL_TYPE_TIMESTAMP:
    2258          16 :                                 type = SQL_TIMESTAMP;
    2259          16 :                                 break;
    2260             :                         }
    2261          32 :                         IOUT(SQLSMALLINT, type);
    2262             :                 }
    2263             :                 break;
    2264         398 :         case SQL_DESC_DISPLAY_SIZE:
    2265         398 :                 IOUT(SQLLEN, drec->sql_desc_display_size);
    2266             :                 break;
    2267           0 :         case SQL_DESC_FIXED_PREC_SCALE:
    2268           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
    2269             :                 break;
    2270         878 :         case SQL_DESC_LABEL:
    2271        2634 :                 SOUT(drec->sql_desc_label);
    2272         878 :                 break;
    2273             :                 /* FIXME special cases for SQL_COLUMN_LENGTH */
    2274         366 :         case SQL_COLUMN_LENGTH:
    2275         366 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2276             :                 break;
    2277         398 :         case SQL_DESC_LENGTH:
    2278         398 :                 IOUT(SQLULEN, drec->sql_desc_length);
    2279             :                 break;
    2280           0 :         case SQL_DESC_LITERAL_PREFIX:
    2281           0 :                 COUT(drec->sql_desc_literal_prefix);
    2282           0 :                 break;
    2283           0 :         case SQL_DESC_LITERAL_SUFFIX:
    2284           0 :                 COUT(drec->sql_desc_literal_suffix);
    2285           0 :                 break;
    2286           0 :         case SQL_DESC_LOCAL_TYPE_NAME:
    2287           0 :                 SOUT(drec->sql_desc_local_type_name);
    2288           0 :                 break;
    2289             : #if SQL_COLUMN_NAME != SQL_DESC_NAME
    2290         878 :         case SQL_COLUMN_NAME:
    2291             : #endif
    2292             :         case SQL_DESC_NAME:
    2293        2634 :                 SOUT(drec->sql_desc_name);
    2294         878 :                 break;
    2295             : #if SQL_COLUMN_NULLABLE != SQL_DESC_NULLABLE
    2296           0 :         case SQL_COLUMN_NULLABLE:
    2297             : #endif
    2298             :         case SQL_DESC_NULLABLE:
    2299           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_nullable);
    2300             :                 break;
    2301           0 :         case SQL_DESC_NUM_PREC_RADIX:
    2302           0 :                 IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
    2303             :                 break;
    2304         398 :         case SQL_DESC_OCTET_LENGTH:
    2305         398 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2306             :                 break;
    2307             :                 /* FIXME special cases for SQL_COLUMN_PRECISION */
    2308         366 :         case SQL_COLUMN_PRECISION:
    2309         366 :                 if (drec->sql_desc_concise_type == SQL_REAL) {
    2310          16 :                         *pfDesc = 7;
    2311             :                         break;
    2312             :                 }
    2313         350 :                 if (drec->sql_desc_concise_type == SQL_DOUBLE) {
    2314          16 :                         *pfDesc = 15;
    2315             :                         break;
    2316             :                 }
    2317         334 :                 if (drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP || drec->sql_desc_concise_type == SQL_TIMESTAMP) {
    2318          32 :                         *pfDesc = drec->sql_desc_precision ? 23 : 16;
    2319             :                         break;
    2320             :                 }
    2321             :         case SQL_DESC_PRECISION:        /* this section may be wrong */
    2322        1400 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2323         700 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2324         534 :                     || drec->sql_desc_concise_type == SQL_TYPE_DATE
    2325         530 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIME
    2326         530 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2327         530 :                     || drec->sql_desc_concise_type == SQL_SS_TIME2
    2328         524 :                     || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
    2329         180 :                         IOUT(SQLSMALLINT, drec->sql_desc_precision);
    2330             :                 else
    2331         520 :                         *pfDesc = drec->sql_desc_length;
    2332             :                 break;
    2333             :                 /* FIXME special cases for SQL_COLUMN_SCALE */
    2334         768 :         case SQL_COLUMN_SCALE:
    2335             :         case SQL_DESC_SCALE:    /* this section may be wrong */
    2336        1536 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2337         768 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2338         570 :                     || drec->sql_desc_concise_type == SQL_TYPE_DATE
    2339         564 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIME
    2340         564 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2341         564 :                     || drec->sql_desc_concise_type == SQL_FLOAT
    2342         564 :                     || drec->sql_desc_concise_type == SQL_SS_TIME2
    2343         556 :                     || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
    2344         216 :                         IOUT(SQLSMALLINT, drec->sql_desc_scale);
    2345             :                 else
    2346         552 :                         *pfDesc = 0;
    2347             :                 break;
    2348           0 :         case SQL_DESC_SCHEMA_NAME:
    2349           0 :                 SOUT(drec->sql_desc_schema_name);
    2350           0 :                 break;
    2351           0 :         case SQL_DESC_SEARCHABLE:
    2352           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_searchable);
    2353             :                 break;
    2354           0 :         case SQL_DESC_TABLE_NAME:
    2355           0 :                 SOUT(drec->sql_desc_table_name);
    2356           0 :                 break;
    2357          38 :         case SQL_DESC_TYPE:
    2358          38 :                 IOUT(SQLSMALLINT, drec->sql_desc_type);
    2359             :                 break;
    2360         106 :         case SQL_DESC_TYPE_NAME:
    2361         106 :                 COUT(drec->sql_desc_type_name);
    2362         106 :                 break;
    2363           0 :         case SQL_DESC_UNNAMED:
    2364           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
    2365             :                 break;
    2366          94 :         case SQL_DESC_UNSIGNED:
    2367          94 :                 IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
    2368             :                 break;
    2369           0 :         case SQL_DESC_UPDATABLE:
    2370           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_updatable);
    2371             :                 break;
    2372           0 :         default:
    2373           0 :                 tdsdump_log(TDS_DBG_INFO2, "SQLColAttribute: fDescType %d not catered for...\n", fDescType);
    2374           0 :                 odbc_errs_add(&stmt->errs, "HY091", NULL);
    2375           0 :                 ODBC_EXIT_(stmt);
    2376             :                 break;
    2377             :         }
    2378             : 
    2379        1862 :         if (result == SQL_SUCCESS_WITH_INFO)
    2380           0 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    2381             : 
    2382        5194 :         ODBC_EXIT(stmt, result);
    2383             : 
    2384             : #undef COUT
    2385             : #undef SOUT
    2386             : #undef IOUT
    2387             : }
    2388             : 
    2389             : SQLRETURN ODBC_PUBLIC ODBC_API
    2390             : SQLColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2391             :                  SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc)
    2392             : {
    2393           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLColAttributes(%p, %d, %d, %p, %d, %p, %p)\n", 
    2394             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2395             : 
    2396           0 :         return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0);
    2397             : }
    2398             : 
    2399             : #if (ODBCVER >= 0x0300)
    2400             : SQLRETURN ODBC_PUBLIC ODBC_API
    2401             : SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2402             :                 SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
    2403             : #ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
    2404             :                 SQLLEN FAR * pfDesc
    2405             : #else
    2406             :                 SQLPOINTER pfDesc
    2407             : #endif
    2408             :         )
    2409             : {
    2410             : 
    2411        2597 :         return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0);
    2412             : }
    2413             : 
    2414             : #ifdef ENABLE_ODBC_WIDE
    2415             : SQLRETURN ODBC_PUBLIC ODBC_API
    2416             : SQLColAttributeW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
    2417             :                 SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
    2418             : #ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
    2419             :                 SQLLEN FAR * pfDesc
    2420             : #else
    2421             :                 SQLPOINTER pfDesc
    2422             : #endif
    2423             :         )
    2424             : {
    2425        2597 :         tdsdump_log(TDS_DBG_FUNC, "SQLColAttributeW(%p, %u, %u, %p, %d, %p, %p)\n",
    2426             :                         hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
    2427             : 
    2428        2597 :         return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc, 1);
    2429             : }
    2430             : #endif
    2431             : #endif
    2432             : 
    2433             : SQLRETURN ODBC_PUBLIC ODBC_API
    2434             : SQLDisconnect(SQLHDBC hdbc)
    2435             : {
    2436             :         int i;
    2437             : 
    2438         900 :         ODBC_ENTER_HDBC;
    2439             : 
    2440         900 :         tdsdump_log(TDS_DBG_FUNC, "SQLDisconnect(%p)\n", hdbc);
    2441             : 
    2442             :         /* free all associated statements */
    2443         927 :         while (dbc->stmt_list) {
    2444          27 :                 tds_mutex_unlock(&dbc->mtx);
    2445          27 :                 _SQLFreeStmt(dbc->stmt_list, SQL_DROP, 1);
    2446          27 :                 tds_mutex_lock(&dbc->mtx);
    2447             :         }
    2448             : 
    2449             :         /* free all associated descriptors */
    2450       90000 :         for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
    2451       90000 :                 if (dbc->uad[i]) {
    2452           8 :                         desc_free(dbc->uad[i]);
    2453           8 :                         dbc->uad[i] = NULL;
    2454             :                 }
    2455             :         }
    2456             : 
    2457             : #ifdef ENABLE_ODBC_WIDE
    2458         900 :         dbc->mb_conv = NULL;
    2459             : #endif
    2460         900 :         tds_close_socket(dbc->tds_socket);
    2461         900 :         tds_free_socket(dbc->tds_socket);
    2462         900 :         dbc->tds_socket = NULL;
    2463         900 :         dbc->cursor_support = 0;
    2464             : 
    2465         900 :         ODBC_EXIT_(dbc);
    2466             : }
    2467             : 
    2468             : static int
    2469        4410 : odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg)
    2470             : {
    2471        4410 :         struct _sql_errors *errs = NULL;
    2472        4410 :         TDS_DBC *dbc = NULL;
    2473        4410 :         TDS_STMT *stmt = NULL;
    2474             : 
    2475        4410 :         tdsdump_log(TDS_DBG_INFO1, "msgno %d %d\n", (int) msg->msgno, TDSETIME);
    2476             : 
    2477        4410 :         if (msg->msgno == TDSETIME) {
    2478             : 
    2479         168 :                 tdsdump_log(TDS_DBG_INFO1, "in timeout\n");
    2480         168 :                 if (!tds)
    2481             :                         return TDS_INT_CANCEL;
    2482             : 
    2483         160 :                 if ((stmt = odbc_get_stmt(tds)) != NULL) {
    2484             :                         /* first time, try to send a cancel */
    2485         160 :                         if (!tds->in_cancel) {
    2486         144 :                                 odbc_errs_add(&stmt->errs, "HYT00", "Timeout expired");
    2487         144 :                                 tdsdump_log(TDS_DBG_INFO1, "returning from timeout\n");
    2488             :                                 return TDS_INT_TIMEOUT;
    2489             :                         }
    2490           8 :                 } else if ((dbc = odbc_get_dbc(tds)) != NULL) {
    2491           8 :                         odbc_errs_add(&dbc->errs, "HYT00", "Timeout expired");
    2492             :                 }
    2493             : 
    2494          24 :                 tds_close_socket(tds);
    2495          24 :                 tdsdump_log(TDS_DBG_INFO1, "returning cancel from timeout\n");
    2496             :                 return TDS_INT_CANCEL;
    2497             :         }
    2498             : 
    2499        4242 :         if (tds && (dbc = odbc_get_dbc(tds)) != NULL) {
    2500        4242 :                 errs = &dbc->errs;
    2501        2241 :                 stmt = odbc_get_stmt(tds);
    2502             :                 if (stmt)
    2503        2241 :                         errs = &stmt->errs;
    2504           0 :         } else if (ctx->parent) {
    2505           0 :                 errs = &((TDS_ENV *) ctx->parent)->errs;
    2506             :         }
    2507        4242 :         if (errs) {
    2508        4242 :                 int severity = msg->severity;
    2509        4242 :                 const char * state = msg->sql_state;
    2510             : 
    2511             :                 /* fix severity for Sybase */
    2512        4242 :                 if (severity <= 10 && dbc && !TDS_IS_MSSQL(dbc->tds_socket) && msg->sql_state && msg->sql_state[0]
    2513          15 :                     && strncmp(msg->sql_state, "00", 2) != 0) {
    2514          15 :                         if (strncmp(msg->sql_state, "01", 2) != 0 && strncmp(msg->sql_state, "IM", 2) != 0)
    2515          11 :                                 severity = 11;
    2516             :                 }
    2517             : 
    2518             :                 /* compute state if not available */
    2519        4242 :                 if (!state)
    2520        3090 :                         state = severity <= 10 ? "01000" : "42000";
    2521             :                 /* add error, do not overwrite connection timeout error */
    2522        4242 :                 if (msg->msgno != TDSEFCON || errs->lastrc != SQL_ERROR || errs->num_errors < 1)
    2523       10709 :                         odbc_errs_add_rdbms(errs, msg->msgno, state, msg->message, msg->line_number, msg->severity,
    2524        6475 :                                             msg->server, stmt ? stmt->curr_param_row + 1 : 0);
    2525             : 
    2526             :                 /* set lastc according */
    2527        4242 :                 if (severity <= 10) {
    2528        3448 :                         if (errs->lastrc == SQL_SUCCESS)
    2529        1878 :                                 errs->lastrc = SQL_SUCCESS_WITH_INFO;
    2530             :                 } else {
    2531         794 :                         errs->lastrc = SQL_ERROR;
    2532             :                 }
    2533             :         }
    2534             :         return TDS_INT_CANCEL;
    2535             : }
    2536             : 
    2537             : /* TODO optimize, change only if some data change (set same value should not set this flag) */
    2538             : #define DESC_SET_NEED_REPREPARE \
    2539             :         do {\
    2540             :                 if (desc->type == DESC_IPD) {\
    2541             :                         assert(IS_HSTMT(desc->parent));\
    2542             :                         ((TDS_STMT *) desc->parent)->need_reprepare = 1;\
    2543             :                  }\
    2544             :         } while(0)
    2545             : 
    2546             : SQLRETURN ODBC_PUBLIC ODBC_API
    2547             : SQLSetDescRec(SQLHDESC hdesc, SQLSMALLINT nRecordNumber, SQLSMALLINT nType, SQLSMALLINT nSubType, SQLLEN nLength,
    2548             :               SQLSMALLINT nPrecision, SQLSMALLINT nScale, SQLPOINTER pData, SQLLEN FAR * pnStringLength, SQLLEN FAR * pnIndicator)
    2549             : {
    2550             :         struct _drecord *drec;
    2551             :         SQLSMALLINT concise_type;
    2552             : 
    2553           0 :         ODBC_ENTER_HDESC;
    2554             : 
    2555           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetDescRec(%p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", 
    2556             :                         hdesc, nRecordNumber, nType, nSubType, (int)nLength, nPrecision, nScale, pData, pnStringLength, pnIndicator);
    2557             : 
    2558           0 :         if (desc->type == DESC_IRD) {
    2559           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    2560           0 :                 ODBC_EXIT_(desc);
    2561             :         }
    2562             : 
    2563           0 :         if (nRecordNumber > desc->header.sql_desc_count || nRecordNumber <= 0) {
    2564           0 :                 odbc_errs_add(&desc->errs, "07009", NULL);
    2565           0 :                 ODBC_EXIT_(desc);
    2566             :         }
    2567             : 
    2568           0 :         drec = &desc->records[nRecordNumber - 1];
    2569             : 
    2570             :         /* check for valid types and return "HY021" if not */
    2571           0 :         if (desc->type == DESC_IPD) {
    2572           0 :                 DESC_SET_NEED_REPREPARE;
    2573           0 :                 concise_type = odbc_get_concise_sql_type(nType, nSubType);
    2574             :         } else {
    2575           0 :                 concise_type = odbc_get_concise_c_type(nType, nSubType);
    2576             :         }
    2577           0 :         if (nType == SQL_INTERVAL || nType == SQL_DATETIME) {
    2578           0 :                 if (!concise_type) {
    2579           0 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    2580           0 :                         ODBC_EXIT_(desc);
    2581             :                 }
    2582             :         } else {
    2583           0 :                 if (concise_type != nType) {
    2584           0 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    2585           0 :                         ODBC_EXIT_(desc);
    2586             :                 }
    2587             :                 nSubType = 0;
    2588             :         }
    2589           0 :         drec->sql_desc_concise_type = concise_type;
    2590           0 :         drec->sql_desc_type = nType;
    2591           0 :         drec->sql_desc_datetime_interval_code = nSubType;
    2592             : 
    2593           0 :         drec->sql_desc_octet_length = nLength;
    2594           0 :         drec->sql_desc_precision = nPrecision;
    2595           0 :         drec->sql_desc_scale = nScale;
    2596           0 :         drec->sql_desc_data_ptr = pData;
    2597           0 :         drec->sql_desc_octet_length_ptr = pnStringLength;
    2598           0 :         drec->sql_desc_indicator_ptr = pnIndicator;
    2599             : 
    2600           0 :         ODBC_EXIT_(desc);
    2601             : }
    2602             : 
    2603          24 : ODBC_FUNC(SQLGetDescRec, (P(SQLHDESC,hdesc), P(SQLSMALLINT,RecordNumber), PCHAROUT(Name,SQLSMALLINT),
    2604             :         P(SQLSMALLINT *,Type), P(SQLSMALLINT *,SubType), P(SQLLEN FAR *,Length),
    2605             :         P(SQLSMALLINT *,Precision), P(SQLSMALLINT *,Scale), P(SQLSMALLINT *,Nullable) WIDE))
    2606             : {
    2607          24 :         struct _drecord *drec = NULL;
    2608          24 :         SQLRETURN rc = SQL_SUCCESS;
    2609             : 
    2610          24 :         ODBC_ENTER_HDESC;
    2611             : 
    2612          24 :         if (RecordNumber <= 0) {
    2613           8 :                 odbc_errs_add(&desc->errs, "07009", NULL);
    2614           8 :                 ODBC_EXIT_(desc);
    2615             :         }
    2616             : 
    2617          16 :         IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2618          16 :         if (RecordNumber > desc->header.sql_desc_count)
    2619           8 :                 ODBC_EXIT(desc, SQL_NO_DATA);
    2620             : 
    2621             :         if (desc->type == DESC_IRD && !desc->header.sql_desc_count) {
    2622             :                 odbc_errs_add(&desc->errs, "HY007", NULL);
    2623             :                 ODBC_EXIT_(desc);
    2624             :         }
    2625             : 
    2626           8 :         drec = &desc->records[RecordNumber - 1];
    2627             : 
    2628          24 :         if ((rc = odbc_set_dstr(desc_get_dbc(desc), szName, cbNameMax, pcbName, &drec->sql_desc_name)) != SQL_SUCCESS)
    2629           0 :                 odbc_errs_add(&desc->errs, "01004", NULL);
    2630             : 
    2631           8 :         if (Type)
    2632           0 :                 *Type = drec->sql_desc_type;
    2633           8 :         if (Length)
    2634           0 :                 *Length = drec->sql_desc_octet_length;
    2635           8 :         if (Precision)
    2636           0 :                 *Precision = drec->sql_desc_precision;
    2637           8 :         if (Scale)
    2638           0 :                 *Scale = drec->sql_desc_scale;
    2639           8 :         if (SubType)
    2640           0 :                 *SubType = drec->sql_desc_datetime_interval_code;
    2641           8 :         if (Nullable)
    2642           0 :                 *Nullable = drec->sql_desc_nullable;
    2643             : 
    2644           8 :         ODBC_EXIT(desc, rc);
    2645             : }
    2646             : 
    2647             : static TDS_DESC*
    2648        2138 : desc_get_focused(TDS_DESC *desc)
    2649             : {
    2650             :         struct _drecord *drec;
    2651        2138 :         int focus = desc->focus;
    2652        2138 :         bool was_apd = false;
    2653             : 
    2654        2138 :         if (focus <= 0)
    2655             :                 return desc;
    2656          10 :         if (desc->type != DESC_IPD && IS_HSTMT(desc->parent)) {
    2657           6 :                 desc = ((TDS_STMT *) desc->parent)->ipd;
    2658           6 :                 was_apd = true;
    2659             :         }
    2660          10 :         if (desc->type == DESC_IPD) {
    2661          10 :                 if (focus > desc->header.sql_desc_count)
    2662             :                         return desc;
    2663             : 
    2664          10 :                 drec = &desc->records[focus - 1];
    2665          10 :                 if (drec->sql_desc_concise_type != SQL_SS_TABLE)
    2666             :                         return desc;
    2667          10 :                 if (was_apd)
    2668           6 :                         return ((SQLTVP *) drec->sql_desc_data_ptr)->apd;
    2669           4 :                 return ((SQLTVP *) drec->sql_desc_data_ptr)->ipd;
    2670             :         }
    2671             :         return desc;
    2672             : }
    2673             : 
    2674        1606 : ODBC_FUNC(SQLGetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType), P(SQLPOINTER,Value),
    2675             :         P(SQLINTEGER,BufferLength), P(SQLINTEGER *,StringLength) WIDE))
    2676             : {
    2677             :         struct _drecord *drec;
    2678        1606 :         SQLRETURN result = SQL_SUCCESS;
    2679             :         SQLINTEGER dummy_size;
    2680             :         TDS_DESC *fdesc;
    2681             : 
    2682        1606 :         ODBC_ENTER_HDESC;
    2683             : 
    2684             : #define COUT(src) result = odbc_set_string_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, src, -1);
    2685             : #define SOUT(src) result = odbc_set_dstr_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, &src);
    2686             : 
    2687             : #if ENABLE_EXTRA_CHECKS
    2688             : #define IOUT(type, src) do { \
    2689             :         /* trick warning if type wrong */ \
    2690             :         type *p_test = &src; p_test = p_test; \
    2691             :         *((type *)Value) = src; \
    2692             :         *StringLength = sizeof(type); } while(0)
    2693             : #else
    2694             : #define IOUT(type, src) do { \
    2695             :         *((type *)Value) = src; \
    2696             :         *StringLength = sizeof(type); } while(0)
    2697             : #endif
    2698             : 
    2699        1606 :         if (!StringLength)
    2700           0 :                 StringLength = &dummy_size;
    2701             : 
    2702        1606 :         fdesc = desc_get_focused(desc);
    2703             : 
    2704             :         /* dont check column index for these */
    2705        1606 :         switch (fDescType) {
    2706          32 :         case SQL_DESC_ALLOC_TYPE:
    2707          32 :                 IOUT(SQLSMALLINT, fdesc->header.sql_desc_alloc_type);
    2708          32 :                 ODBC_EXIT_(desc);
    2709             :                 break;
    2710           4 :         case SQL_DESC_ARRAY_SIZE:
    2711           4 :                 IOUT(SQLULEN, fdesc->header.sql_desc_array_size);
    2712           4 :                 ODBC_EXIT_(desc);
    2713             :                 break;
    2714           0 :         case SQL_DESC_ARRAY_STATUS_PTR:
    2715           0 :                 IOUT(SQLUSMALLINT *, fdesc->header.sql_desc_array_status_ptr);
    2716           0 :                 ODBC_EXIT_(desc);
    2717             :                 break;
    2718           0 :         case SQL_DESC_BIND_OFFSET_PTR:
    2719           0 :                 IOUT(SQLLEN *, fdesc->header.sql_desc_bind_offset_ptr);
    2720           0 :                 ODBC_EXIT_(desc);
    2721             :                 break;
    2722           0 :         case SQL_DESC_BIND_TYPE:
    2723           0 :                 IOUT(SQLINTEGER, fdesc->header.sql_desc_bind_type);
    2724           0 :                 ODBC_EXIT_(desc);
    2725             :                 break;
    2726          30 :         case SQL_DESC_COUNT:
    2727          30 :                 IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2728          30 :                 IOUT(SQLSMALLINT, fdesc->header.sql_desc_count);
    2729          30 :                 ODBC_EXIT_(desc);
    2730             :                 break;
    2731          88 :         case SQL_DESC_ROWS_PROCESSED_PTR:
    2732          88 :                 IOUT(SQLULEN *, fdesc->header.sql_desc_rows_processed_ptr);
    2733          88 :                 ODBC_EXIT_(desc);
    2734             :                 break;
    2735             :         }
    2736             : 
    2737        1452 :         IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    2738        1452 :         if (!fdesc->header.sql_desc_count) {
    2739           0 :                 odbc_errs_add(&desc->errs, "07005", NULL);
    2740           0 :                 ODBC_EXIT_(desc);
    2741             :         }
    2742             : 
    2743        1452 :         if (icol < 1) {
    2744           0 :                 odbc_errs_add(&desc->errs, "07009", "Column out of range");
    2745           0 :                 ODBC_EXIT_(desc);
    2746             :         }
    2747        1452 :         if (icol > fdesc->header.sql_desc_count)
    2748           0 :                 ODBC_EXIT(desc, SQL_NO_DATA);
    2749        1452 :         drec = &fdesc->records[icol - 1];
    2750             : 
    2751        1452 :         tdsdump_log(TDS_DBG_INFO1, "SQLGetDescField: fDescType is %d\n", fDescType);
    2752             : 
    2753        1452 :         switch (fDescType) {
    2754           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    2755           0 :                 IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
    2756             :                 break;
    2757           0 :         case SQL_DESC_BASE_COLUMN_NAME:
    2758           0 :                 SOUT(drec->sql_desc_base_column_name);
    2759           0 :                 break;
    2760           0 :         case SQL_DESC_BASE_TABLE_NAME:
    2761           0 :                 SOUT(drec->sql_desc_base_table_name);
    2762           0 :                 break;
    2763           0 :         case SQL_DESC_CASE_SENSITIVE:
    2764           0 :                 IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
    2765             :                 break;
    2766           0 :         case SQL_DESC_CATALOG_NAME:
    2767           0 :                 SOUT(drec->sql_desc_catalog_name);
    2768           0 :                 break;
    2769         476 :         case SQL_DESC_CONCISE_TYPE:
    2770         476 :                 IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
    2771             :                 break;
    2772           8 :         case SQL_DESC_DATA_PTR:
    2773           8 :                 IOUT(SQLPOINTER, drec->sql_desc_data_ptr);
    2774             :                 break;
    2775         472 :         case SQL_DESC_DATETIME_INTERVAL_CODE:
    2776         472 :                 IOUT(SQLSMALLINT, drec->sql_desc_datetime_interval_code);
    2777             :                 break;
    2778           0 :         case SQL_DESC_DATETIME_INTERVAL_PRECISION:
    2779           0 :                 IOUT(SQLINTEGER, drec->sql_desc_datetime_interval_precision);
    2780             :                 break;
    2781           0 :         case SQL_DESC_DISPLAY_SIZE:
    2782           0 :                 IOUT(SQLLEN, drec->sql_desc_display_size);
    2783             :                 break;
    2784           0 :         case SQL_DESC_FIXED_PREC_SCALE:
    2785           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
    2786             :                 break;
    2787           4 :         case SQL_DESC_INDICATOR_PTR:
    2788           4 :                 IOUT(SQLLEN *, drec->sql_desc_indicator_ptr);
    2789             :                 break;
    2790           0 :         case SQL_DESC_LABEL:
    2791           0 :                 SOUT(drec->sql_desc_label);
    2792           0 :                 break;
    2793           4 :         case SQL_DESC_LENGTH:
    2794           4 :                 IOUT(SQLULEN, drec->sql_desc_length);
    2795             :                 break;
    2796           0 :         case SQL_DESC_LITERAL_PREFIX:
    2797           0 :                 COUT(drec->sql_desc_literal_prefix);
    2798           0 :                 break;
    2799           0 :         case SQL_DESC_LITERAL_SUFFIX:
    2800           0 :                 COUT(drec->sql_desc_literal_suffix);
    2801           0 :                 break;
    2802           0 :         case SQL_DESC_LOCAL_TYPE_NAME:
    2803           0 :                 SOUT(drec->sql_desc_local_type_name);
    2804           0 :                 break;
    2805           0 :         case SQL_DESC_NAME:
    2806           0 :                 SOUT(drec->sql_desc_name);
    2807           0 :                 break;
    2808           0 :         case SQL_DESC_NULLABLE:
    2809           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_nullable);
    2810             :                 break;
    2811           0 :         case SQL_DESC_NUM_PREC_RADIX:
    2812           0 :                 IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
    2813             :                 break;
    2814           4 :         case SQL_DESC_OCTET_LENGTH:
    2815           4 :                 IOUT(SQLLEN, drec->sql_desc_octet_length);
    2816             :                 break;
    2817           4 :         case SQL_DESC_OCTET_LENGTH_PTR:
    2818           4 :                 IOUT(SQLLEN *, drec->sql_desc_octet_length_ptr);
    2819             :                 break;
    2820           0 :         case SQL_DESC_PARAMETER_TYPE:
    2821           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_parameter_type);
    2822             :                 break;
    2823           0 :         case SQL_DESC_PRECISION:
    2824           0 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2825           0 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2826           0 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP)
    2827           0 :                         IOUT(SQLSMALLINT, drec->sql_desc_precision);
    2828             :                 else
    2829             :                         /* TODO support date/time */
    2830           0 :                         *((SQLSMALLINT *) Value) = 0;
    2831             :                 break;
    2832             : #ifdef SQL_DESC_ROWVER
    2833           0 :         case SQL_DESC_ROWVER:
    2834           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_rowver);
    2835             :                 break;
    2836             : #endif
    2837           0 :         case SQL_DESC_SCALE:
    2838           0 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
    2839           0 :                     || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
    2840           0 :                     || drec->sql_desc_concise_type == SQL_TIMESTAMP
    2841           0 :                     || drec->sql_desc_concise_type == SQL_FLOAT)
    2842           0 :                         IOUT(SQLSMALLINT, drec->sql_desc_scale);
    2843             :                 else
    2844           0 :                         *((SQLSMALLINT *) Value) = 0;
    2845             :                 break;
    2846           0 :         case SQL_DESC_SCHEMA_NAME:
    2847           0 :                 SOUT(drec->sql_desc_schema_name);
    2848           0 :                 break;
    2849           0 :         case SQL_DESC_SEARCHABLE:
    2850           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_searchable);
    2851             :                 break;
    2852           0 :         case SQL_DESC_TABLE_NAME:
    2853           0 :                 SOUT(drec->sql_desc_table_name);
    2854           0 :                 break;
    2855         480 :         case SQL_DESC_TYPE:
    2856         480 :                 IOUT(SQLSMALLINT, drec->sql_desc_type);
    2857             :                 break;
    2858           0 :         case SQL_DESC_TYPE_NAME:
    2859           0 :                 COUT(drec->sql_desc_type_name);
    2860           0 :                 break;
    2861           0 :         case SQL_DESC_UNNAMED:
    2862           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
    2863             :                 break;
    2864           0 :         case SQL_DESC_UNSIGNED:
    2865           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
    2866             :                 break;
    2867           0 :         case SQL_DESC_UPDATABLE:
    2868           0 :                 IOUT(SQLSMALLINT, drec->sql_desc_updatable);
    2869             :                 break;
    2870           0 :         default:
    2871           0 :                 odbc_errs_add(&desc->errs, "HY091", NULL);
    2872           0 :                 ODBC_EXIT_(desc);
    2873             :                 break;
    2874             :         }
    2875             : 
    2876           0 :         if (result == SQL_SUCCESS_WITH_INFO)
    2877           0 :                 odbc_errs_add(&desc->errs, "01004", NULL);
    2878             : 
    2879        1452 :         ODBC_EXIT(desc, result);
    2880             : 
    2881             : #undef COUT
    2882             : #undef SOUT
    2883             : #undef IOUT
    2884             : }
    2885             : 
    2886         532 : ODBC_FUNC(SQLSetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType),
    2887             :         P(SQLPOINTER,Value), P(SQLINTEGER,BufferLength) WIDE))
    2888             : {
    2889             :         struct _drecord *drec;
    2890         532 :         SQLRETURN result = SQL_SUCCESS;
    2891             :         TDS_DESC *fdesc;
    2892             : 
    2893         532 :         ODBC_ENTER_HDESC;
    2894             : 
    2895             : #if ENABLE_EXTRA_CHECKS
    2896             : #define IIN(type, dest) do { \
    2897             :         /* trick warning if type wrong */ \
    2898             :         type *p_test = &dest; p_test = p_test; \
    2899             :         dest = (type)(TDS_INTPTR)Value; } while(0)
    2900             : #define PIN(type, dest) do { \
    2901             :         /* trick warning if type wrong */ \
    2902             :         type *p_test = &dest; p_test = p_test; \
    2903             :         dest = (type)Value; } while(0)
    2904             : #else
    2905             : #define IIN(type, dest) dest = (type)(TDS_INTPTR)Value
    2906             : #define PIN(type, dest) dest = (type)Value
    2907             : #endif
    2908             : 
    2909             :         /* special case for IRD */
    2910         532 :         if (desc->type == DESC_IRD && fDescType != SQL_DESC_ARRAY_STATUS_PTR && fDescType != SQL_DESC_ROWS_PROCESSED_PTR) {
    2911           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    2912           0 :                 ODBC_EXIT_(desc);
    2913             :         }
    2914             : 
    2915         532 :         fdesc = desc_get_focused(desc);
    2916             : 
    2917             :         /* dont check column index for these */
    2918         532 :         switch (fDescType) {
    2919           0 :         case SQL_DESC_ALLOC_TYPE:
    2920           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    2921           0 :                 ODBC_EXIT_(desc);
    2922             :                 break;
    2923           0 :         case SQL_DESC_ARRAY_SIZE:
    2924           0 :                 IIN(SQLULEN, fdesc->header.sql_desc_array_size);
    2925           0 :                 ODBC_EXIT_(desc);
    2926             :                 break;
    2927           0 :         case SQL_DESC_ARRAY_STATUS_PTR:
    2928           0 :                 PIN(SQLUSMALLINT *, fdesc->header.sql_desc_array_status_ptr);
    2929           0 :                 ODBC_EXIT_(desc);
    2930             :                 break;
    2931          32 :         case SQL_DESC_ROWS_PROCESSED_PTR:
    2932          32 :                 PIN(SQLULEN *, fdesc->header.sql_desc_rows_processed_ptr);
    2933          32 :                 ODBC_EXIT_(desc);
    2934             :                 break;
    2935           0 :         case SQL_DESC_BIND_TYPE:
    2936           0 :                 IIN(SQLINTEGER, fdesc->header.sql_desc_bind_type);
    2937           0 :                 ODBC_EXIT_(desc);
    2938             :                 break;
    2939           0 :         case SQL_DESC_COUNT:
    2940             :                 {
    2941           0 :                         int n = (int) (TDS_INTPTR) Value;
    2942             : 
    2943           0 :                         if (n <= 0 || n > 4000) {
    2944           0 :                                 odbc_errs_add(&desc->errs, "07009", NULL);
    2945           0 :                                 ODBC_EXIT_(desc);
    2946             :                         }
    2947           0 :                         result = desc_alloc_records(fdesc, n);
    2948           0 :                         if (result == SQL_ERROR)
    2949           0 :                                 odbc_errs_add(&desc->errs, "HY001", NULL);
    2950           0 :                         ODBC_EXIT(desc, result);
    2951             :                 }
    2952             :                 break;
    2953             :         }
    2954             : 
    2955         500 :         if (!fdesc->header.sql_desc_count) {
    2956           0 :                 odbc_errs_add(&desc->errs, "07005", NULL);
    2957           0 :                 ODBC_EXIT_(desc);
    2958             :         }
    2959             : 
    2960         500 :         if (icol <= 0 || icol > fdesc->header.sql_desc_count) {
    2961           0 :                 odbc_errs_add(&desc->errs, "07009", "Column out of range");
    2962           0 :                 ODBC_EXIT_(desc);
    2963             :         }
    2964         500 :         drec = &fdesc->records[icol - 1];
    2965             : 
    2966         500 :         tdsdump_log(TDS_DBG_INFO1, "SQLSetDescField: fDescType is %d\n", fDescType);
    2967             : 
    2968         500 :         switch (fDescType) {
    2969           0 :         case SQL_DESC_AUTO_UNIQUE_VALUE:
    2970             :         case SQL_DESC_BASE_COLUMN_NAME:
    2971             :         case SQL_DESC_BASE_TABLE_NAME:
    2972             :         case SQL_DESC_CASE_SENSITIVE:
    2973             :         case SQL_DESC_CATALOG_NAME:
    2974           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    2975           0 :                 result = SQL_ERROR;
    2976           0 :                 break;
    2977         434 :         case SQL_DESC_CONCISE_TYPE:
    2978         434 :                 DESC_SET_NEED_REPREPARE;
    2979         434 :                 if (fdesc->type == DESC_IPD)
    2980         360 :                         result = odbc_set_concise_sql_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
    2981             :                 else
    2982          74 :                         result = odbc_set_concise_c_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
    2983         434 :                 if (result != SQL_SUCCESS)
    2984         248 :                         odbc_errs_add(&desc->errs, "HY021", NULL);
    2985             :                 break;
    2986           0 :         case SQL_DESC_DATA_PTR:
    2987           0 :                 PIN(SQLPOINTER, drec->sql_desc_data_ptr);
    2988           0 :                 break;
    2989             :                 /* TODO SQL_DESC_DATETIME_INTERVAL_CODE remember to check sql_desc_type */
    2990             :                 /* TODO SQL_DESC_DATETIME_INTERVAL_PRECISION */
    2991           0 :         case SQL_DESC_DISPLAY_SIZE:
    2992             :         case SQL_DESC_FIXED_PREC_SCALE:
    2993           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    2994           0 :                 result = SQL_ERROR;
    2995           0 :                 break;
    2996           0 :         case SQL_DESC_INDICATOR_PTR:
    2997           0 :                 PIN(SQLLEN *, drec->sql_desc_indicator_ptr);
    2998           0 :                 break;
    2999           0 :         case SQL_DESC_LABEL:
    3000           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3001           0 :                 result = SQL_ERROR;
    3002           0 :                 break;
    3003           0 :         case SQL_DESC_LENGTH:
    3004           0 :                 DESC_SET_NEED_REPREPARE;
    3005           0 :                 IIN(SQLULEN, drec->sql_desc_length);
    3006           0 :                 break;
    3007           0 :         case SQL_DESC_LITERAL_PREFIX:
    3008             :         case SQL_DESC_LITERAL_SUFFIX:
    3009             :         case SQL_DESC_LOCAL_TYPE_NAME:
    3010           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3011           0 :                 result = SQL_ERROR;
    3012           0 :                 break;
    3013           0 :         case SQL_DESC_NAME:
    3014           0 :                 if (!odbc_dstr_copy_oct(desc_get_dbc(fdesc), &drec->sql_desc_name, BufferLength, (ODBC_CHAR*) Value)) {
    3015           0 :                         odbc_errs_add(&desc->errs, "HY001", NULL);
    3016           0 :                         result = SQL_ERROR;
    3017             :                 }
    3018             :                 break;
    3019           0 :         case SQL_DESC_NULLABLE:
    3020           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3021           0 :                 result = SQL_ERROR;
    3022           0 :                 break;
    3023           0 :         case SQL_DESC_NUM_PREC_RADIX:
    3024           0 :                 IIN(SQLINTEGER, drec->sql_desc_num_prec_radix);
    3025           0 :                 break;
    3026           0 :         case SQL_DESC_OCTET_LENGTH:
    3027           0 :                 DESC_SET_NEED_REPREPARE;
    3028           0 :                 IIN(SQLLEN, drec->sql_desc_octet_length);
    3029           0 :                 break;
    3030           2 :         case SQL_DESC_OCTET_LENGTH_PTR:
    3031           2 :                 PIN(SQLLEN *, drec->sql_desc_octet_length_ptr);
    3032           2 :                 break;
    3033           0 :         case SQL_DESC_PARAMETER_TYPE:
    3034           0 :                 DESC_SET_NEED_REPREPARE;
    3035           0 :                 IIN(SQLSMALLINT, drec->sql_desc_parameter_type);
    3036           0 :                 break;
    3037          32 :         case SQL_DESC_PRECISION:
    3038          32 :                 DESC_SET_NEED_REPREPARE;
    3039             :                 /* TODO correct ?? */
    3040          32 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
    3041           8 :                         IIN(SQLSMALLINT, drec->sql_desc_precision);
    3042             :                 else
    3043          24 :                         IIN(SQLULEN, drec->sql_desc_length);
    3044             :                 break;
    3045             : #ifdef SQL_DESC_ROWVER
    3046           0 :         case SQL_DESC_ROWVER:
    3047           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3048           0 :                 result = SQL_ERROR;
    3049           0 :                 break;
    3050             : #endif
    3051          32 :         case SQL_DESC_SCALE:
    3052          32 :                 DESC_SET_NEED_REPREPARE;
    3053          32 :                 if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
    3054           8 :                         IIN(SQLSMALLINT, drec->sql_desc_scale);
    3055             :                 else
    3056             :                         /* TODO even for datetime/money ?? */
    3057          24 :                         drec->sql_desc_scale = 0;
    3058             :                 break;
    3059           0 :         case SQL_DESC_SCHEMA_NAME:
    3060             :         case SQL_DESC_SEARCHABLE:
    3061             :         case SQL_DESC_TABLE_NAME:
    3062           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3063           0 :                 result = SQL_ERROR;
    3064           0 :                 break;
    3065           0 :         case SQL_DESC_TYPE:
    3066           0 :                 DESC_SET_NEED_REPREPARE;
    3067           0 :                 IIN(SQLSMALLINT, drec->sql_desc_type);
    3068             :                 /* FIXME what happen for interval/datetime ?? */
    3069           0 :                 drec->sql_desc_concise_type = drec->sql_desc_type;
    3070           0 :                 break;
    3071           0 :         case SQL_DESC_TYPE_NAME:
    3072           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3073           0 :                 result = SQL_ERROR;
    3074           0 :                 break;
    3075           0 :         case SQL_DESC_UNNAMED:
    3076           0 :                 IIN(SQLSMALLINT, drec->sql_desc_unnamed);
    3077           0 :                 break;
    3078           0 :         case SQL_DESC_UNSIGNED:
    3079             :         case SQL_DESC_UPDATABLE:
    3080           0 :                 odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
    3081           0 :                 result = SQL_ERROR;
    3082           0 :                 break;
    3083           0 :         default:
    3084           0 :                 odbc_errs_add(&desc->errs, "HY091", NULL);
    3085           0 :                 ODBC_EXIT_(desc);
    3086             :                 break;
    3087             :         }
    3088             : 
    3089             : #undef IIN
    3090             : 
    3091         500 :         ODBC_EXIT(desc, result);
    3092             : }
    3093             : 
    3094             : SQLRETURN ODBC_PUBLIC ODBC_API
    3095             : SQLCopyDesc(SQLHDESC hsrc, SQLHDESC hdesc)
    3096             : {
    3097             :         TDS_DESC *src;
    3098             : 
    3099          40 :         ODBC_ENTER_HDESC;
    3100             : 
    3101          24 :         tdsdump_log(TDS_DBG_FUNC, "SQLCopyDesc(%p, %p)\n", 
    3102             :                         hsrc, hdesc);
    3103             : 
    3104             :         /* check source descriptor handle, destination one was already checked */
    3105          24 :         if (SQL_NULL_HDESC == hsrc || !IS_HDESC(hsrc)) {
    3106          16 :                 tds_mutex_unlock(&desc->mtx);
    3107          16 :                 return SQL_INVALID_HANDLE;
    3108             :         }
    3109             : 
    3110           8 :         src = (TDS_DESC *) hsrc;
    3111           8 :         CHECK_DESC_EXTRA(src);
    3112             : 
    3113             :         /* do not write on IRD */
    3114           8 :         if (desc->type == DESC_IRD) {
    3115           0 :                 odbc_errs_add(&desc->errs, "HY016", NULL);
    3116           0 :                 ODBC_EXIT_(desc);
    3117             :         }
    3118           8 :         IRD_UPDATE(src, &src->errs, ODBC_EXIT(desc, SQL_ERROR));
    3119             : 
    3120           8 :         ODBC_EXIT(desc, desc_copy(desc, src));
    3121             : }
    3122             : 
    3123             : #if ENABLE_EXTRA_CHECKS
    3124             : static void
    3125       13334 : odbc_ird_check(TDS_STMT * stmt)
    3126             : {
    3127             : #if !ENABLE_ODBC_MARS
    3128       13334 :         TDS_DESC *ird = stmt->ird;
    3129       13334 :         TDSRESULTINFO *res_info = NULL;
    3130       13334 :         int cols = 0, i;
    3131             : 
    3132       13334 :         if (!stmt->tds)
    3133             :                 return;
    3134       12599 :         if (stmt->tds->current_results) {
    3135       12583 :                 res_info = stmt->tds->current_results;
    3136       12583 :                 cols = res_info->num_cols;
    3137             :         }
    3138       12599 :         if (stmt->cursor != NULL)
    3139             :                 return;
    3140             : 
    3141             :         /* check columns number */
    3142       12338 :         assert(ird->header.sql_desc_count <= cols || ird->header.sql_desc_count == 0);
    3143             : 
    3144             : 
    3145             :         /* check all columns */
    3146       51596 :         for (i = 0; i < ird->header.sql_desc_count; ++i) {
    3147       51596 :                 struct _drecord *drec = &ird->records[i];
    3148       51596 :                 TDSCOLUMN *col = res_info->columns[i];
    3149             : 
    3150      154788 :                 assert(strcmp(tds_dstr_cstr(&drec->sql_desc_label), tds_dstr_cstr(&col->column_name)) == 0);
    3151             :         }
    3152             : #endif
    3153             : }
    3154             : #endif
    3155             : 
    3156             : static void
    3157        3204 : odbc_unquote(char *buf, size_t buf_len, const char *start, const char *end)
    3158             : {
    3159             :         char quote;
    3160        3204 :         assert(buf_len > 0);
    3161             : 
    3162             :         /* empty string */
    3163        3204 :         if (start >= end) {
    3164           0 :                 buf[0] = 0;
    3165           0 :                 return;
    3166             :         }
    3167             : 
    3168             :         /* not quoted */
    3169        3204 :         if (*start != '[' && *start != '\"') {
    3170        2388 :                 --buf_len;
    3171        2388 :                 if (end - start < buf_len)
    3172        2388 :                         buf_len = end - start;
    3173        2388 :                 memcpy(buf, start, buf_len);
    3174        2388 :                 buf[buf_len] = 0;
    3175        2388 :                 return;
    3176             :         }
    3177             : 
    3178             :         /* quoted... unquote */
    3179         816 :         quote = (*start == '[') ? ']' : *start;
    3180         816 :         ++start;
    3181        5892 :         while (buf_len > 0 && start < end) {
    3182        5076 :                 if (*start == quote)
    3183         816 :                         if (++start >= end)
    3184             :                                 break;
    3185        4260 :                 *buf++ = *start++;
    3186        4260 :                 --buf_len;
    3187             :         }
    3188         816 :         *buf = 0;
    3189             : }
    3190             : 
    3191             : /* FIXME check result !!! */
    3192             : static SQLRETURN
    3193       64104 : odbc_populate_ird(TDS_STMT * stmt)
    3194             : {
    3195       64104 :         TDS_DESC *ird = stmt->ird;
    3196             :         struct _drecord *drec;
    3197             :         TDSCOLUMN *col;
    3198             :         TDSRESULTINFO *res_info;
    3199             :         int num_cols;
    3200             :         int i;
    3201             : 
    3202       64104 :         desc_free_records(ird);
    3203       64104 :         if (!stmt->tds || !(res_info = stmt->tds->current_results))
    3204             :                 return SQL_SUCCESS;
    3205        8986 :         if (res_info == stmt->tds->param_info)
    3206             :                 return SQL_SUCCESS;
    3207        8412 :         num_cols = res_info->num_cols;
    3208             : 
    3209             :         /* ignore hidden columns... TODO correct? */
    3210       17148 :         while (num_cols > 0 && res_info->columns[num_cols - 1]->column_hidden == 1)
    3211         324 :                 --num_cols;
    3212             : 
    3213        8412 :         if (desc_alloc_records(ird, num_cols) != SQL_SUCCESS)
    3214             :                 goto memory_error;
    3215             : 
    3216       14070 :         for (i = 0; i < num_cols; i++) {
    3217       14070 :                 drec = &ird->records[i];
    3218       14070 :                 col = res_info->columns[i];
    3219       14070 :                 drec->sql_desc_auto_unique_value = col->column_identity ? SQL_TRUE : SQL_FALSE;
    3220             :                 /* TODO SQL_FALSE ?? */
    3221       14070 :                 drec->sql_desc_case_sensitive = SQL_TRUE;
    3222             : 
    3223             :                 /*
    3224             :                  * TODO how to handle when in datetime we change precision ?? 
    3225             :                  * should we change display size too ??
    3226             :                  * is formatting function correct ??
    3227             :                  * we should not convert to string with invalid precision!
    3228             :                  */
    3229       14070 :                 odbc_set_sql_type_info(col, drec, stmt->dbc->env->attr.odbc_version);
    3230             : 
    3231       14070 :                 drec->sql_desc_fixed_prec_scale = (col->column_prec && col->column_scale) ? SQL_TRUE : SQL_FALSE;
    3232       14070 :                 if (!tds_dstr_dup(&drec->sql_desc_label, &col->column_name))
    3233             :                         goto memory_error;
    3234             : 
    3235       28140 :                 if (tds_dstr_isempty(&col->table_column_name)) {
    3236       11832 :                         if (!tds_dstr_dup(&drec->sql_desc_name, &col->column_name))
    3237             :                                 goto memory_error;
    3238             :                 } else {
    3239        2238 :                         if (!tds_dstr_dup(&drec->sql_desc_name, &col->table_column_name))
    3240             :                                 goto memory_error;
    3241        2238 :                         if (!tds_dstr_dup(&drec->sql_desc_base_column_name, &col->table_column_name))
    3242             :                                 goto memory_error;
    3243             :                 }
    3244             : 
    3245             :                 /* extract sql_desc_(catalog/schema/base_table)_name */
    3246             :                 /* TODO extract them dinamically (when needed) ? */
    3247             :                 /* TODO store in libTDS in different way (separately) ? */
    3248       28140 :                 if (!tds_dstr_isempty(&col->table_name)) {
    3249             :                         struct {
    3250             :                                 const char *start;
    3251             :                                 const char *end;
    3252             :                         } partials[4];
    3253             :                         const char *p;
    3254             :                         char buf[256];
    3255             :                         int i;
    3256             : 
    3257        6408 :                         p = tds_dstr_cstr(&col->table_name);
    3258        3204 :                         for (i = 0; ; ++i) {
    3259             :                                 const char *pend;
    3260             : 
    3261        3204 :                                 if (*p == '[' || *p == '\"') {
    3262         816 :                                         pend = tds_skip_quoted(p);
    3263             :                                 } else {
    3264        2388 :                                         pend = strchr(p, '.');
    3265        2388 :                                         if (!pend)
    3266        2388 :                                                 pend = strchr(p, 0);
    3267             :                                 }
    3268        3204 :                                 partials[i].start = p;
    3269        3204 :                                 partials[i].end = pend;
    3270        3204 :                                 p = pend;
    3271        3204 :                                 if (i == 3 || *p != '.')
    3272             :                                         break;
    3273           0 :                                 ++p;
    3274             :                         }
    3275             : 
    3276             :                         /* here i points to last element */
    3277        3204 :                         odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3278        3204 :                         if (!tds_dstr_copy(&drec->sql_desc_base_table_name, buf))
    3279             :                                 goto memory_error;
    3280             : 
    3281        3204 :                         --i;
    3282        3204 :                         if (i >= 0) {
    3283           0 :                                 odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3284           0 :                                 if (!tds_dstr_copy(&drec->sql_desc_schema_name, buf))
    3285             :                                         goto memory_error;
    3286             :                         }
    3287             : 
    3288        3204 :                         --i;
    3289        3204 :                         if (i >= 0) {
    3290           0 :                                 odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
    3291           0 :                                 if (!tds_dstr_copy(&drec->sql_desc_catalog_name, buf))
    3292             :                                         goto memory_error;
    3293             :                         }
    3294             :                 }
    3295             : 
    3296       28140 :                 drec->sql_desc_unnamed = tds_dstr_isempty(&drec->sql_desc_name) ? SQL_UNNAMED : SQL_NAMED;
    3297             :                 /* TODO use is_nullable_type ?? */
    3298       14070 :                 drec->sql_desc_nullable = col->column_nullable ? SQL_TRUE : SQL_FALSE;
    3299             : 
    3300       14070 :                 drec->sql_desc_octet_length_ptr = NULL;
    3301             :                 /* TODO test timestamp from db, FOR BROWSE query */
    3302       14070 :                 drec->sql_desc_rowver = SQL_FALSE;
    3303             :                 /* TODO seem not correct */
    3304       14070 :                 drec->sql_desc_searchable = (drec->sql_desc_unnamed == SQL_NAMED) ? SQL_PRED_SEARCHABLE : SQL_UNSEARCHABLE;
    3305       14070 :                 drec->sql_desc_updatable = col->column_writeable && !col->column_identity ? SQL_TRUE : SQL_FALSE;
    3306             :         }
    3307             :         return SQL_SUCCESS;
    3308             : 
    3309           0 : memory_error:
    3310           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    3311           0 :         return SQL_ERROR;
    3312             : }
    3313             : 
    3314             : static TDSRET
    3315        1710 : odbc_cursor_execute(TDS_STMT * stmt)
    3316             : {
    3317        1710 :         TDSSOCKET *tds = stmt->tds;
    3318        1710 :         int send = 0, i;
    3319             :         TDSRET ret;
    3320             :         TDSCURSOR *cursor;
    3321        1710 :         TDSPARAMINFO *params = stmt->params;
    3322             : 
    3323        1710 :         assert(tds);
    3324        1710 :         assert(stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY);
    3325             : 
    3326        1710 :         tds_release_cursor(&stmt->cursor);
    3327        8550 :         cursor = tds_alloc_cursor(tds, tds_dstr_cstr(&stmt->cursor_name), tds_dstr_len(&stmt->cursor_name),
    3328        3420 :                         tds_dstr_cstr(&stmt->query), tds_dstr_len(&stmt->query));
    3329        1710 :         if (!cursor) {
    3330           0 :                 odbc_unlock_statement(stmt);
    3331             : 
    3332           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    3333           0 :                 return TDS_FAIL;
    3334             :         }
    3335        1710 :         stmt->cursor = cursor;
    3336             : 
    3337             :         /* TODO cursor add enums for tds7 */
    3338        1710 :         switch (stmt->attr.cursor_type) {
    3339             :         default:
    3340             :         case SQL_CURSOR_FORWARD_ONLY:
    3341             :                 i = TDS_CUR_TYPE_FORWARD;
    3342             :                 break;
    3343             :         case SQL_CURSOR_STATIC:
    3344             :                 i = TDS_CUR_TYPE_STATIC;
    3345             :                 break;
    3346             :         case SQL_CURSOR_KEYSET_DRIVEN:
    3347             :                 i = TDS_CUR_TYPE_KEYSET;
    3348             :                 break;
    3349             :         case SQL_CURSOR_DYNAMIC:
    3350             :                 i = TDS_CUR_TYPE_DYNAMIC;
    3351             :                 break;
    3352             :         }
    3353        1710 :         cursor->type = i;
    3354             : 
    3355        1710 :         switch (stmt->attr.concurrency) {
    3356             :         default:
    3357             :         case SQL_CONCUR_READ_ONLY:
    3358             :                 i = TDS_CUR_CONCUR_READ_ONLY;
    3359             :                 break;
    3360             :         case SQL_CONCUR_LOCK:
    3361             :                 i = TDS_CUR_CONCUR_SCROLL_LOCKS;
    3362             :                 break;
    3363             :         case SQL_CONCUR_ROWVER:
    3364             :                 i = TDS_CUR_CONCUR_OPTIMISTIC;
    3365             :                 break;
    3366             :         case SQL_CONCUR_VALUES:
    3367             :                 i = TDS_CUR_CONCUR_OPTIMISTIC_VALUES;
    3368             :                 break;
    3369             :         }
    3370        1710 :         cursor->concurrency = 0x2000 | i;
    3371             : 
    3372        1710 :         ret = tds_cursor_declare(tds, cursor, params, &send);
    3373        1710 :         if (TDS_FAILED(ret))
    3374             :                 return ret;
    3375        1710 :         ret = tds_cursor_open(tds, cursor, params, &send);
    3376        1710 :         if (TDS_FAILED(ret))
    3377             :                 return ret;
    3378             :         /* TODO read results, set row count, check type and scroll returned */
    3379        1710 :         ret = tds_flush_packet(tds);
    3380        1710 :         tds_set_state(tds, TDS_PENDING);
    3381             :         /* set cursor name for TDS7+ */
    3382        3420 :         if (TDS_SUCCEED(ret) && IS_TDS7_PLUS(tds->conn) && !tds_dstr_isempty(&stmt->cursor_name)) {
    3383        1710 :                 ret = odbc_process_tokens(stmt, TDS_RETURN_DONE|TDS_STOPAT_ROW|TDS_STOPAT_COMPUTE);
    3384        1710 :                 stmt->row_count = tds->rows_affected;
    3385        1710 :                 if (ret == TDS_CMD_DONE && cursor->cursor_id != 0) {
    3386         186 :                         ret = tds_cursor_setname(tds, cursor);
    3387         186 :                         tds_set_state(tds, TDS_PENDING);
    3388             :                 } else {
    3389        1524 :                         ret = (ret == TDS_CMD_FAIL) ? TDS_FAIL : TDS_SUCCESS;
    3390             :                 }
    3391        1710 :                 if (!cursor->cursor_id) {
    3392        1518 :                         tds_cursor_dealloc(tds, cursor);
    3393        1518 :                         tds_release_cursor(&stmt->cursor);
    3394             :                 }
    3395             :         }
    3396             :         return ret;
    3397             : }
    3398             : 
    3399             : static TDSHEADERS *
    3400       20753 : odbc_init_headers(TDS_STMT * stmt, TDSHEADERS * head)
    3401             : {
    3402       41508 :         if (tds_dstr_isempty(&stmt->attr.qn_msgtext) || tds_dstr_isempty(&stmt->attr.qn_options))
    3403             :                 return NULL;
    3404             : 
    3405           2 :         memset(head, 0, sizeof(*head));
    3406           2 :         head->qn_timeout = stmt->attr.qn_timeout;
    3407           4 :         head->qn_msgtext = tds_dstr_cstr(&stmt->attr.qn_msgtext);
    3408           4 :         head->qn_options = tds_dstr_cstr(&stmt->attr.qn_options);
    3409           2 :         return head;
    3410             : }
    3411             : 
    3412             : static SQLRETURN
    3413       24586 : _SQLExecute(TDS_STMT * stmt)
    3414             : {
    3415             :         TDSRET ret;
    3416             :         TDSSOCKET *tds;
    3417             :         TDS_INT result_type;
    3418       24586 :         TDS_INT done = 0;
    3419       24586 :         int in_row = 0;
    3420             :         SQLUSMALLINT param_status;
    3421       24586 :         int found_info = 0, found_error = 0;
    3422       24586 :         TDS_INT8 total_rows = TDS_NO_COUNT;
    3423             :         TDSHEADERS head;
    3424             : 
    3425       24586 :         tdsdump_log(TDS_DBG_FUNC, "_SQLExecute(%p)\n", 
    3426             :                         stmt);
    3427             : 
    3428       24586 :         stmt->row = 0;
    3429             :                 
    3430             : 
    3431             :         /* check parameters are all OK */
    3432       24586 :         if (stmt->params && stmt->param_num <= stmt->param_count) {
    3433             :                 /* TODO what error ?? */
    3434           0 :                 ODBC_SAFE_ERROR(stmt);
    3435             :                 return SQL_ERROR;
    3436             :         }
    3437             : 
    3438       24586 :         if (!odbc_lock_statement(stmt))
    3439             :                 return SQL_ERROR;
    3440             : 
    3441       24579 :         tds = stmt->tds;
    3442       24579 :         tdsdump_log(TDS_DBG_FUNC, "_SQLExecute() starting with state %d\n", tds->state);
    3443             : 
    3444       24579 :         if (tds->state != TDS_IDLE) {
    3445           0 :                 if (tds->state == TDS_DEAD) {
    3446           0 :                         odbc_errs_add(&stmt->errs, "08S01", NULL);
    3447             :                 } else {
    3448           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    3449             :                 }
    3450             :                 return SQL_ERROR;
    3451             :         }
    3452             : 
    3453       24579 :         stmt->curr_param_row = 0;
    3454       24579 :         stmt->num_param_rows = ODBC_MAX(1, stmt->apd->header.sql_desc_array_size);
    3455             : 
    3456       24579 :         stmt->row_count = TDS_NO_COUNT;
    3457             : 
    3458       24579 :         if (stmt->prepared_query_is_rpc) {
    3459             :                 /* TODO support stmt->apd->header.sql_desc_array_size for RPC */
    3460             :                 /* get rpc name */
    3461             :                 /* TODO change method */
    3462             :                 /* TODO cursor change way of calling */
    3463        1724 :                 char *name = tds_dstr_buf(&stmt->query);
    3464             :                 char *end, tmp;
    3465             : 
    3466         862 :                 end = name;
    3467         862 :                 end = (char *) odbc_skip_rpc_name(end);
    3468         862 :                 stmt->prepared_pos = end - name;
    3469         862 :                 tmp = *end;
    3470         862 :                 *end = 0;
    3471         862 :                 ret = tds_submit_rpc(tds, name, stmt->params, odbc_init_headers(stmt, &head));
    3472         862 :                 *end = tmp;
    3473       23717 :         } else if (stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY) {
    3474        1710 :                 ret = odbc_cursor_execute(stmt);
    3475       22007 :         } else if (!stmt->is_prepared_query) {
    3476             :                 /* not prepared query */
    3477             :                 /* TODO cursor change way of calling */
    3478             :                 /* SQLExecDirect */
    3479       19891 :                 if (stmt->num_param_rows <= 1) {
    3480       19835 :                         if (!stmt->params) {
    3481       38446 :                                 ret = tds_submit_query_params(tds, tds_dstr_cstr(&stmt->query), NULL, odbc_init_headers(stmt, &head));
    3482             :                         } else {
    3483        1224 :                                 ret = tds_submit_execdirect(tds, tds_dstr_cstr(&stmt->query), stmt->params, odbc_init_headers(stmt, &head));
    3484             :                         }
    3485             :                 } else {
    3486             :                         /* pack multiple submit using language */
    3487             :                         TDSMULTIPLE multiple;
    3488             : 
    3489          56 :                         ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_QUERY, odbc_init_headers(stmt, &head));
    3490         424 :                         for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
    3491             :                                 /* submit a query */
    3492         736 :                                 ret = tds_multiple_query(tds, &multiple, tds_dstr_cstr(&stmt->query), stmt->params);
    3493         368 :                                 if (++stmt->curr_param_row >= stmt->num_param_rows)
    3494             :                                         break;
    3495             :                                 /* than process others parameters */
    3496             :                                 /* TODO handle all results*/
    3497         312 :                                 if (start_parse_prepared_query(stmt, true) != SQL_SUCCESS)
    3498             :                                         break;
    3499             :                         }
    3500          56 :                         if (TDS_SUCCEED(ret))
    3501          56 :                                 ret = tds_multiple_done(tds, &multiple);
    3502             :                 }
    3503        2116 :         } else if (stmt->num_param_rows <= 1 && IS_TDS71_PLUS(tds->conn) && (!stmt->dyn || stmt->need_reprepare)) {
    3504        1324 :                         if (stmt->dyn) {
    3505          60 :                                 if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
    3506           0 :                                         ODBC_RETURN(stmt, SQL_ERROR);
    3507             :                         }
    3508        1324 :                         stmt->need_reprepare = 0;
    3509        2648 :                         ret = tds71_submit_prepexec(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params);
    3510             :         } else {
    3511             :                 /* TODO cursor change way of calling */
    3512             :                 /* SQLPrepare */
    3513             :                 TDSDYNAMIC *dyn;
    3514             : 
    3515             :                 /* prepare dynamic query (only for first SQLExecute call) */
    3516         792 :                 if (!stmt->dyn || (stmt->need_reprepare && !stmt->dyn->emulated && IS_TDS7_PLUS(tds->conn))) {
    3517             : 
    3518             :                         /* free previous prepared statement */
    3519          30 :                         if (stmt->dyn) {
    3520           0 :                                 if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
    3521           0 :                                         ODBC_RETURN(stmt, SQL_ERROR);
    3522             :                         }
    3523          30 :                         stmt->need_reprepare = 0;
    3524             : 
    3525          30 :                         tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
    3526             :                         /* TODO use tds_submit_prepexec (mssql2k, tds71) */
    3527          60 :                         if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
    3528             :                                 /* TODO ?? tds_free_param_results(params); */
    3529           0 :                                 ODBC_SAFE_ERROR(stmt);
    3530             :                                 return SQL_ERROR;
    3531             :                         }
    3532          30 :                         if (TDS_FAILED(tds_process_simple_query(tds))) {
    3533           0 :                                 tds_release_dynamic(&stmt->dyn);
    3534             :                                 /* TODO ?? tds_free_param_results(params); */
    3535           0 :                                 ODBC_SAFE_ERROR(stmt);
    3536             :                                 return SQL_ERROR;
    3537             :                         }
    3538             :                 }
    3539         792 :                 stmt->row_count = TDS_NO_COUNT;
    3540         792 :                 if (stmt->num_param_rows <= 1) {
    3541         762 :                         dyn = stmt->dyn;
    3542         762 :                         tds_free_input_params(dyn);
    3543         762 :                         dyn->params = stmt->params;
    3544             :                         /* prevent double free */
    3545         762 :                         stmt->params = NULL;
    3546         762 :                         tdsdump_log(TDS_DBG_INFO1, "End prepare, execute\n");
    3547             :                         /* TODO return error to client */
    3548         762 :                         ret = tds_submit_execute(tds, dyn);
    3549             :                 } else {
    3550             :                         TDSMULTIPLE multiple;
    3551             : 
    3552          30 :                         ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_EXECUTE, NULL);
    3553         330 :                         for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
    3554         300 :                                 dyn = stmt->dyn;
    3555         300 :                                 tds_free_input_params(dyn);
    3556         300 :                                 dyn->params = stmt->params;
    3557             :                                 /* prevent double free */
    3558         300 :                                 stmt->params = NULL;
    3559         300 :                                 ret = tds_multiple_execute(tds, &multiple, dyn);
    3560         300 :                                 if (++stmt->curr_param_row >= stmt->num_param_rows)
    3561             :                                         break;
    3562             :                                 /* than process others parameters */
    3563             :                                 /* TODO handle all results*/
    3564         270 :                                 if (start_parse_prepared_query(stmt, true) != SQL_SUCCESS)
    3565             :                                         break;
    3566             :                         }
    3567          30 :                         if (TDS_SUCCEED(ret))
    3568          30 :                                 ret = tds_multiple_done(tds, &multiple);
    3569             :                 }
    3570             :         }
    3571       24579 :         if (TDS_FAILED(ret)) {
    3572          16 :                 ODBC_SAFE_ERROR(stmt);
    3573             :                 return SQL_ERROR;
    3574             :         }
    3575             :         /* catch all errors */
    3576       24563 :         if (!odbc_lock_statement(stmt))
    3577           0 :                 ODBC_RETURN_(stmt);
    3578             : 
    3579       24563 :         stmt->row_status = PRE_NORMAL_ROW;
    3580             : 
    3581       24563 :         stmt->curr_param_row = 0;
    3582       24563 :         param_status = SQL_PARAM_SUCCESS;
    3583             : 
    3584             :         /* TODO review this, ODBC return parameter in other way, for compute I don't know */
    3585             :         /* TODO perhaps we should return SQL_NO_DATA if no data available... see old SQLExecute code */
    3586             :         for (;;) {
    3587       40744 :                 result_type = odbc_process_tokens(stmt, TDS_TOKEN_RESULTS);
    3588       40744 :                 tdsdump_log(TDS_DBG_FUNC, "_SQLExecute: odbc_process_tokens returned result_type %d\n", result_type);
    3589       40744 :                 switch (result_type) {
    3590       21532 :                 case TDS_CMD_FAIL:
    3591             :                 case TDS_CMD_DONE:
    3592             :                 case TDS_COMPUTE_RESULT:
    3593             :                 case TDS_ROW_RESULT:
    3594       21532 :                         done = 1;
    3595       21532 :                         break;
    3596             : 
    3597        3549 :                 case TDS_DONE_RESULT:
    3598             :                 case TDS_DONEPROC_RESULT:
    3599        3549 :                         switch (stmt->errs.lastrc) {
    3600         642 :                         case SQL_ERROR:
    3601         642 :                                 found_error = 1;
    3602         642 :                                 param_status = SQL_PARAM_ERROR;
    3603         642 :                                 break;
    3604         452 :                         case SQL_SUCCESS_WITH_INFO:
    3605         452 :                                 found_info = 1;
    3606         452 :                                 param_status = SQL_PARAM_SUCCESS_WITH_INFO;
    3607         452 :                                 break;
    3608             :                         }
    3609        3549 :                         if (stmt->curr_param_row < stmt->num_param_rows && stmt->ipd->header.sql_desc_array_status_ptr)
    3610         620 :                                 stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    3611        3549 :                         param_status = SQL_PARAM_SUCCESS;
    3612        3549 :                         ++stmt->curr_param_row;
    3613             :                         /* actually is quite strange, if prepared always success with info or success
    3614             :                          * if not prepared return last one
    3615             :                          */
    3616        3549 :                         if (stmt->curr_param_row < stmt->num_param_rows || result_type == TDS_DONEPROC_RESULT)
    3617         968 :                                 stmt->errs.lastrc = SQL_SUCCESS;
    3618        3549 :                         if (total_rows == TDS_NO_COUNT)
    3619        3095 :                                 total_rows = stmt->row_count;
    3620         454 :                         else if (stmt->row_count != TDS_NO_COUNT)
    3621         378 :                                 total_rows += stmt->row_count;
    3622        3549 :                         stmt->row_count = TDS_NO_COUNT;
    3623        3549 :                         if (stmt->curr_param_row >= stmt->num_param_rows) {
    3624        2967 :                                 done = 1;
    3625        2967 :                                 break;
    3626             :                         }
    3627             :                         break;
    3628             : 
    3629        7890 :                 case TDS_DONEINPROC_RESULT:
    3630        7890 :                         if (in_row)
    3631          64 :                                 done = 1;
    3632             :                         break;
    3633             : 
    3634             :                         /* ignore metadata, stop at done or row */
    3635        7738 :                 case TDS_ROWFMT_RESULT:
    3636        7738 :                         if (in_row) {
    3637             :                                 done = 1;
    3638             :                                 break;
    3639             :                         }
    3640        7738 :                         stmt->row = 0;
    3641        7738 :                         stmt->row_count = TDS_NO_COUNT;
    3642        7738 :                         stmt->row_status = PRE_NORMAL_ROW;
    3643        7738 :                         in_row = 1;
    3644        7738 :                         break;
    3645             :                 }
    3646       40744 :                 if (done)
    3647             :                         break;
    3648             :         }
    3649       24563 :         if ((found_info || found_error) && stmt->errs.lastrc != SQL_ERROR)
    3650         496 :                 stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    3651       73689 :         if (tds_dstr_isempty(&stmt->attr.qn_msgtext) != tds_dstr_isempty(&stmt->attr.qn_options)) {
    3652           0 :                 odbc_errs_add(&stmt->errs, "HY000", "Attribute ignored");
    3653           0 :                 stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    3654             :         }
    3655       24563 :         if (found_error && stmt->num_param_rows <= 1)
    3656         276 :                 stmt->errs.lastrc = SQL_ERROR;
    3657       24563 :         if (stmt->curr_param_row < stmt->num_param_rows) {
    3658       21596 :                 if (stmt->ipd->header.sql_desc_array_status_ptr)
    3659           0 :                         stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
    3660       21596 :                 ++stmt->curr_param_row;
    3661       21596 :                 if (total_rows == TDS_NO_COUNT)
    3662       21596 :                         total_rows = stmt->row_count;
    3663           0 :                 else if (stmt->row_count != TDS_NO_COUNT)
    3664           0 :                         total_rows += stmt->row_count;
    3665       21596 :                 stmt->row_count = TDS_NO_COUNT;
    3666             :         }
    3667       24563 :         if (stmt->ipd->header.sql_desc_rows_processed_ptr)
    3668          86 :                 *stmt->ipd->header.sql_desc_rows_processed_ptr = ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows);
    3669             : 
    3670       24563 :         if (total_rows != TDS_NO_COUNT)
    3671        6271 :                 stmt->row_count = total_rows;
    3672             : 
    3673       24563 :         odbc_populate_ird(stmt);
    3674       24563 :         switch (result_type) {
    3675       13794 :         case TDS_CMD_DONE:
    3676       13794 :                 odbc_unlock_statement(stmt);
    3677       13794 :                 if (stmt->errs.lastrc == SQL_SUCCESS && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3
    3678       11360 :                     && stmt->row_count == TDS_NO_COUNT && !stmt->cursor && stmt->ird->header.sql_desc_count <= 0)
    3679        7910 :                         ODBC_RETURN(stmt, SQL_NO_DATA);
    3680             :                 break;
    3681             : 
    3682         168 :         case TDS_CMD_FAIL:
    3683             :                 /* TODO test what happened, report correct error to client */
    3684         168 :                 tdsdump_log(TDS_DBG_INFO1, "SQLExecute: bad results\n");
    3685         168 :                 ODBC_SAFE_ERROR(stmt);
    3686             :                 return SQL_ERROR;
    3687             :         }
    3688       16485 :         ODBC_RETURN_(stmt);
    3689             : }
    3690             : 
    3691       20752 : ODBC_FUNC(SQLExecDirect, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
    3692             : {
    3693             :         SQLRETURN res;
    3694             : 
    3695       20752 :         ODBC_ENTER_HSTMT;
    3696             : 
    3697       20752 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide)) {
    3698           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    3699           0 :                 ODBC_EXIT_(stmt);
    3700             :         }
    3701             : 
    3702             :         /* count placeholders */
    3703             :         /* note: szSqlStr can be no-null terminated, so first we set query and then count placeholders */
    3704       41504 :         stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
    3705       20752 :         stmt->param_data_called = 0;
    3706             : 
    3707       20752 :         if (SQL_SUCCESS != prepare_call(stmt)) {
    3708             :                 /* TODO return another better error, prepare_call should set error ?? */
    3709           0 :                 odbc_errs_add(&stmt->errs, "HY000", "Could not prepare call");
    3710           0 :                 ODBC_EXIT_(stmt);
    3711             :         }
    3712             : 
    3713       20752 :         res = start_parse_prepared_query(stmt, true);
    3714       20752 :         if (SQL_SUCCESS != res)
    3715          72 :                 ODBC_EXIT(stmt, res);
    3716             : 
    3717       20680 :         ODBC_EXIT(stmt, _SQLExecute(stmt));
    3718             : }
    3719             : 
    3720             : SQLRETURN ODBC_PUBLIC ODBC_API
    3721             : SQLExecute(SQLHSTMT hstmt)
    3722             : {
    3723             :         ODBC_PRRET_BUF;
    3724             :         SQLRETURN res;
    3725             : 
    3726        3580 :         ODBC_ENTER_HSTMT;
    3727             : 
    3728        3580 :         tdsdump_log(TDS_DBG_FUNC, "SQLExecute(%p)\n", hstmt);
    3729             : 
    3730        3580 :         if (!stmt->is_prepared_query) {
    3731             :                 /* TODO error report, only without DM ?? */
    3732           0 :                 tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns SQL_ERROR (not prepared)\n");
    3733           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    3734             :         }
    3735             : 
    3736             :         /* TODO rebuild should be done for every bindings change, not every time */
    3737             :         /* TODO free previous parameters */
    3738             :         /* build parameters list */
    3739        3580 :         stmt->param_data_called = 0;
    3740        3580 :         stmt->curr_param_row = 0;
    3741        3580 :         if ((res = start_parse_prepared_query(stmt, true)) != SQL_SUCCESS) {
    3742          88 :                 tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s (start_parse_prepared_query failed)\n", odbc_prret(res));
    3743          88 :                 ODBC_EXIT(stmt, res);
    3744             :         }
    3745             : 
    3746             :         /* TODO test if two SQLPrepare on a statement */
    3747             :         /* TODO test unprepare on statement free or connection close */
    3748             : 
    3749        3492 :         res = _SQLExecute(stmt);
    3750             : 
    3751        3492 :         tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s\n", odbc_prret(res));
    3752             : 
    3753        3492 :         ODBC_EXIT(stmt, res);
    3754             : }
    3755             : 
    3756             : static int
    3757      103422 : odbc_process_tokens(TDS_STMT * stmt, unsigned flag)
    3758             : {
    3759             :         TDS_INT result_type;
    3760      103422 :         int done_flags = 0;
    3761      103422 :         TDSSOCKET * tds = stmt->tds;
    3762             : 
    3763      103422 :         flag |= TDS_RETURN_DONE | TDS_RETURN_PROC;
    3764             :         for (;;) {
    3765      140482 :                 TDSRET retcode = tds_process_tokens(tds, &result_type, &done_flags, flag);
    3766      140482 :                 tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: tds_process_tokens returned %d\n", retcode);
    3767      140482 :                 tdsdump_log(TDS_DBG_FUNC, "    result_type=%d, TDS_DONE_COUNT=%x, TDS_DONE_ERROR=%x\n", 
    3768             :                                                 result_type, (done_flags & TDS_DONE_COUNT), (done_flags & TDS_DONE_ERROR));
    3769      140482 :                 switch (retcode) {
    3770             :                 case TDS_SUCCESS:
    3771             :                         break;
    3772             :                 case TDS_NO_MORE_RESULTS:
    3773             :                         return TDS_CMD_DONE;
    3774         160 :                 case TDS_CANCELLED:
    3775         160 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
    3776             :                 default:
    3777             :                         return TDS_CMD_FAIL;
    3778             :                 }
    3779             : 
    3780      117451 :                 switch (result_type) {
    3781         952 :                 case TDS_STATUS_RESULT:
    3782         952 :                         odbc_set_return_status(stmt, ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
    3783         952 :                         break;
    3784         648 :                 case TDS_PARAM_RESULT:
    3785         648 :                         odbc_set_return_params(stmt, ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
    3786         648 :                         break;
    3787             : 
    3788       77149 :                 case TDS_DONE_RESULT:
    3789             :                 case TDS_DONEPROC_RESULT:
    3790       77149 :                         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3791       71939 :                                 flag |= TDS_STOPAT_MSG;
    3792       77149 :                         if (done_flags & TDS_DONE_COUNT) {
    3793             :                                 /* correct ?? overwrite ?? */
    3794       40777 :                                 if (stmt->row_count == TDS_NO_COUNT)
    3795       40777 :                                         stmt->row_count = tds->rows_affected;
    3796             :                         }
    3797       77149 :                         if (done_flags & TDS_DONE_ERROR)
    3798         452 :                                 stmt->errs.lastrc = SQL_ERROR;
    3799             :                         /* test for internal_sp not very fine, used for param set  -- freddy77 */
    3800       77149 :                         if ((done_flags & (TDS_DONE_COUNT|TDS_DONE_ERROR)) != 0
    3801       35984 :                             || (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3802       35512 :                             || (result_type == TDS_DONEPROC_RESULT && tds->current_op == TDS_OP_EXECUTE)) {
    3803             :                                 /* FIXME this row is used only as a flag for update binding, should be cleared if binding/result changed */
    3804       42297 :                                 stmt->row = 0;
    3805             : #if 0
    3806             :                                 tds_free_all_results(tds);
    3807             :                                 odbc_populate_ird(stmt);
    3808             : #endif
    3809       42297 :                                 tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: row_count=%" PRId64 "\n", stmt->row_count);
    3810       42297 :                                 return result_type;
    3811             :                         }
    3812       34852 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed %s\n", 
    3813             :                                         result_type==TDS_DONE_RESULT? "TDS_DONE_RESULT" : "TDS_DONEPROC_RESULT");
    3814             :                         break;
    3815             : 
    3816             :                 /*
    3817             :                  * TODO test flags ? check error and change result ?
    3818             :                  * see also other DONEINPROC handle (below)
    3819             :                  */
    3820        8574 :                 case TDS_DONEINPROC_RESULT:
    3821        8574 :                         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
    3822        4786 :                                 flag |= TDS_STOPAT_MSG;
    3823        8574 :                         if (done_flags & TDS_DONE_COUNT) {
    3824        5402 :                                 stmt->row_count = tds->rows_affected;
    3825             :                         }
    3826        8574 :                         if (done_flags & TDS_DONE_ERROR)
    3827         256 :                                 stmt->errs.lastrc = SQL_ERROR;
    3828             :                         /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
    3829             : #if 0
    3830             :                         tds_free_all_results(tds);
    3831             :                         odbc_populate_ird(stmt);
    3832             : #endif
    3833        8574 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed TDS_DONEINPROC_RESULT\n");
    3834        8574 :                         if (stmt->row_status == PRE_NORMAL_ROW)
    3835        7966 :                                 return result_type;
    3836             :                         break;
    3837             : 
    3838       30128 :                 default:
    3839       30128 :                         tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: returning result_type %d\n", result_type);
    3840       30128 :                         return result_type;
    3841             :                 }
    3842             :         }
    3843             : }
    3844             : 
    3845             : static void
    3846         160 : odbc_fix_data_type_col(TDS_STMT *stmt, int idx)
    3847             : {
    3848         160 :         TDSSOCKET *tds = stmt->tds;
    3849             :         TDSRESULTINFO *resinfo;
    3850             :         TDSCOLUMN *colinfo;
    3851             : 
    3852         160 :         if (!tds)
    3853             :                 return;
    3854             : 
    3855         160 :         resinfo = tds->current_results;
    3856         160 :         if (!resinfo || resinfo->num_cols <= idx)
    3857             :                 return;
    3858             : 
    3859         160 :         colinfo = resinfo->columns[idx];
    3860         160 :         if (colinfo->column_cur_size < 0)
    3861             :                 return;
    3862             : 
    3863         160 :         switch (tds_get_conversion_type(colinfo->column_type, colinfo->column_size)) {
    3864         160 :         case SYBINT2: {
    3865         160 :                 TDS_SMALLINT *data = (TDS_SMALLINT *) colinfo->column_data;
    3866         320 :                 *data = odbc_swap_datetime_sql_type(*data, 0);
    3867             :                 }
    3868         160 :                 break;
    3869           0 :         case SYBINT4: {
    3870           0 :                 TDS_INT *data = (TDS_INT *) colinfo->column_data;
    3871           0 :                 *data = odbc_swap_datetime_sql_type(*data, 0);
    3872             :                 }
    3873           0 :                 break;
    3874             :         default:
    3875             :                 break;
    3876             :         }
    3877             : }
    3878             : 
    3879             : /*
    3880             :  * - handle correctly SQLGetData (for forward cursors accept only row_size == 1
    3881             :  *   for other types application must use SQLSetPos)
    3882             :  * - handle correctly results (SQL_SUCCESS_WITH_INFO if error on some rows,
    3883             :  *   SQL_ERROR for all rows, see doc)
    3884             :  */
    3885             : static SQLRETURN
    3886       19442 : _SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
    3887             : {
    3888             :         TDSSOCKET *tds;
    3889             :         TDSRESULTINFO *resinfo;
    3890             :         TDSCOLUMN *colinfo;
    3891             :         int i;
    3892             :         SQLULEN curr_row, num_rows;
    3893       19442 :         SQLINTEGER len = 0;
    3894             :         struct _drecord *drec_ard;
    3895             :         TDS_DESC *ard;
    3896             :         SQLULEN dummy, *fetched_ptr;
    3897             :         SQLUSMALLINT *status_ptr, row_status;
    3898             :         TDS_INT result_type;
    3899       19442 :         int truncated = 0;
    3900             : 
    3901             : #define AT_ROW(ptr, type) (row_offset ? (type*)(((char*)(ptr)) + row_offset) : &ptr[curr_row])
    3902       19442 :         SQLLEN row_offset = 0;
    3903             : 
    3904       19442 :         tdsdump_log(TDS_DBG_FUNC, "_SQLFetch(%p, %d, %d)\n", stmt, (int)FetchOrientation, (int)FetchOffset);
    3905             : 
    3906       19442 :         if (stmt->ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN && stmt->ard->header.sql_desc_bind_offset_ptr)
    3907           0 :                 row_offset = *stmt->ard->header.sql_desc_bind_offset_ptr;
    3908             : 
    3909       19442 :         ard = stmt->ard;
    3910             : 
    3911       19442 :         tds = stmt->tds;
    3912       19442 :         num_rows = ard->header.sql_desc_array_size;
    3913             : 
    3914             :         /* TODO cursor check also type of cursor (scrollable, not forward) */
    3915       19442 :         if (FetchOrientation != SQL_FETCH_NEXT && (!stmt->cursor || !stmt->dbc->cursor_support)) {
    3916           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
    3917           0 :                 return SQL_ERROR;
    3918             :         }
    3919             : 
    3920             :         /* handle cursors, fetch wanted rows */
    3921       19442 :         if (stmt->cursor && odbc_lock_statement(stmt)) {
    3922         522 :                 TDSCURSOR *cursor = stmt->cursor;
    3923         522 :                 TDS_CURSOR_FETCH fetch_type = TDS_CURSOR_FETCH_NEXT;
    3924             : 
    3925         522 :                 tds = stmt->tds;
    3926             : 
    3927         522 :                 switch (FetchOrientation) {
    3928             :                 case SQL_FETCH_NEXT:
    3929             :                         break;
    3930          12 :                 case SQL_FETCH_FIRST:
    3931          12 :                         fetch_type = TDS_CURSOR_FETCH_FIRST;
    3932          12 :                         break;
    3933          18 :                 case SQL_FETCH_LAST:
    3934          18 :                         fetch_type = TDS_CURSOR_FETCH_LAST;
    3935          18 :                         break;
    3936          24 :                 case SQL_FETCH_PRIOR:
    3937          24 :                         fetch_type = TDS_CURSOR_FETCH_PREV;
    3938          24 :                         break;
    3939          12 :                 case SQL_FETCH_ABSOLUTE:
    3940          12 :                         fetch_type = TDS_CURSOR_FETCH_ABSOLUTE;
    3941          12 :                         break;
    3942          42 :                 case SQL_FETCH_RELATIVE:
    3943          42 :                         fetch_type = TDS_CURSOR_FETCH_RELATIVE;
    3944          42 :                         break;
    3945             :                 /* TODO cursor bookmark */
    3946           0 :                 default:
    3947           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    3948           0 :                         return SQL_ERROR;
    3949             :                 }
    3950             : 
    3951         522 :                 if (cursor->cursor_rows != num_rows) {
    3952         186 :                         int send = 0;
    3953         186 :                         cursor->cursor_rows = num_rows;
    3954             :                         /* TODO handle change rows (tds5) */
    3955             :                         /*
    3956             :                          * TODO curerntly we support cursors only using tds7+
    3957             :                          * so this function can't fail but remember to add error
    3958             :                          * check when tds5 will be supported
    3959             :                          */
    3960         186 :                         tds_cursor_setrows(tds, cursor, &send);
    3961             :                 }
    3962             : 
    3963         522 :                 if (TDS_FAILED(tds_cursor_fetch(tds, cursor, fetch_type, FetchOffset))) {
    3964             :                         /* TODO what kind of error ?? */
    3965           0 :                         ODBC_SAFE_ERROR(stmt);
    3966             :                         return SQL_ERROR;
    3967             :                 }
    3968             : 
    3969             :                 /* TODO handle errors in a better way */
    3970         522 :                 odbc_process_tokens(stmt, TDS_RETURN_ROW|TDS_STOPAT_COMPUTE|TDS_STOPAT_ROW);
    3971         522 :                 stmt->row_status = PRE_NORMAL_ROW;
    3972             :         }
    3973             : 
    3974       19442 :         if (!tds && stmt->row_status == PRE_NORMAL_ROW && stmt->ird->header.sql_desc_count > 0)
    3975           8 :                 ODBC_RETURN(stmt, SQL_NO_DATA);
    3976       19434 :         if (!tds || stmt->row_status == NOT_IN_ROW) {
    3977          24 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    3978          24 :                 return SQL_ERROR;
    3979             :         }
    3980       19410 :         IRD_CHECK;
    3981             : 
    3982       19410 :         if (stmt->ird->header.sql_desc_count <= 0) {
    3983          26 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    3984          26 :                 return SQL_ERROR;
    3985             :         }
    3986             : 
    3987       19384 :         stmt->row++;
    3988             : 
    3989       19384 :         fetched_ptr = &dummy;
    3990       19384 :         if (stmt->ird->header.sql_desc_rows_processed_ptr)
    3991         476 :                 fetched_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    3992       19384 :         *fetched_ptr = 0;
    3993             : 
    3994       19384 :         status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    3995       19384 :         if (status_ptr) {
    3996        2048 :                 for (i = 0; i < num_rows; ++i)
    3997        2048 :                         *status_ptr++ = SQL_ROW_NOROW;
    3998             :                 status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    3999             :         }
    4000             : 
    4001             :         curr_row = 0;
    4002             :         do {
    4003       20722 :                 row_status = SQL_ROW_SUCCESS;
    4004             : 
    4005             :                 /* do not get compute row if we are not expecting a compute row */
    4006       20722 :                 switch (stmt->row_status) {
    4007          32 :                 case AFTER_COMPUTE_ROW:
    4008             :                         /* handle done if needed */
    4009             :                         /* FIXME doesn't seem so fine ... - freddy77 */
    4010          32 :                         tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
    4011          32 :                         goto all_done;
    4012             : 
    4013          32 :                 case IN_COMPUTE_ROW:
    4014             :                         /* compute recorset contains only a row */
    4015             :                         /* we already fetched compute row in SQLMoreResults so do not fetch another one */
    4016          32 :                         num_rows = 1;
    4017          32 :                         stmt->row_status = AFTER_COMPUTE_ROW;
    4018          32 :                         break;
    4019             : 
    4020       20658 :                 default:
    4021             :                         /* FIXME stmt->row_count set correctly ?? TDS_DONE_COUNT not checked */
    4022       20658 :                         switch (odbc_process_tokens(stmt, TDS_STOPAT_ROWFMT|TDS_RETURN_ROW|TDS_STOPAT_COMPUTE)) {
    4023             :                         case TDS_ROW_RESULT:
    4024             :                                 break;
    4025        7012 :                         default:
    4026             : #if 0
    4027             :                                 stmt->row_count = tds->rows_affected;
    4028             : #endif
    4029             :                                 /* 
    4030             :                                  * NOTE do not set row_status to NOT_IN_ROW, 
    4031             :                                  * if compute tds_process_tokens above returns TDS_NO_MORE_RESULTS
    4032             :                                  */
    4033        7012 :                                 stmt->row_status = PRE_NORMAL_ROW;
    4034        7012 :                                 stmt->special_row = ODBC_SPECIAL_NONE;
    4035             : #if 0
    4036             :                                 odbc_populate_ird(stmt);
    4037             : #endif
    4038        7012 :                                 tdsdump_log(TDS_DBG_INFO1, "SQLFetch: NO_DATA_FOUND\n");
    4039             :                                 goto all_done;
    4040             :                                 break;
    4041           0 :                         case TDS_CMD_FAIL:
    4042           0 :                                 ODBC_SAFE_ERROR(stmt);
    4043             :                                 return SQL_ERROR;
    4044             :                                 break;
    4045             :                         }
    4046             : 
    4047       13646 :                         stmt->row_status = IN_NORMAL_ROW;
    4048             : 
    4049             :                         /* handle special row */
    4050       13646 :                         switch (stmt->special_row) {
    4051         148 :                         case ODBC_SPECIAL_GETTYPEINFO:
    4052         148 :                                 odbc_fix_data_type_col(stmt, 1);
    4053         148 :                                 break;
    4054           4 :                         case ODBC_SPECIAL_COLUMNS:
    4055           4 :                                 odbc_fix_data_type_col(stmt, 4);
    4056           4 :                                 odbc_fix_data_type_col(stmt, 13); /* TODO sure ?? */
    4057           4 :                                 break;
    4058           2 :                         case ODBC_SPECIAL_PROCEDURECOLUMNS:
    4059           2 :                                 odbc_fix_data_type_col(stmt, 5);
    4060           2 :                                 odbc_fix_data_type_col(stmt, 14); /* TODO sure ?? */
    4061           2 :                                 break;
    4062           0 :                         case ODBC_SPECIAL_SPECIALCOLUMNS:
    4063           0 :                                 odbc_fix_data_type_col(stmt, 2);
    4064           0 :                                 break;
    4065             :                         case ODBC_SPECIAL_NONE:
    4066             :                                 break;
    4067             :                         }
    4068             :                 }
    4069             : 
    4070       13678 :                 resinfo = tds->current_results;
    4071       13678 :                 if (!resinfo) {
    4072           0 :                         tdsdump_log(TDS_DBG_INFO1, "SQLFetch: !resinfo\n");
    4073             :                         break;
    4074             :                 }
    4075             : 
    4076             :                 /* we got a row, return a row readed even if error (for ODBC specifications) */
    4077       13678 :                 ++(*fetched_ptr);
    4078       66568 :                 for (i = 0; i < resinfo->num_cols; i++) {
    4079       52890 :                         colinfo = resinfo->columns[i];
    4080       52890 :                         colinfo->column_text_sqlgetdatapos = 0;
    4081       52890 :                         colinfo->column_iconv_left = 0;
    4082       52890 :                         drec_ard = (i < ard->header.sql_desc_count) ? &ard->records[i] : NULL;
    4083       14898 :                         if (!drec_ard)
    4084       37992 :                                 continue;
    4085       14898 :                         if (colinfo->column_cur_size < 0) {
    4086        1890 :                                 if (drec_ard->sql_desc_indicator_ptr) {
    4087        1010 :                                         *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = SQL_NULL_DATA;
    4088         880 :                                 } else if (drec_ard->sql_desc_data_ptr) {
    4089           0 :                                         odbc_errs_add(&stmt->errs, "22002", NULL);
    4090           0 :                                         row_status = SQL_ROW_ERROR;
    4091           0 :                                         break;
    4092             :                                 }
    4093        1890 :                                 continue;
    4094             :                         }
    4095             :                         /* set indicator to 0 if data is not null */
    4096       13008 :                         if (drec_ard->sql_desc_indicator_ptr)
    4097        9060 :                                 *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = 0;
    4098             : 
    4099             :                         /* TODO what happen to length if no data is returned (drec->sql_desc_data_ptr == NULL) ?? */
    4100       13008 :                         len = 0;
    4101       13008 :                         if (drec_ard->sql_desc_data_ptr) {
    4102             :                                 int c_type;
    4103        8838 :                                 TDS_CHAR *data_ptr = (TDS_CHAR *) drec_ard->sql_desc_data_ptr;
    4104             : 
    4105        8838 :                                 colinfo->column_text_sqlgetdatapos = 0;
    4106        8838 :                                 colinfo->column_iconv_left = 0;
    4107        8838 :                                 c_type = drec_ard->sql_desc_concise_type;
    4108        8838 :                                 if (c_type == SQL_C_DEFAULT)
    4109           8 :                                         c_type = odbc_sql_to_c_type_default(stmt->ird->records[i].sql_desc_concise_type);
    4110        8838 :                                 if (row_offset || curr_row == 0) {
    4111        7954 :                                         data_ptr += row_offset;
    4112             :                                 } else {
    4113         884 :                                         data_ptr += odbc_get_octet_len(c_type, drec_ard) * curr_row;
    4114             :                                 }
    4115        8838 :                                 len = odbc_tds2sql_col(stmt, colinfo, c_type, data_ptr, drec_ard->sql_desc_octet_length, drec_ard);
    4116        8838 :                                 if (len == SQL_NULL_DATA) {
    4117             :                                         row_status = SQL_ROW_ERROR;
    4118             :                                         break;
    4119             :                                 }
    4120        8838 :                                 if ((c_type == SQL_C_CHAR && len >= drec_ard->sql_desc_octet_length)
    4121        8692 :                                     || (c_type == SQL_C_BINARY && len > drec_ard->sql_desc_octet_length)) {
    4122         146 :                                         truncated = 1;
    4123         146 :                                         stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    4124             :                                 }
    4125             :                         }
    4126       13008 :                         if (drec_ard->sql_desc_octet_length_ptr)
    4127        9060 :                                 *AT_ROW(drec_ard->sql_desc_octet_length_ptr, SQLLEN) = len;
    4128             :                 }
    4129             : 
    4130       13678 :                 if (status_ptr)
    4131        1590 :                         *status_ptr++ = truncated ? SQL_ROW_ERROR : row_status;
    4132       13678 :                 if (row_status == SQL_ROW_ERROR) {
    4133           0 :                         stmt->errs.lastrc = SQL_ERROR;
    4134           0 :                         break;
    4135             :                 }
    4136             : #if SQL_BIND_BY_COLUMN != 0
    4137             :                 if (stmt->ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN)
    4138             : #endif
    4139       13678 :                         row_offset += stmt->ard->header.sql_desc_bind_type;
    4140       13678 :         } while (++curr_row < num_rows);
    4141             : 
    4142       12340 :         if (truncated)
    4143          74 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    4144             : 
    4145       31650 :       all_done:
    4146             :         /* TODO cursor correct ?? */
    4147       19384 :         if (stmt->cursor) {
    4148         522 :                 tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
    4149         522 :                 odbc_unlock_statement(stmt);
    4150             :         }
    4151       19384 :         if (*fetched_ptr == 0 && (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO))
    4152        6932 :                 ODBC_RETURN(stmt, SQL_NO_DATA);
    4153       12452 :         if (stmt->errs.lastrc == SQL_ERROR && (*fetched_ptr > 1 || (*fetched_ptr == 1 && row_status != SQL_ROW_ERROR)))
    4154           0 :                 ODBC_RETURN(stmt, SQL_SUCCESS_WITH_INFO);
    4155       12452 :         ODBC_RETURN_(stmt);
    4156             : }
    4157             : 
    4158             : SQLRETURN ODBC_PUBLIC ODBC_API
    4159             : SQLFetch(SQLHSTMT hstmt)
    4160             : {
    4161             :         SQLRETURN ret;
    4162             :         struct {
    4163             :                 SQLULEN  array_size;
    4164             :                 SQLULEN *rows_processed_ptr;
    4165             :                 SQLUSMALLINT *array_status_ptr;
    4166             :         } keep;
    4167             :         
    4168       18952 :         ODBC_ENTER_HSTMT;
    4169             : 
    4170       18952 :         tdsdump_log(TDS_DBG_FUNC, "SQLFetch(%p)\n", hstmt);
    4171             : 
    4172       18952 :         keep.array_size = stmt->ard->header.sql_desc_array_size;
    4173       18952 :         keep.rows_processed_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    4174       18952 :         keep.array_status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    4175             :         
    4176       18952 :         if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
    4177        3504 :                 stmt->ard->header.sql_desc_array_size = 1;
    4178        3504 :                 stmt->ird->header.sql_desc_rows_processed_ptr = NULL;
    4179        3504 :                 stmt->ird->header.sql_desc_array_status_ptr = NULL;
    4180             :         }
    4181             : 
    4182       18952 :         ret = _SQLFetch(stmt, SQL_FETCH_NEXT, 0);
    4183             : 
    4184       18952 :         if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
    4185        3504 :                 stmt->ard->header.sql_desc_array_size = keep.array_size;
    4186        3504 :                 stmt->ird->header.sql_desc_rows_processed_ptr = keep.rows_processed_ptr;
    4187        3504 :                 stmt->ird->header.sql_desc_array_status_ptr = keep.array_status_ptr;
    4188             :         }
    4189             : 
    4190       18952 :         ODBC_EXIT(stmt, ret);
    4191             : }
    4192             : 
    4193             : #if (ODBCVER >= 0x0300)
    4194             : SQLRETURN ODBC_PUBLIC ODBC_API
    4195             : SQLFetchScroll(SQLHSTMT hstmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
    4196             : {
    4197         476 :         ODBC_ENTER_HSTMT;
    4198             : 
    4199         476 :         tdsdump_log(TDS_DBG_FUNC, "SQLFetchScroll(%p, %d, %d)\n", hstmt, FetchOrientation, (int)FetchOffset);
    4200             : 
    4201         476 :         if (FetchOrientation != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
    4202           0 :                 odbc_errs_add(&stmt->errs, "HY106", NULL);
    4203           0 :                 ODBC_EXIT_(stmt);
    4204             :         }
    4205             : 
    4206         476 :         ODBC_EXIT(stmt, _SQLFetch(stmt, FetchOrientation, FetchOffset));
    4207             : }
    4208             : #endif
    4209             : 
    4210             : 
    4211             : #if (ODBCVER >= 0x0300)
    4212             : SQLRETURN ODBC_PUBLIC ODBC_API
    4213             : SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
    4214             : {
    4215         108 :         tdsdump_log(TDS_DBG_INFO1, "SQLFreeHandle(%d, %p)\n", HandleType, (void *) Handle);
    4216             : 
    4217         108 :         switch (HandleType) {
    4218         100 :         case SQL_HANDLE_STMT:
    4219         100 :                 return _SQLFreeStmt(Handle, SQL_DROP, 0);
    4220             :                 break;
    4221           0 :         case SQL_HANDLE_DBC:
    4222           0 :                 return _SQLFreeConnect(Handle);
    4223             :                 break;
    4224           0 :         case SQL_HANDLE_ENV:
    4225           0 :                 return _SQLFreeEnv(Handle);
    4226             :                 break;
    4227           8 :         case SQL_HANDLE_DESC:
    4228           8 :                 return _SQLFreeDesc(Handle);
    4229             :                 break;
    4230             :         }
    4231             :         return SQL_ERROR;
    4232             : }
    4233             : 
    4234             : static SQLRETURN
    4235         900 : _SQLFreeConnect(SQLHDBC hdbc)
    4236             : {
    4237             :         int i;
    4238             : 
    4239         900 :         ODBC_ENTER_HDBC;
    4240             : 
    4241         900 :         tdsdump_log(TDS_DBG_FUNC, "_SQLFreeConnect(%p)\n", 
    4242             :                         hdbc);
    4243             : 
    4244         900 :         tds_close_socket(dbc->tds_socket);
    4245             : 
    4246             :         /* TODO if connected return error */
    4247         900 :         tds_free_socket(dbc->tds_socket);
    4248             : 
    4249         900 :         odbc_bcp_free_storage(dbc);
    4250             :         /* free attributes */
    4251             : #ifdef TDS_NO_DM
    4252         900 :         tds_dstr_free(&dbc->attr.tracefile);
    4253             : #endif
    4254         900 :         tds_dstr_free(&dbc->attr.current_catalog);
    4255         900 :         tds_dstr_free(&dbc->attr.translate_lib);
    4256         900 :         tds_dstr_zero(&dbc->oldpwd);
    4257         900 :         tds_dstr_free(&dbc->oldpwd);
    4258             : 
    4259         900 :         tds_dstr_free(&dbc->dsn);
    4260             : 
    4261       90900 :         for (i = 0; i < TDS_MAX_APP_DESC; i++) {
    4262       90000 :                 if (dbc->uad[i]) {
    4263           0 :                         desc_free(dbc->uad[i]);
    4264             :                 }
    4265             :         }
    4266         900 :         odbc_errs_reset(&dbc->errs);
    4267         900 :         tds_mutex_unlock(&dbc->mtx);
    4268         900 :         tds_mutex_free(&dbc->mtx);
    4269             : 
    4270         900 :         free(dbc);
    4271             : 
    4272         900 :         return SQL_SUCCESS;
    4273             : }
    4274             : 
    4275             : SQLRETURN ODBC_PUBLIC ODBC_API
    4276             : SQLFreeConnect(SQLHDBC hdbc)
    4277             : {
    4278         900 :         tdsdump_log(TDS_DBG_INFO2, "SQLFreeConnect(%p)\n", hdbc);
    4279         900 :         return _SQLFreeConnect(hdbc);
    4280             : }
    4281             : #endif
    4282             : 
    4283             : static SQLRETURN
    4284         900 : _SQLFreeEnv(SQLHENV henv)
    4285             : {
    4286         900 :         ODBC_ENTER_HENV;
    4287             : 
    4288         900 :         tdsdump_log(TDS_DBG_FUNC, "_SQLFreeEnv(%p)\n", 
    4289             :                         henv);
    4290             : 
    4291         900 :         odbc_errs_reset(&env->errs);
    4292         900 :         tds_free_context(env->tds_ctx);
    4293         900 :         tds_mutex_unlock(&env->mtx);
    4294         900 :         tds_mutex_free(&env->mtx);
    4295         900 :         free(env);
    4296             : 
    4297         900 :         return SQL_SUCCESS;
    4298             : }
    4299             : 
    4300             : SQLRETURN ODBC_PUBLIC ODBC_API
    4301             : SQLFreeEnv(SQLHENV henv)
    4302             : {
    4303         900 :         tdsdump_log(TDS_DBG_FUNC, "SQLFreeEnv(%p)\n", henv);
    4304             : 
    4305         900 :         return _SQLFreeEnv(henv);
    4306             : }
    4307             : 
    4308             : static SQLRETURN
    4309       15063 : _SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force)
    4310             : {
    4311             :         TDSSOCKET *tds;
    4312             : 
    4313       15063 :         ODBC_ENTER_HSTMT;
    4314             : 
    4315       15063 :         tdsdump_log(TDS_DBG_FUNC, "_SQLFreeStmt(%p, %d, %d)\n", hstmt, fOption, force);
    4316             : 
    4317             :         /* check if option correct */
    4318       15063 :         if (fOption != SQL_DROP && fOption != SQL_CLOSE && fOption != SQL_UNBIND && fOption != SQL_RESET_PARAMS) {
    4319           0 :                 tdsdump_log(TDS_DBG_ERROR, "SQLFreeStmt: Unknown option %d\n", fOption);
    4320           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    4321           0 :                 ODBC_EXIT_(stmt);
    4322             :         }
    4323             : 
    4324             :         /* if we have bound columns, free the temporary list */
    4325       15063 :         if (fOption == SQL_DROP || fOption == SQL_UNBIND) {
    4326       13903 :                 desc_free_records(stmt->ard);
    4327             :         }
    4328             : 
    4329             :         /* do the same for bound parameters */
    4330       15063 :         if (fOption == SQL_DROP || fOption == SQL_RESET_PARAMS) {
    4331       13863 :                 desc_free_records(stmt->apd);
    4332       13863 :                 desc_free_records(stmt->ipd);
    4333             :         }
    4334             : 
    4335             :         /* close statement */
    4336       15063 :         if (fOption == SQL_DROP || fOption == SQL_CLOSE) {
    4337             :                 SQLRETURN retcode;
    4338             : 
    4339       13731 :                 tds = stmt->tds;
    4340             :                 /*
    4341             :                  * FIXME -- otherwise make sure the current statement is complete
    4342             :                  */
    4343             :                 /* do not close other running query ! */
    4344       13731 :                 if (tds && tds->state != TDS_IDLE && tds->state != TDS_DEAD) {
    4345         445 :                         if (TDS_SUCCEED(tds_send_cancel(tds)))
    4346         445 :                                 tds_process_cancel(tds);
    4347             :                 }
    4348             : 
    4349             :                 /* free cursor */
    4350       13731 :                 retcode = odbc_free_cursor(stmt);
    4351       13731 :                 if (!force && retcode != SQL_SUCCESS)
    4352           0 :                         ODBC_EXIT(stmt, retcode);
    4353             :         }
    4354             : 
    4355             :         /* free it */
    4356       15063 :         if (fOption == SQL_DROP) {
    4357             :                 SQLRETURN retcode;
    4358             : 
    4359             :                 /* close prepared statement or add to connection */
    4360       13217 :                 retcode = odbc_free_dynamic(stmt);
    4361       13217 :                 if (!force && retcode != SQL_SUCCESS)
    4362           0 :                         ODBC_EXIT(stmt, retcode);
    4363             : 
    4364             :                 /* detatch from list */
    4365       13217 :                 tds_mutex_lock(&stmt->dbc->mtx);
    4366       13217 :                 if (stmt->next)
    4367         232 :                         stmt->next->prev = stmt->prev;
    4368       13217 :                 if (stmt->prev)
    4369          17 :                         stmt->prev->next = stmt->next;
    4370       13217 :                 if (stmt->dbc->stmt_list == stmt)
    4371       13200 :                         stmt->dbc->stmt_list = stmt->next;
    4372       13217 :                 tds_mutex_unlock(&stmt->dbc->mtx);
    4373             : 
    4374       13217 :                 tds_dstr_free(&stmt->query);
    4375       13217 :                 tds_free_param_results(stmt->params);
    4376       13217 :                 odbc_errs_reset(&stmt->errs);
    4377       13217 :                 odbc_unlock_statement(stmt);
    4378       13217 :                 tds_dstr_free(&stmt->cursor_name);
    4379       13217 :                 tds_dstr_free(&stmt->attr.qn_msgtext);
    4380       13217 :                 tds_dstr_free(&stmt->attr.qn_options);
    4381       13217 :                 desc_free(stmt->ird);
    4382       13217 :                 desc_free(stmt->ipd);
    4383       13217 :                 desc_free(stmt->orig_ard);
    4384       13217 :                 desc_free(stmt->orig_apd);
    4385       13217 :                 tds_mutex_unlock(&stmt->mtx);
    4386       13217 :                 tds_mutex_free(&stmt->mtx);
    4387       13217 :                 free(stmt);
    4388             : 
    4389             :                 /* NOTE we freed stmt, do not use ODBC_EXIT */
    4390       13217 :                 return SQL_SUCCESS;
    4391             :         }
    4392        1846 :         ODBC_EXIT_(stmt);
    4393             : }
    4394             : 
    4395             : SQLRETURN ODBC_PUBLIC ODBC_API
    4396             : SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption)
    4397             : {
    4398       14604 :         tdsdump_log(TDS_DBG_FUNC, "SQLFreeStmt(%p, %d)\n", hstmt, fOption);
    4399       14604 :         return _SQLFreeStmt(hstmt, fOption, 0);
    4400             : }
    4401             : 
    4402             : 
    4403             : SQLRETURN ODBC_PUBLIC ODBC_API
    4404             : SQLCloseCursor(SQLHSTMT hstmt)
    4405             : {
    4406             :         /* TODO cursors */
    4407             :         /*
    4408             :          * Basic implementation for when no driver manager is present.
    4409             :          *  - according to ODBC documentation SQLCloseCursor is more or less
    4410             :          *    equivalent to SQLFreeStmt(..., SQL_CLOSE).
    4411             :          *  - indeed that is what the DM does if it can't find the function
    4412             :          *    in the driver, so this is pretty close.
    4413             :          */
    4414             :         /* TODO remember to close cursors really when get implemented */
    4415             :         /* TODO read all results and discard them or use cancellation ?? test behaviour */
    4416             : 
    4417         332 :         tdsdump_log(TDS_DBG_FUNC, "SQLCloseCursor(%p)\n", hstmt);
    4418         332 :         return _SQLFreeStmt(hstmt, SQL_CLOSE, 0);
    4419             : }
    4420             : 
    4421             : static SQLRETURN
    4422           8 : _SQLFreeDesc(SQLHDESC hdesc)
    4423             : {
    4424           8 :         ODBC_ENTER_HDESC;
    4425             : 
    4426           8 :         tdsdump_log(TDS_DBG_FUNC, "_SQLFreeDesc(%p)\n", 
    4427             :                         hdesc);
    4428             : 
    4429           8 :         if (desc->header.sql_desc_alloc_type != SQL_DESC_ALLOC_USER) {
    4430           0 :                 odbc_errs_add(&desc->errs, "HY017", NULL);
    4431           0 :                 ODBC_EXIT_(desc);
    4432             :         }
    4433             : 
    4434           8 :         if (IS_HDBC(desc->parent)) {
    4435           8 :                 TDS_DBC *dbc = (TDS_DBC *) desc->parent;
    4436             :                 TDS_STMT *stmt;
    4437             :                 int i;
    4438             : 
    4439             :                 /* freeing descriptors associated to statements revert state of statements */
    4440           8 :                 tds_mutex_lock(&dbc->mtx);
    4441          16 :                 for (stmt = dbc->stmt_list; stmt != NULL; stmt = stmt->next) {
    4442           8 :                         if (stmt->ard == desc)
    4443           0 :                                 stmt->ard = stmt->orig_ard;
    4444           8 :                         if (stmt->apd == desc)
    4445           0 :                                 stmt->apd = stmt->orig_apd;
    4446             :                 }
    4447           8 :                 tds_mutex_unlock(&dbc->mtx);
    4448             : 
    4449          16 :                 for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
    4450          16 :                         if (dbc->uad[i] == desc) {
    4451           8 :                                 dbc->uad[i] = NULL;
    4452           8 :                                 tds_mutex_unlock(&desc->mtx);
    4453           8 :                                 desc_free(desc);
    4454           8 :                                 break;
    4455             :                         }
    4456             :                 }
    4457             :         }
    4458             :         return SQL_SUCCESS;
    4459             : }
    4460             : 
    4461             : static SQLRETURN
    4462         820 : _SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength WIDE)
    4463             : {
    4464             :         void *src;
    4465             :         size_t size;
    4466             : 
    4467         820 :         ODBC_ENTER_HSTMT;
    4468             : 
    4469             :         /* TODO assign directly, use macro for size */
    4470         820 :         switch (Attribute) {
    4471         396 :         case SQL_ATTR_APP_PARAM_DESC:
    4472         396 :                 size = sizeof(stmt->apd);
    4473         396 :                 src = &stmt->apd;
    4474         396 :                 break;
    4475          96 :         case SQL_ATTR_APP_ROW_DESC:
    4476          96 :                 size = sizeof(stmt->ard);
    4477          96 :                 src = &stmt->ard;
    4478          96 :                 break;
    4479           0 :         case SQL_ATTR_ASYNC_ENABLE:
    4480           0 :                 size = sizeof(stmt->attr.async_enable);
    4481           0 :                 src = &stmt->attr.async_enable;
    4482           0 :                 break;
    4483          12 :         case SQL_ATTR_CONCURRENCY:
    4484          12 :                 size = sizeof(stmt->attr.concurrency);
    4485          12 :                 src = &stmt->attr.concurrency;
    4486          12 :                 break;
    4487          12 :         case SQL_ATTR_CURSOR_TYPE:
    4488          12 :                 size = sizeof(stmt->attr.cursor_type);
    4489          12 :                 src = &stmt->attr.cursor_type;
    4490          12 :                 break;
    4491           0 :         case SQL_ATTR_ENABLE_AUTO_IPD:
    4492           0 :                 size = sizeof(stmt->attr.enable_auto_ipd);
    4493           0 :                 src = &stmt->attr.enable_auto_ipd;
    4494           0 :                 break;
    4495           0 :         case SQL_ATTR_FETCH_BOOKMARK_PTR:
    4496           0 :                 size = sizeof(stmt->attr.fetch_bookmark_ptr);
    4497           0 :                 src = &stmt->attr.fetch_bookmark_ptr;
    4498           0 :                 break;
    4499           0 :         case SQL_ATTR_KEYSET_SIZE:
    4500           0 :                 size = sizeof(stmt->attr.keyset_size);
    4501           0 :                 src = &stmt->attr.keyset_size;
    4502           0 :                 break;
    4503           0 :         case SQL_ATTR_MAX_LENGTH:
    4504           0 :                 size = sizeof(stmt->attr.max_length);
    4505           0 :                 src = &stmt->attr.max_length;
    4506           0 :                 break;
    4507           0 :         case SQL_ATTR_MAX_ROWS:
    4508           0 :                 size = sizeof(stmt->attr.max_rows);
    4509           0 :                 src = &stmt->attr.max_rows;
    4510           0 :                 break;
    4511           0 :         case SQL_ATTR_METADATA_ID:
    4512           0 :                 size = sizeof(stmt->attr.metadata_id);
    4513           0 :                 src = &stmt->attr.metadata_id;
    4514           0 :                 break;
    4515           0 :         case SQL_ATTR_NOSCAN:
    4516           0 :                 size = sizeof(stmt->attr.noscan);
    4517           0 :                 src = &stmt->attr.noscan;
    4518           0 :                 break;
    4519           0 :         case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
    4520           0 :                 size = sizeof(stmt->apd->header.sql_desc_bind_offset_ptr);
    4521           0 :                 src = &stmt->apd->header.sql_desc_bind_offset_ptr;
    4522           0 :                 break;
    4523           0 :         case SQL_ATTR_PARAM_BIND_TYPE:
    4524           0 :                 size = sizeof(stmt->apd->header.sql_desc_bind_type);
    4525           0 :                 src = &stmt->apd->header.sql_desc_bind_type;
    4526           0 :                 break;
    4527           0 :         case SQL_ATTR_PARAM_OPERATION_PTR:
    4528           0 :                 size = sizeof(stmt->apd->header.sql_desc_array_status_ptr);
    4529           0 :                 src = &stmt->apd->header.sql_desc_array_status_ptr;
    4530           0 :                 break;
    4531           0 :         case SQL_ATTR_PARAM_STATUS_PTR:
    4532           0 :                 size = sizeof(stmt->ipd->header.sql_desc_array_status_ptr);
    4533           0 :                 src = &stmt->ipd->header.sql_desc_array_status_ptr;
    4534           0 :                 break;
    4535          48 :         case SQL_ATTR_PARAMS_PROCESSED_PTR:
    4536          48 :                 size = sizeof(stmt->ipd->header.sql_desc_rows_processed_ptr);
    4537          48 :                 src = &stmt->ipd->header.sql_desc_rows_processed_ptr;
    4538          48 :                 break;
    4539           0 :         case SQL_ATTR_PARAMSET_SIZE:
    4540           0 :                 size = sizeof(stmt->apd->header.sql_desc_array_size);
    4541           0 :                 src = &stmt->apd->header.sql_desc_array_size;
    4542           0 :                 break;
    4543           0 :         case SQL_ATTR_QUERY_TIMEOUT:
    4544           0 :                 size = sizeof(stmt->attr.query_timeout);
    4545           0 :                 src = &stmt->attr.query_timeout;
    4546           0 :                 break;
    4547           0 :         case SQL_ATTR_RETRIEVE_DATA:
    4548           0 :                 size = sizeof(stmt->attr.retrieve_data);
    4549           0 :                 src = &stmt->attr.retrieve_data;
    4550           0 :                 break;
    4551           0 :         case SQL_ATTR_ROW_BIND_OFFSET_PTR:
    4552           0 :                 size = sizeof(stmt->ard->header.sql_desc_bind_offset_ptr);
    4553           0 :                 src = &stmt->ard->header.sql_desc_bind_offset_ptr;
    4554           0 :                 break;
    4555             : #if SQL_BIND_TYPE != SQL_ATTR_ROW_BIND_TYPE
    4556             :         case SQL_BIND_TYPE:     /* although this is ODBC2 we must support this attribute */
    4557             : #endif
    4558           0 :         case SQL_ATTR_ROW_BIND_TYPE:
    4559           0 :                 size = sizeof(stmt->ard->header.sql_desc_bind_type);
    4560           0 :                 src = &stmt->ard->header.sql_desc_bind_type;
    4561           0 :                 break;
    4562          18 :         case SQL_ATTR_ROW_NUMBER:
    4563             :                 /* TODO do not get info every time, cache somewhere */
    4564          18 :                 if (stmt->cursor && odbc_lock_statement(stmt)) {
    4565             :                         TDS_UINT row_number, row_count;
    4566             : 
    4567          18 :                         tds_cursor_get_cursor_info(stmt->tds, stmt->cursor, &row_number, &row_count);
    4568          18 :                         stmt->attr.row_number = row_number;
    4569             :                 }
    4570          18 :                 size = sizeof(stmt->attr.row_number);
    4571          18 :                 src = &stmt->attr.row_number;
    4572          18 :                 break;
    4573           0 :         case SQL_ATTR_ROW_OPERATION_PTR:
    4574           0 :                 size = sizeof(stmt->ard->header.sql_desc_array_status_ptr);
    4575           0 :                 src = &stmt->ard->header.sql_desc_array_status_ptr;
    4576           0 :                 break;
    4577           0 :         case SQL_ATTR_ROW_STATUS_PTR:
    4578           0 :                 size = sizeof(stmt->ird->header.sql_desc_array_status_ptr);
    4579           0 :                 src = &stmt->ird->header.sql_desc_array_status_ptr;
    4580           0 :                 break;
    4581          40 :         case SQL_ATTR_ROWS_FETCHED_PTR:
    4582          40 :                 size = sizeof(stmt->ird->header.sql_desc_rows_processed_ptr);
    4583          40 :                 src = &stmt->ird->header.sql_desc_rows_processed_ptr;
    4584          40 :                 break;
    4585           0 :         case SQL_ATTR_ROW_ARRAY_SIZE:
    4586           0 :                 size = sizeof(stmt->ard->header.sql_desc_array_size);
    4587           0 :                 src = &stmt->ard->header.sql_desc_array_size;
    4588           0 :                 break;
    4589           0 :         case SQL_ATTR_SIMULATE_CURSOR:
    4590           0 :                 size = sizeof(stmt->attr.simulate_cursor);
    4591           0 :                 src = &stmt->attr.simulate_cursor;
    4592           0 :                 break;
    4593           0 :         case SQL_ATTR_USE_BOOKMARKS:
    4594           0 :                 size = sizeof(stmt->attr.use_bookmarks);
    4595           0 :                 src = &stmt->attr.use_bookmarks;
    4596           0 :                 break;
    4597          12 :         case SQL_ATTR_CURSOR_SCROLLABLE:
    4598          12 :                 size = sizeof(stmt->attr.cursor_scrollable);
    4599          12 :                 src = &stmt->attr.cursor_scrollable;
    4600          12 :                 break;
    4601          12 :         case SQL_ATTR_CURSOR_SENSITIVITY:
    4602          12 :                 size = sizeof(stmt->attr.cursor_sensitivity);
    4603          12 :                 src = &stmt->attr.cursor_sensitivity;
    4604          12 :                 break;
    4605          72 :         case SQL_ATTR_IMP_ROW_DESC:
    4606          72 :                 size = sizeof(stmt->ird);
    4607          72 :                 src = &stmt->ird;
    4608          72 :                 break;
    4609          94 :         case SQL_ATTR_IMP_PARAM_DESC:
    4610          94 :                 size = sizeof(stmt->ipd);
    4611          94 :                 src = &stmt->ipd;
    4612          94 :                 break;
    4613           8 :         case SQL_ROWSET_SIZE:   /* although this is ODBC2 we must support this attribute */
    4614           8 :                 size = sizeof(stmt->sql_rowset_size);
    4615           8 :                 src = &stmt->sql_rowset_size;
    4616           8 :                 break;
    4617           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_TIMEOUT:
    4618           0 :                 size = sizeof(stmt->attr.qn_timeout);
    4619           0 :                 src = &stmt->attr.qn_timeout;
    4620           0 :                 break;
    4621           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT:
    4622             :                 {
    4623           0 :                         SQLRETURN rc = odbc_set_dstr_oct(stmt->dbc, Value, BufferLength, StringLength, &stmt->attr.qn_msgtext);
    4624           0 :                         ODBC_EXIT(stmt, rc);
    4625             :                 }
    4626           0 :         case SQL_SOPT_SS_QUERYNOTIFICATION_OPTIONS:
    4627             :                 {
    4628           0 :                         SQLRETURN rc = odbc_set_dstr_oct(stmt->dbc, Value, BufferLength, StringLength, &stmt->attr.qn_options);
    4629           0 :                         ODBC_EXIT(stmt, rc);
    4630             :                 }
    4631             :                 /* TODO SQL_COLUMN_SEARCHABLE, although ODBC2 */
    4632           0 :         default:
    4633           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    4634           0 :                 ODBC_EXIT_(stmt);
    4635             :         }
    4636             : 
    4637         820 :         memcpy(Value, src, size);
    4638         820 :         if (StringLength)
    4639         694 :                 *StringLength = size;
    4640             : 
    4641         820 :         ODBC_EXIT_(stmt);
    4642             : }
    4643             : 
    4644             : #if (ODBCVER >= 0x0300)
    4645             : SQLRETURN ODBC_PUBLIC ODBC_API
    4646             : SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    4647             : {
    4648         410 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n", 
    4649             :                         hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
    4650             : 
    4651         410 :         return _SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength _wide0);
    4652             : }
    4653             : 
    4654             : #ifdef ENABLE_ODBC_WIDE
    4655             : SQLRETURN ODBC_PUBLIC ODBC_API
    4656             : SQLGetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
    4657             : {
    4658         410 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n",
    4659             :                         hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
    4660             : 
    4661         410 :         return _SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength, 1);
    4662             : }
    4663             : #endif
    4664             : #endif
    4665             : 
    4666             : SQLRETURN ODBC_PUBLIC ODBC_API
    4667             : SQLGetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    4668             : {
    4669           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtOption(%p, %d, %p)\n", 
    4670             :                         hstmt, fOption, pvParam);
    4671             : 
    4672           0 :         return _SQLGetStmtAttr(hstmt, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL _wide0);
    4673             : }
    4674             : 
    4675             : SQLRETURN ODBC_PUBLIC ODBC_API
    4676             : SQLNumResultCols(SQLHSTMT hstmt, SQLSMALLINT FAR * pccol)
    4677             : {
    4678         692 :         ODBC_ENTER_HSTMT;
    4679             : 
    4680         692 :         tdsdump_log(TDS_DBG_FUNC, "SQLNumResultCols(%p, %p)\n", 
    4681             :                         hstmt, pccol);
    4682             : 
    4683             :         /*
    4684             :          * 3/15/2001 bsb - DBD::ODBC calls SQLNumResultCols on non-result
    4685             :          * generating queries such as 'drop table'
    4686             :          */
    4687             : #if 0
    4688             :         if (stmt->row_status == NOT_IN_ROW) {
    4689             :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4690             :                 ODBC_EXIT_(stmt);
    4691             :         }
    4692             : #endif
    4693         692 :         IRD_UPDATE(stmt->ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    4694         674 :         *pccol = stmt->ird->header.sql_desc_count;
    4695         674 :         ODBC_EXIT_(stmt);
    4696             : }
    4697             : 
    4698        3098 : ODBC_FUNC(SQLPrepare, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
    4699             : {
    4700             :         SQLRETURN retcode;
    4701             : 
    4702        3098 :         ODBC_ENTER_HSTMT;
    4703             : 
    4704             :         /* try to free dynamic associated */
    4705        3098 :         retcode = odbc_free_dynamic(stmt);
    4706        3098 :         if (retcode != SQL_SUCCESS)
    4707           0 :                 ODBC_EXIT(stmt, retcode);
    4708             : 
    4709        3098 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide))
    4710           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    4711        3098 :         stmt->is_prepared_query = 1;
    4712             : 
    4713             :         /* count parameters */
    4714        6196 :         stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
    4715             : 
    4716             :         /* trasform to native (one time, not for every SQLExecute) */
    4717        3098 :         if (SQL_SUCCESS != prepare_call(stmt))
    4718           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    4719             : 
    4720             :         /* TODO needed ?? */
    4721        3098 :         tds_release_dynamic(&stmt->dyn);
    4722             : 
    4723             :         /* try to prepare query */
    4724             :         /* TODO support getting info for RPC */
    4725        3098 :         if (!stmt->prepared_query_is_rpc
    4726        2596 :                  && (stmt->attr.cursor_type == SQL_CURSOR_FORWARD_ONLY && stmt->attr.concurrency == SQL_CONCUR_READ_ONLY)) {
    4727             : 
    4728        1634 :                 tds_free_param_results(stmt->params);
    4729        1634 :                 stmt->params = NULL;
    4730        1634 :                 stmt->param_num = 0;
    4731        1634 :                 stmt->need_reprepare = 0;
    4732             :                 /*
    4733             :                  * using TDS7+ we need parameters to prepare a query so try
    4734             :                  * to get them 
    4735             :                  * TDS5 do not need parameters type and we have always to
    4736             :                  * prepare sepatately so this is not an issue
    4737             :                  */
    4738        1634 :                 if (IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
    4739        1342 :                         stmt->need_reprepare = 1;
    4740        1342 :                         ODBC_EXIT_(stmt);
    4741             :                 }
    4742             : 
    4743         292 :                 tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
    4744         292 :                 if (odbc_lock_statement(stmt))
    4745         292 :                         odbc_prepare(stmt);
    4746             :         }
    4747             : 
    4748        1756 :         ODBC_EXIT_(stmt);
    4749             : }
    4750             : 
    4751             : /* TDS_NO_COUNT must be -1 for SQLRowCount to return -1 when there is no rowcount */
    4752             : #if TDS_NO_COUNT != -1
    4753             : # error TDS_NO_COUNT != -1
    4754             : #endif
    4755             :         
    4756             : SQLRETURN
    4757         288 : _SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
    4758             : {
    4759         288 :         ODBC_ENTER_HSTMT;
    4760             : 
    4761         288 :         tdsdump_log(TDS_DBG_FUNC, "_SQLRowCount(%p, %p),  %ld rows \n", hstmt, pcrow, (long)stmt->row_count);
    4762             : 
    4763         288 :         *pcrow = stmt->row_count;
    4764             : 
    4765         288 :         ODBC_EXIT_(stmt);
    4766             : }
    4767             : 
    4768             : SQLRETURN ODBC_PUBLIC ODBC_API
    4769             : SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
    4770             : {
    4771         288 :         SQLRETURN rc = _SQLRowCount(hstmt, pcrow);
    4772         288 :         tdsdump_log(TDS_DBG_INFO1, "SQLRowCount returns %d, row count %ld\n", rc, (long int) *pcrow);
    4773         288 :         return rc;
    4774             : }
    4775             : 
    4776          78 : ODBC_FUNC(SQLSetCursorName, (P(SQLHSTMT,hstmt), PCHARIN(Cursor,SQLSMALLINT) WIDE))
    4777             : {
    4778          78 :         ODBC_ENTER_HSTMT;
    4779             : 
    4780             :         /* cursor already present, we cannot set name */
    4781          78 :         if (stmt->cursor) {
    4782           0 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    4783           0 :                 ODBC_EXIT_(stmt);
    4784             :         }
    4785             : 
    4786          78 :         if (!odbc_dstr_copy(stmt->dbc, &stmt->cursor_name, cbCursor, szCursor)) {
    4787           0 :                 odbc_errs_add(&stmt->errs, "HY001", NULL);
    4788           0 :                 ODBC_EXIT_(stmt);
    4789             :         }
    4790          78 :         ODBC_EXIT_(stmt);
    4791             : }
    4792             : 
    4793           0 : ODBC_FUNC(SQLGetCursorName, (P(SQLHSTMT,hstmt), PCHAROUT(Cursor,SQLSMALLINT) WIDE))
    4794             : {
    4795             :         SQLRETURN rc;
    4796             : 
    4797           0 :         ODBC_ENTER_HSTMT;
    4798             : 
    4799           0 :         if ((rc = odbc_set_dstr(stmt->dbc, szCursor, cbCursorMax, pcbCursor, &stmt->cursor_name)))
    4800           0 :                 odbc_errs_add(&stmt->errs, "01004", NULL);
    4801             : 
    4802           0 :         ODBC_EXIT(stmt, rc);
    4803             : }
    4804             : 
    4805             : /*
    4806             :  * spinellia@acm.org : copied shamelessly from change_database
    4807             :  * transaction support
    4808             :  * 1 = commit, 0 = rollback
    4809             :  */
    4810             : static SQLRETURN
    4811         611 : change_transaction(TDS_DBC * dbc, int state)
    4812             : {
    4813         611 :         TDSSOCKET *tds = dbc->tds_socket;
    4814             :         int cont;
    4815             :         TDSRET ret;
    4816             : 
    4817         611 :         tdsdump_log(TDS_DBG_INFO1, "change_transaction(0x%p,%d)\n", dbc, state);
    4818         611 :         tds_mutex_check_owned(&dbc->mtx);
    4819             : 
    4820         611 :         if (dbc->attr.autocommit == SQL_AUTOCOMMIT_ON)
    4821             :                 return SQL_SUCCESS;
    4822         595 :         cont = 1;
    4823             : 
    4824             :         /* if pending drop all recordset, don't issue cancel */
    4825         595 :         if (tds->state == TDS_PENDING && dbc->current_statement != NULL) {
    4826             :                 /* TODO what happen on multiple errors ?? discard all ?? */
    4827          16 :                 if (TDS_FAILED(tds_process_simple_query(tds)))
    4828             :                         return SQL_ERROR;
    4829             :         }
    4830             : 
    4831             :         /* TODO better idle check, not thread safe */
    4832         595 :         if (tds->state == TDS_IDLE)
    4833         595 :                 tds->query_timeout = dbc->default_query_timeout;
    4834             : 
    4835             :         /* reset statement so errors will be reported on connection.
    4836             :          * Note that we own the connection lock */
    4837         595 :         if (dbc->current_statement) {
    4838         400 :                 dbc->current_statement->tds = NULL;
    4839         400 :                 dbc->current_statement = NULL;
    4840             :         }
    4841         595 :         tds_set_parent(tds, dbc);
    4842             : 
    4843         595 :         if (state)
    4844         223 :                 ret = tds_submit_commit(tds, cont);
    4845             :         else
    4846         372 :                 ret = tds_submit_rollback(tds, cont);
    4847             : 
    4848         595 :         if (TDS_FAILED(ret)) {
    4849           8 :                 odbc_errs_add(&dbc->errs, "HY000", "Could not perform COMMIT or ROLLBACK");
    4850           8 :                 return SQL_ERROR;
    4851             :         }
    4852             : 
    4853         587 :         if (TDS_FAILED(tds_process_simple_query(tds)))
    4854             :                 return SQL_ERROR;
    4855             : 
    4856             :         /* TODO some query can collect errors so perhaps it's better to return SUCCES_WITH_INFO in such case... */
    4857         587 :         return SQL_SUCCESS;
    4858             : }
    4859             : 
    4860             : static SQLRETURN
    4861         611 : _SQLTransact(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType)
    4862             : {
    4863         611 :         int op = (fType == SQL_COMMIT ? 1 : 0);
    4864             : 
    4865             :         /* I may live without a HENV */
    4866             :         /*     CHECK_HENV; */
    4867             :         /* ..but not without a HDBC! */
    4868         611 :         ODBC_ENTER_HDBC;
    4869             : 
    4870         611 :         tdsdump_log(TDS_DBG_FUNC, "_SQLTransact(%p, %p, %d)\n", 
    4871             :                         henv, hdbc, fType);
    4872             : 
    4873         611 :         ODBC_EXIT(dbc, change_transaction(dbc, op));
    4874             : }
    4875             : 
    4876             : SQLRETURN ODBC_PUBLIC ODBC_API
    4877             : SQLTransact(SQLHENV henv, SQLHDBC hdbc, SQLUSMALLINT fType)
    4878             : {
    4879           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLTransact(%p, %p, %d)\n", henv, hdbc, fType);
    4880             : 
    4881           0 :         return _SQLTransact(henv, hdbc, fType);
    4882             : }
    4883             : 
    4884             : #if ODBCVER >= 0x300
    4885             : SQLRETURN ODBC_PUBLIC ODBC_API
    4886             : SQLEndTran(SQLSMALLINT handleType, SQLHANDLE handle, SQLSMALLINT completionType)
    4887             : {
    4888             :         /*
    4889             :          * Do not call the exported SQLTransact(),
    4890             :          * because we may wind up calling a function with the same name implemented by the DM.
    4891             :          */
    4892         611 :         tdsdump_log(TDS_DBG_FUNC, "SQLEndTran(%d, %p, %d)\n", handleType, handle, completionType);
    4893             : 
    4894         611 :         switch (handleType) {
    4895           0 :         case SQL_HANDLE_ENV:
    4896           0 :                 return _SQLTransact(handle, NULL, completionType);
    4897         611 :         case SQL_HANDLE_DBC:
    4898         611 :                 return _SQLTransact(NULL, handle, completionType);
    4899             :         }
    4900             :         return SQL_ERROR;
    4901             : }
    4902             : #endif
    4903             : 
    4904             : /* end of transaction support */
    4905             : 
    4906             : SQLRETURN ODBC_PUBLIC ODBC_API
    4907             : SQLSetParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbParamDef,
    4908             :             SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN FAR * pcbValue)
    4909             : {
    4910           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetParam(%p, %d, %d, %d, %u, %d, %p, %p)\n", 
    4911             :                         hstmt, ipar, fCType, fSqlType, (unsigned)cbParamDef, ibScale, rgbValue, pcbValue);
    4912             : 
    4913           0 :         return _SQLBindParameter(hstmt, ipar, SQL_PARAM_INPUT_OUTPUT, fCType, fSqlType, cbParamDef, ibScale, rgbValue,
    4914             :                                  SQL_SETPARAM_VALUE_MAX, pcbValue);
    4915             : }
    4916             : 
    4917             : /**
    4918             :  * SQLColumns
    4919             :  *
    4920             :  * Return column information for a table or view. This is
    4921             :  * mapped to a call to sp_columns which - lucky for us - returns
    4922             :  * the exact result set we need.
    4923             :  *
    4924             :  * exec sp_columns [ @table_name = ] object 
    4925             :  *                 [ , [ @table_owner = ] owner ] 
    4926             :  *                 [ , [ @table_qualifier = ] qualifier ] 
    4927             :  *                 [ , [ @column_name = ] column ] 
    4928             :  *                 [ , [ @ODBCVer = ] ODBCVer ] 
    4929             :  *
    4930             :  */
    4931          32 : ODBC_FUNC(SQLColumns, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),     /* object_qualifier */
    4932             :         PCHARIN(SchemaName,SQLSMALLINT),        /* object_owner */
    4933             :         PCHARIN(TableName,SQLSMALLINT), /* object_name */
    4934             :         PCHARIN(ColumnName,SQLSMALLINT) /* column_name */
    4935             :         WIDE))
    4936             : {
    4937             :         int retcode;
    4938          32 :         const char *proc = "sp_columns";
    4939             : 
    4940          32 :         ODBC_ENTER_HSTMT;
    4941             : 
    4942          32 :         if (odbc_get_string_size(cbCatalogName, szCatalogName _wide))
    4943          16 :                 proc = "..sp_columns";
    4944             : 
    4945          32 :         retcode =
    4946          32 :                 odbc_stat_execute(stmt _wide, proc, TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4,
    4947             :                                   "P@table_name", szTableName, cbTableName, "P@table_owner", szSchemaName,
    4948             :                                   cbSchemaName, "O@table_qualifier", szCatalogName, cbCatalogName, "P@column_name", szColumnName,
    4949             :                                   cbColumnName, "V@ODBCVer", (char*) NULL, 0);
    4950          32 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    4951          16 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    4952          16 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    4953          16 :                 odbc_col_setname(stmt, 7, "COLUMN_SIZE");
    4954          16 :                 odbc_col_setname(stmt, 8, "BUFFER_LENGTH");
    4955          16 :                 odbc_col_setname(stmt, 9, "DECIMAL_DIGITS");
    4956          16 :                 odbc_col_setname(stmt, 10, "NUM_PREC_RADIX");
    4957          16 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    4958           4 :                         stmt->special_row = ODBC_SPECIAL_COLUMNS;
    4959             :         }
    4960          32 :         ODBC_EXIT_(stmt);
    4961             : }
    4962             : 
    4963          62 : ODBC_FUNC(SQLGetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,Value), P(SQLINTEGER,BufferLength),
    4964             :         P(SQLINTEGER *,StringLength) WIDE))
    4965             : {
    4966          62 :         const char *p = NULL;
    4967             : 
    4968          62 :         ODBC_ENTER_HDBC;
    4969             : 
    4970          62 :         tdsdump_log(TDS_DBG_FUNC, "_SQLGetConnectAttr(%p, %d, %p, %d, %p)\n", 
    4971             :                         hdbc, (int)Attribute, Value, (int)BufferLength, StringLength);
    4972             : 
    4973          62 :         switch (Attribute) {
    4974           0 :         case SQL_ATTR_AUTOCOMMIT:
    4975           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.autocommit;
    4976             :                 break;
    4977             : #if defined(SQL_ATTR_CONNECTION_DEAD) && defined(SQL_CD_TRUE)
    4978           0 :         case SQL_ATTR_CONNECTION_DEAD:
    4979           0 :                 *((SQLUINTEGER *) Value) = IS_TDSDEAD(dbc->tds_socket) ? SQL_CD_TRUE : SQL_CD_FALSE;
    4980             :                 break;
    4981             : #endif
    4982           0 :         case SQL_ATTR_CONNECTION_TIMEOUT:
    4983           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.connection_timeout;
    4984             :                 break;
    4985           0 :         case SQL_ATTR_ACCESS_MODE:
    4986           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.access_mode;
    4987             :                 break;
    4988          54 :         case SQL_ATTR_CURRENT_CATALOG:
    4989         108 :                 p = tds_dstr_cstr(&dbc->attr.current_catalog);
    4990          54 :                 break;
    4991           0 :         case SQL_ATTR_LOGIN_TIMEOUT:
    4992           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.login_timeout;
    4993             :                 break;
    4994           0 :         case SQL_ATTR_ODBC_CURSORS:
    4995           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.odbc_cursors;
    4996             :                 break;
    4997           0 :         case SQL_ATTR_PACKET_SIZE:
    4998           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.packet_size;
    4999             :                 break;
    5000           0 :         case SQL_ATTR_QUIET_MODE:
    5001           0 :                 *((SQLHWND *) Value) = dbc->attr.quite_mode;
    5002             :                 break;
    5003             : #ifdef TDS_NO_DM
    5004           0 :         case SQL_ATTR_TRACE:
    5005           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.trace;
    5006             :                 break;
    5007           0 :         case SQL_ATTR_TRACEFILE:
    5008           0 :                 p = tds_dstr_cstr(&dbc->attr.tracefile);
    5009           0 :                 break;
    5010             : #endif
    5011           0 :         case SQL_ATTR_TXN_ISOLATION:
    5012           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.txn_isolation;
    5013             :                 break;
    5014           8 :         case SQL_COPT_SS_MARS_ENABLED:
    5015           8 :                 *((SQLUINTEGER *) Value) = dbc->attr.mars_enabled;
    5016             :                 break;
    5017           0 :         case SQL_ATTR_TRANSLATE_LIB:
    5018             :         case SQL_ATTR_TRANSLATE_OPTION:
    5019           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
    5020             :                 break;
    5021           0 :         case SQL_COPT_SS_BCP:
    5022           0 :                 *((SQLUINTEGER *) Value) = dbc->attr.bulk_enabled;
    5023             :                 break;
    5024           0 :         default:
    5025           0 :                 odbc_errs_add(&dbc->errs, "HY092", NULL);
    5026             :                 break;
    5027             :         }
    5028             : 
    5029          54 :         if (p) {
    5030          54 :                 SQLRETURN rc = odbc_set_string_oct(dbc, Value, BufferLength, StringLength, p, -1);
    5031          54 :                 ODBC_EXIT(dbc, rc);
    5032             :         }
    5033           8 :         ODBC_EXIT_(dbc);
    5034             : }
    5035             : 
    5036             : SQLRETURN ODBC_PUBLIC ODBC_API
    5037             : SQLGetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    5038             : {
    5039           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectOption(%p, %u, %p)\n", hdbc, fOption, pvParam);
    5040             : 
    5041           0 :         return _SQLGetConnectAttr(hdbc, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL _wide0);
    5042             : }
    5043             : 
    5044             : #ifdef ENABLE_ODBC_WIDE
    5045             : SQLRETURN ODBC_PUBLIC ODBC_API
    5046             : SQLGetConnectOptionW(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLPOINTER pvParam)
    5047             : {
    5048           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetConnectOptionW(%p, %u, %p)\n", hdbc, fOption, pvParam);
    5049             : 
    5050           0 :         return _SQLGetConnectAttr(hdbc, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL, 1);
    5051             : }
    5052             : #endif
    5053             : 
    5054             : SQLRETURN ODBC_PUBLIC ODBC_API
    5055             : SQLGetData(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
    5056             : {
    5057             :         /* TODO cursors fetch row if needed ?? */
    5058             :         TDSCOLUMN *colinfo;
    5059             :         TDSRESULTINFO *resinfo;
    5060             :         SQLLEN dummy_cb;
    5061             : 
    5062        6880 :         ODBC_ENTER_HSTMT;
    5063             : 
    5064        6880 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetData(%p, %u, %d, %p, %d, %p)\n", 
    5065             :                         hstmt, icol, fCType, rgbValue, (int)cbValueMax, pcbValue);
    5066             : 
    5067        6880 :         if (cbValueMax < 0) {
    5068           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    5069           0 :                 ODBC_EXIT_(stmt);
    5070             :         }
    5071             : 
    5072             :         /* read data from TDS only if current statement */
    5073        6880 :         if ((stmt->cursor == NULL && !stmt->tds)
    5074        6826 :                 || stmt->row_status == PRE_NORMAL_ROW 
    5075        6576 :                 || stmt->row_status == NOT_IN_ROW) 
    5076             :         {
    5077         304 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    5078         304 :                 ODBC_EXIT_(stmt);
    5079             :         }
    5080             : 
    5081        6576 :         IRD_CHECK;
    5082             : 
    5083        6576 :         if (!pcbValue)
    5084         286 :                 pcbValue = &dummy_cb;
    5085             : 
    5086        6576 :         resinfo = stmt->cursor ? stmt->cursor->res_info : stmt->tds->current_results;
    5087        6576 :         if (!resinfo) {
    5088           0 :                 odbc_errs_add(&stmt->errs, "HY010", NULL);
    5089           0 :                 ODBC_EXIT_(stmt);
    5090             :         }
    5091        6576 :         if (icol <= 0 || icol > resinfo->num_cols) {
    5092           0 :                 odbc_errs_add(&stmt->errs, "07009", "Column out of range");
    5093           0 :                 ODBC_EXIT_(stmt);
    5094             :         }
    5095        6576 :         colinfo = resinfo->columns[icol - 1];
    5096             : 
    5097        6576 :         if (colinfo->column_cur_size < 0) {
    5098             :                 /* TODO check what should happen if pcbValue was NULL */
    5099         278 :                 *pcbValue = SQL_NULL_DATA;
    5100             :         } else {
    5101        6298 :                 if (colinfo->column_text_sqlgetdatapos > 0
    5102        1750 :                     && colinfo->column_text_sqlgetdatapos >= colinfo->column_cur_size
    5103         404 :                     && colinfo->column_iconv_left == 0)
    5104             :                         /* TODO check if SQL_SUCCESS instead !! */
    5105         358 :                         ODBC_EXIT(stmt, SQL_NO_DATA);
    5106             : 
    5107        5940 :                 if (!is_variable_type(colinfo->column_type)) {
    5108         420 :                         colinfo->column_text_sqlgetdatapos = 0;
    5109         420 :                         colinfo->column_iconv_left = 0;
    5110             :                 }
    5111             : 
    5112        5940 :                 if (fCType == SQL_C_DEFAULT)
    5113           0 :                         fCType = odbc_sql_to_c_type_default(stmt->ird->records[icol - 1].sql_desc_concise_type);
    5114        5940 :                 if (fCType == SQL_ARD_TYPE) {
    5115           8 :                         if (icol > stmt->ard->header.sql_desc_count) {
    5116           8 :                                 odbc_errs_add(&stmt->errs, "07009", NULL);
    5117           8 :                                 ODBC_EXIT_(stmt);
    5118             :                         }
    5119           0 :                         fCType = stmt->ard->records[icol - 1].sql_desc_concise_type;
    5120             :                 }
    5121        5932 :                 assert(fCType);
    5122             : 
    5123        5932 :                 *pcbValue = odbc_tds2sql_col(stmt, colinfo, fCType, (TDS_CHAR *) rgbValue, cbValueMax, NULL);
    5124        5932 :                 if (*pcbValue == SQL_NULL_DATA)
    5125          32 :                         ODBC_EXIT(stmt, SQL_ERROR);
    5126             :                 
    5127        5900 :                 if (is_variable_type(colinfo->column_type) && (fCType == SQL_C_CHAR || fCType == SQL_C_WCHAR || fCType == SQL_C_BINARY)) {
    5128             :                         /* avoid infinite SQL_SUCCESS on empty strings */
    5129        5480 :                         if (colinfo->column_text_sqlgetdatapos == 0 && cbValueMax > 0)
    5130          32 :                                 ++colinfo->column_text_sqlgetdatapos;
    5131             : 
    5132        5480 :                         if (colinfo->column_text_sqlgetdatapos < colinfo->column_cur_size || colinfo->column_iconv_left != 0) {     /* not all read ?? */
    5133        1448 :                                 odbc_errs_add(&stmt->errs, "01004", "String data, right truncated");
    5134        1448 :                                 ODBC_EXIT_(stmt);
    5135             :                         }
    5136             :                 } else {
    5137         420 :                         int nSybType = tds_get_conversion_type(colinfo->on_server.column_type, colinfo->on_server.column_size);
    5138         420 :                         colinfo->column_text_sqlgetdatapos = colinfo->column_cur_size;
    5139         420 :                         if (is_fixed_type(nSybType) && (fCType == SQL_C_CHAR || fCType == SQL_C_WCHAR || fCType == SQL_C_BINARY)
    5140         314 :                             && cbValueMax < *pcbValue) {
    5141          14 :                                 odbc_errs_add(&stmt->errs, "22003", NULL);
    5142          14 :                                 ODBC_EXIT_(stmt);
    5143             :                         }
    5144             :                 }
    5145             :         }
    5146        4716 :         ODBC_EXIT_(stmt);
    5147             : }
    5148             : 
    5149             : SQLRETURN ODBC_PUBLIC ODBC_API
    5150             : SQLGetFunctions(SQLHDBC hdbc, SQLUSMALLINT fFunction, SQLUSMALLINT FAR * pfExists)
    5151             : {
    5152             :         int i;
    5153             : 
    5154           0 :         ODBC_ENTER_HDBC;
    5155             : 
    5156           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetFunctions: fFunction is %d\n", fFunction);
    5157           0 :         switch (fFunction) {
    5158             : #if (ODBCVER >= 0x0300)
    5159             :         case SQL_API_ODBC3_ALL_FUNCTIONS:
    5160           0 :                 for (i = 0; i < SQL_API_ODBC3_ALL_FUNCTIONS_SIZE; ++i) {
    5161           0 :                         pfExists[i] = 0;
    5162             :                 }
    5163             : 
    5164             :                 /*
    5165             :                  * every api available are contained in a macro
    5166             :                  * all these macro begin with API followed by 2 letter
    5167             :                  * first letter mean pre ODBC 3 (_) or ODBC 3 (3)
    5168             :                  * second letter mean implemented (X) or unimplemented (_)
    5169             :                  * You should copy these macro 3 times... not very good
    5170             :                  * but works. Perhaps best method is build the bit array statically
    5171             :                  * and then use it but I don't know how to build it...
    5172             :                  */
    5173             : #undef ODBC_ALL_API
    5174             : #undef ODBC_COLATTRIBUTE
    5175             : 
    5176             : #if SQL_API_SQLCOLATTRIBUTE != SQL_API_SQLCOLATTRIBUTES
    5177             : #define ODBC_COLATTRIBUTE(s) s
    5178             : #else
    5179             : #define ODBC_COLATTRIBUTE(s)
    5180             : #endif
    5181             : 
    5182             : #define ODBC_ALL_API \
    5183             :         API_X(SQL_API_SQLALLOCCONNECT)\
    5184             :         API_X(SQL_API_SQLALLOCENV)\
    5185             :         API3X(SQL_API_SQLALLOCHANDLE)\
    5186             :         API_X(SQL_API_SQLALLOCSTMT)\
    5187             :         API_X(SQL_API_SQLBINDCOL)\
    5188             :         API_X(SQL_API_SQLBINDPARAM)\
    5189             :         API_X(SQL_API_SQLBINDPARAMETER)\
    5190             :         API__(SQL_API_SQLBROWSECONNECT)\
    5191             :         API3_(SQL_API_SQLBULKOPERATIONS)\
    5192             :         API_X(SQL_API_SQLCANCEL)\
    5193             :         API3X(SQL_API_SQLCLOSECURSOR)\
    5194             :         ODBC_COLATTRIBUTE(API3X(SQL_API_SQLCOLATTRIBUTE))\
    5195             :         API_X(SQL_API_SQLCOLATTRIBUTES)\
    5196             :         API_X(SQL_API_SQLCOLUMNPRIVILEGES)\
    5197             :         API_X(SQL_API_SQLCOLUMNS)\
    5198             :         API_X(SQL_API_SQLCONNECT)\
    5199             :         API3X(SQL_API_SQLCOPYDESC)\
    5200             :         API_X(SQL_API_SQLDESCRIBECOL)\
    5201             :         API__(SQL_API_SQLDESCRIBEPARAM)\
    5202             :         API_X(SQL_API_SQLDISCONNECT)\
    5203             :         API_X(SQL_API_SQLDRIVERCONNECT)\
    5204             :         API3X(SQL_API_SQLENDTRAN)\
    5205             :         API_X(SQL_API_SQLERROR)\
    5206             :         API_X(SQL_API_SQLEXECDIRECT)\
    5207             :         API_X(SQL_API_SQLEXECUTE)\
    5208             :         API_X(SQL_API_SQLEXTENDEDFETCH)\
    5209             :         API_X(SQL_API_SQLFETCH)\
    5210             :         API3X(SQL_API_SQLFETCHSCROLL)\
    5211             :         API_X(SQL_API_SQLFOREIGNKEYS)\
    5212             :         API_X(SQL_API_SQLFREECONNECT)\
    5213             :         API_X(SQL_API_SQLFREEENV)\
    5214             :         API3X(SQL_API_SQLFREEHANDLE)\
    5215             :         API_X(SQL_API_SQLFREESTMT)\
    5216             :         API3X(SQL_API_SQLGETCONNECTATTR)\
    5217             :         API_X(SQL_API_SQLGETCONNECTOPTION)\
    5218             :         API_X(SQL_API_SQLGETCURSORNAME)\
    5219             :         API_X(SQL_API_SQLGETDATA)\
    5220             :         API3X(SQL_API_SQLGETDESCFIELD)\
    5221             :         API3X(SQL_API_SQLGETDESCREC)\
    5222             :         API3X(SQL_API_SQLGETDIAGFIELD)\
    5223             :         API3X(SQL_API_SQLGETDIAGREC)\
    5224             :         API3X(SQL_API_SQLGETENVATTR)\
    5225             :         API_X(SQL_API_SQLGETFUNCTIONS)\
    5226             :         API_X(SQL_API_SQLGETINFO)\
    5227             :         API3X(SQL_API_SQLGETSTMTATTR)\
    5228             :         API_X(SQL_API_SQLGETSTMTOPTION)\
    5229             :         API_X(SQL_API_SQLGETTYPEINFO)\
    5230             :         API_X(SQL_API_SQLMORERESULTS)\
    5231             :         API_X(SQL_API_SQLNATIVESQL)\
    5232             :         API_X(SQL_API_SQLNUMPARAMS)\
    5233             :         API_X(SQL_API_SQLNUMRESULTCOLS)\
    5234             :         API_X(SQL_API_SQLPARAMDATA)\
    5235             :         API_X(SQL_API_SQLPARAMOPTIONS)\
    5236             :         API_X(SQL_API_SQLPREPARE)\
    5237             :         API_X(SQL_API_SQLPRIMARYKEYS)\
    5238             :         API_X(SQL_API_SQLPROCEDURECOLUMNS)\
    5239             :         API_X(SQL_API_SQLPROCEDURES)\
    5240             :         API_X(SQL_API_SQLPUTDATA)\
    5241             :         API_X(SQL_API_SQLROWCOUNT)\
    5242             :         API3X(SQL_API_SQLSETCONNECTATTR)\
    5243             :         API_X(SQL_API_SQLSETCONNECTOPTION)\
    5244             :         API_X(SQL_API_SQLSETCURSORNAME)\
    5245             :         API3X(SQL_API_SQLSETDESCFIELD)\
    5246             :         API3X(SQL_API_SQLSETDESCREC)\
    5247             :         API3X(SQL_API_SQLSETENVATTR)\
    5248             :         API_X(SQL_API_SQLSETPARAM)\
    5249             :         API_X(SQL_API_SQLSETPOS)\
    5250             :         API_X(SQL_API_SQLSETSCROLLOPTIONS)\
    5251             :         API3X(SQL_API_SQLSETSTMTATTR)\
    5252             :         API_X(SQL_API_SQLSETSTMTOPTION)\
    5253             :         API_X(SQL_API_SQLSPECIALCOLUMNS)\
    5254             :         API_X(SQL_API_SQLSTATISTICS)\
    5255             :         API_X(SQL_API_SQLTABLEPRIVILEGES)\
    5256             :         API_X(SQL_API_SQLTABLES)\
    5257             :         API_X(SQL_API_SQLTRANSACT)
    5258             : 
    5259             : #define API_X(n) if (n >= 0 && n < (16*SQL_API_ODBC3_ALL_FUNCTIONS_SIZE)) pfExists[n/16] |= (1 << n%16);
    5260             : #define API__(n)
    5261             : #define API3X(n) if (n >= 0 && n < (16*SQL_API_ODBC3_ALL_FUNCTIONS_SIZE)) pfExists[n/16] |= (1 << n%16);
    5262             : #define API3_(n)
    5263           0 :                 ODBC_ALL_API
    5264             : #undef API_X
    5265             : #undef API__
    5266             : #undef API3X
    5267             : #undef API3_
    5268             :                 break;
    5269             : #endif
    5270             : 
    5271           0 :         case SQL_API_ALL_FUNCTIONS:
    5272           0 :                 tdsdump_log(TDS_DBG_FUNC, "SQLGetFunctions: " "fFunction is SQL_API_ALL_FUNCTIONS\n");
    5273           0 :                 for (i = 0; i < 100; ++i) {
    5274           0 :                         pfExists[i] = SQL_FALSE;
    5275             :                 }
    5276             : 
    5277             : #define API_X(n) if (n >= 0 && n < 100) pfExists[n] = SQL_TRUE;
    5278             : #define API__(n)
    5279             : #define API3X(n)
    5280             : #define API3_(n)
    5281           0 :                 ODBC_ALL_API
    5282             : #undef API_X
    5283             : #undef API__
    5284             : #undef API3X
    5285             : #undef API3_
    5286             :                 break;
    5287             : #define API_X(n) case n:
    5288             : #define API__(n)
    5289             : #if (ODBCVER >= 0x300)
    5290             : #define API3X(n) case n:
    5291             : #else
    5292             : #define API3X(n)
    5293             : #endif
    5294             : #define API3_(n)
    5295           0 :                 ODBC_ALL_API
    5296             : #undef API_X
    5297             : #undef API__
    5298             : #undef API3X
    5299             : #undef API3_
    5300           0 :                 *pfExists = SQL_TRUE;
    5301           0 :                 break;
    5302           0 :         default:
    5303           0 :                 *pfExists = SQL_FALSE;
    5304           0 :                 break;
    5305             :         }
    5306           0 :         ODBC_EXIT(dbc, SQL_SUCCESS);
    5307             : #undef ODBC_ALL_API
    5308             : }
    5309             : 
    5310             : 
    5311             : static SQLRETURN
    5312         660 : _SQLGetInfo(TDS_DBC * dbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    5313             :             SQLSMALLINT FAR * pcbInfoValue _WIDE)
    5314             : {
    5315         660 :         const char *p = NULL;
    5316             :         char buf[32];
    5317             :         TDSSOCKET *tds;
    5318         660 :         int is_ms = -1;
    5319         660 :         unsigned int smajor = 6;
    5320         660 :         SQLUINTEGER mssql7plus_mask = 0;
    5321         660 :         int out_len = -1;
    5322             : 
    5323         660 :         tdsdump_log(TDS_DBG_FUNC, "_SQLGetInfo(%p, %u, %p, %d, %p)\n",
    5324             :                         dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    5325             : 
    5326             : #define SIVAL out_len = sizeof(SQLSMALLINT), *((SQLSMALLINT *) rgbInfoValue)
    5327             : #define USIVAL out_len = sizeof(SQLUSMALLINT), *((SQLUSMALLINT *) rgbInfoValue)
    5328             : #define IVAL out_len = sizeof(SQLINTEGER), *((SQLINTEGER *) rgbInfoValue)
    5329             : #define UIVAL out_len = sizeof(SQLUINTEGER), *((SQLUINTEGER *) rgbInfoValue)
    5330             : #define ULVAL out_len = sizeof(SQLULEN), *((SQLULEN *) rgbInfoValue)
    5331             : 
    5332         660 :         if ((tds = dbc->tds_socket) != NULL) {
    5333         628 :                 is_ms = TDS_IS_MSSQL(tds);
    5334         628 :                 smajor = (tds->conn->product_version >> 24) & 0x7F;
    5335         628 :                 if (is_ms && smajor >= 7)
    5336         494 :                         mssql7plus_mask = ~((SQLUINTEGER) 0);
    5337             :         }
    5338             : 
    5339         660 :         switch (fInfoType) {
    5340             :         case SQL_ACCESSIBLE_PROCEDURES:
    5341             :         case SQL_ACCESSIBLE_TABLES:
    5342             :                 p = "Y";
    5343             :                 break;
    5344             :                 /* SQL_ACTIVE_CONNECTIONS renamed to SQL_MAX_DRIVER_CONNECTIONS */
    5345             : #if (ODBCVER >= 0x0300)
    5346           0 :         case SQL_ACTIVE_ENVIRONMENTS:
    5347           0 :                 UIVAL = 0;
    5348           0 :                 break;
    5349             : #endif /* ODBCVER >= 0x0300 */
    5350             : #if (ODBCVER >= 0x0300)
    5351           0 :         case SQL_AGGREGATE_FUNCTIONS:
    5352           0 :                 UIVAL = SQL_AF_ALL;
    5353           0 :                 break;
    5354           0 :         case SQL_ALTER_DOMAIN:
    5355           0 :                 UIVAL = 0;
    5356           0 :                 break;
    5357             : #endif /* ODBCVER >= 0x0300 */
    5358           0 :         case SQL_ALTER_TABLE:
    5359           0 :                 UIVAL = SQL_AT_ADD_COLUMN | SQL_AT_ADD_COLUMN_DEFAULT | SQL_AT_ADD_COLUMN_SINGLE | SQL_AT_ADD_CONSTRAINT |
    5360             :                         SQL_AT_ADD_TABLE_CONSTRAINT | SQL_AT_CONSTRAINT_NAME_DEFINITION | SQL_AT_DROP_COLUMN_RESTRICT;
    5361           0 :                 break;
    5362             : #if (ODBCVER >= 0x0300)
    5363           0 :         case SQL_ASYNC_MODE:
    5364             :                 /* TODO we hope so in a not-too-far future */
    5365             :                 /* UIVAL = SQL_AM_STATEMENT; */
    5366           0 :                 UIVAL = SQL_AM_NONE;
    5367           0 :                 break;
    5368           0 :         case SQL_BATCH_ROW_COUNT:
    5369           0 :                 UIVAL = SQL_BRC_EXPLICIT;
    5370           0 :                 break;
    5371           0 :         case SQL_BATCH_SUPPORT:
    5372           0 :                 UIVAL = SQL_BS_ROW_COUNT_EXPLICIT | SQL_BS_ROW_COUNT_PROC | SQL_BS_SELECT_EXPLICIT | SQL_BS_SELECT_PROC;
    5373           0 :                 break;
    5374             : #endif /* ODBCVER >= 0x0300 */
    5375           0 :         case SQL_BOOKMARK_PERSISTENCE:
    5376             :                 /* TODO ??? */
    5377           0 :                 UIVAL = SQL_BP_DELETE | SQL_BP_SCROLL | SQL_BP_UPDATE;
    5378           0 :                 break;
    5379           0 :         case SQL_CATALOG_LOCATION:
    5380           0 :                 SIVAL = SQL_CL_START;
    5381           0 :                 break;
    5382             : #if (ODBCVER >= 0x0300)
    5383             :         case SQL_CATALOG_NAME:
    5384             :                 p = "Y";
    5385             :                 break;
    5386             : #endif /* ODBCVER >= 0x0300 */
    5387           0 :         case SQL_CATALOG_NAME_SEPARATOR:
    5388           0 :                 p = ".";
    5389           0 :                 break;
    5390           0 :         case SQL_CATALOG_TERM:
    5391           0 :                 p = "database";
    5392           0 :                 break;
    5393           0 :         case SQL_CATALOG_USAGE:
    5394           0 :                 UIVAL = SQL_CU_DML_STATEMENTS | SQL_CU_PROCEDURE_INVOCATION | SQL_CU_TABLE_DEFINITION;
    5395           0 :                 break;
    5396             :                 /* TODO */
    5397             : #if 0
    5398             :         case SQL_COLLATION_SEQ:
    5399             :                 break;
    5400             : #endif
    5401             :         case SQL_COLUMN_ALIAS:
    5402             :                 p = "Y";
    5403             :                 break;
    5404           0 :         case SQL_CONCAT_NULL_BEHAVIOR:
    5405           0 :                 if (is_ms == -1)
    5406             :                         return SQL_ERROR;
    5407             :                 /* TODO a bit more complicate for mssql2k.. */
    5408           0 :                 SIVAL = (!is_ms || smajor < 7) ? SQL_CB_NON_NULL : SQL_CB_NULL;
    5409           0 :                 break;
    5410             :                 /* TODO SQL_CONVERT_BIGINT SQL_CONVERT_GUID SQL_CONVERT_DATE SQL_CONVERT_TIME */
    5411             :                 /* For Sybase/MSSql6.x we return 0 cause NativeSql is not so implemented */
    5412           0 :         case SQL_CONVERT_BINARY:
    5413           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_VARCHAR |
    5414             :                          SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TINYINT | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR |
    5415           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5416           0 :                 break;
    5417           0 :         case SQL_CONVERT_BIT:
    5418           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5419             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5420           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5421           0 :                 break;
    5422           0 :         case SQL_CONVERT_CHAR:
    5423           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5424             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5425             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5426           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5427           0 :                 break;
    5428           0 :         case SQL_CONVERT_DECIMAL:
    5429           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5430             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5431           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5432           0 :                 break;
    5433           0 :         case SQL_CONVERT_FLOAT:
    5434           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5435           0 :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) &
    5436             :                         mssql7plus_mask;
    5437           0 :                 break;
    5438           0 :         case SQL_CONVERT_INTEGER:
    5439           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5440             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5441           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5442           0 :                 break;
    5443           0 :         case SQL_CONVERT_LONGVARCHAR:
    5444           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5445           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5446           0 :                 break;
    5447           0 :         case SQL_CONVERT_NUMERIC:
    5448           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5449             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5450           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5451           0 :                 break;
    5452           0 :         case SQL_CONVERT_REAL:
    5453           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5454           0 :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BIT | SQL_CVT_TINYINT | SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) &
    5455             :                         mssql7plus_mask;
    5456           0 :                 break;
    5457           0 :         case SQL_CONVERT_SMALLINT:
    5458           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5459             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5460           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5461           0 :                 break;
    5462           0 :         case SQL_CONVERT_TIMESTAMP:
    5463           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TIMESTAMP | SQL_CVT_WCHAR |
    5464           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5465           0 :                 break;
    5466           0 :         case SQL_CONVERT_TINYINT:
    5467           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5468             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT | SQL_CVT_TINYINT |
    5469           0 :                          SQL_CVT_WCHAR | SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5470           0 :                 break;
    5471           0 :         case SQL_CONVERT_VARBINARY:
    5472           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_VARCHAR |
    5473             :                          SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_TINYINT | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR |
    5474           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5475           0 :                 break;
    5476           0 :         case SQL_CONVERT_VARCHAR:
    5477           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5478             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5479             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5480           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5481           0 :                 break;
    5482           0 :         case SQL_CONVERT_LONGVARBINARY:
    5483           0 :                 UIVAL = (SQL_CVT_BINARY | SQL_CVT_LONGVARBINARY | SQL_CVT_VARBINARY) & mssql7plus_mask;
    5484           0 :                 break;
    5485           0 :         case SQL_CONVERT_WLONGVARCHAR:
    5486           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5487           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5488           0 :                 break;
    5489             : #if (ODBCVER >= 0x0300)
    5490           0 :         case SQL_CONVERT_WCHAR:
    5491           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5492             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5493             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5494           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5495           0 :                 break;
    5496           0 :         case SQL_CONVERT_WVARCHAR:
    5497           0 :                 UIVAL = (SQL_CVT_CHAR | SQL_CVT_NUMERIC | SQL_CVT_DECIMAL | SQL_CVT_INTEGER | SQL_CVT_SMALLINT | SQL_CVT_FLOAT |
    5498             :                          SQL_CVT_REAL | SQL_CVT_VARCHAR | SQL_CVT_LONGVARCHAR | SQL_CVT_BINARY | SQL_CVT_VARBINARY | SQL_CVT_BIT |
    5499             :                          SQL_CVT_TINYINT | SQL_CVT_TIMESTAMP | SQL_CVT_LONGVARBINARY | SQL_CVT_WCHAR | SQL_CVT_WLONGVARCHAR |
    5500           0 :                          SQL_CVT_WVARCHAR) & mssql7plus_mask;
    5501           0 :                 break;
    5502             : #endif /* ODBCVER >= 0x0300 */
    5503           0 :         case SQL_CONVERT_FUNCTIONS:
    5504             :                 /* TODO no CAST for Sybase ?? */
    5505           0 :                 UIVAL = SQL_FN_CVT_CONVERT | SQL_FN_CVT_CAST;
    5506           0 :                 break;
    5507             : #if (ODBCVER >= 0x0300)
    5508           0 :         case SQL_CREATE_ASSERTION:
    5509             :         case SQL_CREATE_CHARACTER_SET:
    5510             :         case SQL_CREATE_COLLATION:
    5511             :         case SQL_CREATE_DOMAIN:
    5512           0 :                 UIVAL = 0;
    5513           0 :                 break;
    5514           0 :         case SQL_CREATE_SCHEMA:
    5515           0 :                 UIVAL = SQL_CS_AUTHORIZATION | SQL_CS_CREATE_SCHEMA;
    5516           0 :                 break;
    5517           0 :         case SQL_CREATE_TABLE:
    5518           0 :                 UIVAL = SQL_CT_CREATE_TABLE;
    5519           0 :                 break;
    5520           0 :         case SQL_CREATE_TRANSLATION:
    5521           0 :                 UIVAL = 0;
    5522           0 :                 break;
    5523           0 :         case SQL_CREATE_VIEW:
    5524           0 :                 UIVAL = SQL_CV_CHECK_OPTION | SQL_CV_CREATE_VIEW;
    5525           0 :                 break;
    5526             : #endif /* ODBCVER >= 0x0300 */
    5527           0 :         case SQL_CORRELATION_NAME:
    5528           0 :                 USIVAL = SQL_CN_ANY;
    5529           0 :                 break;
    5530           0 :         case SQL_CURSOR_COMMIT_BEHAVIOR:
    5531             :                 /* currently cursors are not supported however sql server close automaticly cursors on commit */
    5532             :                 /* TODO cursors test what happen if rollback, cursors get properly deleted ?? */
    5533           0 :                 USIVAL = SQL_CB_CLOSE;
    5534           0 :                 break;
    5535           0 :         case SQL_CURSOR_ROLLBACK_BEHAVIOR:
    5536           0 :                 USIVAL = SQL_CB_CLOSE;
    5537           0 :                 break;
    5538           0 :         case SQL_CURSOR_SENSITIVITY:
    5539           0 :                 UIVAL = SQL_SENSITIVE;
    5540           0 :                 break;
    5541           0 :         case SQL_DATABASE_NAME:
    5542           0 :                 p = tds_dstr_cstr(&dbc->attr.current_catalog);
    5543           0 :                 break;
    5544           0 :         case SQL_DATA_SOURCE_NAME:
    5545           0 :                 p = tds_dstr_cstr(&dbc->dsn);
    5546           0 :                 break;
    5547           0 :         case SQL_DATA_SOURCE_READ_ONLY:
    5548             :                 /*
    5549             :                  * TODO: determine the right answer from connection 
    5550             :                  * attribute SQL_ATTR_ACCESS_MODE
    5551             :                  */
    5552           0 :                 p = "N";      /* false, writable */
    5553           0 :                 break;
    5554             : #if (ODBCVER >= 0x0300)
    5555           0 :         case SQL_DATETIME_LITERALS:
    5556             :                 /* TODO ok ?? */
    5557           0 :                 UIVAL = 0;
    5558           0 :                 break;
    5559             : #endif /* ODBCVER >= 0x0300 */
    5560         198 :         case SQL_DBMS_NAME:
    5561         198 :                 p = tds ? tds->conn->product_name : NULL;
    5562             :                 break;
    5563          62 :         case SQL_DBMS_VER:
    5564          62 :                 if (!dbc->tds_socket)
    5565             :                         return SQL_ERROR;
    5566          62 :                 odbc_rdbms_version(dbc->tds_socket, buf);
    5567          62 :                 p = buf;
    5568          62 :                 break;
    5569             : #if (ODBCVER >= 0x0300)
    5570           0 :         case SQL_DDL_INDEX:
    5571           0 :                 UIVAL = 0;
    5572           0 :                 break;
    5573             : #endif /* ODBCVER >= 0x0300 */
    5574           0 :         case SQL_DEFAULT_TXN_ISOLATION:
    5575           0 :                 UIVAL = SQL_TXN_READ_COMMITTED;
    5576           0 :                 break;
    5577             : #if (ODBCVER >= 0x0300)
    5578           0 :         case SQL_DESCRIBE_PARAMETER:
    5579             :                 /* TODO */
    5580           0 :                 p = "N";
    5581           0 :                 break;
    5582             : #endif /* ODBCVER >= 0x0300 */
    5583           8 :         case SQL_DRIVER_HDBC:
    5584           8 :                 ULVAL = (SQLULEN) dbc;
    5585           8 :                 break;
    5586           8 :         case SQL_DRIVER_HENV:
    5587           8 :                 ULVAL = (SQLULEN) dbc->env;
    5588           8 :                 break;
    5589           0 :         case SQL_DRIVER_HSTMT:
    5590           0 :                 ULVAL = (SQLULEN) dbc->current_statement;
    5591           0 :                 break;
    5592         234 :         case SQL_DRIVER_NAME:   /* ODBC 2.0 */
    5593         234 :                 p = "libtdsodbc.so";
    5594         234 :                 break;
    5595           0 :         case SQL_DRIVER_ODBC_VER:
    5596           0 :                 p = "03.50";
    5597           0 :                 break;
    5598           0 :         case SQL_DRIVER_VER:
    5599           0 :                 sprintf(buf, "%02d.%02d.%04d", TDS_VERSION_MAJOR,
    5600             :                         TDS_VERSION_MINOR, TDS_VERSION_SUBVERSION);
    5601           0 :                 p = buf;
    5602           0 :                 break;
    5603             : #if (ODBCVER >= 0x0300)
    5604           0 :         case SQL_DROP_ASSERTION:
    5605             :         case SQL_DROP_CHARACTER_SET:
    5606             :         case SQL_DROP_COLLATION:
    5607             :         case SQL_DROP_DOMAIN:
    5608             :         case SQL_DROP_SCHEMA:
    5609           0 :                 UIVAL = 0;
    5610           0 :                 break;
    5611           0 :         case SQL_DROP_TABLE:
    5612           0 :                 UIVAL = SQL_DT_DROP_TABLE;
    5613           0 :                 break;
    5614           0 :         case SQL_DROP_TRANSLATION:
    5615           0 :                 UIVAL = 0;
    5616           0 :                 break;
    5617           0 :         case SQL_DROP_VIEW:
    5618           0 :                 UIVAL = SQL_DV_DROP_VIEW;
    5619           0 :                 break;
    5620           0 :         case SQL_DYNAMIC_CURSOR_ATTRIBUTES1:
    5621           0 :                 if (dbc->cursor_support)
    5622             :                         /* TODO cursor SQL_CA1_BULK_ADD SQL_CA1_POS_REFRESH SQL_CA1_SELECT_FOR_UPDATE */
    5623           0 :                         UIVAL = SQL_CA1_ABSOLUTE | SQL_CA1_NEXT | SQL_CA1_RELATIVE |
    5624             :                                 SQL_CA1_LOCK_NO_CHANGE |
    5625             :                                 SQL_CA1_POS_DELETE | SQL_CA1_POS_POSITION | SQL_CA1_POS_UPDATE |
    5626             :                                 SQL_CA1_POSITIONED_UPDATE | SQL_CA1_POSITIONED_DELETE;
    5627             :                 else
    5628           0 :                         UIVAL = 0;
    5629             :                 break;
    5630           0 :         case SQL_DYNAMIC_CURSOR_ATTRIBUTES2:
    5631             :                 /* TODO cursors */
    5632             :                 /* Cursors not supported yet */
    5633             :                 /*
    5634             :                  * Should be SQL_CA2_LOCK_CONCURRENCY SQL_CA2_MAX_ROWS_CATALOG SQL_CA2_MAX_ROWS_DELETE 
    5635             :                  * SQL_CA2_MAX_ROWS_INSERT SQL_CA2_MAX_ROWS_SELECT SQL_CA2_MAX_ROWS_UPDATE SQL_CA2_OPT_ROWVER_CONCURRENCY
    5636             :                  * SQL_CA2_OPT_VALUES_CONCURRENCY SQL_CA2_READ_ONLY_CONCURRENCY SQL_CA2_SENSITIVITY_ADDITIONS
    5637             :                  * SQL_CA2_SENSITIVITY_UPDATES SQL_CA2_SIMULATE_UNIQUE
    5638             :                  */
    5639           0 :                 UIVAL = 0;
    5640           0 :                 break;
    5641             : #endif /* ODBCVER >= 0x0300 */
    5642             :         case SQL_EXPRESSIONS_IN_ORDERBY:
    5643             :                 p = "Y";
    5644             :                 break;
    5645           0 :         case SQL_FILE_USAGE:
    5646           0 :                 USIVAL = SQL_FILE_NOT_SUPPORTED;
    5647           0 :                 break;
    5648           0 :         case SQL_FETCH_DIRECTION:
    5649           0 :                 if (dbc->cursor_support)
    5650             :                         /* TODO cursors SQL_FD_FETCH_BOOKMARK */
    5651           0 :                         UIVAL = SQL_FD_FETCH_ABSOLUTE|SQL_FD_FETCH_FIRST|SQL_FD_FETCH_LAST|SQL_FD_FETCH_NEXT|SQL_FD_FETCH_PRIOR|SQL_FD_FETCH_RELATIVE;
    5652             :                 else
    5653           0 :                         UIVAL = 0;
    5654             :                 break;
    5655             : #if (ODBCVER >= 0x0300)
    5656           0 :         case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES1:
    5657           0 :                 if (dbc->cursor_support)
    5658             :                         /* TODO cursors SQL_CA1_SELECT_FOR_UPDATE */
    5659           0 :                         UIVAL = SQL_CA1_NEXT|SQL_CA1_POSITIONED_DELETE|SQL_CA1_POSITIONED_UPDATE;
    5660             :                 else
    5661           0 :                         UIVAL = 0;
    5662             :                 break;
    5663           0 :         case SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2:
    5664             :                 /* TODO cursors */
    5665             :                 /* Cursors not supported yet */
    5666             :                 /*
    5667             :                  * Should be SQL_CA2_LOCK_CONCURRENCY SQL_CA2_MAX_ROWS_CATALOG SQL_CA2_MAX_ROWS_DELETE 
    5668             :                  * SQL_CA2_MAX_ROWS_INSERT SQL_CA2_MAX_ROWS_SELECT SQL_CA2_MAX_ROWS_UPDATE SQL_CA2_OPT_ROWVER_CONCURRENCY
    5669             :                  * SQL_CA2_OPT_VALUES_CONCURRENCY SQL_CA2_READ_ONLY_CONCURRENCY
    5670             :                  */
    5671           0 :                 UIVAL = 0;
    5672           0 :                 break;
    5673             : #endif /* ODBCVER >= 0x0300 */
    5674           0 :         case SQL_GETDATA_EXTENSIONS:
    5675             :                 /* TODO FreeTDS support more ?? */
    5676           0 :                 UIVAL = SQL_GD_BLOCK;
    5677           0 :                 break;
    5678           0 :         case SQL_GROUP_BY:
    5679           0 :                 USIVAL = SQL_GB_GROUP_BY_CONTAINS_SELECT;
    5680           0 :                 break;
    5681           0 :         case SQL_IDENTIFIER_CASE:
    5682             :                 /* TODO configuration dependend */
    5683           0 :                 USIVAL = SQL_IC_MIXED;
    5684           0 :                 break;
    5685           0 :         case SQL_IDENTIFIER_QUOTE_CHAR:
    5686           0 :                 p = "\"";
    5687             :                 /* TODO workaround for Sybase, use SET QUOTED_IDENTIFIER ON and fix unwanted quote */
    5688           0 :                 if (!is_ms)
    5689           0 :                         p = "";
    5690             :                 break;
    5691             : #if (ODBCVER >= 0x0300)
    5692           0 :         case SQL_INDEX_KEYWORDS:
    5693           0 :                 UIVAL = SQL_IK_ASC | SQL_IK_DESC;
    5694           0 :                 break;
    5695             : #endif /* ODBCVER >= 0x0300 */
    5696           0 :         case SQL_INFO_SCHEMA_VIEWS:
    5697             :                 /* TODO finish */
    5698           0 :                 UIVAL = 0;
    5699           0 :                 break;
    5700           0 :         case SQL_INSERT_STATEMENT:
    5701           0 :                 UIVAL = 0;
    5702           0 :                 break;
    5703             :                 /* renamed from SQL_ODBC_SQL_OPT_IEF */
    5704             :         case SQL_INTEGRITY:
    5705             :                 p = "Y";
    5706             :                 break;
    5707           0 :         case SQL_KEYSET_CURSOR_ATTRIBUTES1:
    5708             :         case SQL_KEYSET_CURSOR_ATTRIBUTES2:
    5709             :                 /* TODO cursors */
    5710           0 :                 UIVAL = 0;
    5711           0 :                 break;
    5712           0 :         case SQL_KEYWORDS:
    5713             :                 /* TODO ok for Sybase ? */
    5714           0 :                 p = "BREAK,BROWSE,BULK,CHECKPOINT,CLUSTERED,"
    5715             :                         "COMMITTED,COMPUTE,CONFIRM,CONTROLROW,DATABASE,"
    5716             :                         "DBCC,DISK,DISTRIBUTED,DUMMY,DUMP,ERRLVL,"
    5717             :                         "ERROREXIT,EXIT,FILE,FILLFACTOR,FLOPPY,HOLDLOCK,"
    5718             :                         "IDENTITY_INSERT,IDENTITYCOL,IF,KILL,LINENO,"
    5719             :                         "LOAD,MIRROREXIT,NONCLUSTERED,OFF,OFFSETS,ONCE,"
    5720             :                         "OVER,PERCENT,PERM,PERMANENT,PLAN,PRINT,PROC,"
    5721             :                         "PROCESSEXIT,RAISERROR,READ,READTEXT,RECONFIGURE,"
    5722             :                         "REPEATABLE,RETURN,ROWCOUNT,RULE,SAVE,SERIALIZABLE,"
    5723             :                         "SETUSER,SHUTDOWN,STATISTICS,TAPE,TEMP,TEXTSIZE,"
    5724             :                         "TRAN,TRIGGER,TRUNCATE,TSEQUEL,UNCOMMITTED," "UPDATETEXT,USE,WAITFOR,WHILE,WRITETEXT";
    5725           0 :                 break;
    5726             :         case SQL_LIKE_ESCAPE_CLAUSE:
    5727             :                 p = "Y";
    5728             :                 break;
    5729           0 :         case SQL_LOCK_TYPES:
    5730           0 :                 if (dbc->cursor_support)
    5731           0 :                         IVAL = SQL_LCK_NO_CHANGE;
    5732             :                 else
    5733           0 :                         IVAL = 0;
    5734             :                 break;
    5735             : #if (ODBCVER >= 0x0300)
    5736           0 :         case SQL_MAX_ASYNC_CONCURRENT_STATEMENTS:
    5737           0 :                 UIVAL = 1;
    5738           0 :                 break;
    5739             : #endif /* ODBCVER >= 0x0300 */
    5740             :                 /* TODO same limits for Sybase ? */
    5741           0 :         case SQL_MAX_BINARY_LITERAL_LEN:
    5742           0 :                 UIVAL = 131072;
    5743           0 :                 break;
    5744           0 :         case SQL_MAX_CHAR_LITERAL_LEN:
    5745           0 :                 UIVAL = 131072;
    5746           0 :                 break;
    5747           0 :         case SQL_MAX_CONCURRENT_ACTIVITIES:
    5748           0 :                 USIVAL = 1;
    5749           0 :                 break;
    5750           0 :         case SQL_MAX_COLUMNS_IN_GROUP_BY:
    5751             :         case SQL_MAX_COLUMNS_IN_INDEX:
    5752             :         case SQL_MAX_COLUMNS_IN_ORDER_BY:
    5753             :                 /* TODO Sybase ? */
    5754           0 :                 USIVAL = 16;
    5755           0 :                 break;
    5756           0 :         case SQL_MAX_COLUMNS_IN_SELECT:
    5757             :                 /* TODO Sybase ? */
    5758           0 :                 USIVAL = 4000;
    5759           0 :                 break;
    5760           0 :         case SQL_MAX_COLUMNS_IN_TABLE:
    5761             :                 /* TODO Sybase ? */
    5762           0 :                 USIVAL = 250;
    5763           0 :                 break;
    5764           0 :         case SQL_MAX_DRIVER_CONNECTIONS:
    5765           0 :                 USIVAL = 0;
    5766           0 :                 break;
    5767           0 :         case SQL_MAX_IDENTIFIER_LEN:
    5768           0 :                 if (is_ms == -1)
    5769             :                         return SQL_ERROR;
    5770           0 :                 USIVAL = (!is_ms || smajor < 7) ? 30 : 128;
    5771           0 :                 break;
    5772           0 :         case SQL_MAX_INDEX_SIZE:
    5773           0 :                 UIVAL = 127;
    5774           0 :                 break;
    5775           0 :         case SQL_MAX_PROCEDURE_NAME_LEN:
    5776           0 :                 if (is_ms == -1)
    5777             :                         return SQL_ERROR;
    5778             :                 /* TODO Sybase ? */
    5779           0 :                 USIVAL = (is_ms && smajor >= 7) ? 134 : 36;
    5780           0 :                 break;
    5781           0 :         case SQL_MAX_ROW_SIZE:
    5782           0 :                 if (is_ms == -1)
    5783             :                         return SQL_ERROR;
    5784             :                 /* TODO Sybase ? */
    5785           0 :                 UIVAL = (is_ms && smajor >= 7) ? 8062 : 1962;
    5786           0 :                 break;
    5787           0 :         case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
    5788           0 :                 p = "N";
    5789           0 :                 break;
    5790           0 :         case SQL_MAX_STATEMENT_LEN:
    5791             :                 /* TODO Sybase ? */
    5792           0 :                 UIVAL = 131072;
    5793           0 :                 break;
    5794           0 :         case SQL_MAX_TABLES_IN_SELECT:
    5795             :                 /* TODO Sybase ? */
    5796           0 :                 USIVAL = 16;
    5797           0 :                 break;
    5798           0 :         case SQL_MAX_USER_NAME_LEN:
    5799             :                 /* TODO Sybase ? */
    5800           0 :                 if (is_ms == -1)
    5801             :                         return SQL_ERROR;
    5802           0 :                 USIVAL = (is_ms && smajor >= 7) ? 128 : 30;
    5803           0 :                 break;
    5804           0 :         case SQL_MAX_COLUMN_NAME_LEN:
    5805             :         case SQL_MAX_CURSOR_NAME_LEN:
    5806             :         case SQL_MAX_SCHEMA_NAME_LEN:
    5807             :         case SQL_MAX_CATALOG_NAME_LEN:
    5808             :         case SQL_MAX_TABLE_NAME_LEN:
    5809             :                 /* TODO Sybase ? */
    5810           0 :                 if (is_ms == -1)
    5811             :                         return SQL_ERROR;
    5812           0 :                 USIVAL = (is_ms && smajor >= 7) ? 128 : 30;
    5813           0 :                 break;
    5814             :         case SQL_MULT_RESULT_SETS:
    5815             :                 p = "Y";
    5816             :                 break;
    5817             :         case SQL_MULTIPLE_ACTIVE_TXN:
    5818             :                 p = "Y";
    5819             :                 break;
    5820             :         case SQL_NEED_LONG_DATA_LEN:
    5821             :                 /* current implementation do not require length, however future will, so is correct to return yes */
    5822             :                 p = "Y";
    5823             :                 break;
    5824           0 :         case SQL_NON_NULLABLE_COLUMNS:
    5825           0 :                 USIVAL = SQL_NNC_NON_NULL;
    5826           0 :                 break;
    5827           0 :         case SQL_NULL_COLLATION:
    5828           0 :                 USIVAL = SQL_NC_LOW;
    5829           0 :                 break;
    5830           0 :         case SQL_NUMERIC_FUNCTIONS:
    5831           0 :                 UIVAL = (SQL_FN_NUM_ABS | SQL_FN_NUM_ACOS | SQL_FN_NUM_ASIN | SQL_FN_NUM_ATAN | SQL_FN_NUM_ATAN2 |
    5832             :                          SQL_FN_NUM_CEILING | SQL_FN_NUM_COS | SQL_FN_NUM_COT | SQL_FN_NUM_DEGREES | SQL_FN_NUM_EXP |
    5833             :                          SQL_FN_NUM_FLOOR | SQL_FN_NUM_LOG | SQL_FN_NUM_LOG10 | SQL_FN_NUM_MOD | SQL_FN_NUM_PI | SQL_FN_NUM_POWER |
    5834             :                          SQL_FN_NUM_RADIANS | SQL_FN_NUM_RAND | SQL_FN_NUM_ROUND | SQL_FN_NUM_SIGN | SQL_FN_NUM_SIN |
    5835           0 :                          SQL_FN_NUM_SQRT | SQL_FN_NUM_TAN) & mssql7plus_mask;
    5836           0 :                 break;
    5837           0 :         case SQL_ODBC_API_CONFORMANCE:
    5838           0 :                 SIVAL = SQL_OAC_LEVEL2;
    5839           0 :                 break;
    5840             : #if (ODBCVER >= 0x0300)
    5841           0 :         case SQL_ODBC_INTERFACE_CONFORMANCE:
    5842           0 :                 UIVAL = SQL_OAC_LEVEL2;
    5843           0 :                 break;
    5844             : #endif /* ODBCVER >= 0x0300 */
    5845           0 :         case SQL_ODBC_SAG_CLI_CONFORMANCE:
    5846           0 :                 SIVAL = SQL_OSCC_NOT_COMPLIANT;
    5847           0 :                 break;
    5848           0 :         case SQL_ODBC_SQL_CONFORMANCE:
    5849           0 :                 SIVAL = SQL_OSC_CORE;
    5850           0 :                 break;
    5851             : #ifdef TDS_NO_DM
    5852           0 :         case SQL_ODBC_VER:
    5853             :                 /* TODO check format ##.##.0000 */
    5854           0 :                 p = VERSION;
    5855           0 :                 break;
    5856             : #endif
    5857             : #if (ODBCVER >= 0x0300)
    5858           0 :         case SQL_OJ_CAPABILITIES:
    5859           0 :                 UIVAL = SQL_OJ_ALL_COMPARISON_OPS | SQL_OJ_FULL | SQL_OJ_INNER | SQL_OJ_LEFT | SQL_OJ_NESTED | SQL_OJ_NOT_ORDERED |
    5860             :                         SQL_OJ_RIGHT;
    5861           0 :                 break;
    5862             : #endif /* ODBCVER >= 0x0300 */
    5863           0 :         case SQL_ORDER_BY_COLUMNS_IN_SELECT:
    5864           0 :                 p = "N";
    5865           0 :                 break;
    5866             :         case SQL_OUTER_JOINS:
    5867             :                 p = "Y";
    5868             :                 break;
    5869             : #if (ODBCVER >= 0x0300)
    5870           0 :         case SQL_PARAM_ARRAY_ROW_COUNTS:
    5871           0 :                 UIVAL = SQL_PARC_BATCH;
    5872           0 :                 break;
    5873           0 :         case SQL_PARAM_ARRAY_SELECTS:
    5874           0 :                 UIVAL = SQL_PAS_BATCH;
    5875           0 :                 break;
    5876             : #endif /* ODBCVER >= 0x0300 */
    5877           0 :         case SQL_POS_OPERATIONS:
    5878           0 :                 if (dbc->cursor_support)
    5879             :                         /* TODO cursors SQL_POS_ADD SQL_POS_REFRESH */
    5880             :                         /* test REFRESH, ADD under mssql, under Sybase I don't know how to do it but dblib do */
    5881           0 :                         IVAL = SQL_POS_DELETE | SQL_POS_POSITION | SQL_POS_UPDATE;
    5882             :                 else
    5883           0 :                         IVAL = 0;
    5884             :                 break;
    5885           0 :         case SQL_POSITIONED_STATEMENTS:
    5886             :                 /* TODO cursors SQL_PS_SELECT_FOR_UPDATE */
    5887           0 :                 IVAL = SQL_PS_POSITIONED_DELETE | SQL_PS_POSITIONED_UPDATE;
    5888           0 :                 break;
    5889           0 :         case SQL_PROCEDURE_TERM:
    5890           0 :                 p = "stored procedure";
    5891           0 :                 break;
    5892             :         case SQL_PROCEDURES:
    5893             :                 p = "Y";
    5894             :                 break;
    5895           0 :         case SQL_QUOTED_IDENTIFIER_CASE:
    5896             :                 /* TODO usually insensitive */
    5897           0 :                 USIVAL = SQL_IC_MIXED;
    5898           0 :                 break;
    5899           0 :         case SQL_ROW_UPDATES:
    5900           0 :                 p = "N";
    5901           0 :                 break;
    5902             : #if (ODBCVER >= 0x0300)
    5903           0 :         case SQL_SCHEMA_TERM:
    5904           0 :                 p = "owner";
    5905           0 :                 break;
    5906           0 :         case SQL_SCHEMA_USAGE:
    5907           0 :                 UIVAL = SQL_OU_DML_STATEMENTS | SQL_OU_INDEX_DEFINITION | SQL_OU_PRIVILEGE_DEFINITION | SQL_OU_PROCEDURE_INVOCATION
    5908             :                         | SQL_OU_TABLE_DEFINITION;
    5909           0 :                 break;
    5910             : #endif /* ODBCVER >= 0x0300 */
    5911           0 :         case SQL_SCROLL_CONCURRENCY:
    5912           0 :                 if (dbc->cursor_support)
    5913             :                         /* TODO cursors test them, Sybase support all ?  */
    5914           0 :                         IVAL = SQL_SCCO_LOCK | SQL_SCCO_OPT_ROWVER | SQL_SCCO_OPT_VALUES | SQL_SCCO_READ_ONLY;
    5915             :                 else
    5916           0 :                         IVAL = SQL_SCCO_READ_ONLY;
    5917             :                 break;
    5918           0 :         case SQL_SCROLL_OPTIONS:
    5919           0 :                 if (dbc->cursor_support)
    5920             :                         /* TODO cursors test them, Sybase support all ?? */
    5921           0 :                         UIVAL = SQL_SO_DYNAMIC | SQL_SO_FORWARD_ONLY | SQL_SO_KEYSET_DRIVEN | SQL_SO_STATIC;
    5922             :                 else
    5923           0 :                         UIVAL = SQL_SO_FORWARD_ONLY | SQL_SO_STATIC;
    5924             :                 break;
    5925           0 :         case SQL_SEARCH_PATTERN_ESCAPE:
    5926           0 :                 p = "\\";
    5927           0 :                 break;
    5928           0 :         case SQL_SERVER_NAME:
    5929           0 :                 p = dbc->tds_socket->conn->server;
    5930           0 :                 break;
    5931           0 :         case SQL_SPECIAL_CHARACTERS:
    5932             :                 /* TODO others ?? */
    5933           0 :                 p = "\'\"[]{}";
    5934           0 :                 break;
    5935             : #if (ODBCVER >= 0x0300)
    5936           0 :         case SQL_SQL_CONFORMANCE:
    5937           0 :                 UIVAL = SQL_SC_SQL92_ENTRY;
    5938           0 :                 break;
    5939           0 :         case SQL_SQL92_DATETIME_FUNCTIONS:
    5940             :         case SQL_SQL92_FOREIGN_KEY_DELETE_RULE:
    5941             :         case SQL_SQL92_FOREIGN_KEY_UPDATE_RULE:
    5942           0 :                 UIVAL = 0;
    5943           0 :                 break;
    5944           0 :         case SQL_SQL92_GRANT:
    5945           0 :                 UIVAL = SQL_SG_WITH_GRANT_OPTION;
    5946           0 :                 break;
    5947           0 :         case SQL_SQL92_NUMERIC_VALUE_FUNCTIONS:
    5948           0 :                 UIVAL = 0;
    5949           0 :                 break;
    5950           0 :         case SQL_SQL92_PREDICATES:
    5951             :                 /* TODO Sybase ?? */
    5952           0 :                 UIVAL = SQL_SP_EXISTS | SQL_SP_ISNOTNULL | SQL_SP_ISNULL;
    5953           0 :                 break;
    5954           0 :         case SQL_SQL92_RELATIONAL_JOIN_OPERATORS:
    5955             :                 /* TODO Sybase ?? */
    5956           0 :                 UIVAL = SQL_SRJO_CROSS_JOIN | SQL_SRJO_FULL_OUTER_JOIN | SQL_SRJO_INNER_JOIN | SQL_SRJO_LEFT_OUTER_JOIN |
    5957             :                         SQL_SRJO_RIGHT_OUTER_JOIN | SQL_SRJO_UNION_JOIN;
    5958           0 :                 break;
    5959           0 :         case SQL_SQL92_REVOKE:
    5960           0 :                 UIVAL = SQL_SR_GRANT_OPTION_FOR;
    5961           0 :                 break;
    5962           0 :         case SQL_SQL92_ROW_VALUE_CONSTRUCTOR:
    5963           0 :                 UIVAL = SQL_SRVC_DEFAULT | SQL_SRVC_NULL | SQL_SRVC_ROW_SUBQUERY | SQL_SRVC_VALUE_EXPRESSION;
    5964           0 :                 break;
    5965           0 :         case SQL_SQL92_STRING_FUNCTIONS:
    5966           0 :                 UIVAL = SQL_SSF_LOWER | SQL_SSF_UPPER;
    5967           0 :                 break;
    5968           0 :         case SQL_SQL92_VALUE_EXPRESSIONS:
    5969             :                 /* TODO Sybase ? CAST supported ? */
    5970           0 :                 UIVAL = SQL_SVE_CASE | SQL_SVE_CAST | SQL_SVE_COALESCE | SQL_SVE_NULLIF;
    5971           0 :                 break;
    5972           0 :         case SQL_STANDARD_CLI_CONFORMANCE:
    5973           0 :                 UIVAL = SQL_SCC_ISO92_CLI;
    5974           0 :                 break;
    5975           0 :         case SQL_STATIC_SENSITIVITY:
    5976           0 :                 IVAL = 0;
    5977           0 :                 break;
    5978           0 :         case SQL_STATIC_CURSOR_ATTRIBUTES1:
    5979           0 :                 if (dbc->cursor_support)
    5980             :                         /* TODO cursors SQL_CA1_BOOKMARK SQL_CA1_BULK_FETCH_BY_BOOKMARK SQL_CA1_POS_REFRESH */
    5981           0 :                         UIVAL = SQL_CA1_ABSOLUTE | SQL_CA1_LOCK_NO_CHANGE | SQL_CA1_NEXT | SQL_CA1_POS_POSITION | SQL_CA1_RELATIVE;
    5982             :                 else
    5983           0 :                         UIVAL = 0;
    5984             :                 break;
    5985           0 :         case SQL_STATIC_CURSOR_ATTRIBUTES2:
    5986             :                 /* TODO cursors */
    5987           0 :                 UIVAL = 0;
    5988           0 :                 break;
    5989             : #endif /* ODBCVER >= 0x0300 */
    5990           0 :         case SQL_STRING_FUNCTIONS:
    5991           0 :                 UIVAL = (SQL_FN_STR_ASCII | SQL_FN_STR_BIT_LENGTH | SQL_FN_STR_CHAR | SQL_FN_STR_CONCAT | SQL_FN_STR_DIFFERENCE |
    5992             :                          SQL_FN_STR_INSERT | SQL_FN_STR_LCASE | SQL_FN_STR_LEFT | SQL_FN_STR_LENGTH | SQL_FN_STR_LOCATE_2 |
    5993             :                          SQL_FN_STR_LTRIM | SQL_FN_STR_OCTET_LENGTH | SQL_FN_STR_REPEAT | SQL_FN_STR_RIGHT | SQL_FN_STR_RTRIM |
    5994           0 :                          SQL_FN_STR_SOUNDEX | SQL_FN_STR_SPACE | SQL_FN_STR_SUBSTRING | SQL_FN_STR_UCASE) & mssql7plus_mask;
    5995           0 :                 break;
    5996           0 :         case SQL_SUBQUERIES:
    5997           0 :                 UIVAL = SQL_SQ_COMPARISON | SQL_SQ_CORRELATED_SUBQUERIES | SQL_SQ_EXISTS | SQL_SQ_IN | SQL_SQ_QUANTIFIED;
    5998           0 :                 break;
    5999           0 :         case SQL_SYSTEM_FUNCTIONS:
    6000           0 :                 UIVAL = SQL_FN_SYS_DBNAME | SQL_FN_SYS_IFNULL | SQL_FN_SYS_USERNAME;
    6001           0 :                 break;
    6002           0 :         case SQL_TABLE_TERM:
    6003           0 :                 p = "table";
    6004           0 :                 break;
    6005           0 :         case SQL_TIMEDATE_ADD_INTERVALS:
    6006           0 :                 UIVAL = (SQL_FN_TSI_DAY | SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_HOUR | SQL_FN_TSI_MINUTE | SQL_FN_TSI_MONTH |
    6007           0 :                          SQL_FN_TSI_QUARTER | SQL_FN_TSI_SECOND | SQL_FN_TSI_WEEK | SQL_FN_TSI_YEAR) & mssql7plus_mask;
    6008           0 :                 break;
    6009           0 :         case SQL_TIMEDATE_DIFF_INTERVALS:
    6010           0 :                 UIVAL = (SQL_FN_TSI_DAY | SQL_FN_TSI_FRAC_SECOND | SQL_FN_TSI_HOUR | SQL_FN_TSI_MINUTE | SQL_FN_TSI_MONTH |
    6011           0 :                          SQL_FN_TSI_QUARTER | SQL_FN_TSI_SECOND | SQL_FN_TSI_WEEK | SQL_FN_TSI_YEAR) & mssql7plus_mask;
    6012           0 :                 break;
    6013           0 :         case SQL_TIMEDATE_FUNCTIONS:
    6014           0 :                 UIVAL = (SQL_FN_TD_CURDATE | SQL_FN_TD_CURRENT_DATE | SQL_FN_TD_CURRENT_TIME | SQL_FN_TD_CURRENT_TIMESTAMP |
    6015             :                          SQL_FN_TD_CURTIME | SQL_FN_TD_DAYNAME | SQL_FN_TD_DAYOFMONTH | SQL_FN_TD_DAYOFWEEK | SQL_FN_TD_DAYOFYEAR |
    6016             :                          SQL_FN_TD_EXTRACT | SQL_FN_TD_HOUR | SQL_FN_TD_MINUTE | SQL_FN_TD_MONTH | SQL_FN_TD_MONTHNAME |
    6017             :                          SQL_FN_TD_NOW | SQL_FN_TD_QUARTER | SQL_FN_TD_SECOND | SQL_FN_TD_TIMESTAMPADD | SQL_FN_TD_TIMESTAMPDIFF |
    6018           0 :                          SQL_FN_TD_WEEK | SQL_FN_TD_YEAR) & mssql7plus_mask;
    6019           0 :                 break;
    6020           0 :         case SQL_TXN_CAPABLE:
    6021             :                 /* transaction for DML and DDL */
    6022           0 :                 SIVAL = SQL_TC_ALL;
    6023           0 :                 break;
    6024           0 :         case SQL_TXN_ISOLATION_OPTION:
    6025           0 :                 UIVAL = SQL_TXN_READ_COMMITTED | SQL_TXN_READ_UNCOMMITTED | SQL_TXN_REPEATABLE_READ | SQL_TXN_SERIALIZABLE;
    6026           0 :                 break;
    6027           0 :         case SQL_UNION:
    6028           0 :                 UIVAL = SQL_U_UNION | SQL_U_UNION_ALL;
    6029           0 :                 break;
    6030             :                 /* TODO finish */
    6031           0 :         case SQL_USER_NAME:
    6032             :                 /* TODO this is not correct username */
    6033             :                 /* p = tds_dstr_cstr(&dbc->tds_login->user_name); */
    6034             :                 /* make OpenOffice happy :) */
    6035           0 :                 p = "";
    6036           0 :                 break;
    6037           0 :         case SQL_XOPEN_CLI_YEAR:
    6038             :                 /* TODO check specifications */
    6039           0 :                 p = "1995";
    6040           0 :                 break;
    6041          86 :         case SQL_INFO_FREETDS_TDS_VERSION:
    6042          86 :                 if (!dbc->tds_socket)
    6043             :                         return SQL_ERROR;
    6044          86 :                 UIVAL = TDS_MAJOR(dbc->tds_socket->conn) << 16 | TDS_MINOR(dbc->tds_socket->conn);
    6045          86 :                 break;
    6046          64 :         case SQL_INFO_FREETDS_SOCKET:
    6047          64 :                 if (IS_TDSDEAD(dbc->tds_socket))
    6048             :                         return SQL_ERROR;
    6049          64 :                 ULVAL = dbc->tds_socket->conn->s;
    6050          64 :                 break;
    6051           0 :         default:
    6052           0 :                 odbc_log_unimplemented_type("SQLGetInfo", fInfoType);
    6053           0 :                 odbc_errs_add(&dbc->errs, "HY092", "Option not supported");
    6054           0 :                 return SQL_ERROR;
    6055             :         }
    6056             : 
    6057             :         /* char data */
    6058         660 :         if (p) {
    6059         494 :                 return odbc_set_string_oct(dbc, rgbInfoValue, cbInfoValueMax, pcbInfoValue, p, -1);
    6060             :         } else {
    6061         166 :                 if (out_len > 0 && pcbInfoValue)
    6062         150 :                         *pcbInfoValue = out_len;
    6063             :         }
    6064             : 
    6065             :         return SQL_SUCCESS;
    6066             : #undef SIVAL
    6067             : #undef USIVAL
    6068             : #undef IVAL
    6069             : #undef UIVAL
    6070             : }
    6071             : 
    6072             : SQLRETURN ODBC_PUBLIC ODBC_API
    6073             : SQLGetInfo(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    6074             :            SQLSMALLINT FAR * pcbInfoValue)
    6075             : {
    6076         341 :         ODBC_ENTER_HDBC;
    6077             : 
    6078         341 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetInfo(%p, %d, %p, %d, %p)\n", 
    6079             :                         hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    6080             : 
    6081         341 :         ODBC_EXIT(dbc, _SQLGetInfo(dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue _wide0));
    6082             : }
    6083             : 
    6084             : #ifdef ENABLE_ODBC_WIDE
    6085             : SQLRETURN ODBC_PUBLIC ODBC_API
    6086             : SQLGetInfoW(SQLHDBC hdbc, SQLUSMALLINT fInfoType, SQLPOINTER rgbInfoValue, SQLSMALLINT cbInfoValueMax,
    6087             :            SQLSMALLINT FAR * pcbInfoValue)
    6088             : {
    6089         319 :         ODBC_ENTER_HDBC;
    6090             : 
    6091         319 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetInfoW(%p, %d, %p, %d, %p)\n",
    6092             :                         hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
    6093             : 
    6094         319 :         ODBC_EXIT(dbc, _SQLGetInfo(dbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue, 1));
    6095             : }
    6096             : #endif
    6097             : 
    6098             : static void
    6099             : tds_ascii_strupr(char *s)
    6100             : {
    6101       87550 :         for (; *s; ++s)
    6102       87550 :                 if ('a' <= *s && *s <= 'z')
    6103       21062 :                         *s = *s & (~0x20);
    6104             : }
    6105             : 
    6106             : static void
    6107         270 : odbc_upper_column_names(TDS_STMT * stmt)
    6108             : {
    6109             : #if ENABLE_EXTRA_CHECKS
    6110             :         TDSRESULTINFO *resinfo;
    6111             :         TDSSOCKET *tds;
    6112             : #endif
    6113             :         int icol;
    6114             :         TDS_DESC *ird;
    6115             : 
    6116         270 :         IRD_CHECK;
    6117             : 
    6118             : #if ENABLE_EXTRA_CHECKS
    6119         270 :         tds = stmt->dbc->tds_socket;
    6120         270 :         if (!tds || !tds->current_results)
    6121             :                 return;
    6122             : 
    6123             :         resinfo = tds->current_results;
    6124        3762 :         for (icol = 0; icol < resinfo->num_cols; ++icol) {
    6125        3762 :                 TDSCOLUMN *colinfo = resinfo->columns[icol];
    6126        7524 :                 char *p = tds_dstr_buf(&colinfo->column_name);
    6127        7524 :                 unsigned n, len = tds_dstr_len(&colinfo->column_name);
    6128             : 
    6129             :                 /* upper case */
    6130             :                 /* TODO procedure */
    6131       47800 :                 for (n = 0; n < len; ++n, ++p)
    6132       44038 :                         if ('a' <= *p && *p <= 'z')
    6133       10748 :                                 *p = *p & (~0x20);
    6134             :         }
    6135             : #endif
    6136             : 
    6137         270 :         ird = stmt->ird;
    6138        4302 :         for (icol = ird->header.sql_desc_count; --icol >= 0;) {
    6139        3762 :                 struct _drecord *drec = &ird->records[icol];
    6140             : 
    6141             :                 /* upper case */
    6142       11286 :                 tds_ascii_strupr(tds_dstr_buf(&drec->sql_desc_label));
    6143        7524 :                 tds_ascii_strupr(tds_dstr_buf(&drec->sql_desc_name));
    6144             :         }
    6145             : }
    6146             : 
    6147             : /**
    6148             :  * Change sql datatype to a specific version
    6149             :  * \param sql_type sql data type to change (any type)
    6150             :  * \param version  ODBC version to change to, 2 for ODBC 2, 3 for ODBC 3, 0 swap
    6151             :  */
    6152             : static SQLSMALLINT
    6153             : odbc_swap_datetime_sql_type(SQLSMALLINT sql_type, int version)
    6154             : {
    6155         234 :         switch (sql_type) {
    6156             :         case SQL_TYPE_TIMESTAMP:
    6157             :                 if (version != 3)
    6158           2 :                         sql_type = SQL_TIMESTAMP;
    6159             :                 break;
    6160             :         case SQL_TIMESTAMP:
    6161             :                 if (version != 2)
    6162          18 :                         sql_type = SQL_TYPE_TIMESTAMP;
    6163             :                 break;
    6164             :         case SQL_TYPE_DATE:
    6165             :                 if (version != 3)
    6166           2 :                         sql_type = SQL_DATE;
    6167             :                 break;
    6168             :         case SQL_DATE:
    6169             :                 if (version != 2)
    6170           6 :                         sql_type = SQL_TYPE_DATE;
    6171             :                 break;
    6172             :         case SQL_TYPE_TIME:
    6173             :                 if (version != 3)
    6174           2 :                         sql_type = SQL_TIME;
    6175             :                 break;
    6176             :         case SQL_TIME:
    6177             :                 if (version != 2)
    6178           6 :                         sql_type = SQL_TYPE_TIME;
    6179             :                 break;
    6180             :         }
    6181             :         return sql_type;
    6182             : }
    6183             : 
    6184             : SQLRETURN ODBC_PUBLIC ODBC_API
    6185             : SQLGetTypeInfo(SQLHSTMT hstmt, SQLSMALLINT fSqlType)
    6186             : {
    6187             :         SQLRETURN res;
    6188             :         TDSSOCKET *tds;
    6189             :         TDS_INT result_type;
    6190             :         TDS_INT compute_id;
    6191         116 :         int varchar_pos = -1, n;
    6192             :         static const char sql_templ_default[] = "sp_datatype_info %d";
    6193         116 :         const char *sql_templ = sql_templ_default;
    6194             :         char sql[sizeof(sql_templ_default) + 36];
    6195             :         int odbc3;
    6196             : 
    6197         116 :         ODBC_ENTER_HSTMT;
    6198             : 
    6199         116 :         tdsdump_log(TDS_DBG_FUNC, "SQLGetTypeInfo(%p, %d)\n", hstmt, fSqlType);
    6200             : 
    6201         116 :         tds = stmt->dbc->tds_socket;
    6202         116 :         odbc3 = (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3);
    6203             : 
    6204         116 :         if (IS_TDS73_PLUS(tds->conn))
    6205             :                 sql_templ = "sp_datatype_info_100 %d";
    6206          88 :         else if (IS_TDS72_PLUS(tds->conn))
    6207           0 :                 sql_templ = "sp_datatype_info_90 %d";
    6208             : 
    6209             :         /* For MSSQL6.5 and Sybase 11.9 sp_datatype_info work */
    6210             :         /* TODO what about early Sybase products ? */
    6211             :         /* TODO Does Sybase return all ODBC3 columns? Add them if not */
    6212             :         /* TODO ODBC3 convert type to ODBC version 2 (date) */
    6213         116 :         if (odbc3) {
    6214          58 :                 if (TDS_IS_SYBASE(tds)) {
    6215          16 :                         sprintf(sql, sql_templ, odbc_swap_datetime_sql_type(fSqlType, 0));
    6216          16 :                         stmt->special_row = ODBC_SPECIAL_GETTYPEINFO;
    6217             :                 } else {
    6218          42 :                         sprintf(sql, sql_templ, fSqlType);
    6219          42 :                         strcat(sql, ",3");
    6220             :                 }
    6221             :         } else {
    6222             :                 /* MS ODBC translate SQL_TIMESTAMP to SQL_TYPE_TIMESTAMP even for ODBC 2 apps
    6223             :                  * other DM just pass value straight.
    6224             :                  * Convert always to version 2 to make version 2 datatype works with all DMs
    6225             :                  */
    6226          58 :                 sprintf(sql, sql_templ, odbc_swap_datetime_sql_type(fSqlType, 2));
    6227             :         }
    6228         116 :         if (SQL_SUCCESS != odbc_set_stmt_query(stmt, (ODBC_CHAR*) sql, strlen(sql) _wide0))
    6229           0 :                 ODBC_EXIT(stmt, SQL_ERROR);
    6230             : 
    6231         120 :       redo:
    6232         120 :         res = _SQLExecute(stmt);
    6233             : 
    6234         120 :         odbc_upper_column_names(stmt);
    6235         120 :         if (odbc3) {
    6236          60 :                 odbc_col_setname(stmt, 3, "COLUMN_SIZE");
    6237          60 :                 odbc_col_setname(stmt, 11, "FIXED_PREC_SCALE");
    6238          60 :                 odbc_col_setname(stmt, 12, "AUTO_UNIQUE_VALUE");
    6239             :         }
    6240             : 
    6241             :         /* workaround for a mispelled column name in Sybase */
    6242         120 :         if (TDS_IS_SYBASE(stmt->dbc->tds_socket) && !odbc3)
    6243          18 :                 odbc_col_setname(stmt, 3, "PRECISION");
    6244             : 
    6245         120 :         if (TDS_IS_MSSQL(stmt->dbc->tds_socket) || fSqlType != SQL_VARCHAR || res != SQL_SUCCESS)
    6246         112 :                 ODBC_EXIT(stmt, res);
    6247             : 
    6248             :         /*
    6249             :          * Sybase return first nvarchar for char... and without length !!!
    6250             :          * Some program use first entry so we discard all entry before varchar
    6251             :          */
    6252             :         n = 0;
    6253          36 :         while (tds->current_results) {
    6254             :                 TDSRESULTINFO *resinfo;
    6255             :                 TDSCOLUMN *colinfo;
    6256             :                 char *name;
    6257             : 
    6258             :                 /* if next is varchar leave next for SQLFetch */
    6259          36 :                 if (n == (varchar_pos - 1))
    6260             :                         break;
    6261             : 
    6262          32 :                 switch (tds_process_tokens(stmt->dbc->tds_socket, &result_type, &compute_id, TDS_STOPAT_ROWFMT|TDS_RETURN_ROW)) {
    6263          28 :                 case TDS_SUCCESS:
    6264          28 :                         if (result_type == TDS_ROW_RESULT)
    6265             :                                 break;
    6266             :                 case TDS_NO_MORE_RESULTS:
    6267             :                         /* discard other tokens */
    6268           4 :                         tds_process_simple_query(tds);
    6269           4 :                         if (n >= varchar_pos && varchar_pos > 0)
    6270             :                                 goto redo;
    6271             :                         break;
    6272           0 :                 case TDS_CANCELLED:
    6273           0 :                         odbc_errs_add(&stmt->errs, "HY008", NULL);
    6274           0 :                         res = SQL_ERROR;
    6275           0 :                         break;
    6276             :                 }
    6277          28 :                 if (!tds->current_results)
    6278             :                         break;
    6279          28 :                 ++n;
    6280             : 
    6281          28 :                 resinfo = tds->current_results;
    6282          28 :                 colinfo = resinfo->columns[0];
    6283          28 :                 name = (char *) colinfo->column_data;
    6284          28 :                 if (is_blob_col(colinfo))
    6285           0 :                         name = (char*) ((TDSBLOB *) name)->textvalue;
    6286             :                 /* skip nvarchar and sysname */
    6287          28 :                 if (colinfo->column_cur_size == 7 && memcmp("varchar", name, 7) == 0) {
    6288           4 :                         varchar_pos = n;
    6289             :                 }
    6290             :         }
    6291           4 :         ODBC_EXIT(stmt, res);
    6292             : }
    6293             : 
    6294             : #ifdef ENABLE_ODBC_WIDE
    6295             : SQLRETURN ODBC_PUBLIC ODBC_API
    6296             : SQLGetTypeInfoW(SQLHSTMT hstmt, SQLSMALLINT fSqlType)
    6297             : {
    6298          58 :         return SQLGetTypeInfo(hstmt, fSqlType);
    6299             : }
    6300             : #endif
    6301             : 
    6302             : static SQLRETURN 
    6303         476 : _SQLParamData(SQLHSTMT hstmt, SQLPOINTER FAR * prgbValue)
    6304             : {
    6305         476 :         ODBC_ENTER_HSTMT;
    6306             : 
    6307         476 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamData(%p, %p) [param_num %d, param_data_called = %d]\n", 
    6308           0 :                                         hstmt, prgbValue, stmt->param_num, stmt->param_data_called);
    6309             : 
    6310         476 :         if (stmt->params && stmt->param_num <= stmt->param_count) {
    6311             :                 SQLRETURN res;
    6312             : 
    6313         404 :                 if (stmt->param_num <= 0 || stmt->param_num > stmt->apd->header.sql_desc_count) {
    6314           0 :                         tdsdump_log(TDS_DBG_FUNC, "SQLParamData: logic_error: parameter out of bounds: 0 <= %d < %d\n", 
    6315           0 :                                                    stmt->param_num, stmt->apd->header.sql_desc_count);
    6316           0 :                         ODBC_EXIT(stmt, SQL_ERROR);
    6317             :                 }
    6318             : 
    6319             :                 /*
    6320             :                  * TODO compute output value with this formula:
    6321             :                  * Bound Address + Binding Offset + ((Row Number - 1) x Element Size)
    6322             :                  * (see SQLParamData documentation)
    6323             :                  * This is needed for updates using SQLBulkOperation (not currently supported)
    6324             :                  */
    6325         404 :                 if (!stmt->param_data_called) {
    6326         144 :                         stmt->param_data_called = 1;
    6327         144 :                         *prgbValue = stmt->apd->records[stmt->param_num - 1].sql_desc_data_ptr;
    6328         144 :                         ODBC_EXIT(stmt, SQL_NEED_DATA);
    6329             :                 }
    6330         260 :                 ++stmt->param_num;
    6331         260 :                 switch (res = parse_prepared_query(stmt, true)) {
    6332         116 :                 case SQL_NEED_DATA:
    6333         116 :                         *prgbValue = stmt->apd->records[stmt->param_num - 1].sql_desc_data_ptr;
    6334         116 :                         ODBC_EXIT(stmt, SQL_NEED_DATA);
    6335         144 :                 case SQL_SUCCESS:
    6336         144 :                         ODBC_EXIT(stmt, _SQLExecute(stmt));
    6337             :                 }
    6338           0 :                 ODBC_EXIT(stmt, res);
    6339             :         }
    6340             : 
    6341          72 :         odbc_errs_add(&stmt->errs, "HY010", NULL);
    6342          72 :         ODBC_EXIT_(stmt);
    6343             : }
    6344             : 
    6345             : SQLRETURN ODBC_PUBLIC ODBC_API
    6346             : SQLParamData(SQLHSTMT hstmt, SQLPOINTER FAR * prgbValue)
    6347             : {
    6348             :         ODBC_PRRET_BUF;
    6349         476 :         SQLRETURN ret = _SQLParamData(hstmt, prgbValue);
    6350             :         
    6351         476 :         tdsdump_log(TDS_DBG_FUNC, "SQLParamData returns %s\n", odbc_prret(ret));
    6352             :         
    6353         476 :         return ret;
    6354             : }
    6355             : 
    6356             : SQLRETURN ODBC_PUBLIC ODBC_API
    6357             : SQLPutData(SQLHSTMT hstmt, SQLPOINTER rgbValue, SQLLEN cbValue)
    6358             : {
    6359             :         ODBC_PRRET_BUF;
    6360         652 :         ODBC_ENTER_HSTMT;
    6361             : 
    6362         652 :         tdsdump_log(TDS_DBG_FUNC, "SQLPutData(%p, %p, %i)\n", hstmt, rgbValue, (int)cbValue);
    6363             : 
    6364         652 :         if (stmt->param_data_called) {
    6365             :                 SQLRETURN ret;
    6366         652 :                 const TDSCOLUMN *curcol = stmt->params->columns[stmt->param_num - (stmt->prepared_query_is_func ? 2 : 1)];
    6367             :                 /* TODO do some more tests before setting this flag */
    6368         652 :                 stmt->param_data_called = 1;
    6369         652 :                 ret = continue_parse_prepared_query(stmt, rgbValue, cbValue);
    6370         652 :                 tdsdump_log(TDS_DBG_FUNC, "SQLPutData returns %s, %d bytes left\n", 
    6371           0 :                                           odbc_prret(ret), curcol->column_size - curcol->column_cur_size);
    6372         652 :                 ODBC_EXIT(stmt, ret);
    6373             :         }
    6374             : 
    6375           0 :         odbc_errs_add(&stmt->errs, "HY010", NULL);
    6376           0 :         ODBC_EXIT_(stmt);
    6377             : }
    6378             : 
    6379             : 
    6380        1436 : ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,ValuePtr), P(SQLINTEGER,StringLength) WIDE))
    6381             : {
    6382        1436 :         SQLULEN u_value = (SQLULEN) (TDS_INTPTR) ValuePtr;
    6383             : 
    6384        1436 :         ODBC_ENTER_HDBC;
    6385             : 
    6386        1436 :         tdsdump_log(TDS_DBG_FUNC, "_SQLSetConnectAttr(%p, %d, %p, %d)\n", hdbc, (int)Attribute, ValuePtr, (int)StringLength);
    6387             : 
    6388        1436 :         switch (Attribute) {
    6389         173 :         case SQL_ATTR_AUTOCOMMIT:
    6390             :                 /* spinellia@acm.org */
    6391         173 :                 change_autocommit(dbc, u_value);
    6392         173 :                 break;
    6393           8 :         case SQL_ATTR_CONNECTION_TIMEOUT:
    6394           8 :                 dbc->attr.connection_timeout = u_value;
    6395           8 :                 break;
    6396           0 :         case SQL_ATTR_ACCESS_MODE:
    6397           0 :                 dbc->attr.access_mode = u_value;
    6398           0 :                 break;
    6399          48 :         case SQL_ATTR_CURRENT_CATALOG:
    6400          48 :                 if (!IS_VALID_LEN(StringLength)) {
    6401           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6402           0 :                         break;
    6403             :                 }
    6404             :                 {
    6405          48 :                         DSTR s = DSTR_INITIALIZER;
    6406             : 
    6407          48 :                         if (!odbc_dstr_copy_oct(dbc, &s, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6408           0 :                                 odbc_errs_add(&dbc->errs, "HY001", NULL);
    6409           0 :                                 break;
    6410             :                         }
    6411         144 :                         change_database(dbc, tds_dstr_cstr(&s), tds_dstr_len(&s));
    6412          48 :                         tds_dstr_free(&s);
    6413             :                 }
    6414          48 :                 break;
    6415           0 :         case SQL_ATTR_CURSOR_TYPE:
    6416           0 :                 if (dbc->cursor_support)
    6417           0 :                         dbc->attr.cursor_type = u_value;
    6418             :                 break;
    6419           8 :         case SQL_ATTR_LOGIN_TIMEOUT:
    6420           8 :                 dbc->attr.login_timeout = u_value;
    6421           8 :                 break;
    6422           0 :         case SQL_ATTR_ODBC_CURSORS:
    6423             :                 /* TODO cursors */
    6424           0 :                 dbc->attr.odbc_cursors = u_value;
    6425           0 :                 break;
    6426           0 :         case SQL_ATTR_PACKET_SIZE:
    6427           0 :                 dbc->attr.packet_size = u_value;
    6428           0 :                 break;
    6429           0 :         case SQL_ATTR_QUIET_MODE:
    6430           0 :                 dbc->attr.quite_mode = (SQLHWND) (TDS_INTPTR) ValuePtr;
    6431           0 :                 break;
    6432             : #ifdef TDS_NO_DM
    6433           0 :         case SQL_ATTR_TRACE:
    6434           0 :                 dbc->attr.trace = u_value;
    6435           0 :                 break;
    6436           0 :         case SQL_ATTR_TRACEFILE:
    6437           0 :                 if (!IS_VALID_LEN(StringLength)) {
    6438           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6439           0 :                         break;
    6440             :                 }
    6441           0 :                 if (!odbc_dstr_copy(dbc, &dbc->attr.tracefile, StringLength, (ODBC_CHAR *) ValuePtr))
    6442           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
    6443             :                 break;
    6444             : #endif
    6445          84 :         case SQL_ATTR_TXN_ISOLATION:
    6446          84 :                 if (u_value != dbc->attr.txn_isolation) {
    6447          74 :                         if (change_txn(dbc, u_value) == SQL_SUCCESS)
    6448          58 :                                 dbc->attr.txn_isolation = u_value;
    6449             :                 }
    6450             :                 break;
    6451         415 :         case SQL_COPT_SS_MARS_ENABLED:
    6452         415 :                 dbc->attr.mars_enabled = u_value;
    6453         415 :                 break;
    6454           0 :         case SQL_ATTR_TRANSLATE_LIB:
    6455             :         case SQL_ATTR_TRANSLATE_OPTION:
    6456           0 :                 odbc_errs_add(&dbc->errs, "HYC00", NULL);
    6457           0 :                 break;
    6458           0 :         case SQL_COPT_SS_OLDPWD:
    6459           0 :                 if (!IS_VALID_LEN(StringLength)) {
    6460           0 :                         odbc_errs_add(&dbc->errs, "HY090", NULL);
    6461           0 :                         break;
    6462             :                 }
    6463           0 :                 if (!odbc_dstr_copy(dbc, &dbc->oldpwd, StringLength, (ODBC_CHAR *) ValuePtr))
    6464           0 :                         odbc_errs_add(&dbc->errs, "HY001", NULL);
    6465             :                 else
    6466           0 :                         dbc->use_oldpwd = 1;
    6467             :                 break;
    6468           8 :         case SQL_COPT_SS_BCP:
    6469           8 :                 dbc->attr.bulk_enabled = u_value;
    6470           8 :                 break;
    6471           9 :         case SQL_COPT_TDSODBC_IMPL_BCP_INITA:
    6472           9 :                 if (!ValuePtr)
    6473           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6474             :                 else {
    6475           9 :                         const struct tdsodbc_impl_bcp_init_params *params = (const struct tdsodbc_impl_bcp_init_params*)ValuePtr;
    6476          18 :                         odbc_bcp_init(dbc, (const ODBC_CHAR *) params->tblname, (const ODBC_CHAR *) params->hfile,
    6477           9 :                                       (const ODBC_CHAR *) params->errfile, params->direction _wide0);
    6478             :                 }
    6479             :                 break;
    6480             : #ifdef ENABLE_ODBC_WIDE
    6481           9 :         case SQL_COPT_TDSODBC_IMPL_BCP_INITW:
    6482           9 :                 if (!ValuePtr)
    6483           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6484             :                 else {
    6485           9 :                         const struct tdsodbc_impl_bcp_init_params *params = (const struct tdsodbc_impl_bcp_init_params*)ValuePtr;
    6486          18 :                         odbc_bcp_init(dbc, (const ODBC_CHAR *) params->tblname, (const ODBC_CHAR *) params->hfile,
    6487           9 :                                       (const ODBC_CHAR *) params->errfile, params->direction, 1);
    6488             :                 }
    6489             :                 break;
    6490             : #endif
    6491           0 :         case SQL_COPT_TDSODBC_IMPL_BCP_CONTROL:
    6492           0 :                 if (!ValuePtr)
    6493           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6494             :                 else {
    6495           0 :                         const struct tdsodbc_impl_bcp_control_params *params = (const struct tdsodbc_impl_bcp_control_params*)ValuePtr;
    6496           0 :                         odbc_bcp_control(dbc, params->field, params->value);
    6497             :                 }
    6498             :                 break;
    6499           0 :         case SQL_COPT_TDSODBC_IMPL_BCP_COLPTR:
    6500           0 :                 if (!ValuePtr)
    6501           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6502             :                 else {
    6503           0 :                         const struct tdsodbc_impl_bcp_colptr_params *params = (const struct tdsodbc_impl_bcp_colptr_params*)ValuePtr;
    6504           0 :                         odbc_bcp_colptr(dbc, params->colptr, params->table_column);
    6505             :                 }
    6506             :                 break;
    6507         162 :         case SQL_COPT_TDSODBC_IMPL_BCP_SENDROW:
    6508         162 :                 if (ValuePtr)
    6509           0 :                         odbc_errs_add(&dbc->errs, "HY000", NULL);
    6510             :                 else
    6511         162 :                         odbc_bcp_sendrow(dbc);
    6512             :                 break;
    6513          18 :         case SQL_COPT_TDSODBC_IMPL_BCP_BATCH:
    6514          18 :                 if (!ValuePtr)
    6515           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6516             :                 else {
    6517          18 :                         struct tdsodbc_impl_bcp_batch_params *params = (struct tdsodbc_impl_bcp_batch_params*)ValuePtr;
    6518          18 :                         params->rows = odbc_bcp_batch(dbc);
    6519             :                 }
    6520             :                 break;
    6521          18 :         case SQL_COPT_TDSODBC_IMPL_BCP_DONE:
    6522          18 :                 if (!ValuePtr)
    6523           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6524             :                 else {
    6525          18 :                         struct tdsodbc_impl_bcp_done_params *params = (struct tdsodbc_impl_bcp_done_params*)ValuePtr;
    6526          18 :                         params->rows = odbc_bcp_done(dbc);
    6527             :                 }
    6528             :                 break;
    6529         476 :         case SQL_COPT_TDSODBC_IMPL_BCP_BIND:
    6530         476 :                 if (!ValuePtr)
    6531           0 :                         odbc_errs_add(&dbc->errs, "HY009", NULL);
    6532             :                 else {
    6533         476 :                         const struct tdsodbc_impl_bcp_bind_params *params = (const struct tdsodbc_impl_bcp_bind_params*)ValuePtr;
    6534         476 :                         odbc_bcp_bind(dbc, params->varaddr, params->prefixlen, params->varlen, params->terminator, params->termlen, params->vartype, params->table_column);
    6535             :                 }
    6536             :                 break;
    6537           0 :         default:
    6538           0 :                 odbc_errs_add(&dbc->errs, "HY092", NULL);
    6539           0 :                 break;
    6540             :         }
    6541        1436 :         ODBC_EXIT_(dbc);
    6542             : }
    6543             : 
    6544             : SQLRETURN ODBC_PUBLIC ODBC_API
    6545             : SQLSetConnectOption(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLULEN vParam)
    6546             : {
    6547           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectOption(%p, %d, %u)\n", hdbc, fOption, (unsigned)vParam);
    6548             :         /* XXX: Lost precision */
    6549           0 :         return _SQLSetConnectAttr(hdbc, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS _wide0);
    6550             : }
    6551             : 
    6552             : #ifdef ENABLE_ODBC_WIDE
    6553             : SQLRETURN ODBC_PUBLIC ODBC_API
    6554             : SQLSetConnectOptionW(SQLHDBC hdbc, SQLUSMALLINT fOption, SQLULEN vParam)
    6555             : {
    6556           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetConnectOptionW(%p, %d, %u)\n", hdbc, fOption, (unsigned)vParam);
    6557             :         /* XXX: Lost precision */
    6558           0 :         return _SQLSetConnectAttr(hdbc, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS, 1);
    6559             : }
    6560             : #endif
    6561             : 
    6562             : static SQLRETURN
    6563        4758 : _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength WIDE)
    6564             : {
    6565        4758 :         SQLULEN ui = (SQLULEN) (TDS_INTPTR) ValuePtr;
    6566        4758 :         SQLUSMALLINT *usip = (SQLUSMALLINT *) ValuePtr;
    6567        4758 :         SQLLEN *lp = (SQLLEN *) ValuePtr;
    6568        4758 :         SQLULEN *ulp = (SQLULEN *) ValuePtr;
    6569             : 
    6570        4758 :         ODBC_ENTER_HSTMT;
    6571             : 
    6572        4758 :         tdsdump_log(TDS_DBG_FUNC, "_SQLSetStmtAttr(%p, %d, %p, %d)\n", hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    6573             : 
    6574             :         /* TODO - error checking and real functionality :-) */
    6575             :         /* TODO some setting set also other attribute, see documentation */
    6576        4758 :         switch (Attribute) {
    6577             :                 /* TODO check SQLFreeHandle on descriptor. Is possible to free an associated descriptor ? */
    6578           0 :         case SQL_ATTR_APP_PARAM_DESC:
    6579             :         case SQL_ATTR_APP_ROW_DESC:
    6580             :                 {
    6581             :                         TDS_DESC *orig;
    6582             :                         TDS_DESC **curr;
    6583           0 :                         TDS_DESC *val = (TDS_DESC *) ValuePtr;
    6584             : 
    6585           0 :                         if (Attribute == SQL_ATTR_APP_PARAM_DESC) {
    6586           0 :                                 orig = stmt->orig_apd;
    6587           0 :                                 curr = &stmt->apd;
    6588             :                         } else {
    6589           0 :                                 orig = stmt->orig_ard;
    6590           0 :                                 curr = &stmt->ard;
    6591             :                         }
    6592             :                         /* if ValuePtr is NULL or original descriptor set original */
    6593           0 :                         if (!val || val == orig) {
    6594           0 :                                 *curr = orig;
    6595           0 :                                 break;
    6596             :                         }
    6597             : 
    6598             :                         /* must be allocated by user, not implicit ones */
    6599           0 :                         if (val->header.sql_desc_alloc_type != SQL_DESC_ALLOC_USER) {
    6600           0 :                                 odbc_errs_add(&stmt->errs, "HY017", NULL);
    6601           0 :                                 break;
    6602             :                         }
    6603             :                         /* TODO check HDESC (not associated, from DBC HY024) */
    6604           0 :                         *curr = val;
    6605             :                 }
    6606           0 :                 break;
    6607           0 :         case SQL_ATTR_ASYNC_ENABLE:
    6608           0 :                 if (stmt->attr.async_enable != ui) {
    6609           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6610           0 :                         break;
    6611             :                 }
    6612           0 :                 stmt->attr.async_enable = ui;
    6613           0 :                 break;
    6614         230 :         case SQL_ATTR_CONCURRENCY:
    6615         230 :                 if (stmt->attr.concurrency != ui && !stmt->dbc->cursor_support) {
    6616          26 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6617          26 :                         break;
    6618             :                 }
    6619             : 
    6620         204 :                 if (stmt->cursor) {
    6621           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6622           0 :                         break;
    6623             :                 }
    6624             : 
    6625         204 :                 switch (ui) {
    6626          54 :                 case SQL_CONCUR_READ_ONLY:
    6627          54 :                         stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    6628          54 :                         break;
    6629         150 :                 case SQL_CONCUR_LOCK:
    6630             :                 case SQL_CONCUR_ROWVER:
    6631             :                 case SQL_CONCUR_VALUES:
    6632         150 :                         stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6633         150 :                         break;
    6634           0 :                 default:
    6635           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6636           0 :                         ODBC_EXIT_(stmt);
    6637             :                 }
    6638         204 :                 stmt->attr.concurrency = ui;
    6639         204 :                 break;
    6640        1548 :         case SQL_ATTR_CURSOR_SCROLLABLE:
    6641        1548 :                 if (stmt->attr.cursor_scrollable != ui && !stmt->dbc->cursor_support) {
    6642           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6643           0 :                         break;
    6644             :                 }
    6645             : 
    6646        1548 :                 switch (ui) {
    6647        1512 :                 case SQL_SCROLLABLE:
    6648        1512 :                         stmt->attr.cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    6649        1512 :                         break;
    6650          36 :                 case SQL_NONSCROLLABLE:
    6651          36 :                         stmt->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    6652          36 :                         break;
    6653           0 :                 default:
    6654           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6655           0 :                         ODBC_EXIT_(stmt);
    6656             :                 }
    6657        1548 :                 stmt->attr.cursor_scrollable = ui;
    6658        1548 :                 break;
    6659          54 :         case SQL_ATTR_CURSOR_SENSITIVITY:
    6660             :                 /* don't change anything */
    6661          54 :                 if (ui == SQL_UNSPECIFIED)
    6662             :                         break;
    6663          54 :                 if (stmt->attr.cursor_sensitivity != ui && !stmt->dbc->cursor_support) {
    6664           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6665           0 :                         break;
    6666             :                 }
    6667          54 :                 switch (ui) {
    6668           0 :                 case SQL_INSENSITIVE:
    6669           0 :                         stmt->attr.concurrency = SQL_CONCUR_READ_ONLY;
    6670           0 :                         stmt->attr.cursor_type = SQL_CURSOR_STATIC;
    6671           0 :                         break;
    6672          54 :                 case SQL_SENSITIVE:
    6673          54 :                         stmt->attr.concurrency = SQL_CONCUR_ROWVER;
    6674          54 :                         break;
    6675             :                 }
    6676          54 :                 stmt->attr.cursor_sensitivity = ui;
    6677          54 :                 break;
    6678        1638 :         case SQL_ATTR_CURSOR_TYPE:
    6679        1638 :                 if (stmt->attr.cursor_type != ui && !stmt->dbc->cursor_support) {
    6680           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6681           0 :                         break;
    6682             :                 }
    6683             : 
    6684        1638 :                 if (stmt->cursor) {
    6685           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6686           0 :                         break;
    6687             :                 }
    6688             : 
    6689        1638 :                 switch (ui) {
    6690        1578 :                 case SQL_CURSOR_DYNAMIC:
    6691             :                 case SQL_CURSOR_KEYSET_DRIVEN:
    6692        1578 :                         if (stmt->attr.concurrency != SQL_CONCUR_READ_ONLY)
    6693          66 :                                 stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6694        1578 :                         stmt->attr.cursor_scrollable = SQL_SCROLLABLE;
    6695        1578 :                         break;
    6696          60 :                 case SQL_CURSOR_STATIC:
    6697          60 :                         if (stmt->attr.concurrency != SQL_CONCUR_READ_ONLY)
    6698           0 :                                 stmt->attr.cursor_sensitivity = SQL_SENSITIVE;
    6699             :                         else
    6700          60 :                                 stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    6701          60 :                         stmt->attr.cursor_scrollable = SQL_SCROLLABLE;
    6702          60 :                         break;
    6703           0 :                 case SQL_CURSOR_FORWARD_ONLY:
    6704           0 :                         stmt->attr.cursor_scrollable = SQL_NONSCROLLABLE;
    6705           0 :                         break;
    6706           0 :                 default:
    6707           0 :                         odbc_errs_add(&stmt->errs, "HY092", NULL);
    6708           0 :                         ODBC_EXIT_(stmt);
    6709             :                 }
    6710        1638 :                 stmt->attr.cursor_type = ui;
    6711        1638 :                 break;
    6712           0 :         case SQL_ATTR_ENABLE_AUTO_IPD:
    6713           0 :                 if (stmt->attr.enable_auto_ipd != ui) {
    6714           0 :                         odbc_errs_add(&stmt->errs, "HYC00", NULL);
    6715           0 :                         break;
    6716             :                 }
    6717           0 :                 stmt->attr.enable_auto_ipd = ui;
    6718           0 :                 break;
    6719           0 :         case SQL_ATTR_FETCH_BOOKMARK_PTR:
    6720           0 :                 stmt->attr.fetch_bookmark_ptr = ValuePtr;
    6721           0 :                 break;
    6722           0 :         case SQL_ATTR_IMP_ROW_DESC:
    6723             :         case SQL_ATTR_IMP_PARAM_DESC:
    6724           0 :                 odbc_errs_add(&stmt->errs, "HY017", NULL);
    6725           0 :                 break;
    6726             :                 /* TODO what's is this ??? */
    6727           0 :         case SQL_ATTR_KEYSET_SIZE:
    6728           0 :                 stmt->attr.keyset_size = ui;
    6729           0 :                 break;
    6730             :                 /* TODO max length of data returned. Use SQL TEXTSIZE or just truncate ?? */
    6731           0 :         case SQL_ATTR_MAX_LENGTH:
    6732           0 :                 if (stmt->attr.max_length != ui) {
    6733           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6734           0 :                         break;
    6735             :                 }
    6736           0 :                 stmt->attr.max_length = ui;
    6737           0 :                 break;
    6738             :                 /* TODO max row returned. Use SET ROWCOUNT */
    6739           0 :         case SQL_ATTR_MAX_ROWS:
    6740           0 :                 if (stmt->attr.max_rows != ui) {
    6741           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6742           0 :                         break;
    6743             :                 }
    6744           0 :                 stmt->attr.max_rows = ui;
    6745           0 :                 break;
    6746           0 :         case SQL_ATTR_METADATA_ID:
    6747           0 :                 stmt->attr.metadata_id = ui;
    6748           0 :                 break;
    6749             :                 /* TODO use it !!! */
    6750           0 :         case SQL_ATTR_NOSCAN:
    6751           0 :                 stmt->attr.noscan = ui;
    6752           0 :                 break;
    6753           0 :         case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
    6754           0 :                 stmt->apd->header.sql_desc_bind_offset_ptr = lp;
    6755           0 :                 break;
    6756          62 :         case SQL_ATTR_PARAM_BIND_TYPE:
    6757          62 :                 stmt->apd->header.sql_desc_bind_type = ui;
    6758          62 :                 break;
    6759           0 :         case SQL_ATTR_PARAM_OPERATION_PTR:
    6760           0 :                 stmt->apd->header.sql_desc_array_status_ptr = usip;
    6761           0 :                 break;
    6762          62 :         case SQL_ATTR_PARAM_STATUS_PTR:
    6763          62 :                 stmt->ipd->header.sql_desc_array_status_ptr = usip;
    6764          62 :                 break;
    6765          94 :         case SQL_ATTR_PARAMS_PROCESSED_PTR:
    6766          94 :                 stmt->ipd->header.sql_desc_rows_processed_ptr = ulp;
    6767          94 :                 break;
    6768             :                 /* allow to exec procedure multiple time */
    6769         102 :         case SQL_ATTR_PARAMSET_SIZE:
    6770         102 :                 stmt->apd->header.sql_desc_array_size = ui;
    6771         102 :                 break;
    6772          90 :         case SQL_ATTR_QUERY_TIMEOUT:
    6773          90 :                 stmt->attr.query_timeout = ui;
    6774          90 :                 break;
    6775             :                 /* retrieve data after positioning the cursor */
    6776           0 :         case SQL_ATTR_RETRIEVE_DATA:
    6777             :                 /* TODO cursors */
    6778           0 :                 if (stmt->attr.retrieve_data != ui) {
    6779           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6780           0 :                         break;
    6781             :                 }
    6782           0 :                 stmt->attr.retrieve_data = ui;
    6783           0 :                 break;
    6784         222 :         case SQL_ATTR_ROW_ARRAY_SIZE:
    6785         222 :                 stmt->ard->header.sql_desc_array_size = ui;
    6786         222 :                 break;
    6787           0 :         case SQL_ATTR_ROW_BIND_OFFSET_PTR:
    6788             :                 /* TODO test what happen with column-wise and row-wise bindings and SQLGetData */
    6789           0 :                 stmt->ard->header.sql_desc_bind_offset_ptr = lp;
    6790           0 :                 break;
    6791             : #if SQL_BIND_TYPE != SQL_ATTR_ROW_BIND_TYPE
    6792             :         case SQL_BIND_TYPE:     /* although this is ODBC2 we must support this attribute */
    6793             : #endif
    6794         156 :         case SQL_ATTR_ROW_BIND_TYPE:
    6795         156 :                 stmt->ard->header.sql_desc_bind_type = ui;
    6796         156 :                 break;
    6797           0 :         case SQL_ATTR_ROW_NUMBER:
    6798           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    6799           0 :                 break;
    6800           0 :         case SQL_ATTR_ROW_OPERATION_PTR:
    6801           0 :                 stmt->ard->header.sql_desc_array_status_ptr = usip;
    6802           0 :                 break;
    6803         200 :         case SQL_ATTR_ROW_STATUS_PTR:
    6804         200 :                 stmt->ird->header.sql_desc_array_status_ptr = usip;
    6805         200 :                 break;
    6806         222 :         case SQL_ATTR_ROWS_FETCHED_PTR:
    6807         222 :                 stmt->ird->header.sql_desc_rows_processed_ptr = ulp;
    6808         222 :                 break;
    6809           0 :         case SQL_ATTR_SIMULATE_CURSOR:
    6810             :                 /* TODO cursors */
    6811           0 :                 if (stmt->cursor) {
    6812           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6813           0 :                         break;
    6814             :                 }
    6815           0 :                 if (stmt->attr.simulate_cursor != ui) {
    6816           0 :                         odbc_errs_add(&stmt->errs, "01S02", NULL);
    6817           0 :                         break;
    6818             :                 }
    6819           0 :                 stmt->attr.simulate_cursor = ui;
    6820           0 :                 break;
    6821           0 :         case SQL_ATTR_USE_BOOKMARKS:
    6822           0 :                 if (stmt->cursor) {
    6823           0 :                         odbc_errs_add(&stmt->errs, "24000", NULL);
    6824           0 :                         break;
    6825             :                 }
    6826           0 :                 stmt->attr.use_bookmarks = ui;
    6827           0 :                 break;
    6828          44 :         case SQL_ROWSET_SIZE:   /* although this is ODBC2 we must support this attribute */
    6829          44 :                 if (((TDS_INTPTR) ValuePtr) < 1) {
    6830          24 :                         odbc_errs_add(&stmt->errs, "HY024", NULL);
    6831          24 :                         break;
    6832             :                 }
    6833          20 :                 stmt->sql_rowset_size = ui;
    6834          20 :                 break;
    6835           2 :         case SQL_SOPT_SS_QUERYNOTIFICATION_TIMEOUT:
    6836           2 :                 if (ui < 1) {
    6837           0 :                         odbc_errs_add(&stmt->errs, "HY024", NULL);
    6838           0 :                         break;
    6839             :                 }
    6840           2 :                 stmt->attr.qn_timeout = ui;
    6841           2 :                 break;
    6842           2 :         case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT:
    6843           2 :                 if (!IS_VALID_LEN(StringLength)) {
    6844           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    6845           0 :                         break;
    6846             :                 }
    6847           2 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &stmt->attr.qn_msgtext, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6848           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    6849           0 :                         break;
    6850             :                 }
    6851             :                 break;
    6852           2 :         case SQL_SOPT_SS_QUERYNOTIFICATION_OPTIONS:
    6853           2 :                 if (!IS_VALID_LEN(StringLength)) {
    6854           0 :                         odbc_errs_add(&stmt->errs, "HY090", NULL);
    6855           0 :                         break;
    6856             :                 }
    6857           2 :                 if (!odbc_dstr_copy_oct(stmt->dbc, &stmt->attr.qn_options, StringLength, (ODBC_CHAR*) ValuePtr)) {
    6858           0 :                         odbc_errs_add(&stmt->errs, "HY001", NULL);
    6859           0 :                         break;
    6860             :                 }
    6861             :                 break;
    6862          28 :         case SQL_SOPT_SS_PARAM_FOCUS:
    6863          28 :                 if (ui > 0 && (ui > stmt->apd->header.sql_desc_count
    6864          16 :                                || stmt->ipd->records[ui - 1].sql_desc_concise_type != SQL_SS_TABLE)) {
    6865           2 :                         odbc_errs_add(&stmt->errs, "IM020", NULL);
    6866           2 :                         break;
    6867             :                 }
    6868          26 :                 stmt->attr.param_focus = ui;
    6869          26 :                 stmt->orig_apd->focus = ui;
    6870          26 :                 stmt->ipd->focus = ui;
    6871          26 :                 break;
    6872           0 :         default:
    6873           0 :                 odbc_errs_add(&stmt->errs, "HY092", NULL);
    6874           0 :                 break;
    6875             :         }
    6876        4758 :         ODBC_EXIT_(stmt);
    6877             : }
    6878             : 
    6879             : #if (ODBCVER >= 0x0300)
    6880             : SQLRETURN ODBC_PUBLIC ODBC_API
    6881             : SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength)
    6882             : {
    6883        2360 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtAttr(%p, %d, %p, %d)\n", 
    6884             :                         hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    6885             : 
    6886        2360 :         return _SQLSetStmtAttr(hstmt, Attribute, ValuePtr, StringLength _wide0);
    6887             : }
    6888             : 
    6889             : #ifdef ENABLE_ODBC_WIDE
    6890             : SQLRETURN ODBC_PUBLIC ODBC_API
    6891             : SQLSetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength)
    6892             : {
    6893        2360 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtAttr(%p, %d, %p, %d)\n",
    6894             :                         hstmt, (int)Attribute, ValuePtr, (int)StringLength);
    6895             : 
    6896        2360 :         return _SQLSetStmtAttr(hstmt, Attribute, ValuePtr, StringLength, 1);
    6897             : }
    6898             : #endif
    6899             : #endif
    6900             : 
    6901             : SQLRETURN ODBC_PUBLIC ODBC_API
    6902             : SQLSetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLULEN vParam)
    6903             : {
    6904           6 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetStmtOption(%p, %u, %u)\n", hstmt, fOption, (unsigned)vParam);
    6905             : 
    6906             :         /* XXX: Lost precision */
    6907           6 :         return _SQLSetStmtAttr(hstmt, (SQLINTEGER) fOption, (SQLPOINTER) (TDS_INTPTR) vParam, SQL_NTS _wide0);
    6908             : }
    6909             : 
    6910           0 : ODBC_FUNC(SQLSpecialColumns, (P(SQLHSTMT,hstmt), P(SQLUSMALLINT,fColType), PCHARIN(CatalogName,SQLSMALLINT),
    6911             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT),
    6912             :         P(SQLUSMALLINT,fScope), P(SQLUSMALLINT,fNullable) WIDE))
    6913             : {
    6914             :         int retcode;
    6915             :         char nullable, scope, col_type;
    6916             : 
    6917           0 :         ODBC_ENTER_HSTMT;
    6918             : 
    6919           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSpecialColumns(%p, %d, %p, %d, %p, %d, %p, %d, %d, %d)\n", 
    6920             :                         hstmt, fColType, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, fScope, fNullable);
    6921             : 
    6922             : #ifdef TDS_NO_DM
    6923             :         /* Check column type */
    6924           0 :         if (fColType != SQL_BEST_ROWID && fColType != SQL_ROWVER) {
    6925           0 :                 odbc_errs_add(&stmt->errs, "HY097", NULL);
    6926           0 :                 ODBC_EXIT_(stmt);
    6927             :         }
    6928             : 
    6929             :         /* check our buffer lengths */
    6930           0 :         if (!IS_VALID_LEN(cbCatalogName) || !IS_VALID_LEN(cbSchemaName) || !IS_VALID_LEN(cbTableName)) {
    6931           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    6932           0 :                 ODBC_EXIT_(stmt);
    6933             :         }
    6934             : 
    6935             :         /* Check nullable */
    6936           0 :         if (fNullable != SQL_NO_NULLS && fNullable != SQL_NULLABLE) {
    6937           0 :                 odbc_errs_add(&stmt->errs, "HY099", NULL);
    6938           0 :                 ODBC_EXIT_(stmt);
    6939             :         }
    6940             : 
    6941           0 :         if (!odbc_get_string_size(cbTableName, szTableName _wide)) {
    6942           0 :                 odbc_errs_add(&stmt->errs, "HY009", "SQLSpecialColumns: The table name parameter is required");
    6943           0 :                 ODBC_EXIT_(stmt);
    6944             :         }
    6945             : 
    6946           0 :         switch (fScope) {
    6947             :         case SQL_SCOPE_CURROW:
    6948             :         case SQL_SCOPE_TRANSACTION:
    6949             :         case SQL_SCOPE_SESSION:
    6950             :                 break;
    6951           0 :         default:
    6952           0 :                 odbc_errs_add(&stmt->errs, "HY098", NULL);
    6953           0 :                 ODBC_EXIT_(stmt);
    6954             :         }
    6955             : #endif
    6956             : 
    6957           0 :         if (fNullable == SQL_NO_NULLS)
    6958           0 :                 nullable = 'O';
    6959             :         else
    6960           0 :                 nullable = 'U';
    6961             : 
    6962           0 :         if (fScope == SQL_SCOPE_CURROW)
    6963           0 :                 scope = 'C';
    6964             :         else
    6965           0 :                 scope = 'T';
    6966             : 
    6967           0 :         if (fColType == SQL_BEST_ROWID)
    6968           0 :                 col_type = 'R';
    6969             :         else
    6970           0 :                 col_type = 'V';
    6971             : 
    6972           0 :         retcode =
    6973           0 :                 odbc_stat_execute(stmt _wide, "sp_special_columns", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 7 : 4, "O", szTableName,
    6974             :                                   cbTableName, "O", szSchemaName, cbSchemaName, "O@qualifier", szCatalogName, cbCatalogName,
    6975             :                                   "!@col_type", &col_type, 1, "!@scope", &scope, 1, "!@nullable", &nullable, 1,
    6976             :                                   "V@ODBCVer", (char*) NULL, 0);
    6977           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    6978           0 :                 odbc_col_setname(stmt, 5, "COLUMN_SIZE");
    6979           0 :                 odbc_col_setname(stmt, 6, "BUFFER_LENGTH");
    6980           0 :                 odbc_col_setname(stmt, 7, "DECIMAL_DIGITS");
    6981           0 :                 if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
    6982           0 :                         stmt->special_row = ODBC_SPECIAL_SPECIALCOLUMNS;
    6983             :         }
    6984           0 :         ODBC_EXIT_(stmt);
    6985             : }
    6986             : 
    6987           0 : ODBC_FUNC(SQLStatistics, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    6988             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT), P(SQLUSMALLINT,fUnique),
    6989             :         P(SQLUSMALLINT,fAccuracy) WIDE))
    6990             : {
    6991             :         int retcode;
    6992             :         char unique, accuracy;
    6993             : 
    6994           0 :         ODBC_ENTER_HSTMT;
    6995             : 
    6996           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLStatistics(%p, %p, %d, %p, %d, %p, %d, %d, %d)\n", 
    6997             :                         hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, fUnique, fAccuracy);
    6998             : 
    6999             : #ifdef TDS_NO_DM
    7000             :         /* check our buffer lengths */
    7001           0 :         if (!IS_VALID_LEN(cbCatalogName) || !IS_VALID_LEN(cbSchemaName) || !IS_VALID_LEN(cbTableName)) {
    7002           0 :                 odbc_errs_add(&stmt->errs, "HY090", NULL);
    7003           0 :                 ODBC_EXIT_(stmt);
    7004             :         }
    7005             : 
    7006             :         /* check our uniqueness value */
    7007           0 :         if (fUnique != SQL_INDEX_UNIQUE && fUnique != SQL_INDEX_ALL) {
    7008           0 :                 odbc_errs_add(&stmt->errs, "HY100", NULL);
    7009           0 :                 ODBC_EXIT_(stmt);
    7010             :         }
    7011             : 
    7012             :         /* check our accuracy value */
    7013           0 :         if (fAccuracy != SQL_QUICK && fAccuracy != SQL_ENSURE) {
    7014           0 :                 odbc_errs_add(&stmt->errs, "HY101", NULL);
    7015           0 :                 ODBC_EXIT_(stmt);
    7016             :         }
    7017             : 
    7018           0 :         if (!odbc_get_string_size(cbTableName, szTableName _wide)) {
    7019           0 :                 odbc_errs_add(&stmt->errs, "HY009", NULL);
    7020           0 :                 ODBC_EXIT_(stmt);
    7021             :         }
    7022             : #endif
    7023             : 
    7024           0 :         if (fAccuracy == SQL_ENSURE)
    7025           0 :                 accuracy = 'E';
    7026             :         else
    7027           0 :                 accuracy = 'Q';
    7028             : 
    7029           0 :         if (fUnique == SQL_INDEX_UNIQUE)
    7030           0 :                 unique = 'Y';
    7031             :         else
    7032           0 :                 unique = 'N';
    7033             : 
    7034           0 :         retcode =
    7035           0 :                 odbc_stat_execute(stmt _wide, "sp_statistics", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4, "O@table_qualifier",
    7036             :                                   szCatalogName, cbCatalogName, "O@table_owner", szSchemaName, cbSchemaName, "O@table_name",
    7037             :                                   szTableName, cbTableName, "!@is_unique", &unique, 1, "!@accuracy", &accuracy, 1);
    7038           0 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    7039           0 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    7040           0 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    7041           0 :                 odbc_col_setname(stmt, 8, "ORDINAL_POSITION");
    7042           0 :                 odbc_col_setname(stmt, 10, "ASC_OR_DESC");
    7043             :         }
    7044           0 :         ODBC_EXIT_(stmt);
    7045             : }
    7046             : 
    7047         102 : ODBC_FUNC(SQLTables, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    7048             :         PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT), PCHARIN(TableType,SQLSMALLINT) WIDE))
    7049             : {
    7050             :         int retcode;
    7051         102 :         const char *proc = NULL;
    7052             :         int wildcards;
    7053             :         TDSSOCKET *tds;
    7054         102 :         DSTR schema_name  = DSTR_INITIALIZER;
    7055         102 :         DSTR catalog_name = DSTR_INITIALIZER;
    7056         102 :         DSTR table_name   = DSTR_INITIALIZER;
    7057         102 :         DSTR table_type   = DSTR_INITIALIZER;
    7058             : 
    7059         102 :         ODBC_ENTER_HSTMT;
    7060             : 
    7061         102 :         tdsdump_log(TDS_DBG_FUNC, "SQLTables(%p, %p, %d, %p, %d, %p, %d, %p, %d)\n", 
    7062             :                         hstmt, szCatalogName, cbCatalogName, szSchemaName, cbSchemaName, szTableName, cbTableName, szTableType, cbTableType);
    7063             : 
    7064         102 :         tds = stmt->dbc->tds_socket;
    7065             : 
    7066         102 :         if (!odbc_dstr_copy(stmt->dbc, &catalog_name, cbCatalogName, szCatalogName)
    7067         102 :             || !odbc_dstr_copy(stmt->dbc, &schema_name, cbSchemaName, szSchemaName)
    7068         102 :             || !odbc_dstr_copy(stmt->dbc, &table_name, cbTableName, szTableName)
    7069         102 :             || !odbc_dstr_copy(stmt->dbc, &table_type, cbTableType, szTableType))
    7070             :                 goto memory_error;
    7071             : 
    7072         102 :         if (cbTableName == SQL_NTS)
    7073           0 :                 cbTableName = tds_dstr_len(&table_name);
    7074         102 :         if (cbSchemaName == SQL_NTS)
    7075           0 :                 cbSchemaName = tds_dstr_len(&schema_name);
    7076             : 
    7077             :         /* support wildcards on catalog (only odbc 3) */
    7078         102 :         wildcards = 0;
    7079         140 :         if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3 && stmt->dbc->attr.metadata_id == SQL_FALSE &&
    7080         100 :             (strchr(tds_dstr_cstr(&catalog_name), '%') || strchr(tds_dstr_cstr(&catalog_name), '_')))
    7081             :                 wildcards = 1;
    7082             : 
    7083         102 :         proc = "sp_tables";
    7084         204 :         if (!tds_dstr_isempty(&catalog_name)) {
    7085          14 :                 if (wildcards) {
    7086             :                         /* if catalog specified and wildcards use sp_tableswc under mssql2k */
    7087          14 :                         if (TDS_IS_MSSQL(tds) && tds->conn->product_version >= TDS_MS_VER(8,0,0)) {
    7088          12 :                                 proc = "sp_tableswc";
    7089          24 :                                 if (tds_dstr_isempty(&schema_name))
    7090          12 :                                         if (!tds_dstr_copy(&schema_name, "%"))
    7091             :                                                 goto memory_error;
    7092             :                         }
    7093             :                         /*
    7094             :                          * TODO support wildcards on catalog even for Sybase
    7095             :                          * first execute a select name from master..sysdatabases where name like catalog quoted
    7096             :                          * build a db1..sp_tables args db2..sp_tables args ... query
    7097             :                          * collapse results in a single recordset (how??)
    7098             :                          */
    7099             :                 } else {
    7100             :                         /* if catalog specified and not wildcards use catatog on name (catalog..sp_tables) */
    7101             :                         proc = "..sp_tables";
    7102             :                 }
    7103             :         }
    7104             : 
    7105             :         /* fix type if needed quoting it */
    7106         204 :         if (!tds_dstr_isempty(&table_type)) {
    7107          64 :                 int to_fix = 0;
    7108          64 :                 int elements = 0;
    7109         128 :                 const char *p = tds_dstr_cstr(&table_type);
    7110          64 :                 const char *const end = p + tds_dstr_len(&table_type);
    7111             : 
    7112          24 :                 for (;;) {
    7113          88 :                         const char *begin = p;
    7114             : 
    7115          88 :                         p = (const char*) memchr(p, ',', end - p);
    7116          88 :                         if (!p)
    7117          64 :                                 p = end;
    7118          88 :                         ++elements;
    7119          88 :                         if ((p - begin) < 2 || begin[0] != '\'' || p[-1] != '\'')
    7120          40 :                                 to_fix = 1;
    7121          88 :                         if (p >= end)
    7122             :                                 break;
    7123          24 :                         ++p;
    7124             :                 }
    7125             :                 /* fix it */
    7126          64 :                 tdsdump_log(TDS_DBG_INFO1, "to_fix %d elements %d\n", to_fix, elements);
    7127          64 :                 if (to_fix) {
    7128             :                         char *dst, *type;
    7129             : 
    7130          32 :                         tdsdump_log(TDS_DBG_INFO1, "fixing type elements\n");
    7131          64 :                         type = tds_new(char, tds_dstr_len(&table_type) + elements * 2 + 3);
    7132          32 :                         if (!type)
    7133             :                                 goto memory_error;
    7134             : 
    7135          64 :                         p = tds_dstr_cstr(&table_type);
    7136          32 :                         dst = type;
    7137          24 :                         for (;;) {
    7138          56 :                                 const char *begin = p;
    7139             : 
    7140          56 :                                 p = (const char*) memchr(p, ',', end - p);
    7141          56 :                                 if (!p)
    7142          32 :                                         p = end;
    7143          56 :                                 if ((p - begin) < 2 || begin[0] != '\'' || p[-1] != '\'') {
    7144          40 :                                         *dst++ = '\'';
    7145          40 :                                         memcpy(dst, begin, p - begin);
    7146          40 :                                         dst += p - begin;
    7147          40 :                                         *dst++ = '\'';
    7148             :                                 } else {
    7149          16 :                                         memcpy(dst, begin, p - begin);
    7150          16 :                                         dst += p - begin;
    7151             :                                 }
    7152          56 :                                 if (p >= end)
    7153             :                                         break;
    7154          24 :                                 *dst++ = *p++;
    7155             :                         }
    7156          32 :                         *dst = 0;
    7157          32 :                         if (!tds_dstr_set(&table_type, type)) {
    7158           0 :                                 free(type);
    7159           0 :                                 goto memory_error;
    7160             :                         }
    7161             :                 }
    7162             :         }
    7163             : 
    7164             :         /* special case for catalog list */
    7165         204 :         if (strcmp(tds_dstr_cstr(&catalog_name), "%") == 0 && cbTableName <= 0 && cbSchemaName <= 0) {
    7166           8 :                 retcode =
    7167           8 :                         odbc_stat_execute(stmt _wide, "sp_tables", 3, "$!P@table_name", "", 0,
    7168             :                                           "$!P@table_owner", "", 0, "!P@table_qualifier", "%", 1);
    7169             :         } else {
    7170          94 :                 retcode =
    7171         752 :                         odbc_stat_execute(stmt _wide, proc, 4,
    7172             :                                 "!P@table_name", tds_dstr_cstr(&table_name), tds_dstr_len(&table_name),
    7173             :                                 "!P@table_owner", tds_dstr_cstr(&schema_name), tds_dstr_len(&schema_name),
    7174             :                                 "!P@table_qualifier", tds_dstr_cstr(&catalog_name), tds_dstr_len(&catalog_name),
    7175             :                                 "!@table_type", tds_dstr_cstr(&table_type), tds_dstr_len(&table_type));
    7176             :         }
    7177         102 :         tds_dstr_free(&schema_name);
    7178         102 :         tds_dstr_free(&catalog_name);
    7179         102 :         tds_dstr_free(&table_name);
    7180         102 :         tds_dstr_free(&table_type);
    7181         102 :         if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
    7182          38 :                 odbc_col_setname(stmt, 1, "TABLE_CAT");
    7183          38 :                 odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    7184             :         }
    7185         102 :         ODBC_EXIT_(stmt);
    7186             : 
    7187           0 : memory_error:
    7188           0 :         tds_dstr_free(&schema_name);
    7189           0 :         tds_dstr_free(&catalog_name);
    7190           0 :         tds_dstr_free(&table_name);
    7191           0 :         tds_dstr_free(&table_type);
    7192           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    7193           0 :         ODBC_EXIT_(stmt);
    7194             : }
    7195             : 
    7196             : /** 
    7197             :  * Log a useful message about unimplemented options
    7198             :  * Defying belief, Microsoft defines mutually exclusive options that
    7199             :  * some ODBC implementations #define as duplicate values (meaning, of course, 
    7200             :  * that they couldn't be implemented in the same function because they're 
    7201             :  * indistinguishable.  
    7202             :  * 
    7203             :  * Those duplicates are commented out below.
    7204             :  */
    7205             : static void
    7206           0 : odbc_log_unimplemented_type(const char function_name[], int fType)
    7207             : {
    7208             :         const char *name, *category;
    7209             : 
    7210           0 :         switch (fType) {
    7211             : #ifdef SQL_ALTER_SCHEMA
    7212             :         case SQL_ALTER_SCHEMA:
    7213             :                 name = "SQL_ALTER_SCHEMA";
    7214             :                 category = "Supported SQL";
    7215             :                 break;
    7216             : #endif
    7217             : #ifdef SQL_ANSI_SQL_DATETIME_LITERALS
    7218             :         case SQL_ANSI_SQL_DATETIME_LITERALS:
    7219             :                 name = "SQL_ANSI_SQL_DATETIME_LITERALS";
    7220             :                 category = "Supported SQL";
    7221             :                 break;
    7222             : #endif
    7223             :         case SQL_COLLATION_SEQ:
    7224             :                 name = "SQL_COLLATION_SEQ";
    7225             :                 category = "Data Source Information";
    7226             :                 break;
    7227           0 :         case SQL_CONVERT_BIGINT:
    7228           0 :                 name = "SQL_CONVERT_BIGINT";
    7229           0 :                 category = "Conversion Information";
    7230           0 :                 break;
    7231           0 :         case SQL_CONVERT_DATE:
    7232           0 :                 name = "SQL_CONVERT_DATE";
    7233           0 :                 category = "Conversion Information";
    7234           0 :                 break;
    7235           0 :         case SQL_CONVERT_DOUBLE:
    7236           0 :                 name = "SQL_CONVERT_DOUBLE";
    7237           0 :                 category = "Conversion Information";
    7238           0 :                 break;
    7239           0 :         case SQL_CONVERT_INTERVAL_DAY_TIME:
    7240           0 :                 name = "SQL_CONVERT_INTERVAL_DAY_TIME";
    7241           0 :                 category = "Conversion Information";
    7242           0 :                 break;
    7243           0 :         case SQL_CONVERT_INTERVAL_YEAR_MONTH:
    7244           0 :                 name = "SQL_CONVERT_INTERVAL_YEAR_MONTH";
    7245           0 :                 category = "Conversion Information";
    7246           0 :                 break;
    7247           0 :         case SQL_DM_VER:
    7248           0 :                 name = "SQL_DM_VER";
    7249           0 :                 category = "Added for ODBC 3.x";
    7250           0 :                 break;
    7251           0 :         case SQL_DRIVER_HDESC:
    7252           0 :                 name = "SQL_DRIVER_HDESC";
    7253           0 :                 category = "Driver Information";
    7254           0 :                 break;
    7255           0 :         case SQL_DRIVER_HLIB:
    7256           0 :                 name = "SQL_DRIVER_HLIB";
    7257           0 :                 category = "Driver Information";
    7258           0 :                 break;
    7259             : #ifdef SQL_ODBC_STANDARD_CLI_CONFORMANCE
    7260             :         case SQL_ODBC_STANDARD_CLI_CONFORMANCE:
    7261             :                 name = "SQL_ODBC_STANDARD_CLI_CONFORMANCE";
    7262             :                 category = "Driver Information";
    7263             :                 break;
    7264             : #endif
    7265           0 :         case SQL_USER_NAME:
    7266           0 :                 name = "SQL_USER_NAME";
    7267           0 :                 category = "Data Source Information";
    7268           0 :                 break;
    7269             :         /* TODO extension SQL_INFO_SS_NETLIB_NAME ?? */
    7270           0 :         default:
    7271           0 :                 name = "unknown";
    7272           0 :                 category = "unknown";
    7273           0 :                 break;
    7274             :         }
    7275             : 
    7276           0 :         tdsdump_log(TDS_DBG_INFO1, "not implemented: %s: option/type %d(%s) [category %s]\n", function_name, fType, name,
    7277             :                     category);
    7278             : 
    7279           0 :         return;
    7280             : }
    7281             : 
    7282             : static int
    7283         322 : odbc_quote_metadata(TDS_DBC * dbc, char type, char *dest, DSTR * dstr)
    7284             : {
    7285         322 :         int unquote = 0;
    7286             :         char prev, buf[1200], *dst;
    7287         644 :         const char *s = tds_dstr_cstr(dstr);
    7288         644 :         int len = tds_dstr_len(dstr);
    7289             : 
    7290             :         /* limit string/id lengths */
    7291         322 :         if (len > 384)
    7292           0 :                 len = 384;
    7293             : 
    7294         322 :         if (!type || (type == 'O' && dbc->attr.metadata_id == SQL_FALSE)) {
    7295          80 :                 if (dest)
    7296          80 :                         memcpy(dest, s, len);
    7297             :                 return len;
    7298             :         }
    7299             : 
    7300             :         /* where we can have ID or PV */
    7301         242 :         assert(type == 'P' || (type == 'O' && dbc->attr.metadata_id != SQL_FALSE));
    7302             : 
    7303             :         /* ID ? */
    7304         242 :         if (dbc->attr.metadata_id != SQL_FALSE) {
    7305             :                 /* strip leading and trailing spaces */
    7306           0 :                 while (len > 0 && *s == ' ')
    7307           0 :                         ++s, --len;
    7308           0 :                 while (len > 0 && s[len - 1] == ' ')
    7309           0 :                         --len;
    7310             :                 /* unquote if necessary */
    7311           0 :                 if (len > 2 && *s == '\"' && s[len - 1] == '\"') {
    7312           0 :                         ++s, len -= 2;
    7313           0 :                         unquote = 1;
    7314             :                 }
    7315             :         }
    7316             : 
    7317         242 :         if (!dest)
    7318           0 :                 dest = buf;
    7319         242 :         dst = dest;
    7320             : 
    7321             :         /*
    7322             :          * handle patterns 
    7323             :          * "'" -> "''" (normal string quoting)
    7324             :          *
    7325             :          * if metadata_id is FALSE
    7326             :          * "\_" -> "[_]"
    7327             :          * "\%" -> "[%]"
    7328             :          * "[" -> "[[]"
    7329             :          *
    7330             :          * if metadata_id is TRUE
    7331             :          * "\"\"" -> "\"" (if unquote id)
    7332             :          * "_" -> "[_]"
    7333             :          * "%" -> "[%]"
    7334             :          * "[" -> "[[]"
    7335             :          */
    7336         242 :         prev = 0;
    7337        1506 :         for (; --len >= 0; ++s) {
    7338        1264 :                 switch (*s) {
    7339           0 :                 case '\"':
    7340           0 :                         if (unquote && prev == '\"') {
    7341           0 :                                 prev = 0;       /* avoid "\"\"\"" -> "\"" */
    7342           0 :                                 --dst;
    7343           0 :                                 continue;
    7344             :                         }
    7345             :                         break;
    7346          84 :                 case '_':
    7347             :                 case '%':
    7348          84 :                         if (dbc->attr.metadata_id == SQL_FALSE) {
    7349          84 :                                 if (prev != '\\')
    7350             :                                         break;
    7351           0 :                                 --dst;
    7352             :                         }
    7353             :                 case '[':
    7354           0 :                         if (type != 'P')
    7355             :                                 break;
    7356             :                         /* quote search string */
    7357           0 :                         *dst++ = '[';
    7358           0 :                         *dst++ = *s;
    7359           0 :                         *dst++ = ']';
    7360           0 :                         prev = 0;
    7361           0 :                         continue;
    7362             :                 }
    7363        1264 :                 *dst++ = prev = *s;
    7364             :         }
    7365         242 :         return dst - dest;
    7366             : }
    7367             : 
    7368             : static TDSPARAMINFO*
    7369         322 : odbc_add_char_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, const char *value, size_t len)
    7370             : {
    7371             :         TDSCOLUMN *col;
    7372             : 
    7373         322 :         params = tds_alloc_param_result(params);
    7374         322 :         if (!params)
    7375             :                 return NULL;
    7376             : 
    7377         322 :         col = params->columns[params->num_cols-1];
    7378         322 :         if (!tds_dstr_copy(&col->column_name, name))
    7379             :                 return NULL;
    7380         322 :         tds_set_param_type(tds->conn, col, IS_TDS7_PLUS(tds->conn) ? XSYBNVARCHAR : SYBVARCHAR);
    7381             : 
    7382         322 :         col->column_size = len;
    7383         322 :         if (!tds_alloc_param_data(col))
    7384             :                 return NULL;
    7385             : 
    7386         322 :         memcpy(col->column_data, value, len);
    7387         322 :         col->column_cur_size = len;
    7388             : 
    7389         322 :         return params;
    7390             : }
    7391             : 
    7392             : static TDSPARAMINFO*
    7393          36 : odbc_add_int_param(TDSSOCKET *tds, TDSPARAMINFO *params, const char *name, int value)
    7394             : {
    7395             :         TDSCOLUMN *col;
    7396             : 
    7397          36 :         params = tds_alloc_param_result(params);
    7398          36 :         if (!params)
    7399             :                 return NULL;
    7400             : 
    7401          36 :         col = params->columns[params->num_cols-1];
    7402          36 :         if (!tds_dstr_copy(&col->column_name, name))
    7403             :                 return NULL;
    7404          36 :         tds_set_param_type(tds->conn, col, SYBINT4);
    7405             : 
    7406          36 :         if (!tds_alloc_param_data(col))
    7407             :                 return NULL;
    7408             : 
    7409          36 :         *((TDS_INT*) col->column_data) = value;
    7410          36 :         col->column_cur_size = sizeof(TDS_INT);
    7411             : 
    7412          36 :         return params;
    7413             : }
    7414             : 
    7415             : 
    7416             : static SQLRETURN
    7417         150 : odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...)
    7418             : {
    7419         150 :         int i, len, param_qualifier = -1;
    7420         150 :         char *proc = NULL, *p;
    7421             :         SQLRETURN retcode;
    7422             :         va_list marker;
    7423         150 :         DSTR qualifier = DSTR_INITIALIZER, value = DSTR_INITIALIZER;
    7424             :         TDSPARAMINFO *params;
    7425             : 
    7426             :         /* read all params and calc len required */
    7427         150 :         va_start(marker, nparams);
    7428         150 :         len = strlen(begin) + 3;
    7429         150 :         params = tds_alloc_results(0);
    7430         150 :         if (!params)
    7431             :                 goto mem_error;
    7432         628 :         for (i = 0; i < nparams; ++i) {
    7433             :                 int param_len;
    7434         628 :                 bool convert = true;
    7435         628 :                 bool add_always = false;
    7436             :                 DSTR *out;
    7437             :                 const char *name;
    7438             :                 char type;
    7439             : 
    7440         628 :                 p = va_arg(marker, char *);
    7441             : 
    7442         416 :                 for (; ; ++p) {
    7443        1460 :                         switch (*p) {
    7444          16 :                         case '$':
    7445          16 :                                 add_always = true;
    7446          16 :                                 continue;
    7447         400 :                         case '!':
    7448         400 :                                 convert = false;
    7449         400 :                                 continue;
    7450         534 :                         case 'V':       /* ODBC version */
    7451             :                         case 'O':       /* ordinary arguments */
    7452             :                         case 'P':       /* pattern value arguments */
    7453         534 :                                 type = *p++;
    7454         534 :                                 break;
    7455             :                         default:
    7456             :                                 type = 0;       /* ordinary type */
    7457             :                                 break;
    7458             :                         }
    7459             :                         break;
    7460             :                 }
    7461         628 :                 name = p;
    7462             : 
    7463         628 :                 p = va_arg(marker, char *);
    7464         628 :                 param_len = va_arg(marker, int);
    7465             : 
    7466         628 :                 if (type == 'V') {
    7467          36 :                         int ver = (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) ? 3: 2;
    7468          36 :                         if (!odbc_add_int_param(stmt->dbc->tds_socket, params, name, ver))
    7469             :                                 goto mem_error;
    7470          36 :                         continue;
    7471             :                 }
    7472             : 
    7473             : #ifdef ENABLE_ODBC_WIDE
    7474         592 :                 if (!convert)
    7475         400 :                         out = tds_dstr_copyn(&value, p, param_len);
    7476             :                 else
    7477         192 :                         out = odbc_dstr_copy(stmt->dbc, &value, param_len, (ODBC_CHAR *) p);
    7478             : #else
    7479             :                 out = odbc_dstr_copy(stmt->dbc, &value, param_len, (ODBC_CHAR *) p);
    7480             : #endif
    7481         592 :                 if (!out)
    7482             :                         goto mem_error;
    7483             : 
    7484        1168 :                 if (add_always || !tds_dstr_isempty(&value)) {
    7485             :                         char buf[1200];
    7486             :                         int l;
    7487             : 
    7488         322 :                         l = odbc_quote_metadata(stmt->dbc, type, buf, &value);
    7489         322 :                         if (!odbc_add_char_param(stmt->dbc->tds_socket, params, name, buf, l))
    7490             :                                 goto mem_error;
    7491             : 
    7492         322 :                         if (begin[0] == '.' && strstr(name, "qualifier")) {
    7493          16 :                                 if (!tds_dstr_dup(&qualifier, &value))
    7494             :                                         goto mem_error;
    7495          32 :                                 len += tds_quote_id_rpc(stmt->dbc->tds_socket, NULL,
    7496          16 :                                                         tds_dstr_cstr(&qualifier), tds_dstr_len(&qualifier));
    7497          16 :                                 param_qualifier = i;
    7498             :                         }
    7499             :                 }
    7500             :         }
    7501         150 :         tds_dstr_free(&value);
    7502             : 
    7503             :         /* proc is neither mb or wide, is always utf encoded */
    7504         150 :         retcode = odbc_set_stmt_query(stmt, (ODBC_CHAR *) "-", 1 _wide0);
    7505         150 :         if (retcode != SQL_SUCCESS)
    7506             :                 goto error;
    7507         150 :         stmt->prepared_query_is_rpc = 1;
    7508             : 
    7509             :         /* set params */
    7510         150 :         tds_free_param_results(stmt->params);
    7511         150 :         stmt->param_count = params->num_cols;
    7512         150 :         stmt->param_num = 1 + stmt->param_count;
    7513         150 :         stmt->params = params;
    7514         150 :         params = NULL;
    7515             : 
    7516             :         /* allocate space for string */
    7517         150 :         if (!tds_dstr_alloc(&stmt->query, len))
    7518             :                 goto mem_error;
    7519         300 :         proc = tds_dstr_buf(&stmt->query);
    7520             : 
    7521             :         /* build query string */
    7522         150 :         p = proc;
    7523         150 :         if (param_qualifier >= 0)
    7524          48 :                 p += tds_quote_id_rpc(stmt->dbc->tds_socket, p, tds_dstr_cstr(&qualifier), tds_dstr_len(&qualifier));
    7525         150 :         tds_dstr_free(&qualifier);
    7526         150 :         strcpy(p, begin);
    7527         150 :         p += strlen(begin);
    7528         150 :         tds_dstr_setlen(&stmt->query, p - proc);
    7529         150 :         assert(p - proc + 1 <= len);
    7530             : 
    7531             :         /* execute it */
    7532         150 :         retcode = _SQLExecute(stmt);
    7533         150 :         if (SQL_SUCCEEDED(retcode))
    7534         150 :                 odbc_upper_column_names(stmt);
    7535             : 
    7536         150 :         va_end(marker);
    7537         150 :         ODBC_RETURN(stmt, retcode);
    7538             : 
    7539           0 : mem_error:
    7540           0 :         odbc_errs_add(&stmt->errs, "HY001", NULL);
    7541             : 
    7542           0 : error:
    7543           0 :         tds_dstr_free(&value);
    7544           0 :         tds_dstr_free(&qualifier);
    7545           0 :         tds_free_results(params);
    7546           0 :         va_end(marker);
    7547           0 :         return SQL_ERROR;
    7548             : }
    7549             : 
    7550             : static SQLRETURN
    7551       16375 : odbc_free_dynamic(TDS_STMT * stmt)
    7552             : {
    7553             :         TDSSOCKET *tds;
    7554             : 
    7555       16375 :         if (!stmt->dyn)
    7556             :                 return TDS_SUCCESS;
    7557             : 
    7558        1668 :         tds = stmt->dbc->tds_socket;
    7559        1668 :         if (!tds_needs_unprepare(tds->conn, stmt->dyn)) {
    7560          74 :                 tds_release_dynamic(&stmt->dyn);
    7561          74 :                 return SQL_SUCCESS;
    7562             :         }
    7563             : 
    7564        1594 :         if (odbc_lock_statement(stmt)) {
    7565        1587 :                 if (TDS_SUCCEED(tds_submit_unprepare(stmt->tds, stmt->dyn))
    7566        1587 :                     && TDS_SUCCEED(tds_process_simple_query(stmt->tds))) {
    7567        1587 :                         odbc_unlock_statement(stmt);
    7568        1587 :                         tds_release_dynamic(&stmt->dyn);
    7569        1587 :                         return SQL_SUCCESS;
    7570             :                 }
    7571             :         }
    7572             : 
    7573           7 :         if (TDS_SUCCEED(tds_deferred_unprepare(tds->conn, stmt->dyn))) {
    7574           7 :                 tds_release_dynamic(&stmt->dyn);
    7575           7 :                 return SQL_SUCCESS;
    7576             :         }
    7577             : 
    7578           0 :         ODBC_SAFE_ERROR(stmt);
    7579             :         return SQL_ERROR;
    7580             : }
    7581             : 
    7582             : /**
    7583             :  * Close server cursors
    7584             :  */
    7585             : static SQLRETURN
    7586       13731 : odbc_free_cursor(TDS_STMT * stmt)
    7587             : {
    7588       13731 :         TDSCURSOR *cursor = stmt->cursor;
    7589             :         TDSSOCKET *tds;
    7590             : 
    7591       13731 :         if (!cursor)
    7592             :                 return SQL_SUCCESS;
    7593             : 
    7594             :         /* if possible deallocate now */
    7595         186 :         if (odbc_lock_statement(stmt)) {
    7596         186 :                 tds = stmt->tds;
    7597             : 
    7598         186 :                 cursor->status.dealloc   = TDS_CURSOR_STATE_REQUESTED;
    7599         186 :                 if (TDS_SUCCEED(tds_cursor_close(tds, cursor))) {
    7600         186 :                         if (TDS_SUCCEED(tds_process_simple_query(tds))) {
    7601             :                                 /* TODO check error */
    7602         186 :                                 tds_cursor_dealloc(tds, cursor);
    7603         186 :                                 tds_release_cursor(&stmt->cursor);
    7604         186 :                                 return SQL_SUCCESS;
    7605             :                         }
    7606             :                 }
    7607             :         }
    7608             : 
    7609           0 :         tds = stmt->dbc->tds_socket;
    7610           0 :         if (TDS_SUCCEED(tds_deferred_cursor_dealloc(tds->conn, cursor))) {
    7611           0 :                 tds_release_cursor(&stmt->cursor);
    7612           0 :                 return SQL_SUCCESS;
    7613             :         }
    7614             : 
    7615           0 :         ODBC_SAFE_ERROR(stmt);
    7616             :         return SQL_ERROR;
    7617             : }
    7618             : 
    7619             : SQLRETURN ODBC_PUBLIC ODBC_API
    7620             : SQLSetScrollOptions(SQLHSTMT hstmt, SQLUSMALLINT fConcurrency, SQLLEN crowKeyset, SQLUSMALLINT crowRowset)
    7621             : {
    7622             :         SQLUSMALLINT info;
    7623             :         SQLUINTEGER value, check;
    7624             :         SQLUINTEGER cursor_type;
    7625             : 
    7626           0 :         ODBC_ENTER_HSTMT;
    7627             : 
    7628           0 :         tdsdump_log(TDS_DBG_FUNC, "SQLSetScrollOptions(%p, %u, %ld, %u)\n", 
    7629             :                         hstmt, fConcurrency, (long int) crowKeyset, crowRowset);
    7630             : 
    7631           0 :         if (!stmt->dbc->cursor_support) {
    7632           0 :                 odbc_errs_add(&stmt->errs, "HYC00", NULL);
    7633           0 :                 ODBC_EXIT_(stmt);
    7634             :         }
    7635             : 
    7636           0 :         if (stmt->cursor) {
    7637           0 :                 odbc_errs_add(&stmt->errs, "24000", NULL);
    7638           0 :                 ODBC_EXIT_(stmt);
    7639             :         }
    7640             : 
    7641           0 :         switch (crowKeyset) {
    7642             :         case SQL_SCROLL_FORWARD_ONLY:
    7643             :                 info = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
    7644             :                 cursor_type = SQL_CURSOR_FORWARD_ONLY;
    7645             :                 break;
    7646           0 :         case SQL_SCROLL_STATIC:
    7647           0 :                 info = SQL_STATIC_CURSOR_ATTRIBUTES2;
    7648           0 :                 cursor_type = SQL_CURSOR_STATIC;
    7649           0 :                 break;
    7650           0 :         case SQL_SCROLL_KEYSET_DRIVEN:
    7651           0 :                 info = SQL_KEYSET_CURSOR_ATTRIBUTES2;
    7652           0 :                 cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    7653           0 :                 break;
    7654           0 :         case SQL_SCROLL_DYNAMIC:
    7655           0 :                 info = SQL_DYNAMIC_CURSOR_ATTRIBUTES2;
    7656           0 :                 cursor_type = SQL_CURSOR_DYNAMIC;
    7657           0 :                 break;
    7658           0 :         default:
    7659           0 :                 if (crowKeyset > crowRowset) {
    7660             :                         info = SQL_KEYSET_CURSOR_ATTRIBUTES2;
    7661             :                         cursor_type = SQL_CURSOR_KEYSET_DRIVEN;
    7662             :                         break;
    7663             :                 }
    7664             :                 
    7665           0 :                 odbc_errs_add(&stmt->errs, "HY107", NULL);
    7666           0 :                 ODBC_EXIT_(stmt);
    7667             :         }
    7668             : 
    7669           0 :         switch (fConcurrency) {
    7670             :         case SQL_CONCUR_READ_ONLY:
    7671             :                 check = SQL_CA2_READ_ONLY_CONCURRENCY;
    7672             :                 break;
    7673           0 :         case SQL_CONCUR_LOCK:
    7674           0 :                 check = SQL_CA2_LOCK_CONCURRENCY;
    7675           0 :                 break;
    7676           0 :         case SQL_CONCUR_ROWVER:
    7677           0 :                 check = SQL_CA2_OPT_ROWVER_CONCURRENCY;
    7678           0 :                 break;
    7679           0 :         case SQL_CONCUR_VALUES:
    7680           0 :                 check = SQL_CA2_OPT_VALUES_CONCURRENCY;
    7681           0 :                 break;
    7682           0 :         default:
    7683           0 :                 odbc_errs_add(&stmt->errs, "HY108", NULL);
    7684           0 :                 ODBC_EXIT_(stmt);
    7685             :         }
    7686             : 
    7687           0 :         value = 0;
    7688           0 :         _SQLGetInfo(stmt->dbc, info, &value, sizeof(value), NULL _wide0);
    7689             : 
    7690           0 :         if ((value & check) == 0) {
    7691           0 :                 odbc_errs_add(&stmt->errs, "HYC00", NULL);
    7692           0 :                 ODBC_EXIT_(stmt);
    7693             :         }
    7694             : 
    7695           0 :         _SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER) (TDS_INTPTR) cursor_type, 0 _wide0);
    7696           0 :         _SQLSetStmtAttr(hstmt, SQL_ATTR_CONCURRENCY, (SQLPOINTER) (TDS_INTPTR) fConcurrency, 0 _wide0);
    7697           0 :         _SQLSetStmtAttr(hstmt, SQL_ATTR_KEYSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crowKeyset, 0 _wide0);
    7698           0 :         _SQLSetStmtAttr(hstmt, SQL_ROWSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crowRowset, 0 _wide0);
    7699             : 
    7700           0 :         ODBC_EXIT_(stmt);
    7701             : }
    7702             : 
    7703             : #include "odbc_export.h"
    7704             : 
    7705             : /* Under Windows driver exports functions */
    7706             : /* The win_ prefix is to avoid clash with inline function.
    7707             :  * The prefix is removed from exported functions using definition file.
    7708             :  */
    7709             : #ifdef _WIN32
    7710             : RETCODE SQL_API win_bcp_initA(HDBC hdbc, const char *tblname, const char *hfile,
    7711             :         const char *errfile, int direction);
    7712             : RETCODE SQL_API win_bcp_initW(HDBC hdbc, const SQLWCHAR *tblname, const SQLWCHAR *hfile,
    7713             :         const SQLWCHAR *errfile, int direction);
    7714             : RETCODE SQL_API win_bcp_control(HDBC hdbc, int field, void *value);
    7715             : RETCODE SQL_API win_bcp_colptr(HDBC hdbc, const unsigned char * colptr, int table_column);
    7716             : RETCODE SQL_API win_bcp_sendrow(HDBC hdbc);
    7717             : int SQL_API win_bcp_batch(HDBC hdbc);
    7718             : int SQL_API win_bcp_done(HDBC hdbc);
    7719             : RETCODE SQL_API win_bcp_bind(HDBC hdbc, const unsigned char * varaddr, int prefixlen, int varlen,
    7720             :         const unsigned char * terminator, int termlen, int vartype, int table_column);
    7721             : 
    7722             : RETCODE SQL_API
    7723             : win_bcp_initA(HDBC hdbc, const char *tblname, const char *hfile, const char *errfile, int direction)
    7724             : {
    7725             :         return bcp_initA(hdbc, tblname, hfile, errfile, direction);
    7726             : }
    7727             : 
    7728             : #ifdef ENABLE_ODBC_WIDE
    7729             : RETCODE SQL_API
    7730             : win_bcp_initW(HDBC hdbc, const SQLWCHAR *tblname, const SQLWCHAR *hfile, const SQLWCHAR *errfile, int direction)
    7731             : {
    7732             :         return bcp_initW(hdbc, tblname, hfile, errfile, direction);
    7733             : }
    7734             : #endif
    7735             : 
    7736             : RETCODE SQL_API
    7737             : win_bcp_control(HDBC hdbc, int field, void *value)
    7738             : {
    7739             :         return bcp_control(hdbc, field, value);
    7740             : }
    7741             : 
    7742             : RETCODE SQL_API
    7743             : win_bcp_colptr(HDBC hdbc, const unsigned char * colptr, int table_column)
    7744             : {
    7745             :         return bcp_colptr(hdbc, colptr, table_column);
    7746             : }
    7747             : 
    7748             : RETCODE SQL_API
    7749             : win_bcp_sendrow(HDBC hdbc)
    7750             : {
    7751             :         return bcp_sendrow(hdbc);
    7752             : }
    7753             : 
    7754             : int SQL_API
    7755             : win_bcp_batch(HDBC hdbc)
    7756             : {
    7757             :         return bcp_batch(hdbc);
    7758             : }
    7759             : 
    7760             : int SQL_API
    7761             : win_bcp_done(HDBC hdbc)
    7762             : {
    7763             :         return bcp_done(hdbc);
    7764             : }
    7765             : 
    7766             : RETCODE SQL_API
    7767             : win_bcp_bind(HDBC hdbc, const unsigned char * varaddr, int prefixlen, int varlen,
    7768             :         const unsigned char * terminator, int termlen, int vartype, int table_column)
    7769             : {
    7770             :         return bcp_bind(hdbc, varaddr, prefixlen, varlen, terminator, termlen, vartype, table_column);
    7771             : }
    7772             : #endif
    7773             : 

Generated by: LCOV version 1.13