Cppcheck report - GATE C/C++ Framework: gate/data/odbc_adapter.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2026, Stefan Meislinger                                  |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/
#include "gate/data/odbc_adapter.h"
#include "gate/results.h"
#include "gate/libraries.h"
#include "gate/arrays.h"
#include "gate/debugging.h"
#include "gate/guids.h"
#include "gate/times.h"
#include "gate/data/adapter_base.h"

#if defined(GATE_DATA_ODBC_ENABLED)
#   if !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WINSTORE) && !defined(GATE_SYS_ANDROID) && !defined(GATE_SYS_DOS) && !defined(GATE_SYS_EFI) && !defined(GATE_SYS_OPENBSD) && !defined(GATE_SYS_WASM) && !defined(GATE_SYS_BEOS)
#       define GATE_DATA_ODBC_IMPL
#   endif
#endif


#ifdef GATE_DATA_ODBC_IMPL

#include "gate/platforms.h"
#include <sql.h>
#include <sqlext.h>

#if defined(GATE_COMPILER_MSVC98)
#   ifdef _WIN64
typedef INT64 SQLLEN;
typedef UINT64 SQLULEN;
#   else
#       define SQLLEN SQLINTEGER
#       define SQLULEN SQLUINTEGER
#   endif
#endif

typedef struct gate_odbc_functions
{
    SQLRETURN(SQL_API* AllocConnect)(SQLHENV EnvironmentHandle, SQLHDBC* ConnectionHandle);
    SQLRETURN(SQL_API* FreeEnv)(SQLHENV EnvironmentHandle);
    SQLRETURN(SQL_API* Connect)(SQLHDBC ConnectionHandle, SQLTCHAR* ServerName, SQLSMALLINT NameLength1,
        SQLTCHAR* UserName, SQLSMALLINT NameLength2, SQLTCHAR* Authentication, SQLSMALLINT NameLength3);
    SQLRETURN(SQL_API* FreeConnect)(SQLHDBC ConnectionHandle);
    SQLRETURN(SQL_API* Disconnect)(SQLHDBC ConnectionHandle);
    SQLRETURN(SQL_API* AllocStmt)(SQLHDBC ConnectionHandle, SQLHSTMT* StatementHandle);
    SQLRETURN(SQL_API* Fetch)(SQLHSTMT StatementHandle);
    SQLRETURN(SQL_API* FreeStmt)(SQLHSTMT StatementHandle, SQLUSMALLINT Option);
    SQLRETURN(SQL_API* GetData)(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber,
        SQLSMALLINT TargetType, SQLPOINTER TargetValue, SQLLEN BufferLength, SQLLEN* StrLen_or_Ind);
    SQLRETURN(SQL_API* DescribeCol)(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber, SQLTCHAR* ColumnName,
        SQLSMALLINT BufferLength, SQLSMALLINT* NameLength, SQLSMALLINT* DataType,
        SQLULEN* ColumnSize, SQLSMALLINT* DecimalDigits, SQLSMALLINT* Nullable);
    SQLRETURN(SQL_API* AllocEnv)(SQLHENV* EnvironmentHandle);
    SQLRETURN(SQL_API* SetEnvAttr)(SQLHENV EnvironmentHandle, SQLINTEGER Attribute, SQLPOINTER ValuePtr, SQLINTEGER StringLength);
    SQLRETURN(SQL_API* Prepare)(SQLHSTMT StatementHandle, SQLTCHAR* StatementText, SQLINTEGER TextLength);
    SQLRETURN(SQL_API* Execute)(SQLHSTMT StatementHandle);
    SQLRETURN(SQL_API* GetDiagRec)(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber, SQLTCHAR* Sqlstate,
        SQLINTEGER* NativeError, SQLTCHAR* MessageText, SQLSMALLINT BufferLength, SQLSMALLINT* TextLength);
    SQLRETURN(SQL_API* NumResultCols)(SQLHSTMT StatementHandle, SQLSMALLINT* ColumnCount);
    SQLRETURN(SQL_API* BindParameter)(SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType,
        SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN* pcbValue);
    SQLRETURN(SQL_API* NumParams)(SQLHSTMT StatementHandle, SQLSMALLINT* ParameterCountPtr);
    SQLRETURN(SQL_API* RowCount)(SQLHSTMT StatementHandle, SQLLEN* RowCount);
} gate_odbc_functions_t;

static gate_odbc_functions_t SQL = GATE_INIT_EMPTY;

#if defined(GATE_SYS_WIN)
static const gate_string_t lib_name = GATE_STRING_INIT_STATIC("odbc32");
#else
static const gate_string_t lib_name = GATE_STRING_INIT_STATIC("libodbc.so");
#endif

#define Name_AllocConnect   "SQLAllocConnect"
#define Name_FreeEnv        "SQLFreeEnv"
#define Name_FreeConnect    "SQLFreeConnect"
#define Name_Disconnect     "SQLDisconnect"
#define Name_AllocStmt      "SQLAllocStmt"
#define Name_Fetch          "SQLFetch"
#define Name_FreeStmt       "SQLFreeStmt"
#define Name_GetData        "SQLGetData"
#define Name_AllocEnv       "SQLAllocEnv"
#define Name_Execute        "SQLExecute"
#define Name_NumResultCols  "SQLNumResultCols"
#define Name_BindParameter  "SQLBindParameter"
#define Name_NumParams      "SQLNumParams"
#define Name_RowCount       "SQLRowCount"
#define Name_SetEnvAttr     "SQLSetEnvAttr"


#if defined(GATE_WIN32_UNICODE)
#   define Name_Connect     "SQLConnectW"
#   define Name_DescribeCol "SQLDescribeColW"
#   define Name_Prepare     "SQLPrepareW"
#   define Name_GetDiagRec  "SQLGetDiagRecW"
#else
#   define Name_Connect     "SQLConnect"
#   define Name_DescribeCol "SQLDescribeCol"
#   define Name_Prepare     "SQLPrepare"
#   define Name_GetDiagRec  "SQLGetDiagRec"
#endif

static gate_result_t load_odbc_functions()
{
    static gate_library_t odbc_lib = NULL;
    gate_result_t ret;
    gate_library_t lib = NULL;

    do
    {
        if (odbc_lib != NULL)
        {
            ret = GATE_RESULT_OK;
            break;
        }

        ret = gate_library_open(&lib_name, &lib, 0);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_library_get_function_name(lib, Name_AllocConnect, &SQL.AllocConnect);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_FreeEnv, &SQL.FreeEnv);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_FreeConnect, &SQL.FreeConnect);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_Disconnect, &SQL.Disconnect);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_AllocStmt, &SQL.AllocStmt);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_Fetch, &SQL.Fetch);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_FreeStmt, &SQL.FreeStmt);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_GetData, &SQL.GetData);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_AllocEnv, &SQL.AllocEnv);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_Execute, &SQL.Execute);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_NumResultCols, &SQL.NumResultCols);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_Connect, &SQL.Connect);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_DescribeCol, &SQL.DescribeCol);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_Prepare, &SQL.Prepare);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_GetDiagRec, &SQL.GetDiagRec);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_BindParameter, &SQL.BindParameter);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_NumParams, &SQL.NumParams);
        GATE_BREAK_IF_FAILED(ret);
        ret = gate_library_get_function_name(lib, Name_RowCount, &SQL.RowCount);
        GATE_BREAK_IF_FAILED(ret);

        /* optional functions */
        ret = gate_library_get_function_name(lib, Name_SetEnvAttr, &SQL.SetEnvAttr);<--- Variable 'ret' is reassigned a value before the old one has been used.

        odbc_lib = lib;
        lib = NULL;
        ret = GATE_RESULT_OK;<--- Variable 'ret' is reassigned a value before the old one has been used.
    } while (0);

    if (lib != NULL)
    {
        gate_library_close(lib);
    }

    return ret;
}



static gate_bool_t gate_data_reader_odbc_is_valid(gate_data_reader_base_t* reader)
{
    SQLHSTMT stmt = (SQLHSTMT)reader->native_handles[0];
    return stmt != NULL;
}

static gate_result_t gate_data_reader_odbc_close(gate_data_reader_base_t* reader)
{
    reader->native_handles[0] = NULL;
    return GATE_RESULT_OK;
}

static SQLSMALLINT gate_data_reader_odbc_patch_sql_type(SQLSMALLINT defined_type)
{
    /* some types are defined but in SQLGetData another type must be used */
    switch (defined_type)
    {
    case SQL_DECIMAL:
    case SQL_NUMERIC:
    case SQL_CHAR:
    case SQL_VARCHAR:
    case SQL_LONGVARCHAR:   return SQL_CHAR;
    case SQL_WVARCHAR:
    case SQL_WLONGVARCHAR:  return SQL_WCHAR;
    default: break;
    }
    return defined_type;
}

static gate_value_t* gate_data_reader_odbc_get_value(SQLHSTMT hstmt, SQLUSMALLINT index, SQLSMALLINT sql_type, gate_value_t* value)
{
    gate_value_t* ret = NULL;
    char buffer[8192] = GATE_INIT_EMPTY;
    SQLLEN buffer_used = 0;
    SQLRETURN sql_res;
    gate_bool_t bool_val;
    gate_strbuilder_t text_builder = GATE_INIT_EMPTY;
    gate_string_t text = GATE_STRING_INIT_EMPTY;
    gate_array_t arr = GATE_INIT_EMPTY;
    SQLGUID const* ptr_sql_guid = NULL;
    gate_guid_t guid;
    DATE_STRUCT const* ptr_date_struct = NULL;
    TIME_STRUCT const* ptr_time_struct = NULL;
    TIMESTAMP_STRUCT const* ptr_timestamp_struct = NULL;
    gate_datetime_t dt;

    sql_type = gate_data_reader_odbc_patch_sql_type(sql_type);

    sql_res = SQL.GetData(hstmt, index, sql_type, buffer, sizeof(buffer), &buffer_used);
    switch (sql_res)
    {
    case SQL_SUCCESS:
    case SQL_NO_DATA:
    case SQL_SUCCESS_WITH_INFO:
        {
            /* OK, continue */
            break;
        }
    default:
        {
            /* error case */
            return ret;
        }
    }

    switch (sql_type)
    {
    case SQL_C_STINYINT:
    case SQL_TINYINT: { ret = gate_value_create(GATE_TYPE_I8, buffer, value); break; }
    case SQL_C_SSHORT:
    case SQL_SMALLINT: { ret = gate_value_create(GATE_TYPE_I16, buffer, value); break; }
    case SQL_C_SLONG:
    case SQL_INTEGER: { ret = gate_value_create(GATE_TYPE_I32, buffer, value); break; }
    case SQL_C_SBIGINT:
    case SQL_BIGINT: { ret = gate_value_create(GATE_TYPE_I64, buffer, value); break; }
    case SQL_REAL: { ret = gate_value_create(GATE_TYPE_R32, buffer, value); break; }
    case SQL_FLOAT: { ret = gate_value_create(GATE_TYPE_R32, buffer, value); break; }
    case SQL_DOUBLE: { ret = gate_value_create(GATE_TYPE_R64, buffer, value); break; }
    case SQL_C_UTINYINT: { ret = gate_value_create(GATE_TYPE_UI8, buffer, value); break; }
    case SQL_C_USHORT: { ret = gate_value_create(GATE_TYPE_UI16, buffer, value); break; }
    case SQL_C_ULONG: { ret = gate_value_create(GATE_TYPE_UI32, buffer, value); break; }
    case SQL_C_UBIGINT: { ret = gate_value_create(GATE_TYPE_UI64, buffer, value); break; }
    case SQL_BIT:
        {
            bool_val = buffer[0] == 0 ? false : true;
            ret = gate_value_create(GATE_TYPE_BOOL, &bool_val, value);
            break;
        }

    case SQL_DECIMAL:
    case SQL_NUMERIC:
    case SQL_CHAR:
    case SQL_VARCHAR:
    case SQL_LONGVARCHAR:
        {
            /* extract byte data */
            gate_strbuilder_create(&text_builder, 0);
            gate_strbuilder_append_text(&text_builder, &buffer[0], buffer_used);
            while (sql_res == SQL_SUCCESS_WITH_INFO)
            {
                sql_res = SQL.GetData(hstmt, index, sql_type, buffer, sizeof(buffer), &buffer_used);
                gate_strbuilder_append_text(&text_builder, &buffer[0], buffer_used);
            }
            gate_strbuilder_to_string(&text_builder, &text);
            ret = gate_value_create(GATE_TYPE_STRING, &text, value);
            gate_string_release(&text);
            gate_strbuilder_release(&text_builder);
            break;
        }
    case SQL_WCHAR:
    case SQL_WVARCHAR:
    case SQL_WLONGVARCHAR:
        {
            /* extract UTF16 text */
            gate_strbuilder_create(&text_builder, 0);
            gate_strbuilder_append_text16(&text_builder, (gate_char16_t const*)&buffer[0], buffer_used / sizeof(gate_char16_t));
            while (sql_res == SQL_SUCCESS_WITH_INFO)
            {
                sql_res = SQL.GetData(hstmt, index, sql_type, buffer, sizeof(buffer), &buffer_used);
                gate_strbuilder_append_text16(&text_builder, (gate_char16_t const*)&buffer[0], buffer_used / sizeof(gate_char16_t));
            }
            gate_strbuilder_to_string(&text_builder, &text);
            ret = gate_value_create(GATE_TYPE_STRING, &text, value);
            gate_string_release(&text);
            gate_strbuilder_release(&text_builder);
            break;
        }
    case SQL_BINARY:
    case SQL_VARBINARY:
    case SQL_LONGVARBINARY:
        {
            gate_arraylist_t arrlst = gate_arraylist_create(1, buffer, buffer_used, NULL, NULL);
            if (!gate_arraylist_is_null(arrlst))
            {
                while (sql_res == SQL_SUCCESS_WITH_INFO)
                {
                    sql_res = SQL.GetData(hstmt, index, sql_type, buffer, sizeof(buffer), &buffer_used);
                    gate_arraylist_add_n(arrlst, buffer, buffer_used);
                }
                if (NULL != gate_array_create(&arr, arrlst))
                {
                    ret = gate_value_create(GATE_TYPE_ARRAY, &arr, value);
                    gate_array_release(&arr);
                }
                gate_arraylist_release(&arrlst);
            }
            break;
        }
    case SQL_GUID:
        {
            ptr_sql_guid = (SQLGUID const*)&buffer[0];
            guid.item1 = ptr_sql_guid->Data1;
            guid.item2 = ptr_sql_guid->Data2;
            guid.item3 = ptr_sql_guid->Data3;
            gate_mem_copy(guid.item4, ptr_sql_guid->Data4, 8);
            ret = gate_value_create(GATE_TYPE_GUID, &guid, value);
            break;
        }
    case SQL_TYPE_DATE:
        {
            ptr_date_struct = (DATE_STRUCT const*)&buffer[0];
            dt.date.year = ptr_date_struct->year;
            dt.date.month = (gate_uint8_t)ptr_date_struct->month;
            dt.date.day = (gate_uint8_t)ptr_date_struct->day;
            ret = gate_value_create(GATE_TYPE_DATE, &dt.date, value);
            break;
        }
    case SQL_TYPE_TIME:
        {
            ptr_time_struct = (TIME_STRUCT const*)&buffer[0];
            dt.time.hour = (gate_uint8_t)ptr_time_struct->hour;
            dt.time.minute = (gate_uint8_t)ptr_time_struct->minute;
            dt.time.second = (gate_uint8_t)ptr_time_struct->second;
            dt.time.microsecond = 0;
            ret = gate_value_create(GATE_TYPE_DAYTIME, &dt.time, value);
            break;
        }
    case SQL_TYPE_TIMESTAMP:
        {
            ptr_timestamp_struct = (TIMESTAMP_STRUCT const*)&buffer[0];
            dt.date.year = ptr_timestamp_struct->year;
            dt.date.month = (gate_uint8_t)ptr_timestamp_struct->month;
            dt.date.day = (gate_uint8_t)ptr_timestamp_struct->day;
            dt.time.hour = (gate_uint8_t)ptr_timestamp_struct->hour;
            dt.time.minute = (gate_uint8_t)ptr_timestamp_struct->minute;
            dt.time.second = (gate_uint8_t)ptr_timestamp_struct->second;
            dt.time.microsecond = ptr_timestamp_struct->fraction / 1000;    /*fraction == nanoseconds */
            ret = gate_value_create(GATE_TYPE_DAYTIME, &dt.time, value);
            break;
        }
    default:
        {
            /* not supported */
            break;
        }
    }

    return ret;
}

static gate_result_t gate_data_reader_odbc_next(gate_data_reader_base_t* reader)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    SQLHSTMT hstmt = (SQLHSTMT)reader->native_handles[0];
    SQLRETURN sql_res;
    gate_size_t ndx;

    do
    {
        if (hstmt == NULL)
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        sql_res = SQL.Fetch(hstmt);
        if (SQL_NO_DATA == sql_res)
        {
            gate_data_reader_base_close(reader);
            ret = GATE_RESULT_ENDOFSTREAM;
            break;
        }
        if (SQL_SUCCESS != sql_res)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

        ret = GATE_RESULT_OK;
        for (ndx = 0; ndx != reader->field_count; ++ndx)
        {
            gate_value_release(&reader->values[ndx]);
            gate_data_reader_odbc_get_value(hstmt, (SQLUSMALLINT)(ndx + 1), (SQLUSMALLINT)reader->types[ndx], &reader->values[ndx]);
        }

    } while (0);

    return ret;
}


static gate_result_t gate_data_reader_odbc_init(gate_data_reader_base_t* reader)
{
    gate_result_t ret = GATE_RESULT_OK;
    SQLSMALLINT col_count = 0;
    SQLSMALLINT col_index;
    SQLRETURN sql_ret;
    SQLHSTMT hstmt = (SQLHSTMT)reader->native_handles[0];
    SQLTCHAR colname[1024];
    SQLSMALLINT colname_len;
    SQLSMALLINT coltype;
    SQLULEN colvalue_len;
    SQLSMALLINT colvalue_digits;
    SQLSMALLINT colvalue_nullable;

    do
    {
        sql_ret = SQL.NumResultCols(hstmt, &col_count);
        if (SQL_SUCCESS != sql_ret)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
        reader->field_count = col_count;

        for (col_index = 0; col_index != col_count; ++col_index)
        {
            colname_len = sizeof(colname) / sizeof(colname[0]);
            coltype = 0;
            colvalue_len = 0;
            colvalue_digits = 0;
            colvalue_nullable = 0;
            sql_ret = SQL.DescribeCol(hstmt, (SQLUSMALLINT)(col_index + 1), colname, colname_len, &colname_len,
                &coltype, &colvalue_len, &colvalue_digits, &colvalue_nullable);
#if defined(GATE_SYS_WIN)
            gate_win32_winstr_2_utf8_string((LPCTSTR)&colname[0], colname_len, &reader->names[col_index]);
#else
            gate_string_create(&reader->names[col_index], (char const*)&colname[0], colname_len);
#endif
            reader->types[col_index] = coltype;
        }
    } while (0);

    return ret;
}


static gate_data_reader_t* gate_data_reader_odbc_create(gate_data_statement_base_t* ptr_statement, SQLHSTMT stmt)
{
    gate_data_reader_t* ret = NULL;
    gate_data_handles_t handles = GATE_INIT_EMPTY;

    handles[0] = (void*)stmt;

    ret = gate_data_reader_base_create(
        (gate_data_statement_t*)ptr_statement, handles,
        &gate_data_reader_odbc_init,
        &gate_data_reader_odbc_is_valid,
        &gate_data_reader_odbc_next,
        &gate_data_reader_odbc_close);

    return ret;
}

typedef union odbc_param_value {
    SQLINTEGER sql_int;
    SQLBIGINT sql_bigint;
    SQLDOUBLE sql_double;
    SQL_TIMESTAMP_STRUCT sql_timestamp;
    gate_string_t text;
    gate_blob_t blob;
} odbc_param_value_t;

typedef struct odbc_param {
    SQLSMALLINT         index;  /* parameter index*/
    odbc_param_value_t  value;  /* assigned value to parameter */
    gate_mem_dtor_t     dtor;   /* destructor of value */
    SQLLEN              length; /* bind-length of value */
} odbc_param_t;

static void GATE_CALL odbc_param_dtor(void* dest)
{
    odbc_param_t* const ptr = (odbc_param_t*)dest;
    if (ptr->dtor)
    {
        ptr->dtor(&ptr->value);
        ptr->dtor = NULL;
    }
    gate_mem_clear(ptr, sizeof(odbc_param_t));
}

static odbc_param_t* odbc_param_get(gate_slotlist_t* param_cache, SQLSMALLINT paramIndex)
{
    gate_slotlist_iterator_t iter;
    void* cache_item;
    odbc_param_t* ptr_param;
    cache_item = gate_slotlist_first(param_cache, &iter);
    /* search already existing paramIndex */
    while (cache_item != NULL)
    {   
        ptr_param = (odbc_param_t*)cache_item;
        if (ptr_param->index == paramIndex)
        {
            /* clean-up previous value fields */
            odbc_param_dtor(ptr_param);
            /* re-init empty value with index*/
            ptr_param->index = paramIndex;
            return ptr_param;
        }
        cache_item = gate_slotlist_next(param_cache, &iter);
    }
    /* paramIndex does not exist -> create new entry */
    ptr_param = (odbc_param_t*)gate_mem_alloc(sizeof(odbc_param_t));
    if (NULL != ptr_param)
    {
        gate_mem_clear(ptr_param, sizeof(odbc_param_t));
        ptr_param->index = paramIndex;
        gate_slotlist_import(param_cache, ptr_param);
    }
    return ptr_param;
}

static gate_result_t odbcstmt_init(gate_data_statement_base_t* self)
{
    gate_slotlist_t* ptr_slots = (gate_slotlist_t*)gate_mem_alloc(sizeof(gate_slotlist_t));
    if (ptr_slots == NULL) 
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    if (NULL == gate_slotlist_create(ptr_slots, sizeof(odbc_param_t), NULL, &odbc_param_dtor))
    {
        gate_mem_dealloc(ptr_slots);
        return GATE_RESULT_OUTOFMEMORY;
    }
    self->native_handles[2] = (void*)ptr_slots;
    return GATE_RESULT_OK;
}

static void odbcstmt_close(gate_data_statement_base_t* self)
{
    SQLHSTMT const hstmt = (SQLHSTMT)self->native_handles[1];
    gate_slotlist_t* const ptr_slots = (gate_slotlist_t*)self->native_handles[2];
    if (hstmt != NULL)
    {
        SQL.FreeStmt(hstmt, SQL_CLOSE);
        SQL.FreeStmt(hstmt, SQL_DROP);
        self->native_handles[1] = NULL;
    }
    if (ptr_slots != NULL)
    {
        gate_slotlist_destroy(ptr_slots);
        gate_mem_dealloc(ptr_slots);
        self->native_handles[2] = NULL;
    }
}

static gate_result_t odbcstmt_convert_result(SQLRETURN sql_result, SQLHANDLE sql_handle)
{
    if (SQL_SUCCEEDED(sql_result))
    {
        return GATE_RESULT_OK;
    }
    else
    {
        if (sql_handle != NULL)
        {
            SQLTCHAR sqlState[32] = GATE_INIT_EMPTY;
            SQLINTEGER native_error_code = 0;
            SQLTCHAR sqlMsg[1024] = GATE_INIT_EMPTY;
            SQLSMALLINT sqlMsgLen = 0;
            SQL.GetDiagRec(SQL_HANDLE_STMT, sql_handle, 1, sqlState, &native_error_code, sqlMsg, sizeof(sqlMsg) / sizeof(sqlMsg[0]), &sqlMsgLen);
            return GATE_RESULT_FAILED;
        }
        /* TODO: detailed error analysis */
        return GATE_RESULT_FAILED;
    }
}

static gate_result_t odbcstmt_set_null_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        ptr_param->length = SQL_NULL_DATA;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, NULL, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_bigint_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, gate_int64_t value, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        ptr_param->length = 0;
        ptr_param->value.sql_bigint = value;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, 0, 0, &ptr_param->value.sql_bigint, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_int_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, gate_int32_t value, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        ptr_param->length = 0;
        ptr_param->value.sql_int = value;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &ptr_param->value.sql_int, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_real_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, gate_real64_t value, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        ptr_param->length = 0;
        ptr_param->value.sql_double = value;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &ptr_param->value.sql_double, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_text_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, char const* text, gate_size_t textlen, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        if (NULL == gate_string_create(&ptr_param->value.text, text, textlen))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        ptr_param->dtor = &gate_string_destructor;
        ptr_param->length = textlen;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, (SQLULEN)textlen, 0, (char*)ptr_param->value.text.str, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_binary_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, void const* data, gate_size_t datalen, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        if (NULL == gate_blob_create(&ptr_param->value.blob, data, datalen))
        {
            return GATE_RESULT_OUTOFMEMORY;
        }
        ptr_param->dtor = &gate_blob_destructor;
        ptr_param->length = datalen;
        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_LONGVARBINARY, 0, 0, (SQLPOINTER)ptr_param->value.blob.data, 0, &ptr_param->length);
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}

static gate_result_t odbcstmt_set_datetime_param(SQLHSTMT hstmt, SQLUSMALLINT odbc_index, gate_datetime_t const* dt, gate_slotlist_t* param_cache)
{
    odbc_param_t* ptr_param = odbc_param_get(param_cache, odbc_index);
    if (NULL == ptr_param)
    {
        return GATE_RESULT_OUTOFMEMORY;
    }
    else
    {
        SQLRETURN sql_result;
        SQL_TIMESTAMP_STRUCT* sql_dt = &ptr_param->value.sql_timestamp;
        sql_dt->year = dt->date.year;
        sql_dt->month = dt->date.month;
        sql_dt->day = dt->date.day;
        sql_dt->hour = dt->time.hour;
        sql_dt->minute = dt->time.minute;
        sql_dt->second = dt->time.second;
        sql_dt->fraction = 0;
        ptr_param->length = sizeof(SQL_TIMESTAMP_STRUCT);


        sql_result = SQL.BindParameter(
            hstmt, odbc_index, SQL_PARAM_INPUT, SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP, 0, 0, sql_dt, ptr_param->length, &ptr_param->length);
        if (!SQL_SUCCEEDED(sql_result))
        {
            /* ODBC Date-time structs are not supported by all drivers, try text-representation: */
            gate_result_t result;
            char str[32] = GATE_INIT_EMPTY;
            gate_size_t len = sizeof(str);
            result = gate_date_to_string(dt, 0, "{YYYY}-{MM}-{DD} {hh}:{mm}:{ss}", str, &len);
            if (GATE_SUCCEEDED(result))
            {
                return odbcstmt_set_text_param(hstmt, odbc_index, str, len, param_cache);
            }
        }
        return odbcstmt_convert_result(sql_result, hstmt);
    }
}


static gate_result_t odbcstmt_set_param(gate_data_statement_base_t* self, gate_size_t index, gate_value_t const* value)
{
    SQLHSTMT hstmt = (SQLHSTMT)self->native_handles[1];
    SQLUSMALLINT odbc_index = (SQLUSMALLINT)(index);
    gate_slotlist_t* ptr_slots = (gate_slotlist_t*)self->native_handles[2];
    gate_cstrbuffer8_t buffer;
    gate_datetime_t dt = GATE_INIT_EMPTY;
    gate_result_t ret = GATE_RESULT_FAILED;

    if ((value == NULL) || (value->value_type == GATE_TYPE_EMPTY))
    {
        return odbcstmt_set_null_param(hstmt, odbc_index, ptr_slots);
    }

    switch (value->value_type)
    {
    case GATE_TYPE_BOOL:    return odbcstmt_set_int_param(hstmt, odbc_index, value->content.bool_value ? 1 : 0, ptr_slots);
    case GATE_TYPE_I8:      return odbcstmt_set_int_param(hstmt, odbc_index, (gate_int32_t)value->content.i8_value, ptr_slots);
    case GATE_TYPE_I16:     return odbcstmt_set_int_param(hstmt, odbc_index, (gate_int32_t)value->content.i16_value, ptr_slots);
    case GATE_TYPE_I32:     return odbcstmt_set_int_param(hstmt, odbc_index, (gate_int32_t)value->content.i32_value, ptr_slots);
    case GATE_TYPE_I64:     return odbcstmt_set_bigint_param(hstmt, odbc_index, (gate_int32_t)value->content.i64_value, ptr_slots);
    case GATE_TYPE_UI8:     return odbcstmt_set_int_param(hstmt, odbc_index, (gate_int32_t)value->content.ui8_value, ptr_slots);
    case GATE_TYPE_UI16:    return odbcstmt_set_int_param(hstmt, odbc_index, (gate_int32_t)value->content.ui16_value, ptr_slots);
    case GATE_TYPE_UI32:    return odbcstmt_set_bigint_param(hstmt, odbc_index, (gate_int64_t)value->content.ui32_value, ptr_slots);
    case GATE_TYPE_UI64:    return odbcstmt_set_bigint_param(hstmt, odbc_index, (gate_int64_t)value->content.ui64_value, ptr_slots);

    case GATE_TYPE_R32:     return odbcstmt_set_real_param(hstmt, odbc_index, (gate_real64_t)value->content.r32_value, ptr_slots);
    case GATE_TYPE_R64:     return odbcstmt_set_real_param(hstmt, odbc_index, (gate_real64_t)value->content.r64_value, ptr_slots);

    case GATE_TYPE_BLOB:    return odbcstmt_set_binary_param(hstmt, odbc_index, value->content.blob_value.data, value->content.blob_value.length, ptr_slots);

    case GATE_TYPE_CSTR:    return odbcstmt_set_text_param(hstmt, odbc_index, value->content.cstring_value, gate_str_length(value->content.cstring_value), ptr_slots);
    case GATE_TYPE_STRING:  return odbcstmt_set_text_param(hstmt, odbc_index, value->content.string_value.str, value->content.string_value.length, ptr_slots);

    case GATE_TYPE_WSTR:
        {
            if (NULL == gate_cstrbuffer_create_wstr(&buffer, value->content.wstring_value, gate_wstr_length(value->content.wstring_value)))
            {
                return GATE_RESULT_OUTOFMEMORY;
            }
            ret = odbcstmt_set_text_param(hstmt, odbc_index, gate_cstrbuffer_get(&buffer), gate_cstrbuffer_length(&buffer), ptr_slots);
            gate_cstrbuffer_destroy(&buffer);
            return ret;
        }
    case GATE_TYPE_GUID:
        {
            ret = gate_guid_to_string(&value->content.guid_value, buffer.local_buffer);
            GATE_RETURN_IF_FAILED(ret);
            return odbcstmt_set_text_param(hstmt, odbc_index, buffer.local_buffer, gate_str_length(buffer.local_buffer), ptr_slots);
        }
    case GATE_TYPE_DATE:
        {
            dt.date = value->content.date_value;
            return odbcstmt_set_datetime_param(hstmt, odbc_index, &dt, ptr_slots);
        }
    case GATE_TYPE_DATETIME:
        {
            return odbcstmt_set_datetime_param(hstmt, odbc_index, &value->content.datetime_value, ptr_slots);
        }
    case GATE_TYPE_TIME:
        {
            ret = gate_time_to_datetime(&value->content.time_value, &dt);
            GATE_RETURN_IF_FAILED(ret);
            return odbcstmt_set_datetime_param(hstmt, odbc_index, &dt, ptr_slots);
        }
    case GATE_TYPE_PROPERTY:
    default:
        return GATE_RESULT_INCORRECTTYPE;
    }
}

static gate_result_t odbcstmt_set_named_param(gate_data_statement_base_t* self, gate_string_t const* name, gate_value_t const* value)
{
    /* named parameters are not supported by odbc */
    return GATE_RESULT_NOTSUPPORTED;
}

static gate_result_t odbcstmt_reset(gate_data_statement_base_t* self)
{
    SQLRETURN sql_ret;
    SQLHSTMT hstmt = (SQLHSTMT)self->native_handles[1];

    if (hstmt == NULL)
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    sql_ret = SQL.FreeStmt(hstmt, SQL_RESET_PARAMS);
    switch (sql_ret)
    {
    case SQL_SUCCESS:
    case SQL_SUCCESS_WITH_INFO:
        return GATE_RESULT_OK;
    default:
        return GATE_RESULT_FAILED;
    }
}

static gate_result_t odbcstmt_execute(gate_data_statement_base_t* self, gate_int32_t* affected_rows)
{
    SQLRETURN sql_ret;
    SQLHSTMT hstmt = (SQLHSTMT)self->native_handles[1];
    SQLLEN len_rows = 0;

    if (hstmt == NULL)
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    sql_ret = SQL.Execute(hstmt);
    if ((SQL_SUCCESS != sql_ret) && (SQL_SUCCESS_WITH_INFO != sql_ret))
    {
        SQLTCHAR sqlState[32] = GATE_INIT_EMPTY;
        SQLINTEGER native_error_code = 0;
        SQLTCHAR sqlMsg[1024] = GATE_INIT_EMPTY;
        SQLSMALLINT sqlMsgLen = 0;
        SQL.GetDiagRec(SQL_HANDLE_STMT, hstmt, 1, sqlState, &native_error_code, sqlMsg, sizeof(sqlMsg) / sizeof(sqlMsg[0]), &sqlMsgLen);
        return GATE_RESULT_FAILED;
    }

    /* success case */
    if (affected_rows)
    {
        SQL.RowCount(hstmt, &len_rows);
        *affected_rows = (gate_int32_t)len_rows;
    }
    return GATE_RESULT_OK;
}

static gate_result_t odbcstmt_query(gate_data_statement_base_t* self, gate_data_reader_t** ptr_reader)
{
    SQLRETURN sql_ret;
    SQLHSTMT hstmt = (SQLHSTMT)self->native_handles[1];
    SQLLEN len_rows = 0;

    if (hstmt == NULL)
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    sql_ret = SQL.Execute(hstmt);
    if ((SQL_SUCCESS != sql_ret) && (SQL_SUCCESS_WITH_INFO != sql_ret))
    {
        SQLTCHAR sqlState[32] = GATE_INIT_EMPTY;
        SQLINTEGER native_error_code = 0;
        SQLTCHAR sqlMsg[1024] = GATE_INIT_EMPTY;
        SQLSMALLINT sqlMsgLen = 0;
        SQL.GetDiagRec(SQL_HANDLE_STMT, hstmt, 1, sqlState, &native_error_code, sqlMsg, sizeof(sqlMsg) / sizeof(sqlMsg[0]), &sqlMsgLen);
        return GATE_RESULT_FAILED;
    }

    if (ptr_reader == NULL)
    {
        /* success, reader not required, free unused resources */
        SQL.FreeStmt(hstmt, SQL_CLOSE);
        SQL.FreeStmt(hstmt, SQL_DROP);
        return GATE_RESULT_OK;
    }

    *ptr_reader = gate_data_reader_odbc_create(self, hstmt);
    if (*ptr_reader == NULL)
    {
        /* failed to allocate data reader */
        SQL.FreeStmt(hstmt, SQL_CLOSE);
        SQL.FreeStmt(hstmt, SQL_DROP);
        return GATE_RESULT_FAILED;
    }
    return GATE_RESULT_OK;

}








gate_result_t gate_data_connection_odbc_create_statement(gate_data_connection_base_t* self, gate_string_t const* sql, gate_data_statement_t** ptr_stmt)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    SQLHSTMT hstmt = NULL;
    SQLHDBC hdbc = self->native_handles[0];
    SQLRETURN sql_ret;
    SQLTCHAR cmd[4096 + 2048 + 1024];
    SQLSMALLINT param_count = 0;
    gate_size_t cmd_len;
    gate_data_handles_t handles;
    gate_data_statement_base_t* ptr_stmt_base = NULL;

    do
    {
#if defined(GATE_SYS_WIN)
        cmd_len = gate_win32_utf8_2_winstr(sql->str, sql->length, (LPTSTR)&cmd[0], sizeof(cmd) / sizeof(cmd[0]));
#else
        cmd_len = gate_string_to_buffer(sql, (char*)&cmd[0], sizeof(cmd) / sizeof(cmd[0]));
#endif

        sql_ret = SQL.AllocStmt(hdbc, &hstmt);
        if (SQL_SUCCESS != sql_ret)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }

        sql_ret = SQL.Prepare(hstmt, cmd, (SQLINTEGER)cmd_len);
        if (SQL_SUCCESS != sql_ret)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }

        gate_mem_clear(&handles[0], sizeof(handles));
        handles[0] = (void*)hdbc;
        handles[1] = (void*)hstmt;

        ret = gate_data_statement_base_create(
            self, handles, sql,
            &odbcstmt_init,
            &odbcstmt_close,
            &odbcstmt_set_param,
            &odbcstmt_set_named_param,
            &odbcstmt_reset,
            &odbcstmt_execute,
            &odbcstmt_query,
            &ptr_stmt_base);

        GATE_BREAK_IF_FAILED(ret);

        if (SQL_ERROR != SQL.NumParams(hstmt, &param_count))
        {
            ptr_stmt_base->param_count = param_count;
        }

        /* success case: */
        if (ptr_stmt != NULL)
        {
            *ptr_stmt = (gate_data_statement_t*)ptr_stmt_base;
            ptr_stmt_base = NULL;
        }
        hstmt = NULL;
        ret = GATE_RESULT_OK;
    } while (0);

    if (ptr_stmt_base != NULL)
    {
        gate_object_release(ptr_stmt_base);
    }

    if (hstmt != NULL)
    {
        SQL.FreeStmt(hstmt, SQL_CLOSE);
        SQL.FreeStmt(hstmt, SQL_DROP);
    }
    return ret;
}

static gate_result_t gate_data_connection_odbc_init(gate_data_connection_base_t* self)
{
    GATE_UNUSED_ARG(self);
    return GATE_RESULT_OK;
}

static void gate_data_connection_odbc_close(gate_data_connection_base_t* self)
{
    SQLHDBC hdbc = self->native_handles[0];
    SQLHENV henv = self->native_handles[1];

    if (hdbc != NULL)
    {
        SQL.Disconnect(hdbc);
        SQL.FreeConnect(hdbc);
    }
    if (henv != NULL)
    {
#if !defined(GATE_SYS_WIN)
        /* NOTICE: Windows ODBC 3.x drives produce errors in Application Verifier 
           due to pooled connections or another object hierarchy.
           Explicit freeing is not required and disabled therefor.
        */
        SQL.FreeEnv(henv);
#endif
    }
    gate_mem_clear(self->native_handles, sizeof(self->native_handles));
}



gate_result_t gate_data_adapter_odbc_create(gate_string_t const* path, gate_enumint_t flags, gate_data_connection_t** ptr_connection)
{
    gate_result_t ret = GATE_RESULT_OK;
    SQLTCHAR str_connection[4096];
    gate_size_t str_connection_len;
    SQLTCHAR* str_user = NULL;
    gate_size_t str_user_len = 0;
    SQLTCHAR* str_pass = NULL;
    gate_size_t str_pass_len = 0;
    SQLHENV henv = NULL;
    SQLHDBC hdbc = NULL;
    SQLRETURN sql_ret;
    gate_data_handles_t handles = GATE_INIT_EMPTY;

    do
    {
        ret = load_odbc_functions();
        GATE_BREAK_IF_FAILED(ret);

#if defined(GATE_SYS_WIN)
        str_connection_len = gate_win32_utf8_2_winstr(path->str, path->length, (LPTSTR)&str_connection[0], sizeof(str_connection) / sizeof(str_connection[0]));
#else
        str_connection_len = gate_string_to_buffer(path, (char*)&str_connection[0], sizeof(str_connection) / sizeof(str_connection[0]));
#endif
        sql_ret = SQL.AllocEnv(&henv);
        if (SQL_SUCCESS != sql_ret)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }

        sql_ret = SQL.AllocConnect(henv, &hdbc);
        if (SQL_SUCCESS != sql_ret)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }

        sql_ret = SQL.Connect(hdbc, str_connection, (SQLSMALLINT)str_connection_len,
            str_user, (SQLSMALLINT)str_user_len, str_pass, (SQLSMALLINT)str_pass_len);

        if ((SQL_SUCCESS != sql_ret) && (SQL_SUCCESS_WITH_INFO != sql_ret))
        {
            SQLTCHAR state_msg[1024];
            SQLINTEGER native_error = 0;
            SQLTCHAR error_msg[1024];
            SQLSMALLINT error_msg_used = 0;
            SQL.GetDiagRec(SQL_HANDLE_DBC, hdbc, 1, state_msg, &native_error, error_msg, 1024, &error_msg_used);
            ret = GATE_RESULT_FAILED;
            break;
        }

        handles[0] = (void*)hdbc;
        handles[1] = (void*)henv;
        ret = gate_data_connection_base_create(
            handles,
            &gate_data_connection_odbc_init,
            &gate_data_connection_odbc_close,
            &gate_data_connection_odbc_create_statement,
            ptr_connection);
        if (GATE_SUCCEEDED(ret))
        {
            hdbc = NULL;
            henv = NULL;
        }
    } while (0);

    if (hdbc)
    {
        SQL.Disconnect(hdbc);
        SQL.FreeConnect(hdbc);
    }
    if (henv)
    {
        SQL.FreeEnv(henv);
    }
    return ret;
}

#else  /* GATE_DATA_ODBC_IMPL */

gate_result_t gate_data_adapter_odbc_create(gate_string_t const* path, gate_enumint_t flags, gate_data_connection_t** ptr_connection)
{
    (void)path;
    (void)flags;
    (void)ptr_connection;
    return GATE_RESULT_NOTIMPLEMENTED;
}

#endif