odbc.c

Go to the documentation of this file.

Go to the SVN repository for this file.

/* FreeTDS - Library of routines accessing Sybase and Microsoft databases
 * Copyright (C) 1998, 1999, 2000, 2001  Brian Bruns
 * Copyright (C) 2002-2012  Frediano Ziglio
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#include <config.h>
 
#include <stdarg.h>
#include <stdio.h>
 
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif /* HAVE_STDLIB_H */
 
#if HAVE_STRING_H
#include <string.h>
#endif /* HAVE_STRING_H */
 
#include <assert.h>
#include <ctype.h>
 
#include <freetds/odbc.h>
#include <freetds/iconv.h>
#include <freetds/string.h>
#include <freetds/convert.h>
#include "replacements.h"
#include "sqlwparams.h"
 
/* Include odbcss.h with all bcp functions */
/* The define trick is to make inline functions calls internal
 * _SQLSetConnectAttr instead of SQLSetConnectAttr */
ODBC_FUNC(SQLSetConnectAttr, (P(SQLHDBC,hdbc), P(SQLINTEGER,Attribute), P(SQLPOINTER,ValuePtr), P(SQLINTEGER,StringLength) WIDE));
#define TDSODBC_BCP
#undef SQLSetConnectAttr
#define SQLSetConnectAttr(h, n, p, t) _SQLSetConnectAttr(h, n, p, t _wide0)
#include <odbcss.h>
#undef SQLSetConnectAttr
 
static SQLRETURN _SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc);
static SQLRETURN _SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version);
static SQLRETURN _SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt);
static SQLRETURN _SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc);
static SQLRETURN _SQLFreeConnect(SQLHDBC hdbc);
static SQLRETURN _SQLFreeEnv(SQLHENV henv);
static SQLRETURN _SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force);
static SQLRETURN _SQLFreeDesc(SQLHDESC hdesc);
static SQLRETURN _SQLExecute(TDS_STMT * stmt);
static SQLRETURN _SQLSetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength WIDE);
static SQLRETURN _SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength,
                     SQLINTEGER * StringLength WIDE);
static SQLRETURN _SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc,
                      SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE);
static SQLRETURN _SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset);
static SQLRETURN odbc_populate_ird(TDS_STMT * stmt);
static int odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg);
static void odbc_log_unimplemented_type(const char function_name[], int fType);
static void odbc_upper_column_names(TDS_STMT * stmt);
static void odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name);
static SQLRETURN odbc_stat_execute(TDS_STMT * stmt _WIDE, const char *begin, int nparams, ...);
static SQLRETURN odbc_free_dynamic(TDS_STMT * stmt);
static SQLRETURN odbc_free_cursor(TDS_STMT * stmt);
static SQLRETURN odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs);
static SQLRETURN odbc_prepare(TDS_STMT *stmt);
static SQLSMALLINT odbc_swap_datetime_sql_type(SQLSMALLINT sql_type, int version);
static int odbc_process_tokens(TDS_STMT * stmt, unsigned flag);
static int odbc_lock_statement(TDS_STMT* stmt);
static void odbc_unlock_statement(TDS_STMT* stmt);
 
#if ENABLE_EXTRA_CHECKS
static void odbc_ird_check(TDS_STMT * stmt);
 
#define IRD_CHECK odbc_ird_check(stmt)
#else
#define IRD_CHECK
#endif
 
/**
 * \defgroup odbc_api ODBC API
 * Functions callable by \c ODBC client programs
 */
 
 
/* utils to check handles */
#define INIT_HANDLE(t, n) \
    TDS_##t *n = (TDS_##t*)h##n; \
    if (SQL_NULL_H##t  == h##n || !IS_H##t(h##n)) return SQL_INVALID_HANDLE; \
    tds_mutex_lock(&n->mtx); \
    CHECK_##t##_EXTRA(n); \
    odbc_errs_reset(&n->errs);
 
#define ODBC_ENTER_HSTMT INIT_HANDLE(STMT, stmt)
#define ODBC_ENTER_HDBC  INIT_HANDLE(DBC,  dbc)
#define ODBC_ENTER_HENV  INIT_HANDLE(ENV,  env)
#define ODBC_ENTER_HDESC INIT_HANDLE(DESC, desc)
 
#define IS_VALID_LEN(len) ((len) >= 0 || (len) == SQL_NTS || (len) == SQL_NULL_DATA)
 
#define ODBC_SAFE_ERROR(stmt) \
    do { \
        if (!stmt->errs.num_errors) \
            odbc_errs_add(&stmt->errs, "HY000", "Unknown error"); \
    } while(0)
 
#define DEFAULT_QUERY_TIMEOUT (~((SQLUINTEGER) 0))
 
/*
 * Note: I *HATE* hungarian notation, it has to be the most idiotic thing
 * I've ever seen. So, you will note it is avoided other than in the function
 * declarations. "Gee, let's make our code totally hard to read and they'll
 * beg for GUI tools"
 * Bah!
 */
 
static const char *
odbc_prret(SQLRETURN ret, char *unknown, size_t unknown_size)
{
    switch (ret) {
    case SQL_ERROR:         return "SQL_ERROR";
    case SQL_INVALID_HANDLE:    return "SQL_INVALID_HANDLE";
    case SQL_SUCCESS:       return "SQL_SUCCESS";
    case SQL_SUCCESS_WITH_INFO: return "SQL_SUCCESS_WITH_INFO";
#if ODBCVER >= 0x0300
    case SQL_NO_DATA:       return "SQL_NO_DATA";
#endif
    case SQL_STILL_EXECUTING:   return "SQL_STILL_EXECUTING";
    case SQL_NEED_DATA:     return "SQL_NEED_DATA";
    }
    
    snprintf(unknown, unknown_size, "unknown: %d", (int)ret);
 
    return unknown;
}
#define ODBC_PRRET_BUF  char unknown_prret_buf[24]
#define odbc_prret(ret) odbc_prret(ret, unknown_prret_buf, sizeof(unknown_prret_buf))
 
static void
odbc_col_setname(TDS_STMT * stmt, int colpos, const char *name)
{
#if ENABLE_EXTRA_CHECKS
    TDSRESULTINFO *resinfo;
#endif
 
    IRD_CHECK;
 
#if ENABLE_EXTRA_CHECKS
    if (colpos > 0 && stmt->tds != NULL && (resinfo = stmt->tds->current_results) != NULL) {
        if (colpos <= resinfo->num_cols) {
            /* no overflow possible, name is always shorter */
            if (!tds_dstr_copy(&resinfo->columns[colpos - 1]->column_name, name))
                odbc_errs_add(&stmt->errs, "HY001", NULL);
            tds_dstr_empty(&resinfo->columns[colpos - 1]->table_column_name);
        }
    }
#endif
 
    if (colpos > 0 && colpos <= stmt->ird->header.sql_desc_count) {
        --colpos;
        if (!tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_label, name)
            || !tds_dstr_copy(&stmt->ird->records[colpos].sql_desc_name, name))
            odbc_errs_add(&stmt->errs, "HY001", NULL);
    }
}
 
/* spinellia@acm.org : copied shamelessly from change_database */
static SQLRETURN
change_autocommit(TDS_DBC * dbc, int state)
{
    TDSSOCKET *tds = dbc->tds_socket;
    TDSRET ret;
 
    if (dbc->attr.autocommit == state)
        return SQL_SUCCESS;
 
    /*
     * We may not be connected yet and dbc->tds_socket
     * may not initialized.
     */
    if (tds) {
        /* TODO better idle check, not thread safe */
        if (tds->state == TDS_IDLE)
            tds->query_timeout = dbc->default_query_timeout;
 
        if (state == SQL_AUTOCOMMIT_ON)
            ret = tds_submit_rollback(tds, 0);
        else
            ret = tds_submit_begin_tran(tds);
 
        if (TDS_FAILED(ret)) {
            odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
            return SQL_ERROR;
        }
        if (TDS_FAILED(tds_process_simple_query(tds))) {
            odbc_errs_add(&dbc->errs, "HY000", "Could not change transaction status");
            return SQL_ERROR;
        }
        dbc->attr.autocommit = state;
    } else {
        /* if not connected we will change auto-commit after login */
        dbc->attr.autocommit = state;
    }
    ODBC_RETURN_(dbc);
}
 
static SQLRETURN
change_database(TDS_DBC * dbc, const char *database, size_t database_len)
{
    TDSSOCKET *tds = dbc->tds_socket;
 
    /* 
     * We may not be connected yet and dbc->tds_socket
     * may not initialized.
     */
    if (tds) {
        /* build query */
        char *query = tds_new(char, 6 + tds_quote_id(tds, NULL, database, database_len));
 
        if (!query) {
            odbc_errs_add(&dbc->errs, "HY001", NULL);
            return SQL_ERROR;
        }
        strcpy(query, "USE ");
        tds_quote_id(tds, query + 4, database, database_len);
 
 
        tdsdump_log(TDS_DBG_INFO1, "change_database: executing %s\n", query);
 
        /* TODO better idle check, not thread safe */
        if (tds->state == TDS_IDLE)
            tds->query_timeout = dbc->default_query_timeout;
        if (TDS_FAILED(tds_submit_query(tds, query))) {
            free(query);
            odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
            return SQL_ERROR;
        }
        free(query);
        if (TDS_FAILED(tds_process_simple_query(tds))) {
            odbc_errs_add(&dbc->errs, "HY000", "Could not change database");
            return SQL_ERROR;
        }
    } else {
        if (!tds_dstr_copyn(&dbc->attr.current_catalog, database, database_len)) {
            odbc_errs_add(&dbc->errs, "HY001", NULL);
            return SQL_ERROR;
        }
    }
    ODBC_RETURN_(dbc);
}
 
static SQLRETURN
change_txn(TDS_DBC * dbc, SQLUINTEGER txn_isolation)
{
    char query[64];
    const char *level;
    TDSSOCKET *tds = dbc->tds_socket;
 
    switch (txn_isolation) {
    case SQL_TXN_READ_COMMITTED:
        level = "READ COMMITTED";
        break;
    case SQL_TXN_READ_UNCOMMITTED:
        level = "READ UNCOMMITTED";
        break;
    case SQL_TXN_REPEATABLE_READ:
        level = "REPEATABLE READ";
        break;
    case SQL_TXN_SERIALIZABLE:
        level = "SERIALIZABLE";
        break;
    default:
        odbc_errs_add(&dbc->errs, "HY024", NULL);
        return SQL_ERROR;
    }
 
    /* if not connected return success, will be set after connection */
    if (!tds)
        return SQL_SUCCESS;
 
    if (tds->state != TDS_IDLE) {
        odbc_errs_add(&dbc->errs, "HY011", NULL);
        return SQL_ERROR;
    }
 
    tds->query_timeout = dbc->default_query_timeout;
    sprintf(query, "SET TRANSACTION ISOLATION LEVEL %s", level);
    if (TDS_FAILED(tds_submit_query(tds, query))) {
        ODBC_SAFE_ERROR(dbc);
        return SQL_ERROR;
    }
    if (TDS_FAILED(tds_process_simple_query(tds))) {
        ODBC_SAFE_ERROR(dbc);
        return SQL_ERROR;
    }
 
    return SQL_SUCCESS;
}
 
static TDS_DBC*
odbc_get_dbc(TDSSOCKET *tds)
{
    TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
    if (!chk)
        return NULL;
    if (chk->htype == SQL_HANDLE_DBC)
        return (TDS_DBC *) chk;
    assert(chk->htype == SQL_HANDLE_STMT);
    return ((TDS_STMT *) chk)->dbc;
}
 
static TDS_STMT*
odbc_get_stmt(TDSSOCKET *tds)
{
    TDS_CHK *chk = (TDS_CHK *) tds_get_parent(tds);
    if (!chk || chk->htype != SQL_HANDLE_STMT)
        return NULL;
    return (TDS_STMT *) chk;
}
 
 
static void
odbc_env_change(TDSSOCKET * tds, int type, char *oldval, char *newval)
{
    TDS_DBC *dbc;
 
    assert(tds);
 
    dbc = odbc_get_dbc(tds);
    if (!dbc)
        return;
 
    switch (type) {
    case TDS_ENV_DATABASE:
        tds_dstr_copy(&dbc->attr.current_catalog, newval);
        break;
    case TDS_ENV_PACKSIZE:
        dbc->attr.packet_size = atoi(newval);
        break;
    }
}
 
static SQLRETURN
odbc_connect(TDS_DBC * dbc, TDSLOGIN * login)
{
    TDS_ENV *env = dbc->env;
 
#ifdef ENABLE_ODBC_WIDE
    dbc->mb_conv = NULL;
#endif
    dbc->tds_socket = tds_alloc_socket(env->tds_ctx, 512);
    if (!dbc->tds_socket)
        goto memory_error;
 
    dbc->tds_socket->conn->use_iconv = 0;
    tds_set_parent(dbc->tds_socket, (void *) dbc);
 
    /* Set up our environment change hook */
    dbc->tds_socket->env_chg_func = odbc_env_change;
 
    tds_fix_login(login);
 
    /* use connection timeout if set */
    if (dbc->attr.connection_timeout)
        login->connect_timeout = dbc->attr.connection_timeout;
 
    if (dbc->attr.mars_enabled != SQL_MARS_ENABLED_NO)
        login->mars = 1;
    if (dbc->attr.bulk_enabled != SQL_BCP_OFF)
        tds_set_bulk(login, 1);
 
#ifdef ENABLE_ODBC_WIDE
    /* force utf-8 in order to support wide characters */
    if (!tds_dstr_dup(&dbc->original_charset, &login->client_charset) 
        || !tds_dstr_copy(&login->client_charset, "UTF-8"))
        goto memory_error;
#endif
 
    /* replace password with old one */
    if (dbc->use_oldpwd) {
        if (!tds_dstr_dup(&login->new_password, &login->password)
            || !tds_dstr_dup(&login->password, &dbc->oldpwd))
            goto memory_error;
        login->use_new_password = 1;
    }
 
    if (TDS_FAILED(tds_connect_and_login(dbc->tds_socket, login))) {
        tds_free_socket(dbc->tds_socket);
        dbc->tds_socket = NULL;
        odbc_errs_add(&dbc->errs, "08001", NULL);
        return SQL_ERROR;
    }
#ifdef ENABLE_ODBC_WIDE
    dbc->mb_conv = tds_iconv_get(dbc->tds_socket->conn, tds_dstr_cstr(&dbc->original_charset), "UTF-8");
#endif
 
    dbc->default_query_timeout = dbc->tds_socket->query_timeout;
 
    if (IS_TDS7_PLUS(dbc->tds_socket->conn))
        dbc->cursor_support = 1;
 
#if ENABLE_ODBC_MARS
    /* check if mars is enabled */
    if (!IS_TDS72_PLUS(dbc->tds_socket->conn) || !dbc->tds_socket->conn->mars)
        dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
#else
    dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
#endif
 
    if (dbc->attr.txn_isolation != SQL_TXN_READ_COMMITTED) {
        if (!SQL_SUCCEEDED(change_txn(dbc, dbc->attr.txn_isolation)))
            ODBC_RETURN_(dbc);
    }
 
    if (dbc->attr.autocommit != SQL_AUTOCOMMIT_ON) {
        dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
        if (!SQL_SUCCEEDED(change_autocommit(dbc, SQL_AUTOCOMMIT_OFF)))
            ODBC_RETURN_(dbc);
    }
 
    /* this overwrite any error arrived (wanted behavior, Sybase return error for conversion errors) */
    ODBC_RETURN(dbc, SQL_SUCCESS);
 
memory_error:
    tds_free_socket(dbc->tds_socket);
    dbc->tds_socket = NULL;
    odbc_errs_add(&dbc->errs, "HY001", NULL);
    ODBC_RETURN_(dbc);
}
 
static SQLRETURN
odbc_update_ird(TDS_STMT *stmt, TDS_ERRS *errs)
{
    SQLRETURN res;
 
    if (!stmt->need_reprepare || stmt->prepared_query_is_rpc
        || !stmt->dbc || !IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
        stmt->need_reprepare = 0;
        return SQL_SUCCESS;
    }
 
    /* FIXME where error are put ?? on stmt... */
    if (!odbc_lock_statement(stmt))
        ODBC_RETURN_(stmt);
 
    /* FIXME error */
    res = start_parse_prepared_query(stmt, 0);
    if (res != SQL_SUCCESS) {
        /* prepare with dummy parameters just to fill IRD */
        tds_free_param_results(stmt->params);
        stmt->params = NULL;
        stmt->param_num = 0;
        /*
         * TODO
         * we need to prepare again with parameters but need_reprepare
         * flag is reset by odbc_prepare... perhaps should be checked
         * later, not calling describeCol or similar
         * we need prepare to get dynamic and cause we change parameters
         */
    }
 
    return odbc_prepare(stmt);
}
 
static SQLRETURN
odbc_prepare(TDS_STMT *stmt)
{
    TDSSOCKET *tds = stmt->tds;
    int in_row = 0;
 
    if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
        ODBC_SAFE_ERROR(stmt);
        return SQL_ERROR;
    }
 
    /* try to go to the next recordset */
    /* TODO merge with similar code */
    desc_free_records(stmt->ird);
    stmt->row_status = PRE_NORMAL_ROW;
    for (;;) {
        TDS_INT result_type;
        int done_flags;
 
        switch (tds_process_tokens(tds, &result_type, &done_flags, TDS_RETURN_ROWFMT|TDS_RETURN_DONE)) {
        case TDS_SUCCESS:
            switch (result_type) {
            case TDS_DONE_RESULT:
            case TDS_DONEPROC_RESULT:
            case TDS_DONEINPROC_RESULT:
                stmt->row_count = tds->rows_affected;
                if (done_flags & TDS_DONE_ERROR && !stmt->dyn->emulated)
                    stmt->errs.lastrc = SQL_ERROR;
                /* FIXME this row is used only as a flag for update binding, should be cleared if binding/result changed */
                stmt->row = 0;
                break;
 
            case TDS_ROWFMT_RESULT:
                /* store first row informations */
                if (!in_row)
                    odbc_populate_ird(stmt);
                stmt->row = 0;
                stmt->row_count = TDS_NO_COUNT;
                stmt->row_status = PRE_NORMAL_ROW;
                in_row = 1;
                break;
            }
            continue;
        case TDS_NO_MORE_RESULTS:
            break;
        case TDS_CANCELLED:
            odbc_errs_add(&stmt->errs, "HY008", NULL);
        default:
            stmt->errs.lastrc = SQL_ERROR;
            break;
        }
        break;
    }
 
    if (stmt->errs.lastrc == SQL_ERROR && !stmt->dyn->emulated) {
        tds_release_dynamic(&stmt->dyn);
    }
    odbc_unlock_statement(stmt);
    stmt->need_reprepare = 0;
    ODBC_RETURN_(stmt);
}
 
ODBC_FUNC(SQLDriverConnect, (P(SQLHDBC,hdbc), P(SQLHWND,hwnd), PCHARIN(ConnStrIn,SQLSMALLINT),
    PCHAROUT(ConnStrOut,SQLSMALLINT), P(SQLUSMALLINT,fDriverCompletion) WIDE))
{
    TDSLOGIN *login;
    TDS_PARSED_PARAM params[ODBC_PARAM_SIZE];
    DSTR conn_str = DSTR_INITIALIZER;
 
    ODBC_ENTER_HDBC;
 
#ifdef TDS_NO_DM
    /* Check string length */
    if (!IS_VALID_LEN(cbConnStrIn) || cbConnStrIn == 0) {
        odbc_errs_add(&dbc->errs, "HY090", NULL);
        ODBC_EXIT_(dbc);
    }
 
    /* Check completion param */
    switch (fDriverCompletion) {
    case SQL_DRIVER_NOPROMPT:
    case SQL_DRIVER_COMPLETE:
    case SQL_DRIVER_PROMPT:
    case SQL_DRIVER_COMPLETE_REQUIRED:
        break;
    default:
        odbc_errs_add(&dbc->errs, "HY110", NULL);
        ODBC_EXIT_(dbc);
    }
#endif
 
    if (!odbc_dstr_copy(dbc, &conn_str, cbConnStrIn, szConnStrIn)) {
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
 
    login = tds_alloc_login(0);
    if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale)) {
        tds_free_login(login);
        tds_dstr_free(&conn_str);
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
 
    if (!tds_dstr_isempty(&dbc->attr.current_catalog))
        if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog)) {
            tds_free_login(login);
            tds_dstr_free(&conn_str);
            odbc_errs_add(&dbc->errs, "HY001", NULL);
            ODBC_EXIT_(dbc);
        }
 
    /* parse the DSN string */
    if (!odbc_parse_connect_string(&dbc->errs, tds_dstr_buf(&conn_str), tds_dstr_buf(&conn_str) + tds_dstr_len(&conn_str),
                       login, params)) {
        tds_dstr_free(&conn_str);
        ODBC_EXIT_(dbc);
    }
 
    odbc_set_string(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, tds_dstr_buf(&conn_str), tds_dstr_len(&conn_str));
    tds_dstr_free(&conn_str);
 
    /* add login info */
    if (hwnd && fDriverCompletion != SQL_DRIVER_NOPROMPT
        && (fDriverCompletion == SQL_DRIVER_PROMPT || (!params[ODBC_PARAM_UID].p && !params[ODBC_PARAM_Trusted_Connection].p)
        || tds_dstr_isempty(&login->server_name))) {
#ifdef _WIN32
        char *out = NULL;
 
        /* prompt for login information */
        if (!get_login_info(hwnd, login)) {
            tds_free_login(login);
            odbc_errs_add(&dbc->errs, "08001", "User canceled login");
            ODBC_EXIT_(dbc);
        }
        if (tds_dstr_isempty(&login->user_name)) {
            params[ODBC_PARAM_UID].p = NULL;
            params[ODBC_PARAM_PWD].p = NULL;
            params[ODBC_PARAM_Trusted_Connection].p = "Yes";
            params[ODBC_PARAM_Trusted_Connection].len = 3;
        } else {
            params[ODBC_PARAM_UID].p   = tds_dstr_cstr(&login->user_name);
            params[ODBC_PARAM_UID].len = tds_dstr_len(&login->user_name);
            params[ODBC_PARAM_PWD].p   = tds_dstr_cstr(&login->password);
            params[ODBC_PARAM_PWD].len = tds_dstr_len(&login->password);
            params[ODBC_PARAM_Trusted_Connection].p = NULL;
        }
        if (!odbc_build_connect_string(&dbc->errs, params, &out))
            ODBC_EXIT_(dbc);
 
        odbc_set_string(dbc, szConnStrOut, cbConnStrOutMax, pcbConnStrOut, out, -1);
        tdsdump_log(TDS_DBG_INFO1, "connection string is now: %s\n", out);
        free(out);
#else
        /* we dont support a dialog box */
        odbc_errs_add(&dbc->errs, "HYC00", NULL);
#endif
    }
 
    if (tds_dstr_isempty(&login->server_name)) {
        tds_free_login(login);
        odbc_errs_add(&dbc->errs, "IM007", "Could not find Servername or server parameter");
        ODBC_EXIT_(dbc);
    }
 
    odbc_connect(dbc, login);
 
    tds_free_login(login);
    ODBC_EXIT_(dbc);
}
 
#if 0
SQLRETURN ODBC_API
SQLBrowseConnect(SQLHDBC hdbc, SQLCHAR FAR * szConnStrIn, SQLSMALLINT cbConnStrIn, SQLCHAR FAR * szConnStrOut,
         SQLSMALLINT cbConnStrOutMax, SQLSMALLINT FAR * pcbConnStrOut)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLBrowseConnect(%p, %s, %d, %p, %d, %p)\n", 
            hdbc, szConnStrIn, cbConnStrIn, szConnStrOut, cbConnStrOutMax, pcbConnStrOut);
    ODBC_ENTER_HDBC;
    odbc_errs_add(&dbc->errs, "HYC00", "SQLBrowseConnect: function not implemented");
    ODBC_EXIT_(dbc);
}
#endif
 
 
ODBC_FUNC(SQLColumnPrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT), PCHARIN(SchemaName,SQLSMALLINT),
    PCHARIN(TableName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "sp_column_privileges", 4, "O@table_qualifier", szCatalogName, cbCatalogName,
                  "O@table_owner", szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName,
                  "P@column_name", szColumnName, cbColumnName);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "TABLE_CAT");
        odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    }
    ODBC_EXIT_(stmt);
}
 
#if 0
SQLRETURN ODBC_API
SQLDescribeParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT FAR * pfSqlType, SQLUINTEGER FAR * pcbParamDef,
         SQLSMALLINT FAR * pibScale, SQLSMALLINT FAR * pfNullable)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLDescribeParam(%p, %d, %p, %p, %p, %p)\n", 
            hstmt, ipar, pfSqlType, pcbParamDef, pibScale, pfNullable);
    ODBC_ENTER_HSTMT;
    odbc_errs_add(&stmt->errs, "HYC00", "SQLDescribeParam: function not implemented");
    ODBC_EXIT_(stmt);
}
#endif
 
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLExtendedFetch(SQLHSTMT hstmt, SQLUSMALLINT fFetchType, SQLROWOFFSET irow, SQLROWSETSIZE FAR * pcrow, SQLUSMALLINT FAR * rgfRowStatus)
{
    SQLRETURN ret;
    SQLULEN * tmp_rows;
    SQLUSMALLINT * tmp_status;
    SQLULEN tmp_size;
    SQLLEN * tmp_offset;
    SQLPOINTER tmp_bookmark;
    SQLULEN bookmark;
    SQLULEN out_len = 0;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLExtendedFetch(%p, %d, %d, %p, %p)\n", 
            hstmt, fFetchType, (int)irow, pcrow, rgfRowStatus);
 
    if (fFetchType != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
        odbc_errs_add(&stmt->errs, "HY106", NULL);
        ODBC_EXIT_(stmt);
    }
 
    /* save and change IRD/ARD state */
    tmp_rows = stmt->ird->header.sql_desc_rows_processed_ptr;
    stmt->ird->header.sql_desc_rows_processed_ptr = &out_len;
    tmp_status = stmt->ird->header.sql_desc_array_status_ptr;
    stmt->ird->header.sql_desc_array_status_ptr = rgfRowStatus;
    tmp_size = stmt->ard->header.sql_desc_array_size;
    stmt->ard->header.sql_desc_array_size = stmt->sql_rowset_size;
    tmp_offset = stmt->ard->header.sql_desc_bind_offset_ptr;
    stmt->ard->header.sql_desc_bind_offset_ptr = NULL;
    tmp_bookmark = stmt->attr.fetch_bookmark_ptr;
 
    /* SQL_FETCH_BOOKMARK different */
    if (fFetchType == SQL_FETCH_BOOKMARK) {
        bookmark = irow;
        irow = 0;
        stmt->attr.fetch_bookmark_ptr = &bookmark;
    }
    
    /* TODO errors are sligthly different ... perhaps it's better to leave DM do this job ?? */
    /* TODO check fFetchType can be converted to USMALLINT */
    ret = _SQLFetch(stmt, fFetchType, irow);
 
    /* restore IRD/ARD */
    stmt->ird->header.sql_desc_rows_processed_ptr = tmp_rows;
    if (pcrow)
        *pcrow = out_len;
    stmt->ird->header.sql_desc_array_status_ptr = tmp_status;
    stmt->ard->header.sql_desc_array_size = tmp_size;
    stmt->ard->header.sql_desc_bind_offset_ptr = tmp_offset;
    stmt->attr.fetch_bookmark_ptr = tmp_bookmark;
 
    ODBC_EXIT(stmt, ret);
}
 
ODBC_FUNC(SQLForeignKeys, (P(SQLHSTMT,hstmt), PCHARIN(PkCatalogName,SQLSMALLINT),
    PCHARIN(PkSchemaName,SQLSMALLINT), PCHARIN(PkTableName,SQLSMALLINT),
    PCHARIN(FkCatalogName,SQLSMALLINT), PCHARIN(FkSchemaName,SQLSMALLINT),
    PCHARIN(FkTableName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "sp_fkeys", 6, "O@pktable_qualifier", szPkCatalogName, cbPkCatalogName, "O@pktable_owner",
                  szPkSchemaName, cbPkSchemaName, "O@pktable_name", szPkTableName, cbPkTableName,
                  "O@fktable_qualifier", szFkCatalogName, cbFkCatalogName, "O@fktable_owner", szFkSchemaName,
                  cbFkSchemaName, "O@fktable_name", szFkTableName, cbFkTableName);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "PKTABLE_CAT");
        odbc_col_setname(stmt, 2, "PKTABLE_SCHEM");
        odbc_col_setname(stmt, 5, "FKTABLE_CAT");
        odbc_col_setname(stmt, 6, "FKTABLE_SCHEM");
    }
    ODBC_EXIT_(stmt);
}
 
static int
odbc_lock_statement(TDS_STMT* stmt)
{
#if ENABLE_ODBC_MARS
    TDSSOCKET *tds = stmt->tds;
 
 
    /* we already own a socket, just use it */
    if (!tds) {
        /* try with one saved into DBC */
        TDSSOCKET *dbc_tds = stmt->dbc->tds_socket;
        tds_mutex_lock(&stmt->dbc->mtx);
 
        if (stmt->dbc->current_statement == NULL
            || stmt->dbc->current_statement == stmt) {
            tds = dbc_tds;
            stmt->dbc->current_statement = stmt;
        }
 
        /* try to grab current locked one */
        if (!tds && dbc_tds->state == TDS_IDLE) {
            stmt->dbc->current_statement->tds = NULL;
            tds = dbc_tds;
            stmt->dbc->current_statement = stmt;
        }
        tds_mutex_unlock(&stmt->dbc->mtx);
 
        /* try with MARS */
        if (!tds)
            tds = tds_alloc_additional_socket(dbc_tds->conn);
    }
    if (tds) {
        tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
            stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
        tds_set_parent(tds, stmt);
        stmt->tds = tds;
        return 1;
    }
    odbc_errs_add(&stmt->errs, "24000", NULL);
    return 0;
#else
    TDSSOCKET *tds = stmt->dbc->tds_socket;
 
    tds_mutex_lock(&stmt->dbc->mtx);
    if (stmt->dbc->current_statement != NULL
        && stmt->dbc->current_statement != stmt) {
        if (!tds || tds->state != TDS_IDLE) {
            tds_mutex_unlock(&stmt->dbc->mtx);
            odbc_errs_add(&stmt->errs, "24000", NULL);
            return 0;
        }
        stmt->dbc->current_statement->tds = NULL;
    }
    stmt->dbc->current_statement = stmt;
    if (tds) {
        tds->query_timeout = (stmt->attr.query_timeout != DEFAULT_QUERY_TIMEOUT) ?
            stmt->attr.query_timeout : stmt->dbc->default_query_timeout;
        tds_set_parent(tds, stmt);
        stmt->tds = tds;
    }
    tds_mutex_unlock(&stmt->dbc->mtx);
    return 1;
#endif
}
 
static void
odbc_unlock_statement(TDS_STMT* stmt)
{
    TDSSOCKET * tds;
 
    tds_mutex_lock(&stmt->dbc->mtx);
    tds = stmt->tds;
    if (stmt->dbc->current_statement == stmt) {
        assert(tds == stmt->dbc->tds_socket);
        if (tds->state == TDS_IDLE) {
            stmt->dbc->current_statement = NULL;
            tds_set_parent(tds, stmt->dbc);
            stmt->tds = NULL;
        }
#if ENABLE_ODBC_MARS
    } else if (tds) {
        if (tds->state == TDS_IDLE || tds->state == TDS_DEAD) {
            assert(tds != stmt->dbc->tds_socket);
            tds_free_socket(tds);
            stmt->tds = NULL;
        }
#endif
    }
    tds_mutex_unlock(&stmt->dbc->mtx);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLMoreResults(SQLHSTMT hstmt)
{
    TDSSOCKET *tds;
    TDS_INT result_type;
    TDSRET tdsret;
    int in_row = 0;
    SQLUSMALLINT param_status;
    int token_flags;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLMoreResults(%p)\n", hstmt);
 
    tds = stmt->tds;
 
    /* We already read all results... */
    if (!tds)
        ODBC_EXIT(stmt, SQL_NO_DATA);
 
    stmt->row_count = TDS_NO_COUNT;
    stmt->special_row = ODBC_SPECIAL_NONE;
 
    /* TODO this code is TOO similar to _SQLExecute, merge it - freddy77 */
    /* try to go to the next recordset */
    if (stmt->row_status == IN_COMPUTE_ROW) {
        /* FIXME doesn't seem so fine ... - freddy77 */
        tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
        stmt->row_status = IN_COMPUTE_ROW;
        in_row = 1;
    }
 
    param_status = SQL_PARAM_SUCCESS;
    token_flags = (TDS_TOKEN_RESULTS & (~TDS_STOPAT_COMPUTE)) | TDS_RETURN_COMPUTE;
    if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
        token_flags |= TDS_RETURN_MSG;
    for (;;) {
        result_type = odbc_process_tokens(stmt, token_flags);
        tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: result_type=%d, row_count=%" PRId64 ", lastrc=%d\n",
                        result_type, stmt->row_count, stmt->errs.lastrc);
        switch (result_type) {
        case TDS_CMD_DONE:
#if 1 /* !UNIXODBC */
            tds_free_all_results(tds);
#endif
            odbc_populate_ird(stmt);
            odbc_unlock_statement(stmt);
            if (stmt->row_count == TDS_NO_COUNT && !in_row) {
                stmt->row_status = NOT_IN_ROW;
                tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_status=%d\n", stmt->row_status);
            }
            tdsdump_log(TDS_DBG_INFO1, "SQLMoreResults: row_count=%" PRId64 ", lastrc=%d\n", stmt->row_count, stmt->errs.lastrc);
            if (stmt->row_count == TDS_NO_COUNT) {
                if (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
                    ODBC_EXIT(stmt, SQL_NO_DATA);
            }
            ODBC_EXIT_(stmt);
 
        case TDS_CMD_FAIL:
            ODBC_SAFE_ERROR(stmt);
            ODBC_EXIT_(stmt);
 
        case TDS_COMPUTE_RESULT:
            switch (stmt->row_status) {
            /* skip this recordset */
            case IN_COMPUTE_ROW:
                /* TODO here we should set current_results to normal results */
                in_row = 1;
                /* fall through */
            /* in normal row, put in compute status */
            case AFTER_COMPUTE_ROW:
            case IN_NORMAL_ROW:
            case PRE_NORMAL_ROW:
                stmt->row_status = IN_COMPUTE_ROW;
                odbc_populate_ird(stmt);
                ODBC_EXIT_(stmt);
            case NOT_IN_ROW:
                /* this should never happen, protocol error */
                ODBC_SAFE_ERROR(stmt);
                ODBC_EXIT_(stmt);
                break;
            }
            break;
 
        case TDS_ROW_RESULT:
            if (in_row || (stmt->row_status != IN_NORMAL_ROW && stmt->row_status != PRE_NORMAL_ROW)) {
                stmt->row_status = PRE_NORMAL_ROW;
                odbc_populate_ird(stmt);
                ODBC_EXIT_(stmt);
            }
            /* Skipping current result set's rows to access next resultset or proc's retval */
            tdsret = tds_process_tokens(tds, &result_type, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_STOPAT_COMPUTE);
            /* TODO should we set in_row ?? */
            switch (tdsret) {
            case TDS_CANCELLED:
                odbc_errs_add(&stmt->errs, "HY008", NULL);
            default:
                if (TDS_FAILED(tdsret)) {
                    ODBC_SAFE_ERROR(stmt);
                    ODBC_EXIT_(stmt);
                }
            }
            break;
 
        case TDS_DONE_RESULT:
        case TDS_DONEPROC_RESULT:
            /* FIXME here ??? */
            if (!in_row)
                tds_free_all_results(tds);
            switch (stmt->errs.lastrc) {
            case SQL_ERROR:
                param_status = SQL_PARAM_ERROR;
                break;
            case SQL_SUCCESS_WITH_INFO:
                param_status = SQL_PARAM_SUCCESS_WITH_INFO;
                break;
            }
            if (stmt->curr_param_row < stmt->num_param_rows) {
                if (stmt->ipd->header.sql_desc_array_status_ptr)
                    stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
                ++stmt->curr_param_row;
                if (stmt->ipd->header.sql_desc_rows_processed_ptr)
                    *stmt->ipd->header.sql_desc_rows_processed_ptr = stmt->curr_param_row;
            }
            if (stmt->curr_param_row < stmt->num_param_rows) {
#if 0
                if (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO)
                    found_info = 1;
                if (stmt->errs.lastrc == SQL_ERROR)
                    found_error = 1;
#endif
                stmt->errs.lastrc = SQL_SUCCESS;
                param_status = SQL_PARAM_SUCCESS;
                break;
            }
            odbc_populate_ird(stmt);
            ODBC_EXIT_(stmt);
            break;
 
            /*
             * TODO test flags ? check error and change result ? 
             * see also other DONEINPROC handle (below)
             */
        case TDS_DONEINPROC_RESULT:
            if (in_row) {
                odbc_populate_ird(stmt);
                ODBC_EXIT_(stmt);
            }
            /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
            tds_free_all_results(tds);
            odbc_populate_ird(stmt);
            break;
 
            /* do not stop at metadata, an error can follow... */
        case TDS_ROWFMT_RESULT:
            if (in_row) {
                odbc_populate_ird(stmt);
                ODBC_EXIT_(stmt);
            }
            stmt->row = 0;
            stmt->row_count = TDS_NO_COUNT;
            /* we expect a row */
            stmt->row_status = PRE_NORMAL_ROW;
            in_row = 1;
            break;
 
        case TDS_MSG_RESULT:
            if (!in_row) {
                tds_free_all_results(tds);
                odbc_populate_ird(stmt);
            }
            in_row = 1;
            break;
        }
    }
    ODBC_EXIT(stmt, SQL_ERROR);
}
 
ODBC_FUNC(SQLNativeSql, (P(SQLHDBC,hdbc), PCHARIN(SqlStrIn,SQLINTEGER),
    PCHAROUT(SqlStr,SQLINTEGER) WIDE))
{
    SQLRETURN ret = SQL_SUCCESS;
    DSTR query = DSTR_INITIALIZER;
 
    ODBC_ENTER_HDBC;
 
#ifdef TDS_NO_DM
    if (!szSqlStrIn || !IS_VALID_LEN(cbSqlStrIn)) {
        odbc_errs_add(&dbc->errs, "HY009", NULL);
        ODBC_EXIT_(dbc);
    }
#endif
 
    if (!odbc_dstr_copy(dbc, &query, cbSqlStrIn, szSqlStrIn)) {
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
 
    native_sql(dbc, &query);
 
    /* FIXME if error set some kind of error */
    ret = odbc_set_string(dbc, szSqlStr, cbSqlStrMax, pcbSqlStr, tds_dstr_cstr(&query), -1);
 
    tds_dstr_free(&query);
 
    ODBC_EXIT(dbc, ret);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLNumParams(SQLHSTMT hstmt, SQLSMALLINT FAR * pcpar)
{
    ODBC_ENTER_HSTMT;
    tdsdump_log(TDS_DBG_FUNC, "SQLNumParams(%p, %p)\n", hstmt, pcpar);
    *pcpar = stmt->param_count;
    ODBC_EXIT_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLParamOptions(SQLHSTMT hstmt, SQLULEN crow, SQLULEN FAR * pirow)
{
    SQLRETURN res;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLParamOptions(%p, %lu, %p)\n", hstmt, (unsigned long int)crow, pirow);
 
    /* emulate for ODBC 2 DM */
    res = _SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, pirow, 0 _wide0);
    if (res != SQL_SUCCESS)
        return res;
    return _SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) (TDS_INTPTR) crow, 0 _wide0);
}
 
ODBC_FUNC(SQLPrimaryKeys, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "sp_pkeys", 3, "O@table_qualifier", szCatalogName, cbCatalogName, "O@table_owner",
                  szSchemaName, cbSchemaName, "O@table_name", szTableName, cbTableName);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "TABLE_CAT");
        odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    }
    ODBC_EXIT_(stmt);
}
 
ODBC_FUNC(SQLProcedureColumns, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT), PCHARIN(ColumnName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "sp_sproc_columns", TDS_IS_MSSQL(stmt->dbc->tds_socket) ? 5 : 4,
                  "O@procedure_qualifier", szCatalogName, cbCatalogName,
                  "P@procedure_owner", szSchemaName, cbSchemaName, "P@procedure_name", szProcName, cbProcName,
                  "P@column_name", szColumnName, cbColumnName, "V@ODBCVer", (char*) NULL, 0);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
        odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
        odbc_col_setname(stmt, 8, "COLUMN_SIZE");
        odbc_col_setname(stmt, 9, "BUFFER_LENGTH");
        odbc_col_setname(stmt, 10, "DECIMAL_DIGITS");
        odbc_col_setname(stmt, 11, "NUM_PREC_RADIX");
        if (TDS_IS_SYBASE(stmt->dbc->tds_socket))
            stmt->special_row = ODBC_SPECIAL_PROCEDURECOLUMNS;
    }
    ODBC_EXIT_(stmt);
}
 
ODBC_FUNC(SQLProcedures, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(ProcName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "..sp_stored_procedures", 3, "P@sp_name", szProcName, cbProcName, "P@sp_owner", szSchemaName,
                  cbSchemaName, "O@sp_qualifier", szCatalogName, cbCatalogName);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "PROCEDURE_CAT");
        odbc_col_setname(stmt, 2, "PROCEDURE_SCHEM");
    }
    ODBC_EXIT_(stmt);
}
 
static TDSPARAMINFO*
odbc_build_update_params(TDS_STMT * stmt, SQLSETPOSIROW n_row)
{
        SQLSMALLINT n;
    TDSPARAMINFO * params = NULL;
    struct _drecord *drec_ird;
 
    for (n = 0; n < stmt->ird->header.sql_desc_count && n < stmt->ard->header.sql_desc_count; ++n) {
        TDSPARAMINFO *temp_params;
        TDSCOLUMN *curcol;
 
        drec_ird = &stmt->ird->records[n];
 
        if (drec_ird->sql_desc_updatable == SQL_FALSE)
            continue;
 
        /* we have certainly a parameter */
        if (!(temp_params = tds_alloc_param_result(params)))
            goto memory_error;
                params = temp_params;
 
        curcol = params->columns[params->num_cols - 1];
        if (!tds_dstr_dup(&curcol->column_name, &drec_ird->sql_desc_name))
            goto memory_error;
 
        /* TODO use all infos... */
        if (!tds_dstr_dup(&curcol->table_name, &drec_ird->sql_desc_base_table_name))
            goto memory_error;
 
        switch (odbc_sql2tds(stmt, drec_ird, &stmt->ard->records[n], curcol, 1, stmt->ard, n_row)) {
        case SQL_NEED_DATA:
            goto memory_error;
        case SQL_ERROR:
            tds_free_param_results(params);
            return NULL;
        }
    }
    return params;
 
memory_error:
    tds_free_param_results(params);
    odbc_errs_add(&stmt->errs, "HY001", NULL);
    return NULL;
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLSetPos(SQLHSTMT hstmt, SQLSETPOSIROW irow, SQLUSMALLINT fOption, SQLUSMALLINT fLock)
{
    TDSRET ret;
    TDSSOCKET *tds;
    TDS_CURSOR_OPERATION op;
    TDSPARAMINFO *params = NULL;
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLSetPos(%p, %ld, %d, %d)\n", 
            hstmt, (long) irow, fOption, fLock);
 
    if (!stmt->dbc->cursor_support) {
        odbc_errs_add(&stmt->errs, "HYC00", "SQLSetPos: function not implemented");
        ODBC_EXIT_(stmt);
    }
 
    /* TODO handle irow == 0 (all rows) */
 
    if (!stmt->cursor) {
        odbc_errs_add(&stmt->errs, "HY109", NULL);
        ODBC_EXIT_(stmt);
    }
 
    switch (fOption) {
    case SQL_POSITION:
        op = TDS_CURSOR_POSITION;
        break;
    /* TODO cursor support */
    case SQL_REFRESH:
    default:
        odbc_errs_add(&stmt->errs, "HY092", NULL);
        ODBC_EXIT_(stmt);
        break;
    case SQL_UPDATE:
        op = TDS_CURSOR_UPDATE;
        /* prepare paremeters for update */
        /* scan all columns and build parameter list */
        params = odbc_build_update_params(stmt, irow >= 1 ? irow - 1 : 0);
        if (!params) {
            ODBC_SAFE_ERROR(stmt);
            ODBC_EXIT_(stmt);
        }
        break;
    case SQL_DELETE:
        op = TDS_CURSOR_DELETE;
        break;
    case SQL_ADD:
        op = TDS_CURSOR_INSERT;
        break;
    }
 
    if (!odbc_lock_statement(stmt)) {
        tds_free_param_results(params);
        ODBC_EXIT_(stmt);
    }
 
    tds = stmt->tds;
 
    if (TDS_FAILED(tds_cursor_update(tds, stmt->cursor, op, irow, params))) {
        tds_free_param_results(params);
        ODBC_SAFE_ERROR(stmt);
        ODBC_EXIT_(stmt);
    }
    tds_free_param_results(params);
    params = NULL;
 
    ret = tds_process_simple_query(tds);
    odbc_unlock_statement(stmt);
    if (TDS_FAILED(ret)) {
        ODBC_SAFE_ERROR(stmt);
        ODBC_EXIT_(stmt);
    }
 
    ODBC_EXIT_(stmt);
}
 
ODBC_FUNC(SQLTablePrivileges, (P(SQLHSTMT,hstmt), PCHARIN(CatalogName,SQLSMALLINT),
    PCHARIN(SchemaName,SQLSMALLINT), PCHARIN(TableName,SQLSMALLINT) WIDE))
{
    int retcode;
 
    ODBC_ENTER_HSTMT;
 
    retcode =
        odbc_stat_execute(stmt _wide, "sp_table_privileges", 3, "O@table_qualifier", szCatalogName, cbCatalogName,
                  "P@table_owner", szSchemaName, cbSchemaName, "P@table_name", szTableName, cbTableName);
    if (SQL_SUCCEEDED(retcode) && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
        odbc_col_setname(stmt, 1, "TABLE_CAT");
        odbc_col_setname(stmt, 2, "TABLE_SCHEM");
    }
    ODBC_EXIT_(stmt);
}
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLSetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER StringLength)
{
    SQLINTEGER i_val = (SQLINTEGER) (TDS_INTPTR) Value;
 
    ODBC_ENTER_HENV;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLSetEnvAttr(%p, %d, %p, %d)\n", henv, (int)Attribute, Value, (int)StringLength);
 
    switch (Attribute) {
    case SQL_ATTR_CONNECTION_POOLING:
    case SQL_ATTR_CP_MATCH:
        odbc_errs_add(&env->errs, "HYC00", NULL);
        break;
    case SQL_ATTR_ODBC_VERSION:
        switch (i_val) {
        case SQL_OV_ODBC3:
        case SQL_OV_ODBC2:
            env->attr.odbc_version = i_val;
            break;
        default:
            odbc_errs_add(&env->errs, "HY024", NULL);
            break;
        }
        break;
    case SQL_ATTR_OUTPUT_NTS:
        /* TODO - Make this really work */
                env->attr.output_nts = i_val;
                /* env->attr.output_nts = SQL_TRUE; */
        break;
    default:
        odbc_errs_add(&env->errs, "HY092", NULL);
        break;
    }
    ODBC_EXIT_(env);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLGetEnvAttr(SQLHENV henv, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
        SQLINTEGER size;
    void *src;
 
    ODBC_ENTER_HENV;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLGetEnvAttr(%p, %d, %p, %d, %p)\n", 
            henv, (int)Attribute, Value, (int)BufferLength, StringLength);
 
    switch (Attribute) {
    case SQL_ATTR_CONNECTION_POOLING:
        src = &env->attr.connection_pooling;
        size = sizeof(env->attr.connection_pooling);
        break;
    case SQL_ATTR_CP_MATCH:
        src = &env->attr.cp_match;
        size = sizeof(env->attr.cp_match);
        break;
    case SQL_ATTR_ODBC_VERSION:
        src = &env->attr.odbc_version;
        size = sizeof(env->attr.odbc_version);
        break;
    case SQL_ATTR_OUTPUT_NTS:
        /* TODO handle output_nts flags */
        env->attr.output_nts = SQL_TRUE;
        src = &env->attr.output_nts;
        size = sizeof(env->attr.output_nts);
        break;
    default:
        odbc_errs_add(&env->errs, "HY092", NULL);
        ODBC_EXIT_(env);
        break;
    }
 
    if (StringLength) {
        *StringLength = size;
    }
    memcpy(Value, src, size);
 
    ODBC_EXIT_(env);
}
 
#endif
 
#define IRD_UPDATE(desc, errs, exit) \
    do { \
        if (desc->type == DESC_IRD && ((TDS_STMT*)desc->parent)->need_reprepare && \
            odbc_update_ird((TDS_STMT*)desc->parent, errs) != SQL_SUCCESS) \
            exit; \
    } while(0)
 
static SQLRETURN
_SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
          SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
{
    TDS_DESC *apd, *ipd;
    struct _drecord *drec;
    SQLSMALLINT orig_apd_size, orig_ipd_size;
    int is_numeric = 0;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n", 
            hstmt, (unsigned short)ipar, (int)fParamType, (int)fCType, (int)fSqlType, (unsigned int)cbColDef, 
            (int)ibScale, rgbValue, (int)cbValueMax, pcbValue);
 
#ifdef TDS_NO_DM
    /* TODO - more error checking ...  XXX smurph */
 
    /* Check param type */
    switch (fParamType) {
    case SQL_PARAM_INPUT:
    case SQL_PARAM_INPUT_OUTPUT:
    case SQL_PARAM_OUTPUT:
        break;
    default:
        odbc_errs_add(&stmt->errs, "HY105", NULL);
        ODBC_EXIT_(stmt);
    }
 
    /* Check max buffer length */
    if (cbValueMax < 0) {
        odbc_errs_add(&stmt->errs, "HY090", NULL);
        ODBC_EXIT_(stmt);
    }
#endif
 
    /* check cbColDef and ibScale */
    if (fSqlType == SQL_DECIMAL || fSqlType == SQL_NUMERIC) {
        is_numeric = 1;
        if (cbColDef < 1 || cbColDef > 38) {
            odbc_errs_add(&stmt->errs, "HY104", "Invalid precision value");
            ODBC_EXIT_(stmt);
        }
                if (ibScale < 0 || (SQLULEN)ibScale > cbColDef) {
            odbc_errs_add(&stmt->errs, "HY104", "Invalid scale value");
            ODBC_EXIT_(stmt);
        }
    }
 
    /* Check parameter number */
    if (ipar <= 0 || ipar > 4000) {
        odbc_errs_add(&stmt->errs, "07009", NULL);
        ODBC_EXIT_(stmt);
    }
 
    /* fill APD related fields */
    apd = stmt->apd;
    orig_apd_size = apd->header.sql_desc_count;
    if (ipar > apd->header.sql_desc_count && desc_alloc_records(apd, ipar) != SQL_SUCCESS) {
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        ODBC_EXIT_(stmt);
    }
    drec = &apd->records[ipar - 1];
 
    if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
        desc_alloc_records(apd, orig_apd_size);
        odbc_errs_add(&stmt->errs, "HY004", NULL);
        ODBC_EXIT_(stmt);
    }
 
    stmt->need_reprepare = 1;
 
    /* TODO other types ?? handle SQL_C_DEFAULT */
    if (drec->sql_desc_type == SQL_C_CHAR || drec->sql_desc_type == SQL_C_WCHAR || drec->sql_desc_type == SQL_C_BINARY)
        drec->sql_desc_octet_length = cbValueMax;
    drec->sql_desc_indicator_ptr = pcbValue;
    drec->sql_desc_octet_length_ptr = pcbValue;
    drec->sql_desc_data_ptr = (char *) rgbValue;
 
    /* field IPD related fields */
    ipd = stmt->ipd;
    orig_ipd_size = ipd->header.sql_desc_count;
    if (ipar > ipd->header.sql_desc_count && desc_alloc_records(ipd, ipar) != SQL_SUCCESS) {
        desc_alloc_records(apd, orig_apd_size);
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        ODBC_EXIT_(stmt);
    }
    drec = &ipd->records[ipar - 1];
 
    drec->sql_desc_parameter_type = fParamType;
    if (odbc_set_concise_sql_type(fSqlType, drec, 0) != SQL_SUCCESS) {
        desc_alloc_records(ipd, orig_ipd_size);
        desc_alloc_records(apd, orig_apd_size);
        odbc_errs_add(&stmt->errs, "HY004", NULL);
        ODBC_EXIT_(stmt);
    }
    if (is_numeric) {
                drec->sql_desc_precision = (SQLSMALLINT) cbColDef;
        drec->sql_desc_scale = ibScale;
    } else {
        drec->sql_desc_length = cbColDef;
    }
 
    ODBC_EXIT_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLBindParameter(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType,
         SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLBindParameter(%p, %u, %d, %d, %d, %u, %d, %p, %d, %p)\n", 
            hstmt, (unsigned)ipar, fParamType, fCType, (int)fSqlType, (unsigned)cbColDef, ibScale, rgbValue, (int)cbValueMax, pcbValue);
    return _SQLBindParameter(hstmt, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue);
}
 
 
/* compatibility with X/Open */
SQLRETURN ODBC_PUBLIC ODBC_API
SQLBindParam(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale,
         SQLPOINTER rgbValue, SQLLEN FAR * pcbValue)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLBindParam(%p, %d, %d, %d, %u, %d, %p, %p)\n", 
            hstmt, ipar, fCType, fSqlType, (unsigned)cbColDef, ibScale, rgbValue, pcbValue);
    return _SQLBindParameter(hstmt, ipar, SQL_PARAM_INPUT, fCType, fSqlType, cbColDef, ibScale, rgbValue, 0, pcbValue);
}
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(%d, %p, %p)\n", HandleType, InputHandle, OutputHandle);
 
    switch (HandleType) {
    case SQL_HANDLE_STMT:
        return _SQLAllocStmt(InputHandle, OutputHandle);
        break;
    case SQL_HANDLE_DBC:
        return _SQLAllocConnect(InputHandle, OutputHandle);
        break;
    case SQL_HANDLE_ENV:
        return _SQLAllocEnv(OutputHandle, SQL_OV_ODBC3);
        break;
    case SQL_HANDLE_DESC:
        return _SQLAllocDesc(InputHandle, OutputHandle);
        break;
    }
    
    /*
     * As the documentation puts it, 
     *  "There is no handle with which to associate additional diagnostic information."
     *
     * The DM must catch HY092 because the driver has no valid handle at this early stage in which 
     * to store the error for later retrieval by the application.  
     */
    tdsdump_log(TDS_DBG_FUNC, "SQLAllocHandle(): invalid HandleType, error HY092: should be caught by DM\n");
    return SQL_ERROR;
}
#endif
 
static SQLRETURN
_SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
{
    TDS_DBC *dbc;
 
    ODBC_ENTER_HENV;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLAllocConnect(%p, %p)\n", henv, phdbc);
 
    dbc = tds_new0(TDS_DBC, 1);
    if (!dbc) {
        odbc_errs_add(&env->errs, "HY001", NULL);
        ODBC_EXIT_(env);
    }
 
    dbc->htype = SQL_HANDLE_DBC;
    dbc->env = env;
    tds_dstr_init(&dbc->dsn);
 
    dbc->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    dbc->attr.access_mode = SQL_MODE_READ_WRITE;
    dbc->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    dbc->attr.auto_ipd = SQL_FALSE;
    /*
     * spinellia@acm.org
     * after login is enabled autocommit
     */
    dbc->attr.autocommit = SQL_AUTOCOMMIT_ON;
    dbc->attr.connection_dead = SQL_CD_TRUE;    /* No connection yet */
    dbc->attr.connection_timeout = 0;
    /* This is set in the environment change function */
    tds_dstr_init(&dbc->attr.current_catalog);
    dbc->attr.login_timeout = 0;    /* TODO */
    dbc->attr.metadata_id = SQL_FALSE;
    dbc->attr.odbc_cursors = SQL_CUR_USE_IF_NEEDED;
    dbc->attr.packet_size = 0;
    dbc->attr.quite_mode = NULL;    /* We don't support GUI dialogs yet */
#ifdef TDS_NO_DM
    dbc->attr.trace = SQL_OPT_TRACE_OFF;
    tds_dstr_init(&dbc->attr.tracefile);
#endif
    tds_dstr_init(&dbc->attr.translate_lib);
#ifdef ENABLE_ODBC_WIDE
    tds_dstr_init(&dbc->original_charset);
#endif
    tds_dstr_init(&dbc->oldpwd);
    dbc->attr.translate_option = 0;
    dbc->attr.txn_isolation = SQL_TXN_READ_COMMITTED;
    dbc->attr.mars_enabled = SQL_MARS_ENABLED_NO;
    dbc->attr.bulk_enabled = SQL_BCP_OFF;
 
    tds_mutex_init(&dbc->mtx);
    *phdbc = (SQLHDBC) dbc;
 
    ODBC_EXIT_(env);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLAllocConnect(SQLHENV henv, SQLHDBC FAR * phdbc)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLAllocConnect(%p, %p)\n", henv, phdbc);
 
    return _SQLAllocConnect(henv, phdbc);
}
 
static SQLRETURN
_SQLAllocEnv(SQLHENV FAR * phenv, SQLINTEGER odbc_version)
{
    TDS_ENV *env;
    TDSCONTEXT *ctx;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLAllocEnv(%p, %d)\n",
            phenv, (int) odbc_version);
 
    env = tds_new0(TDS_ENV, 1);
    if (!env)
        return SQL_ERROR;
 
    env->htype = SQL_HANDLE_ENV;
    env->attr.odbc_version = odbc_version;
    /* TODO use it */
    env->attr.output_nts = SQL_TRUE;
 
    ctx = tds_alloc_context(env);
    if (!ctx) {
        free(env);
        return SQL_ERROR;
    }
    env->tds_ctx = ctx;
    ctx->msg_handler = odbc_errmsg_handler;
    ctx->err_handler = odbc_errmsg_handler;
 
    /* ODBC has its own format */
    free(ctx->locale->date_fmt);
    ctx->locale->date_fmt = strdup("%Y-%m-%d %H:%M:%S.%z");
 
    tds_mutex_init(&env->mtx);
    *phenv = (SQLHENV) env;
 
    return SQL_SUCCESS;
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLAllocEnv(SQLHENV FAR * phenv)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLAllocEnv(%p)\n", phenv);
 
    return _SQLAllocEnv(phenv, SQL_OV_ODBC2);
}
 
static SQLRETURN
_SQLAllocDesc(SQLHDBC hdbc, SQLHDESC FAR * phdesc)
{
    int i;
 
    ODBC_ENTER_HDBC;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLAllocDesc(%p, %p)\n", hdbc, phdesc);
 
    for (i = 0; ; ++i) {
        if (i >= TDS_MAX_APP_DESC) {
            odbc_errs_add(&dbc->errs, "HY014", NULL);
            break;
        }
        if (dbc->uad[i] == NULL) {
            TDS_DESC *desc = desc_alloc(dbc, DESC_ARD, SQL_DESC_ALLOC_USER);
            if (desc == NULL) {
                odbc_errs_add(&dbc->errs, "HY001", NULL);
                break;
            }
            dbc->uad[i] = desc;
            *phdesc = (SQLHDESC) desc;
            break;
        }
    }
    ODBC_EXIT_(dbc);
}
 
static SQLRETURN
_SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
{
    TDS_STMT *stmt;
    char *pstr;
 
    ODBC_ENTER_HDBC;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
 
    stmt = tds_new0(TDS_STMT, 1);
    if (!stmt) {
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
    tds_dstr_init(&stmt->cursor_name);
    tds_dstr_init(&stmt->query);
 
    stmt->htype = SQL_HANDLE_STMT;
    stmt->dbc = dbc;
    stmt->num_param_rows = 1;
    pstr = NULL;
    /* TODO test initial cursor ... */
        if (asprintf(&pstr, "SQL_CUR%p", stmt) < 0
            ||  !tds_dstr_set(&stmt->cursor_name, pstr)) {
        free(stmt);
        free(pstr);
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
    /* do not free pstr tds_dstr_set do it if necessary */
 
    /* allocate descriptors */
    stmt->ird = desc_alloc(stmt, DESC_IRD, SQL_DESC_ALLOC_AUTO);
    stmt->ard = desc_alloc(stmt, DESC_ARD, SQL_DESC_ALLOC_AUTO);
    stmt->ipd = desc_alloc(stmt, DESC_IPD, SQL_DESC_ALLOC_AUTO);
    stmt->apd = desc_alloc(stmt, DESC_APD, SQL_DESC_ALLOC_AUTO);
    if (!stmt->ird || !stmt->ard || !stmt->ipd || !stmt->apd) {
        tds_dstr_free(&stmt->cursor_name);
        desc_free(stmt->ird);
        desc_free(stmt->ard);
        desc_free(stmt->ipd);
        desc_free(stmt->apd);
        free(stmt);
        odbc_errs_add(&dbc->errs, "HY001", NULL);
        ODBC_EXIT_(dbc);
    }
 
    /* save original ARD and APD */
    stmt->orig_apd = stmt->apd;
    stmt->orig_ard = stmt->ard;
 
    /* set the default statement attributes */
/*  stmt->attr.app_param_desc = stmt->apd; */
/*  stmt->attr.app_row_desc = stmt->ard; */
    stmt->attr.async_enable = SQL_ASYNC_ENABLE_OFF;
    stmt->attr.concurrency = SQL_CONCUR_READ_ONLY;
    stmt->attr.cursor_scrollable = SQL_NONSCROLLABLE;
    stmt->attr.cursor_sensitivity = SQL_INSENSITIVE;
    stmt->attr.cursor_type = SQL_CURSOR_FORWARD_ONLY;
    /* TODO ?? why two attributes */
    stmt->attr.enable_auto_ipd = dbc->attr.auto_ipd = SQL_FALSE;
    stmt->attr.fetch_bookmark_ptr = NULL;
/*  stmt->attr.imp_param_desc = stmt->ipd; */
/*  stmt->attr.imp_row_desc = stmt->ird; */
    stmt->attr.keyset_size = 0;
    stmt->attr.max_length = 0;
    stmt->attr.max_rows = 0;
    stmt->attr.metadata_id = dbc->attr.metadata_id;
    /* TODO check this flag in prepare_call */
    stmt->attr.noscan = SQL_NOSCAN_OFF;
    assert(stmt->apd->header.sql_desc_bind_offset_ptr == NULL);
    assert(stmt->apd->header.sql_desc_bind_type == SQL_PARAM_BIND_BY_COLUMN);
    assert(stmt->apd->header.sql_desc_array_status_ptr == NULL);
    assert(stmt->ipd->header.sql_desc_array_status_ptr == NULL);
    assert(stmt->ipd->header.sql_desc_rows_processed_ptr == NULL);
    assert(stmt->apd->header.sql_desc_array_size == 1);
    stmt->attr.query_timeout = DEFAULT_QUERY_TIMEOUT;
    stmt->attr.retrieve_data = SQL_RD_ON;
    assert(stmt->ard->header.sql_desc_array_size == 1);
    assert(stmt->ard->header.sql_desc_bind_offset_ptr == NULL);
    assert(stmt->ard->header.sql_desc_bind_type == SQL_BIND_BY_COLUMN);
    stmt->attr.row_number = 0;
    assert(stmt->ard->header.sql_desc_array_status_ptr == NULL);
    assert(stmt->ird->header.sql_desc_array_status_ptr == NULL);
    assert(stmt->ird->header.sql_desc_rows_processed_ptr == NULL);
    stmt->attr.simulate_cursor = SQL_SC_NON_UNIQUE;
    stmt->attr.use_bookmarks = SQL_UB_OFF;
    tds_dstr_init(&stmt->attr.qn_msgtext);
    tds_dstr_init(&stmt->attr.qn_options);
    stmt->attr.qn_timeout = 432000;
 
    stmt->sql_rowset_size = 1;
 
    stmt->row_count = TDS_NO_COUNT;
    stmt->row_status = NOT_IN_ROW;
 
    /* insert into list */
    stmt->next = dbc->stmt_list;
    if (dbc->stmt_list)
        dbc->stmt_list->prev = stmt;
    dbc->stmt_list = stmt;
 
    tds_mutex_init(&stmt->mtx);
    *phstmt = (SQLHSTMT) stmt;
 
    if (dbc->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY)
        _SQLSetStmtAttr(stmt, SQL_CURSOR_TYPE, (SQLPOINTER) (TDS_INTPTR) dbc->attr.cursor_type, SQL_IS_INTEGER _wide0);
 
    ODBC_EXIT_(dbc);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLAllocStmt(SQLHDBC hdbc, SQLHSTMT FAR * phstmt)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLAllocStmt(%p, %p)\n", hdbc, phstmt);
 
    return _SQLAllocStmt(hdbc, phstmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLBindCol(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLSMALLINT fCType, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN FAR * pcbValue)
{
    TDS_DESC *ard;
    struct _drecord *drec;
    SQLSMALLINT orig_ard_size;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLBindCol(%p, %d, %d, %p, %d, %p)\n", 
            hstmt, icol, fCType, rgbValue, (int)cbValueMax, pcbValue);
 
    /* TODO - More error checking XXX smurph */
 
#ifdef TDS_NO_DM
    /* check conversion type */
    switch (fCType) {
    case SQL_C_CHAR:
    case SQL_C_WCHAR:
    case SQL_C_BINARY:
    case SQL_C_DEFAULT:
        /* check max buffer length */
        if (!IS_VALID_LEN(cbValueMax)) {
            odbc_errs_add(&stmt->errs, "HY090", NULL);
            ODBC_EXIT_(stmt);
        }
        break;
    }
#endif
 
    if (icol <= 0 || icol > 4000) {
        odbc_errs_add(&stmt->errs, "07009", NULL);
        ODBC_EXIT_(stmt);
    }
 
    ard = stmt->ard;
    orig_ard_size = ard->header.sql_desc_count;
    if (icol > ard->header.sql_desc_count && desc_alloc_records(ard, icol) != SQL_SUCCESS) {
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        ODBC_EXIT_(stmt);
    }
 
    drec = &ard->records[icol - 1];
 
    if (odbc_set_concise_c_type(fCType, drec, 0) != SQL_SUCCESS) {
        desc_alloc_records(ard, orig_ard_size);
        odbc_errs_add(&stmt->errs, "HY003", NULL);
        ODBC_EXIT_(stmt);
    }
    drec->sql_desc_octet_length = cbValueMax;
    drec->sql_desc_octet_length_ptr = pcbValue;
    drec->sql_desc_indicator_ptr = pcbValue;
    drec->sql_desc_data_ptr = rgbValue;
 
    /* force rebind */
    stmt->row = 0;
 
    ODBC_EXIT_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLCancel(SQLHSTMT hstmt)
{
    TDSSOCKET *tds;
 
    /*
     * FIXME this function can be called from other thread, do not free 
     * errors for this function
     * If function is called from another thread errors are not touched
     */
    /* TODO some tests required */
    TDS_STMT *stmt = (TDS_STMT*)hstmt;
    if (SQL_NULL_HSTMT == hstmt || !IS_HSTMT(hstmt))
        return SQL_INVALID_HANDLE;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLCancel(%p)\n", hstmt);
 
        tds_mutex_lock(&stmt->dbc->mtx);
    tds = stmt->tds;
        tds_mutex_unlock(&stmt->dbc->mtx);
 
    /* cancelling an inactive statement ?? */
    if (!tds) {
        ODBC_SAFE_ERROR(stmt);
        ODBC_EXIT_(stmt);
    }
    if (tds_mutex_trylock(&stmt->mtx) == 0) {
        CHECK_STMT_EXTRA(stmt);
        odbc_errs_reset(&stmt->errs);
 
        /* FIXME test current statement */
        /* FIXME here we are unlocked */
 
        if (TDS_FAILED(tds_send_cancel(tds))) {
            ODBC_SAFE_ERROR(stmt);
            ODBC_EXIT_(stmt);
        }
 
        if (TDS_FAILED(tds_process_cancel(tds))) {
            ODBC_SAFE_ERROR(stmt);
            ODBC_EXIT_(stmt);
        }
 
        /* only if we processed cancel reset statement */
        if (tds->state == TDS_IDLE)
            odbc_unlock_statement(stmt);
 
        ODBC_EXIT_(stmt);
    }
 
    /* don't access error here, just return error */
    if (TDS_FAILED(tds_send_cancel(tds)))
        return SQL_ERROR;
    return SQL_SUCCESS;
}
 
ODBC_FUNC(SQLConnect, (P(SQLHDBC,hdbc), PCHARIN(DSN,SQLSMALLINT), PCHARIN(UID,SQLSMALLINT),
    PCHARIN(AuthStr,SQLSMALLINT) WIDE))
{
    TDSLOGIN *login;
    DSTR *s;
 
    ODBC_ENTER_HDBC;
 
#ifdef TDS_NO_DM
    if (szDSN && !IS_VALID_LEN(cbDSN)) {
        odbc_errs_add(&dbc->errs, "HY090", "Invalid DSN buffer length");
        ODBC_EXIT_(dbc);
    }
 
    if (szUID && !IS_VALID_LEN(cbUID)) {
        odbc_errs_add(&dbc->errs, "HY090", "Invalid UID buffer length");
        ODBC_EXIT_(dbc);
    }
 
    if (szAuthStr && !IS_VALID_LEN(cbAuthStr)) {
        odbc_errs_add(&dbc->errs, "HY090", "Invalid PWD buffer length");
        ODBC_EXIT_(dbc);
    }
#endif
 
    login = tds_alloc_login(0);
    if (!login || !tds_init_login(login, dbc->env->tds_ctx->locale))
        goto memory_error;
 
    /* data source name */
    if (odbc_get_string_size(cbDSN, szDSN _wide))
        s = odbc_dstr_copy(dbc, &dbc->dsn, cbDSN, szDSN);
    else
        s = tds_dstr_copy(&dbc->dsn, "DEFAULT");
    if (!s)
        goto memory_error;
 
 
    if (!odbc_get_dsn_info(&dbc->errs, tds_dstr_cstr(&dbc->dsn), login)) {
        tds_free_login(login);
        ODBC_EXIT_(dbc);
    }
 
    if (!tds_dstr_isempty(&dbc->attr.current_catalog))
        if (!tds_dstr_dup(&login->database, &dbc->attr.current_catalog))
            goto memory_error;
 
    /*
     * username/password are never saved to ini file,
     * so you do not check in ini file
     */
    /* user id */
    if (odbc_get_string_size(cbUID, szUID _wide)) {
        if (!odbc_dstr_copy(dbc, &login->user_name, cbUID, szUID))
            goto memory_error;
    }
 
    /* password */
    if (szAuthStr && !tds_dstr_isempty(&login->user_name)) {
        if (!odbc_dstr_copy(dbc, &login->password, cbAuthStr, szAuthStr))
            goto memory_error;
    }
 
    /* DO IT */
    odbc_connect(dbc, login);
 
    tds_free_login(login);
    ODBC_EXIT_(dbc);
 
memory_error:
    tds_free_login(login);
    odbc_errs_add(&dbc->errs, "HY001", NULL);
    ODBC_EXIT_(dbc);
}
 
ODBC_FUNC(SQLDescribeCol, (P(SQLHSTMT,hstmt), P(SQLUSMALLINT,icol), PCHAROUT(ColName,SQLSMALLINT),
    P(SQLSMALLINT FAR *,pfSqlType), P(SQLULEN FAR *,pcbColDef),
    P(SQLSMALLINT FAR *,pibScale), P(SQLSMALLINT FAR *,pfNullable) WIDE))
{
    TDS_DESC *ird;
    struct _drecord *drec;
    SQLRETURN result;
 
    ODBC_ENTER_HSTMT;
 
    ird = stmt->ird;
    IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
 
    if (icol <= 0 || icol > ird->header.sql_desc_count) {
        odbc_errs_add(&stmt->errs, "07009", "Column out of range");
        ODBC_EXIT_(stmt);
    }
    /* check name length */
    if (cbColNameMax < 0) {
        odbc_errs_add(&stmt->errs, "HY090", NULL);
        ODBC_EXIT_(stmt);
    }
    drec = &ird->records[icol - 1];
 
    /* cbColNameMax can be 0 (to retrieve name length) */
    if (szColName == NULL)
        cbColNameMax = 0;
 
    /* straight copy column name up to cbColNameMax */
    result = odbc_set_string(stmt->dbc, szColName, cbColNameMax, pcbColName, tds_dstr_cstr(&drec->sql_desc_label), -1);
    if (szColName && result == SQL_SUCCESS_WITH_INFO)
        odbc_errs_add(&stmt->errs, "01004", NULL);
 
    if (pfSqlType) {
        /* TODO sure ? check documentation for date and intervals */
        *pfSqlType = drec->sql_desc_concise_type;
    }
 
    if (pcbColDef) {
        if (drec->sql_desc_type == SQL_NUMERIC || drec->sql_desc_type == SQL_DECIMAL) {
            *pcbColDef = drec->sql_desc_precision;
        } else {
            *pcbColDef = drec->sql_desc_length;
        }
    }
    if (pibScale) {
        *pibScale = drec->sql_desc_scale;
    }
    if (pfNullable) {
        *pfNullable = drec->sql_desc_nullable;
    }
    ODBC_EXIT_(stmt);
}
 
static SQLRETURN
_SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType, SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax,
         SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc _WIDE)
{
    TDS_DESC *ird;
    struct _drecord *drec;
    SQLRETURN result = SQL_SUCCESS;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLColAttribute(%p, %u, %u, %p, %d, %p, %p)\n", 
            hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
 
    ird = stmt->ird;
 
#define COUT(src) result = odbc_set_string_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, src ? src : "", -1);
#define SOUT(src) result = odbc_set_string_oct(stmt->dbc, rgbDesc, cbDescMax, pcbDesc, tds_dstr_cstr(&src), -1);
 
/* SQLColAttribute returns always attributes using SQLINTEGER */
#if ENABLE_EXTRA_CHECKS
#define IOUT(type, src) do { \
    /* trick warning if type wrong */ \
    type *p_test = &src; p_test = p_test; \
    *pfDesc = src; } while(0)
#else
#define IOUT(type, src) *pfDesc = src
#endif
 
    IRD_UPDATE(ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
 
    /* dont check column index for these */
    switch (fDescType) {
#if SQL_COLUMN_COUNT != SQL_DESC_COUNT
    case SQL_COLUMN_COUNT:
#endif
    case SQL_DESC_COUNT:
        IOUT(SQLSMALLINT, ird->header.sql_desc_count);
        ODBC_EXIT(stmt, SQL_SUCCESS);
        break;
    }
 
    if (!ird->header.sql_desc_count) {
        odbc_errs_add(&stmt->errs, "07005", NULL);
        ODBC_EXIT_(stmt);
    }
 
    if (icol <= 0 || icol > ird->header.sql_desc_count) {
        odbc_errs_add(&stmt->errs, "07009", "Column out of range");
        ODBC_EXIT_(stmt);
    }
    drec = &ird->records[icol - 1];
 
    tdsdump_log(TDS_DBG_INFO1, "SQLColAttribute: fDescType is %d\n", fDescType);
 
    switch (fDescType) {
    case SQL_DESC_AUTO_UNIQUE_VALUE:
        IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
        break;
    case SQL_DESC_BASE_COLUMN_NAME:
        SOUT(drec->sql_desc_base_column_name);
        break;
    case SQL_DESC_BASE_TABLE_NAME:
        SOUT(drec->sql_desc_base_table_name);
        break;
    case SQL_DESC_CASE_SENSITIVE:
        IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
        break;
    case SQL_DESC_CATALOG_NAME:
        SOUT(drec->sql_desc_catalog_name);
        break;
#if SQL_COLUMN_TYPE != SQL_DESC_CONCISE_TYPE
    case SQL_COLUMN_TYPE:
#endif
    case SQL_DESC_CONCISE_TYPE:
        /* special case, get ODBC 2 type, not ODBC 3 SQL_DESC_CONCISE_TYPE (different for datetime) */
        if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3) {
            IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
            break;
        }
 
        /* get type and convert it to ODBC 2 type */
        {
            SQLSMALLINT type = drec->sql_desc_concise_type;
 
            switch (type) {
            case SQL_TYPE_DATE:
                type = SQL_DATE;
                break;
            case SQL_TYPE_TIME:
                type = SQL_TIME;
                break;
            case SQL_TYPE_TIMESTAMP:
                type = SQL_TIMESTAMP;
                break;
            }
            IOUT(SQLSMALLINT, type);
        }
        break;
    case SQL_DESC_DISPLAY_SIZE:
        IOUT(SQLLEN, drec->sql_desc_display_size);
        break;
    case SQL_DESC_FIXED_PREC_SCALE:
        IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
        break;
    case SQL_DESC_LABEL:
        SOUT(drec->sql_desc_label);
        break;
        /* FIXME special cases for SQL_COLUMN_LENGTH */
    case SQL_COLUMN_LENGTH:
        IOUT(SQLLEN, drec->sql_desc_octet_length);
        break;
    case SQL_DESC_LENGTH:
        IOUT(SQLULEN, drec->sql_desc_length);
        break;
    case SQL_DESC_LITERAL_PREFIX:
        COUT(drec->sql_desc_literal_prefix);
        break;
    case SQL_DESC_LITERAL_SUFFIX:
        COUT(drec->sql_desc_literal_suffix);
        break;
    case SQL_DESC_LOCAL_TYPE_NAME:
        SOUT(drec->sql_desc_local_type_name);
        break;
#if SQL_COLUMN_NAME != SQL_DESC_NAME
    case SQL_COLUMN_NAME:
#endif
    case SQL_DESC_NAME:
        SOUT(drec->sql_desc_name);
        break;
#if SQL_COLUMN_NULLABLE != SQL_DESC_NULLABLE
    case SQL_COLUMN_NULLABLE:
#endif
    case SQL_DESC_NULLABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_nullable);
        break;
    case SQL_DESC_NUM_PREC_RADIX:
        IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
        break;
    case SQL_DESC_OCTET_LENGTH:
        IOUT(SQLLEN, drec->sql_desc_octet_length);
        break;
        /* FIXME special cases for SQL_COLUMN_PRECISION */
    case SQL_COLUMN_PRECISION:
        if (drec->sql_desc_concise_type == SQL_REAL) {
            *pfDesc = 7;
            break;
        }
        if (drec->sql_desc_concise_type == SQL_DOUBLE) {
            *pfDesc = 15;
            break;
        }
        if (drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP || drec->sql_desc_concise_type == SQL_TIMESTAMP) {
            *pfDesc = drec->sql_desc_precision ? 23 : 16;
            break;
        }
    case SQL_DESC_PRECISION:    /* this section may be wrong */
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
            || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_TYPE_DATE
            || drec->sql_desc_concise_type == SQL_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_SS_TIME2
            || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
            IOUT(SQLSMALLINT, drec->sql_desc_precision);
        else
            *pfDesc = drec->sql_desc_length;
        break;
        /* FIXME special cases for SQL_COLUMN_SCALE */
    case SQL_COLUMN_SCALE:
    case SQL_DESC_SCALE:    /* this section may be wrong */
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
            || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_TYPE_DATE
            || drec->sql_desc_concise_type == SQL_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_FLOAT
            || drec->sql_desc_concise_type == SQL_SS_TIME2
            || drec->sql_desc_concise_type == SQL_SS_TIMESTAMPOFFSET)
            IOUT(SQLSMALLINT, drec->sql_desc_scale);
        else
            *pfDesc = 0;
        break;
    case SQL_DESC_SCHEMA_NAME:
        SOUT(drec->sql_desc_schema_name);
        break;
    case SQL_DESC_SEARCHABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_searchable);
        break;
    case SQL_DESC_TABLE_NAME:
        SOUT(drec->sql_desc_table_name);
        break;
    case SQL_DESC_TYPE:
        IOUT(SQLSMALLINT, drec->sql_desc_type);
        break;
    case SQL_DESC_TYPE_NAME:
        COUT(drec->sql_desc_type_name);
        break;
    case SQL_DESC_UNNAMED:
        IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
        break;
    case SQL_DESC_UNSIGNED:
        IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
        break;
    case SQL_DESC_UPDATABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_updatable);
        break;
    default:
        tdsdump_log(TDS_DBG_INFO2, "SQLColAttribute: fDescType %d not catered for...\n", fDescType);
        odbc_errs_add(&stmt->errs, "HY091", NULL);
        ODBC_EXIT_(stmt);
        break;
    }
 
    if (result == SQL_SUCCESS_WITH_INFO)
        odbc_errs_add(&stmt->errs, "01004", NULL);
 
    ODBC_EXIT(stmt, result);
 
#undef COUT
#undef SOUT
#undef IOUT
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLColAttributes(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
         SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc, SQLLEN FAR * pfDesc)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLColAttributes(%p, %d, %d, %p, %d, %p, %p)\n", 
            hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
 
    return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc _wide0);
}
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLColAttribute(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
        SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
#ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
        SQLLEN FAR * pfDesc
#else
        SQLPOINTER pfDesc
#endif
    )
{
 
        return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax,
                                pcbDesc, (SQLLEN*) pfDesc _wide0);
}
 
#ifdef ENABLE_ODBC_WIDE
SQLRETURN ODBC_PUBLIC ODBC_API
SQLColAttributeW(SQLHSTMT hstmt, SQLUSMALLINT icol, SQLUSMALLINT fDescType,
        SQLPOINTER rgbDesc, SQLSMALLINT cbDescMax, SQLSMALLINT FAR * pcbDesc,
#ifdef TDS_SQLCOLATTRIBUTE_SQLLEN
        SQLLEN FAR * pfDesc
#else
        SQLPOINTER pfDesc
#endif
    )
{
    tdsdump_log(TDS_DBG_FUNC, "SQLColAttributeW(%p, %u, %u, %p, %d, %p, %p)\n",
            hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc);
 
    return _SQLColAttribute(hstmt, icol, fDescType, rgbDesc, cbDescMax, pcbDesc, pfDesc, 1);
}
#endif
#endif
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLDisconnect(SQLHDBC hdbc)
{
    int i;
        struct _hstmt *stmt, *next;
 
    ODBC_ENTER_HDBC;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLDisconnect(%p)\n", hdbc);
 
    /* free all associated statements */
        for (stmt = dbc->stmt_list;  stmt != NULL;  stmt = next) {
                next = stmt->next;
        tds_mutex_unlock(&dbc->mtx);
        _SQLFreeStmt(stmt, SQL_DROP, 1);
        tds_mutex_lock(&dbc->mtx);
    }
 
    /* free all associated descriptors */
    for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
        if (dbc->uad[i]) {
            desc_free(dbc->uad[i]);
            dbc->uad[i] = NULL;
        }
    }
 
#ifdef ENABLE_ODBC_WIDE
    dbc->mb_conv = NULL;
#endif
    tds_close_socket(dbc->tds_socket);
    tds_free_socket(dbc->tds_socket);
    dbc->tds_socket = NULL;
    dbc->cursor_support = 0;
 
    ODBC_EXIT_(dbc);
}
 
static int
odbc_errmsg_handler(const TDSCONTEXT * ctx, TDSSOCKET * tds, TDSMESSAGE * msg)
{
    struct _sql_errors *errs = NULL;
    TDS_DBC *dbc = NULL;
    TDS_STMT *stmt = NULL;
 
    tdsdump_log(TDS_DBG_INFO1, "msgno %d %d\n", (int) msg->msgno, TDSETIME);
 
    if (msg->msgno == TDSETIME) {
 
        tdsdump_log(TDS_DBG_INFO1, "in timeout\n");
        if (!tds)
            return TDS_INT_CANCEL;
 
        if ((stmt = odbc_get_stmt(tds)) != NULL) {
            /* first time, try to send a cancel */
            if (!tds->in_cancel) {
                odbc_errs_add(&stmt->errs, "HYT00", "Timeout expired");
                tdsdump_log(TDS_DBG_INFO1, "returning from timeout\n");
                return TDS_INT_TIMEOUT;
            }
        } else if ((dbc = odbc_get_dbc(tds)) != NULL) {
            odbc_errs_add(&dbc->errs, "HYT00", "Timeout expired");
        }
 
        tds_close_socket(tds);
        tdsdump_log(TDS_DBG_INFO1, "returning cancel from timeout\n");
        return TDS_INT_CANCEL;
    }
 
    if (tds && (dbc = odbc_get_dbc(tds)) != NULL) {
        errs = &dbc->errs;
        stmt = odbc_get_stmt(tds);
        if (stmt)
            errs = &stmt->errs;
    } else if (ctx->parent) {
        errs = &((TDS_ENV *) ctx->parent)->errs;
    }
    if (errs) {
        int severity = msg->severity;
        const char * state = msg->sql_state;
 
        /* fix severity for Sybase */
        if (severity <= 10 && dbc && !TDS_IS_MSSQL(dbc->tds_socket) && msg->sql_state && msg->sql_state[0]
            && strncmp(msg->sql_state, "00", 2) != 0) {
            if (strncmp(msg->sql_state, "01", 2) != 0 && strncmp(msg->sql_state, "IM", 2) != 0)
                severity = 11;
        }
 
        /* compute state if not available */
        if (!state)
            state = severity <= 10 ? "01000" : "42000";
        /* add error, do not overwrite connection timeout error */
        if (msg->msgno != TDSEFCON || errs->lastrc != SQL_ERROR || errs->num_errors < 1)
            odbc_errs_add_rdbms(errs, msg->msgno, state, msg->message, msg->line_number, msg->severity,
                        msg->server, stmt ? stmt->curr_param_row + 1 : 0);
 
        /* set lastc according */
        if (severity <= 10) {
            if (errs->lastrc == SQL_SUCCESS)
                errs->lastrc = SQL_SUCCESS_WITH_INFO;
        } else {
            errs->lastrc = SQL_ERROR;
        }
    }
    return TDS_INT_CANCEL;
}
 
/* TODO optimize, change only if some data change (set same value should not set this flag) */
#define DESC_SET_NEED_REPREPARE \
    do {\
        if (desc->type == DESC_IPD) {\
            assert(IS_HSTMT(desc->parent));\
            ((TDS_STMT *) desc->parent)->need_reprepare = 1;\
         }\
    } while(0)
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLSetDescRec(SQLHDESC hdesc, SQLSMALLINT nRecordNumber, SQLSMALLINT nType, SQLSMALLINT nSubType, SQLLEN nLength,
          SQLSMALLINT nPrecision, SQLSMALLINT nScale, SQLPOINTER pData, SQLLEN FAR * pnStringLength, SQLLEN FAR * pnIndicator)
{
    struct _drecord *drec;
    SQLSMALLINT concise_type;
 
    ODBC_ENTER_HDESC;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLSetDescRec(%p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", 
            hdesc, nRecordNumber, nType, nSubType, (int)nLength, nPrecision, nScale, pData, pnStringLength, pnIndicator);
 
    if (desc->type == DESC_IRD) {
        odbc_errs_add(&desc->errs, "HY016", NULL);
        ODBC_EXIT_(desc);
    }
 
    if (nRecordNumber > desc->header.sql_desc_count || nRecordNumber <= 0) {
        odbc_errs_add(&desc->errs, "07009", NULL);
        ODBC_EXIT_(desc);
    }
 
    drec = &desc->records[nRecordNumber - 1];
 
    /* check for valid types and return "HY021" if not */
    if (desc->type == DESC_IPD) {
        DESC_SET_NEED_REPREPARE;
        concise_type = odbc_get_concise_sql_type(nType, nSubType);
    } else {
        concise_type = odbc_get_concise_c_type(nType, nSubType);
    }
    if (nType == SQL_INTERVAL || nType == SQL_DATETIME) {
        if (!concise_type) {
            odbc_errs_add(&desc->errs, "HY021", NULL);
            ODBC_EXIT_(desc);
        }
    } else {
        if (concise_type != nType) {
            odbc_errs_add(&desc->errs, "HY021", NULL);
            ODBC_EXIT_(desc);
        }
        nSubType = 0;
    }
    drec->sql_desc_concise_type = concise_type;
    drec->sql_desc_type = nType;
    drec->sql_desc_datetime_interval_code = nSubType;
 
    drec->sql_desc_octet_length = nLength;
    drec->sql_desc_precision = nPrecision;
    drec->sql_desc_scale = nScale;
    drec->sql_desc_data_ptr = pData;
    drec->sql_desc_octet_length_ptr = pnStringLength;
    drec->sql_desc_indicator_ptr = pnIndicator;
 
    ODBC_EXIT_(desc);
}
 
ODBC_FUNC(SQLGetDescRec, (P(SQLHDESC,hdesc), P(SQLSMALLINT,RecordNumber), PCHAROUT(Name,SQLSMALLINT),
    P(SQLSMALLINT *,Type), P(SQLSMALLINT *,SubType), P(SQLLEN FAR *,Length),
    P(SQLSMALLINT *,Precision), P(SQLSMALLINT *,Scale), P(SQLSMALLINT *,Nullable) WIDE))
{
    struct _drecord *drec = NULL;
    SQLRETURN rc = SQL_SUCCESS;
 
    ODBC_ENTER_HDESC;
 
    if (RecordNumber <= 0) {
        odbc_errs_add(&desc->errs, "07009", NULL);
        ODBC_EXIT_(desc);
    }
 
    IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    if (RecordNumber > desc->header.sql_desc_count)
        ODBC_EXIT(desc, SQL_NO_DATA);
 
    if (desc->type == DESC_IRD && !desc->header.sql_desc_count) {
        odbc_errs_add(&desc->errs, "HY007", NULL);
        ODBC_EXIT_(desc);
    }
 
    drec = &desc->records[RecordNumber - 1];
 
    if ((rc = odbc_set_string(desc_get_dbc(desc), szName, cbNameMax, pcbName, tds_dstr_cstr(&drec->sql_desc_name), -1)) != SQL_SUCCESS)
        odbc_errs_add(&desc->errs, "01004", NULL);
 
    if (Type)
        *Type = drec->sql_desc_type;
    if (Length)
        *Length = drec->sql_desc_octet_length;
    if (Precision)
        *Precision = drec->sql_desc_precision;
    if (Scale)
        *Scale = drec->sql_desc_scale;
    if (SubType)
        *SubType = drec->sql_desc_datetime_interval_code;
    if (Nullable)
        *Nullable = drec->sql_desc_nullable;
 
    ODBC_EXIT(desc, rc);
}
 
ODBC_FUNC(SQLGetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType), P(SQLPOINTER,Value),
    P(SQLINTEGER,BufferLength), P(SQLINTEGER *,StringLength) WIDE))
{
    struct _drecord *drec;
    SQLRETURN result = SQL_SUCCESS;
 
    ODBC_ENTER_HDESC;
 
#define COUT(src) result = odbc_set_string_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, src, -1);
#define SOUT(src) result = odbc_set_string_oct(desc_get_dbc(desc), Value, BufferLength, StringLength, tds_dstr_cstr(&src), -1);
 
#if ENABLE_EXTRA_CHECKS
#define IOUT(type, src) do { \
    /* trick warning if type wrong */ \
    type *p_test = &src; p_test = p_test; \
    *((type *)Value) = src; } while(0)
#else
#define IOUT(type, src) *((type *)Value) = src
#endif
 
    /* dont check column index for these */
    switch (fDescType) {
    case SQL_DESC_ALLOC_TYPE:
        IOUT(SQLSMALLINT, desc->header.sql_desc_alloc_type);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ARRAY_SIZE:
        IOUT(SQLULEN, desc->header.sql_desc_array_size);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ARRAY_STATUS_PTR:
        IOUT(SQLUSMALLINT *, desc->header.sql_desc_array_status_ptr);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_BIND_OFFSET_PTR:
        IOUT(SQLLEN *, desc->header.sql_desc_bind_offset_ptr);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_BIND_TYPE:
        IOUT(SQLINTEGER, desc->header.sql_desc_bind_type);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_COUNT:
        IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
        IOUT(SQLSMALLINT, desc->header.sql_desc_count);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ROWS_PROCESSED_PTR:
        IOUT(SQLULEN *, desc->header.sql_desc_rows_processed_ptr);
        ODBC_EXIT_(desc);
        break;
    }
 
    IRD_UPDATE(desc, &desc->errs, ODBC_EXIT(desc, SQL_ERROR));
    if (!desc->header.sql_desc_count) {
        odbc_errs_add(&desc->errs, "07005", NULL);
        ODBC_EXIT_(desc);
    }
 
    if (icol < 1) {
        odbc_errs_add(&desc->errs, "07009", "Column out of range");
        ODBC_EXIT_(desc);
    }
    if (icol > desc->header.sql_desc_count)
        ODBC_EXIT(desc, SQL_NO_DATA);
    drec = &desc->records[icol - 1];
 
    tdsdump_log(TDS_DBG_INFO1, "SQLGetDescField: fDescType is %d\n", fDescType);
 
    switch (fDescType) {
    case SQL_DESC_AUTO_UNIQUE_VALUE:
        IOUT(SQLUINTEGER, drec->sql_desc_auto_unique_value);
        break;
    case SQL_DESC_BASE_COLUMN_NAME:
        SOUT(drec->sql_desc_base_column_name);
        break;
    case SQL_DESC_BASE_TABLE_NAME:
        SOUT(drec->sql_desc_base_table_name);
        break;
    case SQL_DESC_CASE_SENSITIVE:
        IOUT(SQLINTEGER, drec->sql_desc_case_sensitive);
        break;
    case SQL_DESC_CATALOG_NAME:
        SOUT(drec->sql_desc_catalog_name);
        break;
    case SQL_DESC_CONCISE_TYPE:
        IOUT(SQLSMALLINT, drec->sql_desc_concise_type);
        break;
    case SQL_DESC_DATA_PTR:
        IOUT(SQLPOINTER, drec->sql_desc_data_ptr);
        break;
    case SQL_DESC_DATETIME_INTERVAL_CODE:
        IOUT(SQLSMALLINT, drec->sql_desc_datetime_interval_code);
        break;
    case SQL_DESC_DATETIME_INTERVAL_PRECISION:
        IOUT(SQLINTEGER, drec->sql_desc_datetime_interval_precision);
        break;
    case SQL_DESC_DISPLAY_SIZE:
        IOUT(SQLLEN, drec->sql_desc_display_size);
        break;
    case SQL_DESC_FIXED_PREC_SCALE:
        IOUT(SQLSMALLINT, drec->sql_desc_fixed_prec_scale);
        break;
    case SQL_DESC_INDICATOR_PTR:
        IOUT(SQLLEN *, drec->sql_desc_indicator_ptr);
        break;
    case SQL_DESC_LABEL:
        SOUT(drec->sql_desc_label);
        break;
    case SQL_DESC_LENGTH:
        IOUT(SQLULEN, drec->sql_desc_length);
        break;
    case SQL_DESC_LITERAL_PREFIX:
        COUT(drec->sql_desc_literal_prefix);
        break;
    case SQL_DESC_LITERAL_SUFFIX:
        COUT(drec->sql_desc_literal_suffix);
        break;
    case SQL_DESC_LOCAL_TYPE_NAME:
        SOUT(drec->sql_desc_local_type_name);
        break;
    case SQL_DESC_NAME:
        SOUT(drec->sql_desc_name);
        break;
    case SQL_DESC_NULLABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_nullable);
        break;
    case SQL_DESC_NUM_PREC_RADIX:
        IOUT(SQLINTEGER, drec->sql_desc_num_prec_radix);
        break;
    case SQL_DESC_OCTET_LENGTH:
        IOUT(SQLLEN, drec->sql_desc_octet_length);
        break;
    case SQL_DESC_OCTET_LENGTH_PTR:
        IOUT(SQLLEN *, drec->sql_desc_octet_length_ptr);
        break;
    case SQL_DESC_PARAMETER_TYPE:
        IOUT(SQLSMALLINT, drec->sql_desc_parameter_type);
        break;
    case SQL_DESC_PRECISION:
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
            || drec->sql_desc_concise_type == SQL_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP)
            IOUT(SQLSMALLINT, drec->sql_desc_precision);
        else
            /* TODO support date/time */
            *((SQLSMALLINT *) Value) = 0;
        break;
#ifdef SQL_DESC_ROWVER
    case SQL_DESC_ROWVER:
        IOUT(SQLSMALLINT, drec->sql_desc_rowver);
        break;
#endif
    case SQL_DESC_SCALE:
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL
            || drec->sql_desc_concise_type == SQL_TYPE_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_TIMESTAMP
            || drec->sql_desc_concise_type == SQL_FLOAT)
            IOUT(SQLSMALLINT, drec->sql_desc_scale);
        else
            *((SQLSMALLINT *) Value) = 0;
        break;
    case SQL_DESC_SCHEMA_NAME:
        SOUT(drec->sql_desc_schema_name);
        break;
    case SQL_DESC_SEARCHABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_searchable);
        break;
    case SQL_DESC_TABLE_NAME:
        SOUT(drec->sql_desc_table_name);
        break;
    case SQL_DESC_TYPE:
        IOUT(SQLSMALLINT, drec->sql_desc_type);
        break;
    case SQL_DESC_TYPE_NAME:
        COUT(drec->sql_desc_type_name);
        break;
    case SQL_DESC_UNNAMED:
        IOUT(SQLSMALLINT, drec->sql_desc_unnamed);
        break;
    case SQL_DESC_UNSIGNED:
        IOUT(SQLSMALLINT, drec->sql_desc_unsigned);
        break;
    case SQL_DESC_UPDATABLE:
        IOUT(SQLSMALLINT, drec->sql_desc_updatable);
        break;
    default:
        odbc_errs_add(&desc->errs, "HY091", NULL);
        ODBC_EXIT_(desc);
        break;
    }
 
    if (result == SQL_SUCCESS_WITH_INFO)
        odbc_errs_add(&desc->errs, "01004", NULL);
 
    ODBC_EXIT(desc, result);
 
#undef COUT
#undef SOUT
#undef IOUT
}
 
ODBC_FUNC(SQLSetDescField, (P(SQLHDESC,hdesc), P(SQLSMALLINT,icol), P(SQLSMALLINT,fDescType),
    P(SQLPOINTER,Value), P(SQLINTEGER,BufferLength) WIDE))
{
    struct _drecord *drec;
    SQLRETURN result = SQL_SUCCESS;
 
    ODBC_ENTER_HDESC;
 
#if ENABLE_EXTRA_CHECKS
#define IIN(type, dest) do { \
    /* trick warning if type wrong */ \
    type *p_test = &dest; p_test = p_test; \
    dest = (type)(TDS_INTPTR)Value; } while(0)
#define PIN(type, dest) do { \
    /* trick warning if type wrong */ \
    type *p_test = &dest; p_test = p_test; \
    dest = (type)Value; } while(0)
#else
#define IIN(type, dest) dest = (type)(TDS_INTPTR)Value
#define PIN(type, dest) dest = (type)Value
#endif
 
    /* special case for IRD */
    if (desc->type == DESC_IRD && fDescType != SQL_DESC_ARRAY_STATUS_PTR && fDescType != SQL_DESC_ROWS_PROCESSED_PTR) {
        odbc_errs_add(&desc->errs, "HY016", NULL);
        ODBC_EXIT_(desc);
    }
 
    /* dont check column index for these */
    switch (fDescType) {
    case SQL_DESC_ALLOC_TYPE:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ARRAY_SIZE:
        IIN(SQLULEN, desc->header.sql_desc_array_size);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ARRAY_STATUS_PTR:
        PIN(SQLUSMALLINT *, desc->header.sql_desc_array_status_ptr);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_ROWS_PROCESSED_PTR:
        PIN(SQLULEN *, desc->header.sql_desc_rows_processed_ptr);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_BIND_TYPE:
        IIN(SQLINTEGER, desc->header.sql_desc_bind_type);
        ODBC_EXIT_(desc);
        break;
    case SQL_DESC_COUNT:
        {
            int n = (int) (TDS_INTPTR) Value;
 
            if (n <= 0 || n > 4000) {
                odbc_errs_add(&desc->errs, "07009", NULL);
                ODBC_EXIT_(desc);
            }
            result = desc_alloc_records(desc, n);
            if (result == SQL_ERROR)
                odbc_errs_add(&desc->errs, "HY001", NULL);
            ODBC_EXIT(desc, result);
        }
        break;
    }
 
    if (!desc->header.sql_desc_count) {
        odbc_errs_add(&desc->errs, "07005", NULL);
        ODBC_EXIT_(desc);
    }
 
    if (icol <= 0 || icol > desc->header.sql_desc_count) {
        odbc_errs_add(&desc->errs, "07009", "Column out of range");
        ODBC_EXIT_(desc);
    }
    drec = &desc->records[icol - 1];
 
    tdsdump_log(TDS_DBG_INFO1, "SQLColAttributes: fDescType is %d\n", fDescType);
 
    switch (fDescType) {
    case SQL_DESC_AUTO_UNIQUE_VALUE:
    case SQL_DESC_BASE_COLUMN_NAME:
    case SQL_DESC_BASE_TABLE_NAME:
    case SQL_DESC_CASE_SENSITIVE:
    case SQL_DESC_CATALOG_NAME:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_CONCISE_TYPE:
        DESC_SET_NEED_REPREPARE;
        if (desc->type == DESC_IPD)
            result = odbc_set_concise_sql_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
        else
            result = odbc_set_concise_c_type((SQLSMALLINT) (TDS_INTPTR) Value, drec, 0);
        if (result != SQL_SUCCESS)
            odbc_errs_add(&desc->errs, "HY021", NULL);
        break;
    case SQL_DESC_DATA_PTR:
        PIN(SQLPOINTER, drec->sql_desc_data_ptr);
        break;
        /* TODO SQL_DESC_DATETIME_INTERVAL_CODE remember to check sql_desc_type */
        /* TODO SQL_DESC_DATETIME_INTERVAL_PRECISION */
    case SQL_DESC_DISPLAY_SIZE:
    case SQL_DESC_FIXED_PREC_SCALE:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_INDICATOR_PTR:
        PIN(SQLLEN *, drec->sql_desc_indicator_ptr);
        break;
    case SQL_DESC_LABEL:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_LENGTH:
        DESC_SET_NEED_REPREPARE;
        IIN(SQLULEN, drec->sql_desc_length);
        break;
    case SQL_DESC_LITERAL_PREFIX:
    case SQL_DESC_LITERAL_SUFFIX:
    case SQL_DESC_LOCAL_TYPE_NAME:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_NAME:
        if (!odbc_dstr_copy_oct(desc_get_dbc(desc), &drec->sql_desc_name, BufferLength, (ODBC_CHAR*) Value)) {
            odbc_errs_add(&desc->errs, "HY001", NULL);
            result = SQL_ERROR;
        }
        break;
    case SQL_DESC_NULLABLE:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_NUM_PREC_RADIX:
        IIN(SQLINTEGER, drec->sql_desc_num_prec_radix);
        break;
    case SQL_DESC_OCTET_LENGTH:
        DESC_SET_NEED_REPREPARE;
        IIN(SQLLEN, drec->sql_desc_octet_length);
        break;
    case SQL_DESC_OCTET_LENGTH_PTR:
        PIN(SQLLEN *, drec->sql_desc_octet_length_ptr);
        break;
    case SQL_DESC_PARAMETER_TYPE:
        DESC_SET_NEED_REPREPARE;
        IIN(SQLSMALLINT, drec->sql_desc_parameter_type);
        break;
    case SQL_DESC_PRECISION:
        DESC_SET_NEED_REPREPARE;
        /* TODO correct ?? */
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
            IIN(SQLSMALLINT, drec->sql_desc_precision);
        else
            IIN(SQLULEN, drec->sql_desc_length);
        break;
#ifdef SQL_DESC_ROWVER
    case SQL_DESC_ROWVER:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
#endif
    case SQL_DESC_SCALE:
        DESC_SET_NEED_REPREPARE;
        if (drec->sql_desc_concise_type == SQL_NUMERIC || drec->sql_desc_concise_type == SQL_DECIMAL)
            IIN(SQLSMALLINT, drec->sql_desc_scale);
        else
            /* TODO even for datetime/money ?? */
            drec->sql_desc_scale = 0;
        break;
    case SQL_DESC_SCHEMA_NAME:
    case SQL_DESC_SEARCHABLE:
    case SQL_DESC_TABLE_NAME:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_TYPE:
        DESC_SET_NEED_REPREPARE;
        IIN(SQLSMALLINT, drec->sql_desc_type);
        /* FIXME what happen for interval/datetime ?? */
        drec->sql_desc_concise_type = drec->sql_desc_type;
        break;
    case SQL_DESC_TYPE_NAME:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    case SQL_DESC_UNNAMED:
        IIN(SQLSMALLINT, drec->sql_desc_unnamed);
        break;
    case SQL_DESC_UNSIGNED:
    case SQL_DESC_UPDATABLE:
        odbc_errs_add(&desc->errs, "HY091", "Descriptor type read only");
        result = SQL_ERROR;
        break;
    default:
        odbc_errs_add(&desc->errs, "HY091", NULL);
        ODBC_EXIT_(desc);
        break;
    }
 
#undef IIN
 
    ODBC_EXIT(desc, result);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLCopyDesc(SQLHDESC hsrc, SQLHDESC hdesc)
{
    TDS_DESC *src;
 
    ODBC_ENTER_HDESC;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLCopyDesc(%p, %p)\n", 
            hsrc, hdesc);
 
    if (SQL_NULL_HDESC == hsrc || !IS_HDESC(hsrc))
        return SQL_INVALID_HANDLE;
    src = (TDS_DESC *) hsrc;
    CHECK_DESC_EXTRA(src);
 
    /* do not write on IRD */
    if (desc->type == DESC_IRD) {
        odbc_errs_add(&desc->errs, "HY016", NULL);
        ODBC_EXIT_(desc);
    }
    IRD_UPDATE(src, &src->errs, ODBC_EXIT(desc, SQL_ERROR));
 
    ODBC_EXIT(desc, desc_copy(desc, src));
}
 
#if ENABLE_EXTRA_CHECKS
static void
odbc_ird_check(TDS_STMT * stmt)
{
#if !ENABLE_ODBC_MARS
    TDS_DESC *ird = stmt->ird;
    TDSRESULTINFO *res_info = NULL;
    int cols = 0, i;
 
    if (!stmt->tds)
        return;
    if (stmt->tds->current_results) {
        res_info = stmt->tds->current_results;
        cols = res_info->num_cols;
    }
    if (stmt->cursor != NULL)
        return;
 
    /* check columns number */
    assert(ird->header.sql_desc_count <= cols || ird->header.sql_desc_count == 0);
 
 
    /* check all columns */
    for (i = 0; i < ird->header.sql_desc_count; ++i) {
        struct _drecord *drec = &ird->records[i];
        TDSCOLUMN *col = res_info->columns[i];
 
        assert(strcmp(tds_dstr_cstr(&drec->sql_desc_label), tds_dstr_cstr(&col->column_name)) == 0);
    }
#endif
}
#endif
 
static void
odbc_unquote(char *buf, size_t buf_len, const char *start, const char *end)
{
    char quote;
    assert(buf_len > 0);
 
    /* empty string */
    if (start >= end) {
        buf[0] = 0;
        return;
    }
 
    /* not quoted */
    if (*start != '[' && *start != '\"') {
        --buf_len;
                if (end < start + buf_len)
            buf_len = end - start;
        memcpy(buf, start, buf_len);
        buf[buf_len] = 0;
        return;
    }
 
    /* quoted... unquote */
    quote = (*start == '[') ? ']' : *start;
    ++start;
    while (buf_len > 0 && start < end) {
        if (*start == quote)
            if (++start >= end)
                break;
        *buf++ = *start++;
        --buf_len;
    }
    *buf = 0;
}
 
/* FIXME check result !!! */
static SQLRETURN
odbc_populate_ird(TDS_STMT * stmt)
{
    TDS_DESC *ird = stmt->ird;
    struct _drecord *drec;
    TDSCOLUMN *col;
    TDSRESULTINFO *res_info;
    int num_cols;
    int i;
 
    desc_free_records(ird);
    if (!stmt->tds || !(res_info = stmt->tds->current_results))
        return SQL_SUCCESS;
    if (res_info == stmt->tds->param_info)
        return SQL_SUCCESS;
    num_cols = res_info->num_cols;
 
    /* ignore hidden columns... TODO correct? */
    while (num_cols > 0 && res_info->columns[num_cols - 1]->column_hidden == 1)
        --num_cols;
 
    if (desc_alloc_records(ird, num_cols) != SQL_SUCCESS)
        goto memory_error;
 
    for (i = 0; i < num_cols; i++) {
        drec = &ird->records[i];
        col = res_info->columns[i];
        drec->sql_desc_auto_unique_value = col->column_identity ? SQL_TRUE : SQL_FALSE;
        /* TODO SQL_FALSE ?? */
        drec->sql_desc_case_sensitive = SQL_TRUE;
 
        /*
         * TODO how to handle when in datetime we change precision ?? 
         * should we change display size too ??
         * is formatting function correct ??
         * we should not convert to string with invalid precision!
         */
        odbc_set_sql_type_info(col, drec, stmt->dbc->env->attr.odbc_version);
 
        drec->sql_desc_fixed_prec_scale = (col->column_prec && col->column_scale) ? SQL_TRUE : SQL_FALSE;
        if (!tds_dstr_dup(&drec->sql_desc_label, &col->column_name))
            goto memory_error;
 
        if (tds_dstr_isempty(&col->table_column_name)) {
            if (!tds_dstr_dup(&drec->sql_desc_name, &col->column_name))
                goto memory_error;
        } else {
            if (!tds_dstr_dup(&drec->sql_desc_name, &col->table_column_name))
                goto memory_error;
            if (!tds_dstr_dup(&drec->sql_desc_base_column_name, &col->table_column_name))
                goto memory_error;
        }
 
        /* extract sql_desc_(catalog/schema/base_table)_name */
        /* TODO extract them dinamically (when needed) ? */
        /* TODO store in libTDS in different way (separately) ? */
        if (!tds_dstr_isempty(&col->table_name)) {
            struct {
                const char *start;
                const char *end;
            } partials[4];
            const char *p;
            char buf[256];
            int i;
 
            p = tds_dstr_cstr(&col->table_name);
            for (i = 0; ; ++i) {
                const char *pend;
 
                if (*p == '[' || *p == '\"') {
                    pend = tds_skip_quoted(p);
                } else {
                    pend = strchr(p, '.');
                    if (!pend)
                        pend = strchr(p, 0);
                }
                partials[i].start = p;
                partials[i].end = pend;
                p = pend;
                if (i == 3 || *p != '.')
                    break;
                ++p;
            }
 
            /* here i points to last element */
            odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
            if (!tds_dstr_copy(&drec->sql_desc_base_table_name, buf))
                goto memory_error;
 
            --i;
            if (i >= 0) {
                odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
                if (!tds_dstr_copy(&drec->sql_desc_schema_name, buf))
                    goto memory_error;
            }
 
            --i;
            if (i >= 0) {
                odbc_unquote(buf, sizeof(buf), partials[i].start, partials[i].end);
                if (!tds_dstr_copy(&drec->sql_desc_catalog_name, buf))
                    goto memory_error;
            }
        }
 
        drec->sql_desc_unnamed = tds_dstr_isempty(&drec->sql_desc_name) ? SQL_UNNAMED : SQL_NAMED;
        /* TODO use is_nullable_type ?? */
        drec->sql_desc_nullable = col->column_nullable ? SQL_TRUE : SQL_FALSE;
 
        drec->sql_desc_octet_length_ptr = NULL;
        /* TODO test timestamp from db, FOR BROWSE query */
        drec->sql_desc_rowver = SQL_FALSE;
        /* TODO seem not correct */
        drec->sql_desc_searchable = (drec->sql_desc_unnamed == SQL_NAMED) ? SQL_PRED_SEARCHABLE : SQL_UNSEARCHABLE;
        drec->sql_desc_updatable = col->column_writeable && !col->column_identity ? SQL_TRUE : SQL_FALSE;
    }
    return SQL_SUCCESS;
 
memory_error:
    odbc_errs_add(&stmt->errs, "HY001", NULL);
    return SQL_ERROR;
}
 
static TDSRET
odbc_cursor_execute(TDS_STMT * stmt)
{
    TDSSOCKET *tds = stmt->tds;
    int send = 0, i;
    TDSRET ret;
    TDSCURSOR *cursor;
    TDSPARAMINFO *params = stmt->params;
 
    assert(tds);
    assert(stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY);
 
    tds_release_cursor(&stmt->cursor);
    cursor = tds_alloc_cursor(tds, tds_dstr_cstr(&stmt->cursor_name), tds_dstr_len(&stmt->cursor_name),
            tds_dstr_cstr(&stmt->query), tds_dstr_len(&stmt->query));
    if (!cursor) {
        odbc_unlock_statement(stmt);
 
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        return TDS_FAIL;
    }
    stmt->cursor = cursor;
 
    /* TODO cursor add enums for tds7 */
    switch (stmt->attr.cursor_type) {
    default:
    case SQL_CURSOR_FORWARD_ONLY:
        i = TDS_CUR_TYPE_FORWARD;
        break;
    case SQL_CURSOR_STATIC:
        i = TDS_CUR_TYPE_STATIC;
        break;
    case SQL_CURSOR_KEYSET_DRIVEN:
        i = TDS_CUR_TYPE_KEYSET;
        break;
    case SQL_CURSOR_DYNAMIC:
        i = TDS_CUR_TYPE_DYNAMIC;
        break;
    }
    cursor->type = i;
 
    switch (stmt->attr.concurrency) {
    default:
    case SQL_CONCUR_READ_ONLY:
        i = TDS_CUR_CONCUR_READ_ONLY;
        break;
    case SQL_CONCUR_LOCK:
        i = TDS_CUR_CONCUR_SCROLL_LOCKS;
        break;
    case SQL_CONCUR_ROWVER:
        i = TDS_CUR_CONCUR_OPTIMISTIC;
        break;
    case SQL_CONCUR_VALUES:
        i = TDS_CUR_CONCUR_OPTIMISTIC_VALUES;
        break;
    }
    cursor->concurrency = 0x2000 | i;
 
    ret = tds_cursor_declare(tds, cursor, params, &send);
    if (TDS_FAILED(ret))
        return ret;
    ret = tds_cursor_open(tds, cursor, params, &send);
    if (TDS_FAILED(ret))
        return ret;
    /* TODO read results, set row count, check type and scroll returned */
    ret = tds_flush_packet(tds);
    tds_set_state(tds, TDS_PENDING);
    /* set cursor name for TDS7+ */
    if (TDS_SUCCEED(ret) && IS_TDS7_PLUS(tds->conn) && !tds_dstr_isempty(&stmt->cursor_name)) {
        ret = odbc_process_tokens(stmt, TDS_RETURN_DONE|TDS_STOPAT_ROW|TDS_STOPAT_COMPUTE);
        stmt->row_count = tds->rows_affected;
        if (ret == TDS_CMD_DONE && cursor->cursor_id != 0) {
            ret = tds_cursor_setname(tds, cursor);
            tds_set_state(tds, TDS_PENDING);
        } else {
            ret = (ret == TDS_CMD_FAIL) ? TDS_FAIL : TDS_SUCCESS;
        }
        if (!cursor->cursor_id) {
            tds_cursor_dealloc(tds, cursor);
            tds_release_cursor(&stmt->cursor);
        }
    }
    return ret;
}
 
static TDSHEADERS *
odbc_init_headers(TDS_STMT * stmt, TDSHEADERS * head)
{
    if (tds_dstr_isempty(&stmt->attr.qn_msgtext) || tds_dstr_isempty(&stmt->attr.qn_options))
        return NULL;
 
    memset(head, 0, sizeof(*head));
    head->qn_timeout = stmt->attr.qn_timeout;
    head->qn_msgtext = tds_dstr_cstr(&stmt->attr.qn_msgtext);
    head->qn_options = tds_dstr_cstr(&stmt->attr.qn_options);
    return head;
}
 
static SQLRETURN
_SQLExecute(TDS_STMT * stmt)
{
    TDSRET ret;
    TDSSOCKET *tds;
    TDS_INT result_type;
    TDS_INT done = 0;
    int in_row = 0;
    SQLUSMALLINT param_status;
    int found_info = 0, found_error = 0;
    TDS_INT8 total_rows = TDS_NO_COUNT;
    TDSHEADERS head;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLExecute(%p)\n", 
            stmt);
 
    stmt->row = 0;
        
 
    /* check parameters are all OK */
        if (stmt->params && stmt->param_num <= (int) stmt->param_count) {
        /* TODO what error ?? */
        ODBC_SAFE_ERROR(stmt);
        return SQL_ERROR;
    }
 
    if (!odbc_lock_statement(stmt))
        return SQL_ERROR;
 
    tds = stmt->tds;
    tdsdump_log(TDS_DBG_FUNC, "_SQLExecute() starting with state %d\n", tds->state);
 
    if (tds->state != TDS_IDLE) {
        if (tds->state == TDS_DEAD) {
            odbc_errs_add(&stmt->errs, "08S01", NULL);
        } else {
            odbc_errs_add(&stmt->errs, "24000", NULL);
        }
        return SQL_ERROR;
    }
 
    stmt->curr_param_row = 0;
    stmt->num_param_rows = ODBC_MAX(1, stmt->apd->header.sql_desc_array_size);
 
    stmt->row_count = TDS_NO_COUNT;
 
    if (stmt->prepared_query_is_rpc) {
        /* TODO support stmt->apd->header.sql_desc_array_size for RPC */
        /* get rpc name */
        /* TODO change method */
        /* TODO cursor change way of calling */
        char *name = tds_dstr_buf(&stmt->query);
        char *end, tmp;
 
        end = name;
        end = (char *) odbc_skip_rpc_name(end);
        stmt->prepared_pos = end;
        tmp = *end;
        *end = 0;
        ret = tds_submit_rpc(tds, name, stmt->params, odbc_init_headers(stmt, &head));
        *end = tmp;
    } else if (stmt->attr.cursor_type != SQL_CURSOR_FORWARD_ONLY || stmt->attr.concurrency != SQL_CONCUR_READ_ONLY) {
        ret = odbc_cursor_execute(stmt);
    } else if (!stmt->is_prepared_query) {
        /* not prepared query */
        /* TODO cursor change way of calling */
        /* SQLExecDirect */
        if (stmt->num_param_rows <= 1) {
            if (!stmt->params) {
                ret = tds_submit_query_params(tds, tds_dstr_cstr(&stmt->query), NULL, odbc_init_headers(stmt, &head));
            } else {
                ret = tds_submit_execdirect(tds, tds_dstr_cstr(&stmt->query), stmt->params, odbc_init_headers(stmt, &head));
            }
        } else {
            /* pack multiple submit using language */
            TDSMULTIPLE multiple;
 
            ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_QUERY, odbc_init_headers(stmt, &head));
            for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
                /* submit a query */
                ret = tds_multiple_query(tds, &multiple, tds_dstr_cstr(&stmt->query), stmt->params);
                if (++stmt->curr_param_row >= stmt->num_param_rows)
                    break;
                /* than process others parameters */
                /* TODO handle all results*/
                if (start_parse_prepared_query(stmt, 1) != SQL_SUCCESS)
                    break;
            }
            if (TDS_SUCCEED(ret))
                ret = tds_multiple_done(tds, &multiple);
        }
    } else if (stmt->num_param_rows <= 1 && IS_TDS71_PLUS(tds->conn) && (!stmt->dyn || stmt->need_reprepare)) {
            if (stmt->dyn) {
                if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
                    ODBC_RETURN(stmt, SQL_ERROR);
            }
            stmt->need_reprepare = 0;
            ret = tds71_submit_prepexec(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params);
    } else {
        /* TODO cursor change way of calling */
        /* SQLPrepare */
        TDSDYNAMIC *dyn;
 
        /* prepare dynamic query (only for first SQLExecute call) */
        if (!stmt->dyn || (stmt->need_reprepare && !stmt->dyn->emulated && IS_TDS7_PLUS(tds->conn))) {
 
            /* free previous prepared statement */
            if (stmt->dyn) {
                if (odbc_free_dynamic(stmt) != SQL_SUCCESS)
                    ODBC_RETURN(stmt, SQL_ERROR);
            }
            stmt->need_reprepare = 0;
 
            tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
            /* TODO use tds_submit_prepexec (mssql2k, tds71) */
            if (TDS_FAILED(tds_submit_prepare(tds, tds_dstr_cstr(&stmt->query), NULL, &stmt->dyn, stmt->params))) {
                /* TODO ?? tds_free_param_results(params); */
                ODBC_SAFE_ERROR(stmt);
                return SQL_ERROR;
            }
            if (TDS_FAILED(tds_process_simple_query(tds))) {
                tds_release_dynamic(&stmt->dyn);
                /* TODO ?? tds_free_param_results(params); */
                ODBC_SAFE_ERROR(stmt);
                return SQL_ERROR;
            }
        }
        stmt->row_count = TDS_NO_COUNT;
        if (stmt->num_param_rows <= 1) {
            dyn = stmt->dyn;
            tds_free_input_params(dyn);
            dyn->params = stmt->params;
            /* prevent double free */
            stmt->params = NULL;
            tdsdump_log(TDS_DBG_INFO1, "End prepare, execute\n");
            /* TODO return error to client */
            ret = tds_submit_execute(tds, dyn);
        } else {
            TDSMULTIPLE multiple;
 
            ret = tds_multiple_init(tds, &multiple, TDS_MULTIPLE_EXECUTE, NULL);
            for (stmt->curr_param_row = 0; TDS_SUCCEED(ret); ) {
                dyn = stmt->dyn;
                tds_free_input_params(dyn);
                dyn->params = stmt->params;
                /* prevent double free */
                stmt->params = NULL;
                ret = tds_multiple_execute(tds, &multiple, dyn);
                if (++stmt->curr_param_row >= stmt->num_param_rows)
                    break;
                /* than process others parameters */
                /* TODO handle all results*/
                if (start_parse_prepared_query(stmt, 1) != SQL_SUCCESS)
                    break;
            }
            if (TDS_SUCCEED(ret))
                ret = tds_multiple_done(tds, &multiple);
        }
    }
    if (TDS_FAILED(ret)) {
        ODBC_SAFE_ERROR(stmt);
        return SQL_ERROR;
    }
    /* catch all errors */
    if (!odbc_lock_statement(stmt))
        ODBC_RETURN_(stmt);
 
    stmt->row_status = PRE_NORMAL_ROW;
 
    stmt->curr_param_row = 0;
    param_status = SQL_PARAM_SUCCESS;
 
    /* TODO review this, ODBC return parameter in other way, for compute I don't know */
    /* TODO perhaps we should return SQL_NO_DATA if no data available... see old SQLExecute code */
    for (;;) {
        result_type = odbc_process_tokens(stmt, TDS_TOKEN_RESULTS);
        tdsdump_log(TDS_DBG_FUNC, "_SQLExecute: odbc_process_tokens returned result_type %d\n", result_type);
        switch (result_type) {
        case TDS_CMD_FAIL:
        case TDS_CMD_DONE:
        case TDS_COMPUTE_RESULT:
        case TDS_ROW_RESULT:
            done = 1;
            break;
 
        case TDS_DONE_RESULT:
        case TDS_DONEPROC_RESULT:
            switch (stmt->errs.lastrc) {
            case SQL_ERROR:
                found_error = 1;
                param_status = SQL_PARAM_ERROR;
                break;
            case SQL_SUCCESS_WITH_INFO:
                found_info = 1;
                param_status = SQL_PARAM_SUCCESS_WITH_INFO;
                break;
            }
            if (stmt->curr_param_row < stmt->num_param_rows && stmt->ipd->header.sql_desc_array_status_ptr)
                stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
            param_status = SQL_PARAM_SUCCESS;
            ++stmt->curr_param_row;
            /* actually is quite strange, if prepared always success with info or success
             * if not prepared return last one
             */
            if (stmt->curr_param_row < stmt->num_param_rows || result_type == TDS_DONEPROC_RESULT)
                stmt->errs.lastrc = SQL_SUCCESS;
            if (total_rows == TDS_NO_COUNT)
                total_rows = stmt->row_count;
            else if (stmt->row_count != TDS_NO_COUNT)
                total_rows += stmt->row_count;
            stmt->row_count = TDS_NO_COUNT;
            if (stmt->curr_param_row >= stmt->num_param_rows) {
                done = 1;
                break;
            }
            break;
 
        case TDS_DONEINPROC_RESULT:
            if (in_row)
                done = 1;
            break;
 
            /* ignore metadata, stop at done or row */
        case TDS_ROWFMT_RESULT:
            if (in_row) {
                done = 1;
                break;
            }
            stmt->row = 0;
            stmt->row_count = TDS_NO_COUNT;
            stmt->row_status = PRE_NORMAL_ROW;
            in_row = 1;
            break;
        }
        if (done)
            break;
    }
    if ((found_info || found_error) && stmt->errs.lastrc != SQL_ERROR)
        stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    if (tds_dstr_isempty(&stmt->attr.qn_msgtext) != tds_dstr_isempty(&stmt->attr.qn_options)) {
        odbc_errs_add(&stmt->errs, "HY000", "Attribute ignored");
        stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
    }
    if (found_error && stmt->num_param_rows <= 1)
        stmt->errs.lastrc = SQL_ERROR;
    if (stmt->curr_param_row < stmt->num_param_rows) {
        if (stmt->ipd->header.sql_desc_array_status_ptr)
            stmt->ipd->header.sql_desc_array_status_ptr[stmt->curr_param_row] = param_status;
        ++stmt->curr_param_row;
        if (total_rows == TDS_NO_COUNT)
            total_rows = stmt->row_count;
        else if (stmt->row_count != TDS_NO_COUNT)
            total_rows += stmt->row_count;
        stmt->row_count = TDS_NO_COUNT;
    }
    if (stmt->ipd->header.sql_desc_rows_processed_ptr)
        *stmt->ipd->header.sql_desc_rows_processed_ptr = ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows);
 
    if (total_rows != TDS_NO_COUNT)
        stmt->row_count = total_rows;
 
    odbc_populate_ird(stmt);
    switch (result_type) {
    case TDS_CMD_DONE:
        odbc_unlock_statement(stmt);
        if (stmt->errs.lastrc == SQL_SUCCESS && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3
            && stmt->row_count == TDS_NO_COUNT && !stmt->cursor)
            ODBC_RETURN(stmt, SQL_NO_DATA);
        break;
 
    case TDS_CMD_FAIL:
        /* TODO test what happened, report correct error to client */
        tdsdump_log(TDS_DBG_INFO1, "SQLExecute: bad results\n");
        ODBC_SAFE_ERROR(stmt);
        return SQL_ERROR;
    }
    ODBC_RETURN_(stmt);
}
 
ODBC_FUNC(SQLExecDirect, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
{
    SQLRETURN res;
 
    ODBC_ENTER_HSTMT;
 
    if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide)) {
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        ODBC_EXIT_(stmt);
    }
 
    /* count placeholders */
    /* note: szSqlStr can be no-null terminated, so first we set query and then count placeholders */
    stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
    stmt->param_data_called = 0;
 
    if (SQL_SUCCESS != prepare_call(stmt)) {
        /* TODO return another better error, prepare_call should set error ?? */
        odbc_errs_add(&stmt->errs, "HY000", "Could not prepare call");
        ODBC_EXIT_(stmt);
    }
 
    res = start_parse_prepared_query(stmt, 1);
    if (SQL_SUCCESS != res)
        ODBC_EXIT(stmt, res);
 
    ODBC_EXIT(stmt, _SQLExecute(stmt));
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLExecute(SQLHSTMT hstmt)
{
    ODBC_PRRET_BUF;
    SQLRETURN res;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLExecute(%p)\n", hstmt);
 
    if (!stmt->is_prepared_query) {
        /* TODO error report, only without DM ?? */
        tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns SQL_ERROR (not prepared)\n");
        ODBC_EXIT(stmt, SQL_ERROR);
    }
 
    /* TODO rebuild should be done for every bindings change, not every time */
    /* TODO free previous parameters */
    /* build parameters list */
    stmt->param_data_called = 0;
    stmt->curr_param_row = 0;
    if ((res = start_parse_prepared_query(stmt, 1)) != SQL_SUCCESS) {
        tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s (start_parse_prepared_query failed)\n", odbc_prret(res));
        ODBC_EXIT(stmt, res);
    }
 
    /* TODO test if two SQLPrepare on a statement */
    /* TODO test unprepare on statement free or connection close */
 
    res = _SQLExecute(stmt);
 
    tdsdump_log(TDS_DBG_FUNC, "SQLExecute returns %s\n", odbc_prret(res));
 
    ODBC_EXIT(stmt, res);
}
 
static int
odbc_process_tokens(TDS_STMT * stmt, unsigned flag)
{
    TDS_INT result_type;
        int done_flags = 0;
    TDSSOCKET * tds = stmt->tds;
 
    flag |= TDS_RETURN_DONE | TDS_RETURN_PROC;
    for (;;) {
        TDSRET retcode = tds_process_tokens(tds, &result_type, &done_flags, flag);
        tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: tds_process_tokens returned %d\n", retcode);
        tdsdump_log(TDS_DBG_FUNC, "    result_type=%d, TDS_DONE_COUNT=%x, TDS_DONE_ERROR=%x\n", 
                        result_type, (done_flags & TDS_DONE_COUNT), (done_flags & TDS_DONE_ERROR));
        switch (retcode) {
        case TDS_SUCCESS:
            break;
        case TDS_NO_MORE_RESULTS:
            return TDS_CMD_DONE;
        case TDS_CANCELLED:
            odbc_errs_add(&stmt->errs, "HY008", NULL);
        default:
            return TDS_CMD_FAIL;
        }
 
        switch (result_type) {
        case TDS_STATUS_RESULT:
            odbc_set_return_status(stmt, ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
            break;
        case TDS_PARAM_RESULT:
            odbc_set_return_params(stmt, ODBC_MIN(stmt->curr_param_row, stmt->num_param_rows - 1));
            break;
 
        case TDS_DONE_RESULT:
        case TDS_DONEPROC_RESULT:
            if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
                flag |= TDS_STOPAT_MSG;
            if (done_flags & TDS_DONE_COUNT) {
                /* correct ?? overwrite ?? */
                if (stmt->row_count == TDS_NO_COUNT)
                    stmt->row_count = tds->rows_affected;
            }
            if (done_flags & TDS_DONE_ERROR)
                stmt->errs.lastrc = SQL_ERROR;
            /* test for internal_sp not very fine, used for param set  -- freddy77 */
            if ((done_flags & (TDS_DONE_COUNT|TDS_DONE_ERROR)) != 0
                || (stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO && stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
                || (result_type == TDS_DONEPROC_RESULT && tds->current_op == TDS_OP_EXECUTE)) {
                /* FIXME this row is used only as a flag for update binding, should be cleared if binding/result changed */
                stmt->row = 0;
#if 0
                tds_free_all_results(tds);
                odbc_populate_ird(stmt);
#endif
                tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: row_count=%" PRId64 "\n", stmt->row_count);
                return result_type;
            }
            tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed %s\n", 
                    result_type==TDS_DONE_RESULT? "TDS_DONE_RESULT" : "TDS_DONEPROC_RESULT");
            break;
 
        /*
         * TODO test flags ? check error and change result ?
         * see also other DONEINPROC handle (below)
         */
        case TDS_DONEINPROC_RESULT:
            if (stmt->dbc->env->attr.odbc_version == SQL_OV_ODBC3)
                flag |= TDS_STOPAT_MSG;
            if (done_flags & TDS_DONE_COUNT) {
                stmt->row_count = tds->rows_affected;
            }
            if (done_flags & TDS_DONE_ERROR)
                stmt->errs.lastrc = SQL_ERROR;
            /* TODO perhaps it can be a problem if SET NOCOUNT ON, test it */
#if 0
            tds_free_all_results(tds);
            odbc_populate_ird(stmt);
#endif
            tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: processed TDS_DONEINPROC_RESULT\n");
            if (stmt->row_status == PRE_NORMAL_ROW)
                return result_type;
            break;
 
        default:
            tdsdump_log(TDS_DBG_FUNC, "odbc_process_tokens: returning result_type %d\n", result_type);
            return result_type;
        }
    }
}
 
static void
odbc_fix_data_type_col(TDS_STMT *stmt, int idx)
{
    TDSSOCKET *tds = stmt->tds;
    TDSRESULTINFO *resinfo;
    TDSCOLUMN *colinfo;
 
    if (!tds)
        return;
 
    resinfo = tds->current_results;
    if (!resinfo || resinfo->num_cols <= idx)
        return;
 
    colinfo = resinfo->columns[idx];
    if (colinfo->column_cur_size < 0)
        return;
 
    switch (tds_get_conversion_type(colinfo->column_type, colinfo->column_size)) {
    case SYBINT2: {
        TDS_SMALLINT *data = (TDS_SMALLINT *) colinfo->column_data;
        *data = odbc_swap_datetime_sql_type(*data, 0);
        }
        break;
    case SYBINT4: {
        TDS_INT *data = (TDS_INT *) colinfo->column_data;
        *data = odbc_swap_datetime_sql_type(*data, 0);
        }
        break;
        default:
                break;
    }
}
 
/*
 * - handle correctly SQLGetData (for forward cursors accept only row_size == 1
 *   for other types application must use SQLSetPos)
 * - handle correctly results (SQL_SUCCESS_WITH_INFO if error on some rows,
 *   SQL_ERROR for all rows, see doc)
 */
static SQLRETURN
_SQLFetch(TDS_STMT * stmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
{
    TDSSOCKET *tds;
    TDSRESULTINFO *resinfo;
    TDSCOLUMN *colinfo;
    int i;
    SQLULEN curr_row, num_rows;
        SQLLEN len = 0;
    TDS_CHAR *src;
    int srclen;
    struct _drecord *drec_ard;
    TDS_DESC *ard;
    SQLULEN dummy, *fetched_ptr;
    SQLUSMALLINT *status_ptr, row_status;
    TDS_INT result_type;
    int truncated = 0;
 
#define AT_ROW(ptr, type) (row_offset ? (type*)(((char*)(ptr)) + row_offset) : &ptr[curr_row])
    SQLLEN row_offset = 0;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLFetch(%p, %d, %d)\n", stmt, (int)FetchOrientation, (int)FetchOffset);
 
    if (stmt->ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN && stmt->ard->header.sql_desc_bind_offset_ptr)
        row_offset = *stmt->ard->header.sql_desc_bind_offset_ptr;
 
    ard = stmt->ard;
 
    tds = stmt->tds;
    num_rows = ard->header.sql_desc_array_size;
 
    /* TODO cursor check also type of cursor (scrollable, not forward) */
    if (FetchOrientation != SQL_FETCH_NEXT && (!stmt->cursor || !stmt->dbc->cursor_support)) {
        odbc_errs_add(&stmt->errs, "HY106", NULL);
        return SQL_ERROR;
    }
 
    /* handle cursors, fetch wanted rows */
    if (stmt->cursor && odbc_lock_statement(stmt)) {
        TDSCURSOR *cursor = stmt->cursor;
        TDS_CURSOR_FETCH fetch_type = TDS_CURSOR_FETCH_NEXT;
 
        tds = stmt->tds;
 
        switch (FetchOrientation) {
        case SQL_FETCH_NEXT:
            break;
        case SQL_FETCH_FIRST:
            fetch_type = TDS_CURSOR_FETCH_FIRST;
            break;
        case SQL_FETCH_LAST:
            fetch_type = TDS_CURSOR_FETCH_LAST;
            break;
        case SQL_FETCH_PRIOR:
            fetch_type = TDS_CURSOR_FETCH_PREV;
            break;
        case SQL_FETCH_ABSOLUTE:
            fetch_type = TDS_CURSOR_FETCH_ABSOLUTE;
            break;
        case SQL_FETCH_RELATIVE:
            fetch_type = TDS_CURSOR_FETCH_RELATIVE;
            break;
        /* TODO cursor bookmark */
        default:
            odbc_errs_add(&stmt->errs, "HYC00", NULL);
            return SQL_ERROR;
        }
 
        if (cursor->cursor_rows != num_rows) {
            int send = 0;
            cursor->cursor_rows = num_rows;
            /* TODO handle change rows (tds5) */
            /*
             * TODO curerntly we support cursors only using tds7+
             * so this function can't fail but remember to add error
             * check when tds5 will be supported
             */
            tds_cursor_setrows(tds, cursor, &send);
        }
 
        if (TDS_FAILED(tds_cursor_fetch(tds, cursor, fetch_type, FetchOffset))) {
            /* TODO what kind of error ?? */
            ODBC_SAFE_ERROR(stmt);
            return SQL_ERROR;
        }
 
        /* TODO handle errors in a better way */
        odbc_process_tokens(stmt, TDS_RETURN_ROW|TDS_STOPAT_COMPUTE|TDS_STOPAT_ROW);
        stmt->row_status = PRE_NORMAL_ROW;
    }
 
    if (!tds || stmt->row_status == NOT_IN_ROW) {
        odbc_errs_add(&stmt->errs, "24000", NULL);
        return SQL_ERROR;
    }
    IRD_CHECK;
 
    if (stmt->ird->header.sql_desc_count <= 0) {
        odbc_errs_add(&stmt->errs, "24000", NULL);
        return SQL_ERROR;
    }
 
    stmt->row++;
 
    fetched_ptr = &dummy;
    if (stmt->ird->header.sql_desc_rows_processed_ptr)
        fetched_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    *fetched_ptr = 0;
 
    status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    if (status_ptr) {
                for (i = 0; (SQLULEN) i < num_rows; ++i)
            *status_ptr++ = SQL_ROW_NOROW;
        status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    }
 
    curr_row = 0;
    do {
        row_status = SQL_ROW_SUCCESS;
 
        /* do not get compute row if we are not expecting a compute row */
        switch (stmt->row_status) {
        case AFTER_COMPUTE_ROW:
            /* handle done if needed */
            /* FIXME doesn't seem so fine ... - freddy77 */
            tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
            goto all_done;
 
        case IN_COMPUTE_ROW:
            /* compute recorset contains only a row */
            /* we already fetched compute row in SQLMoreResults so do not fetch another one */
            num_rows = 1;
            stmt->row_status = AFTER_COMPUTE_ROW;
            break;
 
        default:
            /* FIXME stmt->row_count set correctly ?? TDS_DONE_COUNT not checked */
            switch (odbc_process_tokens(stmt, TDS_STOPAT_ROWFMT|TDS_RETURN_ROW|TDS_STOPAT_COMPUTE)) {
            case TDS_ROW_RESULT:
                break;
            default:
#if 0
                stmt->row_count = tds->rows_affected;
#endif
                /* 
                 * NOTE do not set row_status to NOT_IN_ROW, 
                 * if compute tds_process_tokens above returns TDS_NO_MORE_RESULTS
                 */
                stmt->row_status = PRE_NORMAL_ROW;
                stmt->special_row = ODBC_SPECIAL_NONE;
#if 0
                odbc_populate_ird(stmt);
#endif
                tdsdump_log(TDS_DBG_INFO1, "SQLFetch: NO_DATA_FOUND\n");
                goto all_done;
                break;
            case TDS_CMD_FAIL:
                ODBC_SAFE_ERROR(stmt);
                return SQL_ERROR;
                break;
            }
 
            stmt->row_status = IN_NORMAL_ROW;
 
            /* handle special row */
            switch (stmt->special_row) {
            case ODBC_SPECIAL_GETTYPEINFO:
                odbc_fix_data_type_col(stmt, 1);
                break;
            case ODBC_SPECIAL_COLUMNS:
                odbc_fix_data_type_col(stmt, 4);
                odbc_fix_data_type_col(stmt, 13); /* TODO sure ?? */
                break;
            case ODBC_SPECIAL_PROCEDURECOLUMNS:
                odbc_fix_data_type_col(stmt, 5);
                odbc_fix_data_type_col(stmt, 14); /* TODO sure ?? */
                break;
            case ODBC_SPECIAL_SPECIALCOLUMNS:
                odbc_fix_data_type_col(stmt, 2);
                break;
            case ODBC_SPECIAL_NONE:
                break;
            }
        }
 
        resinfo = tds->current_results;
        if (!resinfo) {
            tdsdump_log(TDS_DBG_INFO1, "SQLFetch: !resinfo\n");
            break;
        }
 
        /* we got a row, return a row readed even if error (for ODBC specifications) */
        ++(*fetched_ptr);
        for (i = 0; i < resinfo->num_cols; i++) {
            colinfo = resinfo->columns[i];
            colinfo->column_text_sqlgetdatapos = 0;
            drec_ard = (i < ard->header.sql_desc_count) ? &ard->records[i] : NULL;
            if (!drec_ard)
                continue;
            if (colinfo->column_cur_size < 0) {
                if (drec_ard->sql_desc_indicator_ptr) {
                    *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = SQL_NULL_DATA;
                } else if (drec_ard->sql_desc_data_ptr) {
                    odbc_errs_add(&stmt->errs, "22002", NULL);
                    row_status = SQL_ROW_ERROR;
                    break;
                }
                continue;
            }
            /* set indicator to 0 if data is not null */
            if (drec_ard->sql_desc_indicator_ptr)
                *AT_ROW(drec_ard->sql_desc_indicator_ptr, SQLLEN) = 0;
 
            /* TODO what happen to length if no data is returned (drec->sql_desc_data_ptr == NULL) ?? */
            len = 0;
            if (drec_ard->sql_desc_data_ptr) {
                int c_type;
                TDS_CHAR *data_ptr = (TDS_CHAR *) drec_ard->sql_desc_data_ptr;
 
                src = (TDS_CHAR *) colinfo->column_data;
                srclen = colinfo->column_cur_size;
                colinfo->column_text_sqlgetdatapos = 0;
                c_type = drec_ard->sql_desc_concise_type;
                if (c_type == SQL_C_DEFAULT)
                    c_type = odbc_sql_to_c_type_default(stmt->ird->records[i].sql_desc_concise_type);
                if (row_offset || curr_row == 0) {
                    data_ptr += row_offset;
                } else {
                    data_ptr += odbc_get_octet_len(c_type, drec_ard) * curr_row;
                }
                len = odbc_tds2sql(stmt, colinfo, tds_get_conversion_type(colinfo->on_server.column_type, colinfo->on_server.column_size),
                              src, srclen, c_type, data_ptr, drec_ard->sql_desc_octet_length, drec_ard);
                if (len == SQL_NULL_DATA) {
                    row_status = SQL_ROW_ERROR;
                    break;
                }
                if ((c_type == SQL_C_CHAR && len >= drec_ard->sql_desc_octet_length)
                    || (c_type == SQL_C_BINARY && len > drec_ard->sql_desc_octet_length)) {
                    truncated = 1;
                    stmt->errs.lastrc = SQL_SUCCESS_WITH_INFO;
                }
            }
            if (drec_ard->sql_desc_octet_length_ptr)
                *AT_ROW(drec_ard->sql_desc_octet_length_ptr, SQLLEN) = len;
        }
 
        if (status_ptr)
            *status_ptr++ = truncated ? SQL_ROW_ERROR : row_status;
        if (row_status == SQL_ROW_ERROR) {
            stmt->errs.lastrc = SQL_ERROR;
            break;
        }
#if SQL_BIND_BY_COLUMN != 0
        if (stmt->ard->header.sql_desc_bind_type != SQL_BIND_BY_COLUMN)
#endif
            row_offset += stmt->ard->header.sql_desc_bind_type;
    } while (++curr_row < num_rows);
 
    if (truncated)
        odbc_errs_add(&stmt->errs, "01004", NULL);
 
      all_done:
    /* TODO cursor correct ?? */
    if (stmt->cursor) {
        tds_process_tokens(tds, &result_type, NULL, TDS_TOKEN_TRAILING);
        odbc_unlock_statement(stmt);
    }
    if (*fetched_ptr == 0 && (stmt->errs.lastrc == SQL_SUCCESS || stmt->errs.lastrc == SQL_SUCCESS_WITH_INFO))
        ODBC_RETURN(stmt, SQL_NO_DATA);
    if (stmt->errs.lastrc == SQL_ERROR && (*fetched_ptr > 1 || (*fetched_ptr == 1 && row_status != SQL_ROW_ERROR)))
        ODBC_RETURN(stmt, SQL_SUCCESS_WITH_INFO);
    ODBC_RETURN_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFetch(SQLHSTMT hstmt)
{
    SQLRETURN ret;
    struct {
        SQLULEN  array_size;
        SQLULEN *rows_processed_ptr;
        SQLUSMALLINT *array_status_ptr;
    } keep;
    
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLFetch(%p)\n", hstmt);
 
    keep.array_size = stmt->ard->header.sql_desc_array_size;
    keep.rows_processed_ptr = stmt->ird->header.sql_desc_rows_processed_ptr;
    keep.array_status_ptr = stmt->ird->header.sql_desc_array_status_ptr;
    
    if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
        stmt->ard->header.sql_desc_array_size = 1;
        stmt->ird->header.sql_desc_rows_processed_ptr = NULL;
        stmt->ird->header.sql_desc_array_status_ptr = NULL;
    }
 
    ret = _SQLFetch(stmt, SQL_FETCH_NEXT, 0);
 
    if (stmt->dbc->env->attr.odbc_version != SQL_OV_ODBC3) {
        stmt->ard->header.sql_desc_array_size = keep.array_size;
        stmt->ird->header.sql_desc_rows_processed_ptr = keep.rows_processed_ptr;
        stmt->ird->header.sql_desc_array_status_ptr = keep.array_status_ptr;
    }
 
    ODBC_EXIT(stmt, ret);
}
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFetchScroll(SQLHSTMT hstmt, SQLSMALLINT FetchOrientation, SQLLEN FetchOffset)
{
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLFetchScroll(%p, %d, %d)\n", hstmt, FetchOrientation, (int)FetchOffset);
 
    if (FetchOrientation != SQL_FETCH_NEXT && !stmt->dbc->cursor_support) {
        odbc_errs_add(&stmt->errs, "HY106", NULL);
        ODBC_EXIT_(stmt);
    }
 
    ODBC_EXIT(stmt, _SQLFetch(stmt, FetchOrientation, FetchOffset));
}
#endif
 
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
{
    tdsdump_log(TDS_DBG_INFO1, "SQLFreeHandle(%d, %p)\n", HandleType, (void *) Handle);
 
    switch (HandleType) {
    case SQL_HANDLE_STMT:
        return _SQLFreeStmt(Handle, SQL_DROP, 0);
        break;
    case SQL_HANDLE_DBC:
        return _SQLFreeConnect(Handle);
        break;
    case SQL_HANDLE_ENV:
        return _SQLFreeEnv(Handle);
        break;
    case SQL_HANDLE_DESC:
        return _SQLFreeDesc(Handle);
        break;
    }
    return SQL_ERROR;
}
 
static SQLRETURN
_SQLFreeConnect(SQLHDBC hdbc)
{
    int i;
 
    ODBC_ENTER_HDBC;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLFreeConnect(%p)\n", 
            hdbc);
 
    tds_close_socket(dbc->tds_socket);
 
    /* TODO if connected return error */
    tds_free_socket(dbc->tds_socket);
 
    odbc_bcp_free_storage(dbc);
    /* free attributes */
#ifdef TDS_NO_DM
    tds_dstr_free(&dbc->attr.tracefile);
#endif
    tds_dstr_free(&dbc->attr.current_catalog);
    tds_dstr_free(&dbc->attr.translate_lib);
    tds_dstr_zero(&dbc->oldpwd);
    tds_dstr_free(&dbc->oldpwd);
 
#ifdef ENABLE_ODBC_WIDE
    tds_dstr_free(&dbc->original_charset);
#endif
    tds_dstr_free(&dbc->dsn);
 
    for (i = 0; i < TDS_MAX_APP_DESC; i++) {
        if (dbc->uad[i]) {
            desc_free(dbc->uad[i]);
        }
    }
    odbc_errs_reset(&dbc->errs);
    tds_mutex_unlock(&dbc->mtx);
    tds_mutex_free(&dbc->mtx);
 
    free(dbc);
 
    return SQL_SUCCESS;
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFreeConnect(SQLHDBC hdbc)
{
    tdsdump_log(TDS_DBG_INFO2, "SQLFreeConnect(%p)\n", hdbc);
    return _SQLFreeConnect(hdbc);
}
#endif
 
static SQLRETURN
_SQLFreeEnv(SQLHENV henv)
{
    ODBC_ENTER_HENV;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLFreeEnv(%p)\n", 
            henv);
 
    odbc_errs_reset(&env->errs);
    tds_free_context(env->tds_ctx);
    tds_mutex_unlock(&env->mtx);
    tds_mutex_free(&env->mtx);
    free(env);
 
    return SQL_SUCCESS;
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFreeEnv(SQLHENV henv)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLFreeEnv(%p)\n", henv);
 
    return _SQLFreeEnv(henv);
}
 
static SQLRETURN
_SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption, int force)
{
    TDSSOCKET *tds;
 
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLFreeStmt(%p, %d, %d)\n", hstmt, fOption, force);
 
    /* check if option correct */
    if (fOption != SQL_DROP && fOption != SQL_CLOSE && fOption != SQL_UNBIND && fOption != SQL_RESET_PARAMS) {
        tdsdump_log(TDS_DBG_ERROR, "SQLFreeStmt: Unknown option %d\n", fOption);
        odbc_errs_add(&stmt->errs, "HY092", NULL);
        ODBC_EXIT_(stmt);
    }
 
    /* if we have bound columns, free the temporary list */
    if (fOption == SQL_DROP || fOption == SQL_UNBIND) {
        desc_free_records(stmt->ard);
    }
 
    /* do the same for bound parameters */
    if (fOption == SQL_DROP || fOption == SQL_RESET_PARAMS) {
        desc_free_records(stmt->apd);
        desc_free_records(stmt->ipd);
    }
 
    /* close statement */
    if (fOption == SQL_DROP || fOption == SQL_CLOSE) {
        SQLRETURN retcode;
 
        tds = stmt->tds;
        /*
         * FIXME -- otherwise make sure the current statement is complete
         */
        /* do not close other running query ! */
        if (tds && tds->state != TDS_IDLE && tds->state != TDS_DEAD) {
            if (TDS_SUCCEED(tds_send_cancel(tds)))
                tds_process_cancel(tds);
        }
 
        /* free cursor */
        retcode = odbc_free_cursor(stmt);
        if (!force && retcode != SQL_SUCCESS)
            ODBC_EXIT(stmt, retcode);
    }
 
    /* free it */
    if (fOption == SQL_DROP) {
        SQLRETURN retcode;
 
        /* close prepared statement or add to connection */
        retcode = odbc_free_dynamic(stmt);
        if (!force && retcode != SQL_SUCCESS)
            ODBC_EXIT(stmt, retcode);
 
        /* detatch from list */
        tds_mutex_lock(&stmt->dbc->mtx);
        if (stmt->next)
            stmt->next->prev = stmt->prev;
        if (stmt->prev)
            stmt->prev->next = stmt->next;
        if (stmt->dbc->stmt_list == stmt)
            stmt->dbc->stmt_list = stmt->next;
        tds_mutex_unlock(&stmt->dbc->mtx);
 
        tds_dstr_free(&stmt->query);
        tds_free_param_results(stmt->params);
        odbc_errs_reset(&stmt->errs);
        odbc_unlock_statement(stmt);
        tds_dstr_free(&stmt->cursor_name);
        tds_dstr_free(&stmt->attr.qn_msgtext);
        tds_dstr_free(&stmt->attr.qn_options);
        desc_free(stmt->ird);
        desc_free(stmt->ipd);
        desc_free(stmt->orig_ard);
        desc_free(stmt->orig_apd);
        tds_mutex_unlock(&stmt->mtx);
        tds_mutex_free(&stmt->mtx);
        free(stmt);
 
        /* NOTE we freed stmt, do not use ODBC_EXIT */
        return SQL_SUCCESS;
    }
    ODBC_EXIT_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLFreeStmt(SQLHSTMT hstmt, SQLUSMALLINT fOption)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLFreeStmt(%p, %d)\n", hstmt, fOption);
    return _SQLFreeStmt(hstmt, fOption, 0);
}
 
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLCloseCursor(SQLHSTMT hstmt)
{
    /* TODO cursors */
    /*
     * Basic implementation for when no driver manager is present.
     *  - according to ODBC documentation SQLCloseCursor is more or less
     *    equivalent to SQLFreeStmt(..., SQL_CLOSE).
     *  - indeed that is what the DM does if it can't find the function
     *    in the driver, so this is pretty close.
     */
    /* TODO remember to close cursors really when get implemented */
    /* TODO read all results and discard them or use cancellation ?? test behaviour */
 
    tdsdump_log(TDS_DBG_FUNC, "SQLCloseCursor(%p)\n", hstmt);
    return _SQLFreeStmt(hstmt, SQL_CLOSE, 0);
}
 
static SQLRETURN
_SQLFreeDesc(SQLHDESC hdesc)
{
    ODBC_ENTER_HDESC;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLFreeDesc(%p)\n", 
            hdesc);
 
    if (desc->header.sql_desc_alloc_type != SQL_DESC_ALLOC_USER) {
        odbc_errs_add(&desc->errs, "HY017", NULL);
        ODBC_EXIT_(desc);
    }
 
    if (IS_HDBC(desc->parent)) {
        TDS_DBC *dbc = (TDS_DBC *) desc->parent;
        TDS_STMT *stmt;
        int i;
 
        /* freeing descriptors associated to statements revert state of statements */
        tds_mutex_lock(&dbc->mtx);
        for (stmt = dbc->stmt_list; stmt != NULL; stmt = stmt->next) {
            if (stmt->ard == desc)
                stmt->ard = stmt->orig_ard;
            if (stmt->apd == desc)
                stmt->apd = stmt->orig_apd;
        }
        tds_mutex_unlock(&dbc->mtx);
 
        for (i = 0; i < TDS_MAX_APP_DESC; ++i) {
            if (dbc->uad[i] == desc) {
                dbc->uad[i] = NULL;
                tds_mutex_unlock(&desc->mtx);
                desc_free(desc);
                break;
            }
        }
    }
    return SQL_SUCCESS;
}
 
static SQLRETURN
_SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength WIDE)
{
    void *src;
        SQLINTEGER size;
 
    ODBC_ENTER_HSTMT;
 
    /* TODO assign directly, use macro for size */
    switch (Attribute) {
    case SQL_ATTR_APP_PARAM_DESC:
        size = sizeof(stmt->apd);
        src = &stmt->apd;
        break;
    case SQL_ATTR_APP_ROW_DESC:
        size = sizeof(stmt->ard);
        src = &stmt->ard;
        break;
    case SQL_ATTR_ASYNC_ENABLE:
        size = sizeof(stmt->attr.async_enable);
        src = &stmt->attr.async_enable;
        break;
    case SQL_ATTR_CONCURRENCY:
        size = sizeof(stmt->attr.concurrency);
        src = &stmt->attr.concurrency;
        break;
    case SQL_ATTR_CURSOR_TYPE:
        size = sizeof(stmt->attr.cursor_type);
        src = &stmt->attr.cursor_type;
        break;
    case SQL_ATTR_ENABLE_AUTO_IPD:
        size = sizeof(stmt->attr.enable_auto_ipd);
        src = &stmt->attr.enable_auto_ipd;
        break;
    case SQL_ATTR_FETCH_BOOKMARK_PTR:
        size = sizeof(stmt->attr.fetch_bookmark_ptr);
        src = &stmt->attr.fetch_bookmark_ptr;
        break;
    case SQL_ATTR_KEYSET_SIZE:
        size = sizeof(stmt->attr.keyset_size);
        src = &stmt->attr.keyset_size;
        break;
    case SQL_ATTR_MAX_LENGTH:
        size = sizeof(stmt->attr.max_length);
        src = &stmt->attr.max_length;
        break;
    case SQL_ATTR_MAX_ROWS:
        size = sizeof(stmt->attr.max_rows);
        src = &stmt->attr.max_rows;
        break;
    case SQL_ATTR_METADATA_ID:
        size = sizeof(stmt->attr.metadata_id);
        src = &stmt->attr.noscan;
        break;
    case SQL_ATTR_NOSCAN:
        size = sizeof(stmt->attr.noscan);
        src = &stmt->attr.noscan;
        break;
    case SQL_ATTR_PARAM_BIND_OFFSET_PTR:
        size = sizeof(stmt->apd->header.sql_desc_bind_offset_ptr);
        src = &stmt->apd->header.sql_desc_bind_offset_ptr;
        break;
    case SQL_ATTR_PARAM_BIND_TYPE:
        size = sizeof(stmt->apd->header.sql_desc_bind_type);
        src = &stmt->apd->header.sql_desc_bind_type;
        break;
    case SQL_ATTR_PARAM_OPERATION_PTR:
        size = sizeof(stmt->apd->header.sql_desc_array_status_ptr);
        src = &stmt->apd->header.sql_desc_array_status_ptr;
        break;
    case SQL_ATTR_PARAM_STATUS_PTR:
        size = sizeof(stmt->ipd->header.sql_desc_array_status_ptr);
        src = &stmt->ipd->header.sql_desc_array_status_ptr;
        break;
    case SQL_ATTR_PARAMS_PROCESSED_PTR:
        size = sizeof(stmt->ipd->header.sql_desc_rows_processed_ptr);
        src = &stmt->ipd->header.sql_desc_rows_processed_ptr;
        break;
    case SQL_ATTR_PARAMSET_SIZE:
        size = sizeof(stmt->apd->header.sql_desc_array_size);
        src = &stmt->apd->header.sql_desc_array_size;
        break;
    case SQL_ATTR_QUERY_TIMEOUT:
        size = sizeof(stmt->attr.query_timeout);
        src = &stmt->attr.query_timeout;
        break;
    case SQL_ATTR_RETRIEVE_DATA:
        size = sizeof(stmt->attr.retrieve_data);
        src = &stmt->attr.retrieve_data;
        break;
    case SQL_ATTR_ROW_BIND_OFFSET_PTR:
        size = sizeof(stmt->ard->header.sql_desc_bind_offset_ptr);
        src = &stmt->ard->header.sql_desc_bind_offset_ptr;
        break;
#if SQL_BIND_TYPE != SQL_ATTR_ROW_BIND_TYPE
    case SQL_BIND_TYPE: /* although this is ODBC2 we must support this attribute */
#endif
    case SQL_ATTR_ROW_BIND_TYPE:
        size = sizeof(stmt->ard->header.sql_desc_bind_type);
        src = &stmt->ard->header.sql_desc_bind_type;
        break;
    case SQL_ATTR_ROW_NUMBER:
        /* TODO do not get info every time, cache somewhere */
        if (stmt->cursor && odbc_lock_statement(stmt)) {
            TDS_UINT row_number, row_count;
 
            tds_cursor_get_cursor_info(stmt->tds, stmt->cursor, &row_number, &row_count);
            stmt->attr.row_number = row_number;
        }
        size = sizeof(stmt->attr.row_number);
        src = &stmt->attr.row_number;
        break;
    case SQL_ATTR_ROW_OPERATION_PTR:
        size = sizeof(stmt->ard->header.sql_desc_array_status_ptr);
        src = &stmt->ard->header.sql_desc_array_status_ptr;
        break;
    case SQL_ATTR_ROW_STATUS_PTR:
        size = sizeof(stmt->ird->header.sql_desc_array_status_ptr);
        src = &stmt->ird->header.sql_desc_array_status_ptr;
        break;
    case SQL_ATTR_ROWS_FETCHED_PTR:
        size = sizeof(stmt->ird->header.sql_desc_rows_processed_ptr);
        src = &stmt->ird->header.sql_desc_rows_processed_ptr;
        break;
    case SQL_ATTR_ROW_ARRAY_SIZE:
        size = sizeof(stmt->ard->header.sql_desc_array_size);
        src = &stmt->ard->header.sql_desc_array_size;
        break;
    case SQL_ATTR_SIMULATE_CURSOR:
        size = sizeof(stmt->attr.simulate_cursor);
        src = &stmt->attr.simulate_cursor;
        break;
    case SQL_ATTR_USE_BOOKMARKS:
        size = sizeof(stmt->attr.use_bookmarks);
        src = &stmt->attr.use_bookmarks;
        break;
    case SQL_ATTR_CURSOR_SCROLLABLE:
        size = sizeof(stmt->attr.cursor_scrollable);
        src = &stmt->attr.cursor_scrollable;
        break;
    case SQL_ATTR_CURSOR_SENSITIVITY:
        size = sizeof(stmt->attr.cursor_sensitivity);
        src = &stmt->attr.cursor_sensitivity;
        break;
    case SQL_ATTR_IMP_ROW_DESC:
        size = sizeof(stmt->ird);
        src = &stmt->ird;
        break;
    case SQL_ATTR_IMP_PARAM_DESC:
        size = sizeof(stmt->ipd);
        src = &stmt->ipd;
        break;
    case SQL_ROWSET_SIZE:   /* although this is ODBC2 we must support this attribute */
        size = sizeof(stmt->sql_rowset_size);
        src = &stmt->sql_rowset_size;
        break;
    case SQL_SOPT_SS_QUERYNOTIFICATION_TIMEOUT:
        size = sizeof(stmt->attr.qn_timeout);
        src = &stmt->attr.qn_timeout;
        break;
    case SQL_SOPT_SS_QUERYNOTIFICATION_MSGTEXT:
        {
            SQLRETURN rc = odbc_set_string_oct(stmt->dbc, Value, BufferLength, StringLength, tds_dstr_cstr(&stmt->attr.qn_msgtext), tds_dstr_len(&stmt->attr.qn_msgtext));
            ODBC_EXIT(stmt, rc);
        }
    case SQL_SOPT_SS_QUERYNOTIFICATION_OPTIONS:
        {
            SQLRETURN rc = odbc_set_string_oct(stmt->dbc, Value, BufferLength, StringLength, tds_dstr_cstr(&stmt->attr.qn_options), tds_dstr_len(&stmt->attr.qn_options));
            ODBC_EXIT(stmt, rc);
        }
        /* TODO SQL_COLUMN_SEARCHABLE, although ODBC2 */
    default:
        odbc_errs_add(&stmt->errs, "HY092", NULL);
        ODBC_EXIT_(stmt);
    }
 
    memcpy(Value, src, size);
    if (StringLength)
        *StringLength = size;
 
    ODBC_EXIT_(stmt);
}
 
#if (ODBCVER >= 0x0300)
SQLRETURN ODBC_PUBLIC ODBC_API
SQLGetStmtAttr(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n", 
            hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
 
    return _SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength _wide0);
}
 
#ifdef ENABLE_ODBC_WIDE
SQLRETURN ODBC_PUBLIC ODBC_API
SQLGetStmtAttrW(SQLHSTMT hstmt, SQLINTEGER Attribute, SQLPOINTER Value, SQLINTEGER BufferLength, SQLINTEGER * StringLength)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtAttr(%p, %d, %p, %d, %p)\n",
            hstmt, (int)Attribute, Value, (int)BufferLength, StringLength);
 
    return _SQLGetStmtAttr(hstmt, Attribute, Value, BufferLength, StringLength, 1);
}
#endif
#endif
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLGetStmtOption(SQLHSTMT hstmt, SQLUSMALLINT fOption, SQLPOINTER pvParam)
{
    tdsdump_log(TDS_DBG_FUNC, "SQLGetStmtOption(%p, %d, %p)\n", 
            hstmt, fOption, pvParam);
 
    return _SQLGetStmtAttr(hstmt, (SQLINTEGER) fOption, pvParam, SQL_MAX_OPTION_STRING_LENGTH, NULL _wide0);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLNumResultCols(SQLHSTMT hstmt, SQLSMALLINT FAR * pccol)
{
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "SQLNumResultCols(%p, %p)\n", 
            hstmt, pccol);
 
    /*
     * 3/15/2001 bsb - DBD::ODBC calls SQLNumResultCols on non-result
     * generating queries such as 'drop table'
     */
#if 0
    if (stmt->row_status == NOT_IN_ROW) {
        odbc_errs_add(&stmt->errs, "24000", NULL);
        ODBC_EXIT_(stmt);
    }
#endif
    IRD_UPDATE(stmt->ird, &stmt->errs, ODBC_EXIT(stmt, SQL_ERROR));
    *pccol = stmt->ird->header.sql_desc_count;
    ODBC_EXIT_(stmt);
}
 
ODBC_FUNC(SQLPrepare, (P(SQLHSTMT,hstmt), PCHARIN(SqlStr,SQLINTEGER) WIDE))
{
    SQLRETURN retcode;
 
    ODBC_ENTER_HSTMT;
 
    /* try to free dynamic associated */
    retcode = odbc_free_dynamic(stmt);
    if (retcode != SQL_SUCCESS)
        ODBC_EXIT(stmt, retcode);
 
    if (SQL_SUCCESS != odbc_set_stmt_query(stmt, szSqlStr, cbSqlStr _wide))
        ODBC_EXIT(stmt, SQL_ERROR);
    stmt->is_prepared_query = 1;
 
    /* count parameters */
    stmt->param_count = tds_count_placeholders(tds_dstr_cstr(&stmt->query));
 
    /* trasform to native (one time, not for every SQLExecute) */
    if (SQL_SUCCESS != prepare_call(stmt))
        ODBC_EXIT(stmt, SQL_ERROR);
 
    /* TODO needed ?? */
    tds_release_dynamic(&stmt->dyn);
 
    /* try to prepare query */
    /* TODO support getting info for RPC */
    if (!stmt->prepared_query_is_rpc
         && (stmt->attr.cursor_type == SQL_CURSOR_FORWARD_ONLY && stmt->attr.concurrency == SQL_CONCUR_READ_ONLY)) {
 
        tds_free_param_results(stmt->params);
        stmt->params = NULL;
        stmt->param_num = 0;
        stmt->need_reprepare = 0;
        /*
         * using TDS7+ we need parameters to prepare a query so try
         * to get them 
         * TDS5 do not need parameters type and we have always to
         * prepare sepatarely so this is not an issue
         */
        if (IS_TDS7_PLUS(stmt->dbc->tds_socket->conn)) {
            stmt->need_reprepare = 1;
            ODBC_EXIT_(stmt);
        }
 
        tdsdump_log(TDS_DBG_INFO1, "Creating prepared statement\n");
        if (odbc_lock_statement(stmt))
            odbc_prepare(stmt);
    }
 
    ODBC_EXIT_(stmt);
}
 
/* TDS_NO_COUNT must be -1 for SQLRowCount to return -1 when there is no rowcount */
#if TDS_NO_COUNT != -1
# error TDS_NO_COUNT != -1
#endif
    
SQLRETURN
_SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
{
    ODBC_ENTER_HSTMT;
 
    tdsdump_log(TDS_DBG_FUNC, "_SQLRowCount(%p, %p),  %ld rows \n", hstmt, pcrow, (long)stmt->row_count);
 
    *pcrow = stmt->row_count;
 
    ODBC_EXIT_(stmt);
}
 
SQLRETURN ODBC_PUBLIC ODBC_API
SQLRowCount(SQLHSTMT hstmt, SQLLEN FAR * pcrow)
{
    SQLRETURN rc = _SQLRowCount(hstmt, pcrow);
    tdsdump_log(TDS_DBG_INFO1, "SQLRowCount returns %d, row count %ld\n", rc, (long int) *pcrow);
    return rc;
}
 
ODBC_FUNC(SQLSetCursorName, (P(SQLHSTMT,hstmt), PCHARIN(Cursor,SQLSMALLINT) WIDE))
{
    ODBC_ENTER_HSTMT;
 
    /* cursor already present, we cannot set name */
    if (stmt->cursor) {
        odbc_errs_add(&stmt->errs, "24000", NULL);
        ODBC_EXIT_(stmt);
    }
 
    if (!odbc_dstr_copy(stmt->dbc, &stmt->cursor_name, cbCursor, szCursor)) {
        odbc_errs_add(&stmt->errs, "HY001", NULL);
        ODBC_EXIT_(stmt);
    }
    ODBC_EXIT_(stmt);
}
 
ODBC_FUNC(SQLGetCursorName, (P(SQLHSTMT,hstmt), PCHAROUT(Cursor,SQLSMALLINT) WIDE))
{
    SQLRETURN rc;
 
    ODBC_ENTER_HSTMT;
 
    if ((rc = odbc_set_string(stmt->dbc, szCursor, cbCursorMax, pcbCursor, tds_dstr_cstr(&stmt->cursor_name), -1)))
        odbc_errs_add(&stmt->errs, "01004", NULL);
 
    ODBC_EXIT(stmt, rc);
}
 
/*
 * spinellia@acm.org : copied shamelessly from change_database
 * transaction support
 * 1 = commit, 0 = rollback
 */
static SQLRETURN
change_transaction(TDS_DBC * dbc, int state)
{
    TDSSOCKET *tds = dbc->tds_socket;
    int cont;
    TDSRET ret;
 
    tdsdump_log(TDS_DBG_INFO1, "change_transaction(0x%p,%d)\n", dbc, state);
 
    if (dbc->attr.autocommit == SQL_AUTOCOMMIT_ON)
        cont = 0;
    else
        cont = 1;
 
    /* if pending drop all recordset, don't issue cancel */
    if