@zowe/db2-for-zowe-cli 6.1.17 → 6.1.18

package/node_modules/ibm_db/src/odbc.cpp

@@ -1,1396 +1,1495 @@
-/*
-  Copyright (c) 2013, Dan VerWeire <dverweire@gmail.com>
-  Copyright (c) 2010, Lee Smith<notwink@gmail.com>
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted, provided that the above
-  copyright notice and this permission notice appear in all copies.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-#ifdef __MVS__
-#define _AE_BIMODAL
-#include <_Nascii.h>
-#endif
-
-// On AIX, GCC auto-generates _GLOBAL__FI_*/_GLOBAL__FD_* init/fini functions
-// in every shared library via crtcxa.o. The fini function calls __cxa_finalize
-// which crashes with SIGILL (jump to 0x0) because atexit handlers registered
-// by libdb2.a become invalid during process exit. (#439, #1045)
-// We override the init/fini with this no-op to prevent the crash.
-#ifdef _AIX
-extern "C" void __ibmdb_aix_noop(void) {}
-#endif
-
-#include <string.h>
-#include <stdint.h>
-#include <type_traits>
-#include <time.h>
-#include <cassert>
-#include <cstdlib>
-#include <uv.h>
-#ifdef _AIX
-#include <signal.h>
-#include <unistd.h>
-#endif
-
-#include "odbc.h"
-#include "odbc_connection.h"
-#include "odbc_result.h"
-#include "odbc_statement.h"
-
-#ifdef _WIN32
-#include "strptime.h"
-#endif
-
-#define FILE_PARAM 3
-#define DATA_AT_EXEC_PARAM 5
-
-namespace {
-template <typename HandleType>
-unsigned long long HandleToLogValueImpl(HandleType handle, std::true_type)
-{
-  return static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(handle));
-}
-
-template <typename HandleType>
-unsigned long long HandleToLogValueImpl(HandleType handle, std::false_type)
-{
-  return static_cast<unsigned long long>(handle);
-}
-
-template <typename HandleType>
-unsigned long long HandleToLogValue(HandleType handle)
-{
-  return HandleToLogValueImpl(handle, typename std::is_pointer<HandleType>::type());
-}
-}
-
-uv_mutex_t ODBC::g_odbcMutex;
-uv_async_t ODBC::g_async;
-
-Napi::FunctionReference ODBC::constructor;
-
-Napi::Object ODBC::Init(Napi::Env env, Napi::Object exports)
-{
-  DEBUG_PRINTF("ODBC::Init\n");
-
-  Napi::Function func = DefineClass(env, "ODBC", {
-    InstanceMethod("createConnection", &ODBC::CreateConnection, NAPI_METHOD_ATTR),
-    InstanceMethod("createConnectionSync", &ODBC::CreateConnectionSync, NAPI_METHOD_ATTR),
-    StaticValue("SQL_CLOSE", Napi::Number::New(env, SQL_CLOSE), napi_enumerable),
-    StaticValue("SQL_DROP", Napi::Number::New(env, SQL_DROP), napi_enumerable),
-    StaticValue("SQL_UNBIND", Napi::Number::New(env, SQL_UNBIND), napi_enumerable),
-    StaticValue("SQL_RESET_PARAMS", Napi::Number::New(env, SQL_RESET_PARAMS), napi_enumerable),
-    StaticValue("SQL_DESTROY", Napi::Number::New(env, SQL_DESTROY), napi_enumerable),
-    StaticValue("FETCH_ARRAY", Napi::Number::New(env, FETCH_ARRAY), napi_enumerable),
-    StaticValue("FETCH_OBJECT", Napi::Number::New(env, FETCH_OBJECT), napi_enumerable),
-  });
-
-  constructor = Napi::Persistent(func);
-  constructor.SuppressDestruct();
-  exports.Set("ODBC", func);
-
-  // Initialize the cross platform mutex provided by libuv
-  uv_mutex_init(&ODBC::g_odbcMutex);
-
-  return exports;
-}
-
-ODBC::~ODBC()
-{
-  DEBUG_PRINTF("ODBC::~ODBC\n");
-  this->Free();
-}
-
-void ODBC::Free()
-{
-  DEBUG_PRINTF("ODBC::Free: m_hEnv = 0x%llx\n", HandleToLogValue(m_hEnv));
-  if (m_hEnv)
-  {
-    SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
-    m_hEnv = (SQLHENV)NULL;
-  }
-}
-
-ODBC::ODBC(const Napi::CallbackInfo &info) : Napi::ObjectWrap<ODBC>(info)
-{
-  Napi::Env env = info.Env();
-  DEBUG_PRINTF("ODBC::New - Entry\n");
-
-  m_hEnv = (SQLHENV)NULL;
-
-#ifdef __MVS__
-  int ori_mode = __ae_thread_swapmode(__AE_EBCDIC_MODE);
-#endif
-  int ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_hEnv);
-#ifdef __MVS__
-  __ae_thread_swapmode(ori_mode);
-#endif
-  if (!SQL_SUCCEEDED(ret))
-  {
-    DEBUG_PRINTF("ODBC::New - ERROR ALLOCATING ENV HANDLE!!\n");
-    Napi::Value objError = ODBC::GetSQLError(env, SQL_HANDLE_ENV, m_hEnv);
-    napi_throw(env, objError);
-    return;
-  }
-
-  ret = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_UINTEGER);
-
-  if (!SQL_SUCCEEDED(ret))
-  {
-    DEBUG_PRINTF("ODBC::New - ERROR SETTING ODBC VERSION!!\n");
-    Napi::Value objError = ODBC::GetSQLError(env, SQL_HANDLE_ENV, m_hEnv);
-    SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
-    m_hEnv = (SQLHENV)NULL;
-    napi_throw(env, objError);
-    return;
-  }
-
-  DEBUG_PRINTF("ODBC::New - Exit\n");
-}
-
-/*
- * CreateConnection
- */
-Napi::Value ODBC::CreateConnection(const Napi::CallbackInfo &info)
-{
-  DEBUG_PRINTF("ODBC::CreateConnection - Entry\n");
-  Napi::Env env = info.Env();
-
-  REQ_FUN_ARG(0, cb);
-
-  uv_work_t *work_req = (uv_work_t *)(calloc(1, sizeof(uv_work_t)));
-  MEMCHECK(work_req);
-
-  create_connection_work_data *data =
-      (create_connection_work_data *)(calloc(1, sizeof(create_connection_work_data)));
-  if (!data) free(work_req);
-  MEMCHECK(data);
-
-  data->cb = new Napi::FunctionReference(Napi::Persistent(cb));
-  data->dbo = this;
-  data->env = env;
-
-  work_req->data = data;
-
-  uv_queue_work(uv_default_loop(), work_req, UV_CreateConnection, (uv_after_work_cb)UV_AfterCreateConnection);
-
-  this->Ref();
-
-  DEBUG_PRINTF("ODBC::CreateConnection - Exit\n");
-  return env.Undefined();
-}
-
-void ODBC::UV_CreateConnection(uv_work_t *req)
-{
-  DEBUG_PRINTF("ODBC::UV_CreateConnection - Entry\n");
-  create_connection_work_data *data = (create_connection_work_data *)(req->data);
-  data->result = SQLAllocHandle(SQL_HANDLE_DBC, data->dbo->m_hEnv, &data->hDBC);
-  DEBUG_PRINTF("ODBC::UV_CreateConnection - Exit: hDBC = 0x%llx\n", HandleToLogValue(data->hDBC));
-}
-
-void ODBC::UV_AfterCreateConnection(uv_work_t *req, int status)
-{
-  DEBUG_PRINTF("ODBC::UV_AfterCreateConnection - Entry\n");
-  create_connection_work_data *data = (create_connection_work_data *)(req->data);
-  Napi::Env env(data->env);
-  Napi::HandleScope scope(env);
-
-  if (!SQL_SUCCEEDED(data->result))
-  {
-    Napi::Value error = ODBC::GetSQLError(env, SQL_HANDLE_ENV, data->dbo->m_hEnv);
-    data->cb->Call({error});
-  }
-  else
-  {
-    Napi::Value args[2] = {
-      Napi::External<void>::New(env, (void *)(intptr_t)data->dbo->m_hEnv),
-      Napi::External<void>::New(env, (void *)(intptr_t)data->hDBC)
-    };
-    Napi::Object js_result = ODBCConnection::constructor.New({args[0], args[1]});
-    data->cb->Call({env.Null(), js_result});
-  }
-  PropagateCallbackException(env);
-
-  data->dbo->Unref();
-  delete data->cb;
-  free(data);
-  free(req);
-  DEBUG_PRINTF("ODBC::UV_AfterCreateConnection - Exit\n");
-}
-
-/*
- * CreateConnectionSync
- */
-Napi::Value ODBC::CreateConnectionSync(const Napi::CallbackInfo &info)
-{
-  DEBUG_PRINTF("ODBC::CreateConnectionSync - Entry\n");
-  Napi::Env env = info.Env();
-
-  SQLHDBC hDBC;
-  SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, &hDBC);
-
-  if (!SQL_SUCCEEDED(ret))
-  {
-    // TODO: do something!
-  }
-
-  Napi::Value params[2] = {
-    Napi::External<void>::New(env, (void *)(intptr_t)m_hEnv),
-    Napi::External<void>::New(env, (void *)(intptr_t)hDBC)
-  };
-  Napi::Object js_result = ODBCConnection::constructor.New({params[0], params[1]});
-
-  DEBUG_PRINTF("ODBC::CreateConnectionSync - Exit: hDBC = 0x%llx\n", HandleToLogValue(hDBC));
-  return js_result;
-}
-
-/*
- * GetColumns
- */
-Column *ODBC::GetColumns(SQLHSTMT hStmt, short *colCount)
-{
-  SQLRETURN ret;
-  SQLSMALLINT buflen;
-  SQLSMALLINT typebuflen;
-  DEBUG_PRINTF("ODBC::GetColumns - Entry\n");
-
-  *colCount = 0;
-  ret = SQLNumResultCols(hStmt, colCount);
-
-  if (!SQL_SUCCEEDED(ret))
-  {
-    return new Column[0];
-  }
-
-  Column *columns = new Column[*colCount];
-  char colname[MAX_FIELD_SIZE];
-
-  for (int i = 0; i < *colCount; i++)
-  {
-    columns[i].index = i + 1;
-    columns[i].getData = false;
-    columns[i].isFileBound = false;
-    colname[0] = '\0';
-    buflen = 0;
-
-    ret = SQLColAttribute(hStmt, columns[i].index,
-#ifdef STRICT_COLUMN_NAMES
-                          SQL_DESC_NAME,
-#else
-                          SQL_DESC_LABEL,
-#endif
-                          colname, (SQLSMALLINT)MAX_FIELD_SIZE, &buflen, NULL);
-
-    columns[i].name_len = buflen;
-    if (buflen > 0)
-    {
-      columns[i].name = new unsigned char[buflen + 2];
-      memcpy(columns[i].name, colname, buflen);
-      columns[i].name[buflen] = '\0';
-      columns[i].name[buflen + 1] = '\0';
-    }
-    DEBUG_PRINTF("ODBC::GetColumns index = %i, buflen=%i\n", columns[i].index, buflen);
-
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_DISPLAY_SIZE,
-                          NULL, 0, NULL, &columns[i].max_display_len);
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_PRECISION,
-                          NULL, 0, NULL, &columns[i].precision);
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_SCALE,
-                          NULL, 0, NULL, &columns[i].scale);
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_LENGTH,
-                          NULL, 0, NULL, &columns[i].field_len);
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_CONCISE_TYPE,
-                          NULL, 0, NULL, &columns[i].type);
-
-    columns[i].type_name = new unsigned char[(MAX_FIELD_SIZE)];
-    columns[i].type_name[0] = '\0';
-
-    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_TYPE_NAME,
-                          columns[i].type_name, (SQLSMALLINT)(MAX_FIELD_SIZE),
-                          &typebuflen, NULL);
-  }
-  DEBUG_PRINTF("ODBC::GetColumns - Exit\n");
-  return columns;
-}
-
-/*
- * FreeColumns
- */
-void ODBC::FreeColumns(Column *&columns, short *colCount)
-{
-  DEBUG_PRINTF("ODBC::FreeColumns - Entry\n");
-  for (int i = 0; i < *colCount; i++)
-  {
-    delete[] columns[i].name;
-    delete[] columns[i].type_name;
-  }
-  if (columns != NULL)
-  {
-    delete[] columns;
-    columns = NULL;
-  }
-  *colCount = 0;
-  DEBUG_PRINTF("ODBC::FreeColumns - Exit\n");
-}
-
-/*
- * GetColumnValue
- */
-Napi::Value ODBC::GetColumnValue(Napi::Env env, SQLHSTMT hStmt, Column column,
-                                  uint16_t *buffer, size_t bufferLength)
-{
-  if (column.isFileBound) {
-    return env.Null();
-  }
-
-  SQLLEN len = 0;
-  SQLLEN maxBuffSize = 0;
-  unsigned short terCharLen = 1;
-  SQLRETURN ret = SQL_SUCCESS;
-  SQLSMALLINT ctype = SQL_C_TCHAR;
-  char *errmsg = (char *)"[node-ibm_db] Error in ODBC::GetColumnValue";
-
-#ifdef UNICODE
-  terCharLen = 2;
-#endif
-
-  DEBUG_PRINTF("Column Type : %i\t%i\t%i\t%i\n", column.type, SQL_DATETIME,
-               SQL_TIMESTAMP, SQL_TYPE_TIME);
-
-  switch (column.type)
-  {
-  case SQL_BLOB:
-  case SQL_BINARY:
-  case SQL_VARBINARY:
-  case SQL_LONGVARBINARY:
-    terCharLen = 0;
-    ctype = SQL_C_BINARY;
-    break;
-  }
-
-  switch (column.type)
-  {
-  case SQL_INTEGER:
-  case SQL_SMALLINT:
-  case SQL_TINYINT:
-  {
-    SQLINTEGER value;
-    ret = SQLGetData(hStmt, column.index, SQL_C_SLONG, &value, sizeof(value), &len);
-
-    if (len == SQL_NULL_DATA) return env.Null();
-    return Napi::Number::New(env, (double)value);
-  }
-  break;
-
-  case SQL_NUMERIC:
-  case SQL_DECIMAL:
-  case SQL_DECFLOAT:
-  case SQL_FLOAT:
-  case SQL_REAL:
-  case SQL_DOUBLE:
-  {
-    double value;
-    ret = SQLGetData(hStmt, column.index, SQL_C_DOUBLE, &value, sizeof(value), &len);
-
-    if (len == SQL_NULL_DATA) return env.Null();
-    return Napi::Number::New(env, value);
-  }
-  break;
-
-  case SQL_DATETIME:
-  case SQL_TIMESTAMP:
-  {
-    SQL_TIMESTAMP_STRUCT odbcTime;
-#ifdef _WIN32
-    struct tm timeInfo = {};
-    ret = SQLGetData(hStmt, column.index, SQL_C_CHAR, &odbcTime, sizeof(odbcTime), &len);
-#else
-#if defined(_AIX) || defined(__MVS__)
-    struct tm timeInfo = {0, 0, 0, 0, 0, 0, 0, 0, 0};
-#else
-    struct tm timeInfo = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-#endif
-    ret = SQLGetData(hStmt, column.index, SQL_C_TYPE_TIMESTAMP, &odbcTime, sizeof(odbcTime), &len);
-#endif
-
-    if (len == SQL_NULL_DATA) return env.Null();
-
-    timeInfo.tm_year = odbcTime.year - 1900;
-    timeInfo.tm_mon = odbcTime.month - 1;
-    timeInfo.tm_mday = odbcTime.day;
-    timeInfo.tm_hour = odbcTime.hour;
-    timeInfo.tm_min = odbcTime.minute;
-    timeInfo.tm_sec = odbcTime.second;
-    timeInfo.tm_isdst = -1;
-
-#ifdef TIMEGM
-    return Napi::Date::New(env, (double(timegm(&timeInfo)) * 1000) + (odbcTime.fraction / 1000000));
-#else
-    return Napi::Date::New(env, (double(mktime(&timeInfo)) * 1000) + (odbcTime.fraction / 1000000));
-#endif
-  }
-  break;
-
-  case SQL_BIT:
-  {
-    char bit[4] = {'\0'};
-    ret = SQLGetData(hStmt, column.index, SQL_C_CHAR, &bit, 4, &len);
-    if (len == SQL_NULL_DATA) return env.Null();
-    return Napi::Boolean::New(env, (*bit == '0') ? false : true);
-  }
-  break;
-
-  case SQL_TYPE_TIME:
-  case SQL_BIGINT:
-    if (column.type == SQL_BIGINT) ctype = SQL_C_CHAR;
-    /* fall through */
-  case SQL_DBCLOB:
-    if (column.type == SQL_DBCLOB) ctype = SQL_C_CHAR;
-    /* fall through */
-  default:
-  {
-    uint16_t *tmp_out_ptr = NULL;
-    uint32_t bufferSize = 0;
-    uint32_t newbufflen = 0;
-    unsigned short secondGetData = 0;
-    len = 0;
-    bufferSize = bufferLength + terCharLen;
-
-    if (buffer == NULL)
-    {
-      buffer = (uint16_t *)malloc(bufferSize);
-      if (buffer == NULL)
-      {
-        errmsg = (char *)"Failed to allocate memory buffer for column data.";
-        napi_throw(env, ODBC::GetSQLError(env, SQL_HANDLE_STMT, hStmt, errmsg));
-        return env.Undefined();
-      }
-    }
-    maxBuffSize = bufferSize;
-    memset(buffer, '\0', bufferSize);
-    ret = SQLGetData(hStmt, column.index, ctype, (char *)buffer, maxBuffSize, &len);
-
-    if (column.getData) { secondGetData = 1; }
-    else if (ret == SQL_SUCCESS_WITH_INFO && len > 0)
-    {
-      if (len + terCharLen > 0x3fffffff)
-        newbufflen = 0x3fffffff;
-      else
-        newbufflen = len + terCharLen;
-
-      tmp_out_ptr = (uint16_t *)malloc(newbufflen);
-      if (tmp_out_ptr == NULL)
-      {
-        ret = (SQLRETURN)-3;
-        newbufflen = bufferSize;
-      }
-      else
-      {
-        memcpy(tmp_out_ptr, (char *)buffer, bufferLength);
-        free((uint16_t *)buffer);
-        buffer = tmp_out_ptr;
-        maxBuffSize = newbufflen - bufferLength;
-        len = 0;
-        ret = SQLGetData(hStmt, column.index, ctype, (char *)buffer + bufferLength, maxBuffSize, &len);
-        ret = SQL_SUCCESS;
-        len = newbufflen;
-        secondGetData = 1;
-      }
-    }
-    if (len >= 0) newbufflen = len;
-
-    if (len == SQL_NULL_DATA)
-    {
-      FREE(buffer);
-      return env.Null();
-    }
-    else if (SQL_SUCCEEDED(ret) || secondGetData)
-    {
-      if (ctype == SQL_C_BINARY)
-      {
-        // Return binary data as buffer - transfer ownership to Node
-        Napi::Buffer<char> buf = Napi::Buffer<char>::Copy(env, (char *)buffer, newbufflen);
-        FREE(buffer);
-        return buf;
-      }
-      else
-      {
-#ifdef UNICODE
-        Napi::Value str = Napi::String::New(env, (char16_t *)buffer);
-#else
-        Napi::Value str = Napi::String::New(env, (char *)buffer);
-#endif
-        FREE(buffer);
-        return str;
-      }
-    }
-    else
-    {
-      FREE(buffer);
-      if (ret == SQL_INVALID_HANDLE)
-      {
-        unsigned long long hstmt_value = HandleToLogValue(hStmt);
-#ifdef __MVS__
-        __fprintf_a(stdout, "Invalid Handle: SQLGetData return code = %i, stmt handle = 0x%llx"
-                ", columnType = %i, index = %i\n",
-              ret, hstmt_value, (int)column.type, column.index);
-#else
-        fprintf(stdout, "Invalid Handle: SQLGetData return code = %i, stmt handle = 0x%llx"
-            ", columnType = %i, index = %i\n",
-          ret, hstmt_value, (int)column.type, column.index);
-#endif
-        assert(ret != SQL_INVALID_HANDLE);
-      }
-      napi_throw(env, ODBC::GetSQLError(env, SQL_HANDLE_STMT, hStmt, errmsg));
-      return env.Undefined();
-    }
-  }
-  }
-}
-
-/*
- * GetOutputParameter
- */
-Napi::Value ODBC::GetOutputParameter(Napi::Env env, Parameter *prm)
-{
-  bool sqlTypeBinary = false;
-
-  switch (prm->type)
-  {
-  case SQL_BLOB:
-  case SQL_BINARY:
-  case SQL_VARBINARY:
-  case SQL_LONGVARBINARY:
-    sqlTypeBinary = true;
-    break;
-  }
-
-  if (((int)prm->length == SQL_NULL_DATA) || !prm->buffer)
-  {
-    return env.Null();
-  }
-
-  switch (prm->type)
-  {
-  case SQL_INTEGER:
-  case SQL_SMALLINT:
-  case SQL_TINYINT:
-  case SQL_BOOLEAN:
-  case SQL_NUMERIC:
-  case SQL_BIGINT:
-    if (prm->length == sizeof(int))
-      return Napi::Number::New(env, *(int *)prm->buffer);
-    else if (prm->length == sizeof(short))
-      return Napi::Number::New(env, *(short *)prm->buffer);
-    else if (prm->length == sizeof(long))
-      return Napi::Number::New(env, (double)*(long *)prm->buffer);
-    else if (prm->length == sizeof(long long))
-      return Napi::Number::New(env, (double)*(long long *)prm->buffer);
-    else
-      return Napi::Number::New(env, *(char *)prm->buffer);
-    break;
-
-  case SQL_DECIMAL:
-  case SQL_FLOAT:
-  case SQL_DECFLOAT:
-  case SQL_REAL:
-  case SQL_DOUBLE:
-    return Napi::Number::New(env, *(double *)prm->buffer);
-    break;
-
-  case SQL_BIT:
-    return Napi::Boolean::New(env, (*((char *)prm->buffer) == '0') ? false : true);
-    break;
-
-  default:
-    if (prm->isBuffer)
-    {
-      return Napi::Buffer<char>::Copy(env, (char *)prm->buffer, prm->length);
-    }
-    else if (sqlTypeBinary || prm->c_type == SQL_C_BINARY)
-    {
-      prm->isBuffer = true;
-      return Napi::Buffer<char>::Copy(env, (char *)prm->buffer, prm->length);
-    }
-    else
-    {
-#ifdef UNICODE
-      return Napi::String::New(env, (char16_t *)prm->buffer);
-#else
-      return Napi::String::New(env, (char *)prm->buffer);
-#endif
-    }
-  }
-}
-
-/*
- * GetRecordTuple
- */
-Napi::Object ODBC::GetRecordTuple(Napi::Env env, SQLHSTMT hStmt, Column *columns,
-                                   short *colCount, uint16_t *buffer, size_t bufferLength)
-{
-  Napi::Object tuple = Napi::Object::New(env);
-
-  for (int i = 0; i < *colCount; i++)
-  {
-#ifdef UNICODE
-    tuple.Set(Napi::String::New(env, (char16_t *)columns[i].name),
-              GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
-#else
-    tuple.Set(Napi::String::New(env, (const char *)columns[i].name),
-              GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
-#endif
-  }
-
-  return tuple;
-}
-
-/*
- * GetRecordArray
- */
-Napi::Value ODBC::GetRecordArray(Napi::Env env, SQLHSTMT hStmt, Column *columns,
-                                  short *colCount, uint16_t *buffer, size_t bufferLength)
-{
-  Napi::Array array = Napi::Array::New(env);
-
-  for (int i = 0; i < *colCount; i++)
-  {
-    array.Set(i, GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
-  }
-
-  return array;
-}
-
-/*
- * GetParametersFromArray
- */
-Parameter *ODBC::GetParametersFromArray(Napi::Env env, Napi::Array values, int *paramCount)
-{
-  DEBUG_PRINTF("ODBC::GetParametersFromArray\n");
-  *paramCount = values.Length();
-
-  Parameter *params = (Parameter *)malloc(*paramCount * sizeof(Parameter));
-  if (*paramCount != 0 && !params)
-  {
-    Napi::Error::New(env, "Could not allocate enough memory for params").ThrowAsJavaScriptException();
-    return params;
-  }
-  memset(params, '\0', *paramCount * sizeof(Parameter));
-
-  for (int i = 0; i < *paramCount; i++)
-  {
-    Napi::Value value = values.Get(i);
-    params[i].paramtype = SQL_PARAM_INPUT;
-    params[i].size = 0;
-    params[i].length = SQL_NULL_DATA;
-    params[i].buffer_length = 0;
-    params[i].decimals = 0;
-    params[i].isBuffer = false;
-
-    if (value.IsArray())
-    {
-      Napi::Array paramArray = value.As<Napi::Array>();
-      int arrlen = paramArray.Length();
-      if (arrlen < 4)
-      {
-        Napi::Error::New(env, "Wrong param format!").ThrowAsJavaScriptException();
-        return params;
-      }
-
-      Napi::Value val = paramArray.Get((uint32_t)0);
-      if (val.IsNumber()) params[i].paramtype = val.As<Napi::Number>().Int32Value();
-
-      val = paramArray.Get((uint32_t)1);
-      if (val.IsNumber()) params[i].c_type = val.As<Napi::Number>().Int32Value();
-      else params[i].c_type = SQL_C_CHAR;
-
-      val = paramArray.Get((uint32_t)2);
-      if (val.IsNumber()) params[i].type = val.As<Napi::Number>().Int32Value();
-      else params[i].type = SQL_CHAR;
-
-      if (arrlen == 5)
-      {
-        val = paramArray.Get((uint32_t)4);
-        if (val.IsNumber()) params[i].buffer_length = val.As<Napi::Number>().Int32Value();
-      }
-
-      val = paramArray.Get((uint32_t)3);
-      if (params[i].paramtype == DATA_AT_EXEC_PARAM && val.IsArray())
-      {
-        GetDataAtExecParam(env, val, &params[i], i + 1);
-      }
-      else if (val.IsNull() || val.IsUndefined())
-      {
-        GetNullParam(&params[i], i + 1);
-      }
-      else if (val.IsNumber() && !val.IsNull() && params[i].type != 3)
-      {
-        // Check if integer
-        double dval = val.As<Napi::Number>().DoubleValue();
-        int32_t ival = val.As<Napi::Number>().Int32Value();
-        if (dval == (double)ival && params[i].type != 3)
-          GetInt32Param(env, val, &params[i], i + 1);
-        else
-          GetNumberParam(env, val, &params[i], i + 1);
-      }
-      else if (val.IsBoolean())
-      {
-        GetBoolParam(env, val, &params[i], i + 1);
-      }
-      else if (val.IsArray())
-      {
-        GetArrayParam(env, val, &params[i], i + 1);
-      }
-      else if (val.IsBuffer())
-      {
-        GetBufferParam(val, &params[i], i + 1);
-      }
-      else
-      {
-        GetStringParam(env, val, &params[i], i + 1);
-      }
-    }
-    else if (value.IsBuffer())
-    {
-      GetBufferParam(value, &params[i], i + 1);
-    }
-    else if (value.IsString())
-    {
-      GetStringParam(env, value, &params[i], i + 1);
-    }
-    else if (value.IsNull() || value.IsUndefined())
-    {
-      GetNullParam(&params[i], i + 1);
-    }
-    else if (value.IsNumber())
-    {
-      double dval = value.As<Napi::Number>().DoubleValue();
-      int32_t ival = value.As<Napi::Number>().Int32Value();
-      if (dval == (double)ival)
-        GetInt32Param(env, value, &params[i], i + 1);
-      else
-        GetNumberParam(env, value, &params[i], i + 1);
-    }
-    else if (value.IsBoolean())
-    {
-      GetBoolParam(env, value, &params[i], i + 1);
-    }
-  }
-  return params;
-}
-
-void ODBC::GetStringParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  int length = 0;
-  int bufflen = 0;
-  int terCharLen = 1;
-  bool isBinary = (param->c_type == SQL_C_BINARY);
-
-  // Determine string length using encoding that matches NAN behavior:
-  // SQL_C_BINARY -> Latin-1 (WriteOneByte), UNICODE -> UTF-16 (Write), else -> UTF-8
-  if (isBinary) {
-    size_t latin1_len = 0;
-    napi_get_value_string_latin1(env, value, NULL, 0, &latin1_len);
-    length = (int)latin1_len;
-  }
-#ifdef UNICODE
-  else {
-    size_t utf16_len = 0;
-    napi_get_value_string_utf16(env, value, NULL, 0, &utf16_len);
-    length = (int)utf16_len;
-  }
-#else
-  else {
-    std::string utf8str = value.ToString().Utf8Value();
-    length = (int)utf8str.length();
-  }
-#endif
-
-  bufflen = length;
-  param->length = length;
-  if (!param->c_type || (param->c_type == SQL_CHAR))
-    param->c_type = SQL_C_TCHAR;
-#ifdef UNICODE
-  param->length = SQL_NTS;
-  if (!param->type || (param->type == SQL_CHAR))
-    param->type = (length >= 8000) ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
-  if (!isBinary)
-    bufflen = (length + 1) * sizeof(uint16_t);
-  terCharLen = 2;
-#else
-  if (!param->type || (param->type == SQL_CHAR))
-    param->type = (length >= 8000) ? SQL_LONGVARCHAR : SQL_VARCHAR;
-  if (!isBinary)
-  {
-    std::string utf8str = value.ToString().Utf8Value();
-    bufflen = (int)utf8str.length() + 1;
-    param->length = bufflen - 1;
-  }
-#endif
-  if (isBinary) { bufflen = length + 1; }
-  if (bufflen <= param->buffer_length &&
-      ((param->paramtype % 2 == 0) || (param->arraySize > 0)))
-  {
-    bufflen = param->buffer_length + terCharLen;
-  }
-  param->buffer_length = bufflen;
-  param->size = bufflen;
-
-  param->buffer = malloc(param->buffer_length);
-  if (!param->buffer) return;
-  memset(param->buffer, 0, param->buffer_length);
-
-  // Copy string data using correct encoding (matching NAN behavior)
-  if (param->paramtype == FILE_PARAM) {
-    // FILE_PARAM: use UTF-8 (matches NAN's WriteUtf8)
-    std::string utf8str = value.ToString().Utf8Value();
-    memcpy(param->buffer, utf8str.c_str(), utf8str.length());
-  } else if (isBinary) {
-    // SQL_C_BINARY: use Latin-1 (matches NAN's WriteOneByte)
-    size_t copied = 0;
-    napi_get_value_string_latin1(env, value, (char *)param->buffer, param->buffer_length, &copied);
-  } else {
-#ifdef UNICODE
-    // UNICODE text: use UTF-16 (matches NAN's String::Write)
-    size_t copied = 0;
-    napi_get_value_string_utf16(env, value, (char16_t *)param->buffer, length + 1, &copied);
-#else
-    // Non-UNICODE text: use UTF-8 (matches NAN's WriteUtf8)
-    std::string utf8str = value.ToString().Utf8Value();
-    memcpy(param->buffer, utf8str.c_str(), utf8str.length());
-#endif
-  }
-
-#ifdef UNICODE
-  ((char *)param->buffer)[param->buffer_length - 2] = '\0';
-#endif
-  ((char *)param->buffer)[param->buffer_length - 1] = '\0';
-
-  if (param->paramtype == FILE_PARAM)
-  {
-    param->decimals = param->buffer_length;
-    param->fileOption = SQL_FILE_READ;
-    param->fileIndicator = 0;
-  }
-}
-
-void ODBC::GetBufferParam(Napi::Value value, Parameter *param, int num)
-{
-  Napi::Buffer<char> buffer = value.As<Napi::Buffer<char>>();
-  param->buffer = (char *)buffer.Data();
-  param->length = buffer.Length();
-  int bufflen = param->length;
-  param->isBuffer = true;
-
-  if (bufflen <= param->buffer_length &&
-      ((param->paramtype % 2 == 0) || (param->arraySize > 0)))
-  {
-    bufflen = param->buffer_length;
-  }
-  param->buffer_length = bufflen;
-  param->size = bufflen;
-
-  if (!param->c_type || (param->c_type == SQL_CHAR))
-    param->c_type = SQL_C_TCHAR;
-#ifdef UNICODE
-  param->length = SQL_NTS;
-  if (!param->type || (param->type == SQL_CHAR))
-    param->type = (param->length >= 8000) ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
-  if (param->c_type != SQL_C_BINARY) param->size /= 2;
-#else
-  if (!param->type || (param->type == SQL_CHAR))
-    param->type = (param->length >= 8000) ? SQL_LONGVARCHAR : SQL_VARCHAR;
-#endif
-
-  if (param->paramtype == FILE_PARAM)
-  {
-    param->decimals = param->buffer_length;
-    param->fileOption = SQL_FILE_READ;
-    param->fileIndicator = 0;
-  }
-}
-
-void ODBC::GetDataAtExecParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  Napi::Array chunkArray = value.As<Napi::Array>();
-  int numChunks = chunkArray.Length();
-
-  if (numChunks == 0)
-  {
-    Napi::Error::New(env, "DATA_AT_EXEC: Data array must not be empty").ThrowAsJavaScriptException();
-    return;
-  }
-
-  param->chunks = (void **)calloc(numChunks, sizeof(void *));
-  param->chunkLens = (SQLLEN *)calloc(numChunks, sizeof(SQLLEN));
-  if (!param->chunks || !param->chunkLens)
-  {
-    Napi::Error::New(env, "Failed to allocate chunk arrays for DATA_AT_EXEC").ThrowAsJavaScriptException();
-    return;
-  }
-  param->chunkCount = numChunks;
-
-  SQLLEN totalSize = 0;
-  for (int j = 0; j < numChunks; j++)
-  {
-    Napi::Value chunk = chunkArray.Get(j);
-    if (!chunk.IsBuffer())
-    {
-      Napi::Error::New(env, "DATA_AT_EXEC: each element in Data array must be a Buffer").ThrowAsJavaScriptException();
-      return;
-    }
-    Napi::Buffer<char> buf = chunk.As<Napi::Buffer<char>>();
-    param->chunks[j] = buf.Data();
-    param->chunkLens[j] = (SQLLEN)buf.Length();
-    totalSize += param->chunkLens[j];
-  }
-
-  if (param->buffer_length > 0)
-    param->size = param->buffer_length;
-  else
-    param->size = totalSize;
-
-  param->buffer = NULL;
-  param->buffer_length = 0;
-  param->length = SQL_LEN_DATA_AT_EXEC((SQLLEN)param->size);
-  param->isBuffer = true;
-}
-
-void ODBC::GetNullParam(Parameter *param, int num)
-{
-  param->c_type = param->c_type ? param->c_type : SQL_C_DEFAULT;
-  param->type = param->type ? param->type : SQL_VARCHAR;
-  param->length = SQL_NULL_DATA;
-
-  if (param->paramtype % 2 == 0)
-  {
-    if (param->type == SQL_BIGINT || param->type == SQL_INTEGER ||
-        param->type == SQL_BOOLEAN || param->type == SQL_SMALLINT ||
-        param->type == SQL_TINYINT)
-    {
-      param->buffer = new int64_t(0);
-    }
-    else if (param->type == SQL_DECIMAL || param->type == SQL_DOUBLE ||
-             param->type == SQL_REAL || param->type == SQL_FLOAT ||
-             param->type == SQL_NUMERIC || param->type == SQL_DECFLOAT)
-    {
-      param->buffer = new double(0);
-    }
-    else if (param->buffer_length > 0)
-    {
-      param->buffer = malloc(param->buffer_length);
-    }
-    else
-      param->buffer = malloc(8);
-  }
-}
-
-void ODBC::GetInt32Param(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  int64_t *number = new int64_t(value.As<Napi::Number>().Int32Value());
-  param->c_type = SQL_C_SBIGINT;
-  if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
-  param->buffer = number;
-  param->length = sizeof(number);
-}
-
-void ODBC::GetNumberParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  double *number = new double(value.As<Napi::Number>().DoubleValue());
-  std::string string = value.ToString().Utf8Value();
-  int length = (int)string.length();
-  char *ptr = strchr((char *)string.c_str(), '.');
-
-  if (!param->c_type || (param->c_type == SQL_C_CHAR)) param->c_type = SQL_C_DOUBLE;
-  if (!param->type || (param->type == SQL_CHAR)) param->type = SQL_DECIMAL;
-  param->buffer = number;
-  param->buffer_length = sizeof(double);
-  param->length = param->buffer_length;
-  param->size = sizeof(double);
-  if (ptr)
-  {
-    param->decimals = length - (ptr - string.c_str()) - 1;
-    if (param->type == SQL_DECIMAL) param->size = length - 1;
-  }
-  else
-  {
-    param->decimals = 0;
-    if (param->type == SQL_DECIMAL) param->size = length;
-  }
-}
-
-void ODBC::GetBoolParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  bool boolean = value.As<Napi::Boolean>().Value();
-  int64_t *number = new int64_t(boolean ? 1 : 0);
-  param->c_type = SQL_C_SBIGINT;
-  if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
-  param->buffer = number;
-  param->length = sizeof(number);
-}
-
-void ODBC::GetArrayParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
-{
-  Napi::Array valueArray = value.As<Napi::Array>();
-  int arrlen = valueArray.Length();
-
-  param->arraySize = arrlen;
-  if (arrlen <= 0)
-  {
-    param->buffer = new int[0];
-    return;
-  }
-
-  param->strLenArray = new SQLINTEGER[arrlen];
-
-  for (int j = 0; j < arrlen; j++)
-  {
-    Napi::Value val = valueArray.Get(j);
-    if (val.IsNull() || val.IsUndefined())
-    {
-      param->strLenArray[j] = SQL_NULL_DATA;
-      if (j == arrlen - 1)
-      {
-        GetNullParam(param, num);
-        param->buffer = new int[arrlen];
-      }
-      continue;
-    }
-    else if (val.IsNumber())
-    {
-      double dval = val.As<Napi::Number>().DoubleValue();
-      int32_t ival = val.As<Napi::Number>().Int32Value();
-      if (dval == (double)ival && param->type != 3)
-      {
-        int64_t *number = new int64_t[arrlen];
-        for (int i = j; i < arrlen; i++)
-        {
-          if (i != j)
-          {
-            val = valueArray.Get(i);
-            if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
-          }
-          number[i] = val.As<Napi::Number>().Int64Value();
-          param->strLenArray[i] = sizeof(int64_t);
-        }
-        param->c_type = SQL_C_SBIGINT;
-        if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
-        param->buffer = number;
-      }
-      else
-      {
-        double *number = new double[arrlen];
-        int decimals = 0;
-        for (int i = j; i < arrlen; i++)
-        {
-          if (i != j)
-          {
-            val = valueArray.Get(i);
-            if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
-          }
-          GetNumberParam(env, val, param, num);
-          number[i] = *(double *)param->buffer;
-          param->strLenArray[i] = param->length;
-          delete (double *)param->buffer;
-          param->buffer = NULL;
-          decimals = (decimals < param->decimals) ? param->decimals : decimals;
-        }
-        param->decimals = decimals;
-        param->buffer = number;
-      }
-    }
-    else if (val.IsBoolean())
-    {
-      int64_t *boolean = new int64_t[arrlen];
-      for (int i = j; i < arrlen; i++)
-      {
-        if (i != j)
-        {
-          val = valueArray.Get(i);
-          if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
-        }
-        GetBoolParam(env, val, param, num);
-        boolean[i] = *(int64_t *)(param->buffer);
-        param->strLenArray[i] = (SQLINTEGER)param->length;
-        delete (int64_t *)param->buffer;
-        param->buffer = NULL;
-      }
-      param->buffer = boolean;
-    }
-    else
-    {
-      SQLPOINTER *buff = (SQLPOINTER *)NULL;
-      SQLULEN bufflen = 0;
-      SQLULEN cbValueMax = 0;
-
-      SQLPOINTER *elemBufs = new SQLPOINTER[arrlen]();
-      SQLULEN *elemLens = new SQLULEN[arrlen]();
-      SQLLEN *elemDataLens = new SQLLEN[arrlen]();
-      bool *elemIsBuf = new bool[arrlen]();
-
-      for (int i = j; i < arrlen; i++)
-      {
-        if (i != j)
-        {
-          val = valueArray.Get(i);
-          if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
-        }
-        if (val.IsBuffer())
-        {
-          GetBufferParam(val, param, num);
-        }
-        else
-        {
-          GetStringParam(env, val, param, num);
-#ifdef UNICODE
-          param->buffer_length -= 2;
-#else
-          param->buffer_length -= 1;
-#endif
-        }
-        elemBufs[i] = param->buffer;
-        elemLens[i] = param->buffer_length;
-        elemDataLens[i] = param->length;
-        elemIsBuf[i] = param->isBuffer;
-        param->buffer = NULL;
-
-        if ((SQLULEN)param->buffer_length > cbValueMax)
-          cbValueMax = (SQLULEN)param->buffer_length;
-      }
-
-      bufflen = (SQLULEN)arrlen * cbValueMax;
-      buff = (SQLPOINTER *)malloc(bufflen);
-      memset(buff, 0, bufflen);
-
-      for (int i = j; i < arrlen; i++)
-      {
-        if (elemBufs[i] == NULL) continue;
-        SQLULEN copyLen = cbValueMax;
-        if (copyLen > (SQLULEN)elemDataLens[i]) copyLen = (SQLULEN)elemDataLens[i];
-        memcpy((char *)buff + (SQLULEN)i * cbValueMax, elemBufs[i], copyLen);
-        param->strLenArray[i] = (SQLINTEGER)copyLen;
-        if (!elemIsBuf[i]) FREE(elemBufs[i]);
-      }
-
-      delete[] elemBufs;
-      delete[] elemLens;
-      delete[] elemDataLens;
-      delete[] elemIsBuf;
-
-      param->buffer = buff;
-      param->buffer_length = cbValueMax;
-      param->size = cbValueMax;
-    }
-    break;
-  }
-}
-
-SQLRETURN ODBC::BindParameters(SQLHSTMT hSTMT, Parameter params[], int count)
-{
-  SQLRETURN ret = SQL_SUCCESS;
-  Parameter prm;
-
-  for (int i = 0; i < count; i++)
-  {
-    prm = params[i];
-
-    if (prm.paramtype == FILE_PARAM)
-    {
-      ret = SQLBindFileToParam(hSTMT, i + 1, prm.type, (SQLCHAR *)prm.buffer,
-                               NULL, &params[i].fileOption, prm.decimals, &params[i].fileIndicator);
-    }
-    else if (prm.paramtype == DATA_AT_EXEC_PARAM)
-    {
-      ret = SQLBindParameter(hSTMT, i + 1, SQL_PARAM_INPUT, prm.c_type, prm.type,
-                             prm.size, 0, (SQLPOINTER)(intptr_t)(i + 1), 0, &params[i].length);
-    }
-    else if (prm.arraySize > 0)
-    {
-      ret = SQLBindParameter(hSTMT, i + 1, prm.paramtype, prm.c_type, prm.type,
-                             prm.size, prm.decimals, prm.buffer, prm.buffer_length, prm.strLenArray);
-    }
-    else
-    {
-      ret = SQLBindParameter(hSTMT, i + 1, prm.paramtype, prm.c_type, prm.type,
-                             prm.size, prm.decimals, prm.buffer, prm.buffer_length, &params[i].length);
-    }
-
-    if (ret == SQL_ERROR) break;
-  }
-  return ret;
-}
-
-SQLRETURN ODBC::PutDataLoop(SQLHSTMT hSTMT, Parameter params[], int count)
-{
-  SQLRETURN ret;
-  SQLPOINTER token;
-
-  DEBUG_PRINTF("ODBC::PutDataLoop - Entry\n");
-
-  while ((ret = SQLParamData(hSTMT, &token)) == SQL_NEED_DATA)
-  {
-    int paramIdx = (int)(intptr_t)token - 1;
-
-    if (paramIdx < 0 || paramIdx >= count ||
-        params[paramIdx].chunks == NULL || params[paramIdx].chunkCount == 0)
-    {
-      return SQL_ERROR;
-    }
-
-    for (int j = 0; j < params[paramIdx].chunkCount; j++)
-    {
-      ret = SQLPutData(hSTMT, params[paramIdx].chunks[j], params[paramIdx].chunkLens[j]);
-      if (!SQL_SUCCEEDED(ret)) return ret;
-    }
-  }
-
-  DEBUG_PRINTF("ODBC::PutDataLoop - Exit, ret=%d\n", ret);
-  return ret;
-}
-
-/*
- * CallbackSQLError
- */
-Napi::Value ODBC::CallbackSQLError(Napi::Env env, SQLSMALLINT handleType,
-                                    SQLHANDLE handle, Napi::FunctionReference *cb)
-{
-  return CallbackSQLError(env, handleType, handle, (char *)"[node-ibm_db] SQL_ERROR", cb);
-}
-
-Napi::Value ODBC::CallbackSQLError(Napi::Env env, SQLSMALLINT handleType,
-                                    SQLHANDLE handle, char *message,
-                                    Napi::FunctionReference *cb)
-{
-  Napi::Value objError = ODBC::GetSQLError(env, handleType, handle, message);
-  cb->Call({objError});
-  return env.Undefined();
-}
-
-/*
- * GetSQLError
- */
-Napi::Value ODBC::GetSQLError(Napi::Env env, SQLSMALLINT handleType, SQLHANDLE handle)
-{
-  return GetSQLError(env, handleType, handle, (char *)"[ibm_db] SQL_ERROR");
-}
-
-Napi::Value ODBC::GetSQLError(Napi::Env env, SQLSMALLINT handleType,
-                               SQLHANDLE handle, char *message)
-{
-  DEBUG_PRINTF("ODBC::GetSQLError : handleType=%i, handle=0x%llx\n", handleType, HandleToLogValue(handle));
-
-  SQLINTEGER i = 0;
-  SQLINTEGER native;
-  SQLSMALLINT len;
-  SQLRETURN ret;
-  char errorSQLState[14];
-  char errorMessage[SQL_MAX_MESSAGE_LENGTH];
-  errorMessage[0] = '\0';
-  errorSQLState[0] = '\0';
-  native = 0;
-
-  ret = SQLGetDiagRec(handleType, handle, 1,
-                      (SQLTCHAR *)errorSQLState, &native,
-                      (SQLTCHAR *)errorMessage, sizeof(errorMessage), &len);
-
-  if (ret == -2)
-  {
-    strcpy(errorMessage, "CLI0600E Invalid connection handle or connection is closed. SQLSTATE=S1000");
-    strcpy(errorSQLState, "S1000");
-    native = -1;
-  }
-
-  // Create a proper Error object so that (err instanceof Error) === true
-#ifdef UNICODE
-  Napi::Error error = Napi::Error::New(env, Napi::String::New(env, (char16_t *)errorMessage));
-#else
-  Napi::Error error = Napi::Error::New(env, Napi::String::New(env, errorMessage));
-#endif
-  Napi::Object objError = error.Value();
-  objError.Set("error", Napi::String::New(env, message));
-  objError.Set("sqlcode", Napi::Number::New(env, (double)native));
-#ifdef UNICODE
-  objError.Set("sqlstate", Napi::String::New(env, (char16_t *)errorSQLState));
-#else
-  objError.Set("sqlstate", Napi::String::New(env, errorSQLState));
-#endif
-
-  return objError;
-}
-
-/*
- * GetAllRecordsSync
- */
-Napi::Array ODBC::GetAllRecordsSync(Napi::Env env, SQLHENV hENV, SQLHDBC hDBC,
-                                     SQLHSTMT hSTMT, uint16_t *buffer, size_t bufferLength)
-{
-  DEBUG_PRINTF("ODBC::GetAllRecordsSync\n");
-
-  int count = 0;
-  short colCount = 0;
-  Column *columns = GetColumns(hSTMT, &colCount);
-  Napi::Array rows = Napi::Array::New(env);
-
-  while (true)
-  {
-    SQLRETURN ret = SQLFetch(hSTMT);
-
-    if (ret == SQL_ERROR)
-    {
-      // error - break and return what we have
-      break;
-    }
-    if (ret == SQL_NO_DATA) break;
-
-    rows.Set(count, ODBC::GetRecordTuple(env, hSTMT, columns, &colCount, buffer, bufferLength));
-    count++;
-  }
-  ODBC::FreeColumns(columns, &colCount);
-  return rows;
-}
-
-#ifdef _AIX
-// On AIX, GCC's _GLOBAL__FD_node calls __cxa_finalize(NULL) during exit()
-// which crashes with SIGILL (jump to 0x0) because libdb2's __cxa_atexit
-// handlers become invalid. We install a SIGILL handler at module load time
-// so it is in place before any exit path runs module finalization.
-// Note: atexit() runs AFTER __modfini64 on AIX, and env cleanup hooks
-// are skipped by process.exit(), so neither approach works alone.
-// Installing at load time covers all exit paths. (#439, #1045)
-static void AIX_SigillHandler(int sig)
-{
-  _exit(0);
-}
-#endif
-
-// Module initialization
-Napi::Object InitAll(Napi::Env env, Napi::Object exports)
-{
-  ODBC::Init(env, exports);
-  ODBCResult::Init(env, exports);
-  ODBCConnection::Init(env, exports);
-  ODBCStatement::Init(env, exports);
-
-#ifdef _AIX
-  // Install SIGILL handler early — must be in place before exit() triggers
-  // __modfini64 → _GLOBAL__FD_node → __cxa_finalize(NULL) crash.
-  struct sigaction sa;
-  memset(&sa, 0, sizeof(sa));
-  sa.sa_handler = AIX_SigillHandler;
-  sigemptyset(&sa.sa_mask);
-  sa.sa_flags = 0;
-  sigaction(SIGILL, &sa, NULL);
-#endif
-
-  return exports;
-}
-
-NODE_API_MODULE(odbc_bindings, InitAll)
+/*
+  Copyright (c) 2013, Dan VerWeire <dverweire@gmail.com>
+  Copyright (c) 2010, Lee Smith<notwink@gmail.com>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+#ifdef __MVS__
+#define _AE_BIMODAL
+#include <_Nascii.h>
+#endif
+
+// On AIX, GCC auto-generates _GLOBAL__FI_*/_GLOBAL__FD_* init/fini functions
+// in every shared library via crtcxa.o. The fini function calls __cxa_finalize
+// which crashes with SIGILL (jump to 0x0) because atexit handlers registered
+// by libdb2.a become invalid during process exit. (#439, #1045)
+// We override the init/fini with this no-op to prevent the crash.
+#ifdef _AIX
+extern "C" void __ibmdb_aix_noop(void) {}
+#endif
+
+#include <string.h>
+#include <stdint.h>
+#include <type_traits>
+#include <time.h>
+#include <cassert>
+#include <cstdlib>
+#include <uv.h>
+#ifdef _AIX
+#include <signal.h>
+#include <unistd.h>
+#include <exception>
+#include <cstdio>
+#include <typeinfo>
+#include <cxxabi.h>
+#endif
+
+#include "odbc.h"
+#include "odbc_connection.h"
+#include "odbc_result.h"
+#include "odbc_statement.h"
+
+#ifdef _WIN32
+#include "strptime.h"
+#endif
+
+#define FILE_PARAM 3
+#define DATA_AT_EXEC_PARAM 5
+
+namespace {
+template <typename HandleType>
+unsigned long long HandleToLogValueImpl(HandleType handle, std::true_type)
+{
+  return static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(handle));
+}
+
+template <typename HandleType>
+unsigned long long HandleToLogValueImpl(HandleType handle, std::false_type)
+{
+  return static_cast<unsigned long long>(handle);
+}
+
+template <typename HandleType>
+unsigned long long HandleToLogValue(HandleType handle)
+{
+  return HandleToLogValueImpl(handle, typename std::is_pointer<HandleType>::type());
+}
+}
+
+uv_mutex_t ODBC::g_odbcMutex;
+uv_async_t ODBC::g_async;
+
+Napi::FunctionReference ODBC::constructor;
+
+Napi::Object ODBC::Init(Napi::Env env, Napi::Object exports)
+{
+  DEBUG_PRINTF("ODBC::Init\n");
+
+  Napi::Function func = DefineClass(env, "ODBC", {
+    InstanceMethod("createConnection", &ODBC::CreateConnection, NAPI_METHOD_ATTR),
+    InstanceMethod("createConnectionSync", &ODBC::CreateConnectionSync, NAPI_METHOD_ATTR),
+    StaticValue("SQL_CLOSE", Napi::Number::New(env, SQL_CLOSE), napi_enumerable),
+    StaticValue("SQL_DROP", Napi::Number::New(env, SQL_DROP), napi_enumerable),
+    StaticValue("SQL_UNBIND", Napi::Number::New(env, SQL_UNBIND), napi_enumerable),
+    StaticValue("SQL_RESET_PARAMS", Napi::Number::New(env, SQL_RESET_PARAMS), napi_enumerable),
+    StaticValue("SQL_DESTROY", Napi::Number::New(env, SQL_DESTROY), napi_enumerable),
+    StaticValue("FETCH_ARRAY", Napi::Number::New(env, FETCH_ARRAY), napi_enumerable),
+    StaticValue("FETCH_OBJECT", Napi::Number::New(env, FETCH_OBJECT), napi_enumerable),
+  });
+
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("ODBC", func);
+
+  // Initialize the cross platform mutex provided by libuv
+  uv_mutex_init(&ODBC::g_odbcMutex);
+
+  return exports;
+}
+
+ODBC::~ODBC()
+{
+  DEBUG_PRINTF("ODBC::~ODBC\n");
+  this->Free();
+}
+
+void ODBC::Free()
+{
+  DEBUG_PRINTF("ODBC::Free: m_hEnv = 0x%llx\n", HandleToLogValue(m_hEnv));
+  if (m_hEnv)
+  {
+    SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
+    m_hEnv = (SQLHENV)NULL;
+  }
+}
+
+ODBC::ODBC(const Napi::CallbackInfo &info) : Napi::ObjectWrap<ODBC>(info)
+{
+  Napi::Env env = info.Env();
+  DEBUG_PRINTF("ODBC::New - Entry\n");
+
+  m_hEnv = (SQLHENV)NULL;
+
+#ifdef __MVS__
+  int ori_mode = __ae_thread_swapmode(__AE_EBCDIC_MODE);
+#endif
+  int ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_hEnv);
+#ifdef __MVS__
+  __ae_thread_swapmode(ori_mode);
+#endif
+  if (!SQL_SUCCEEDED(ret))
+  {
+    DEBUG_PRINTF("ODBC::New - ERROR ALLOCATING ENV HANDLE!!\n");
+    Napi::Value objError = ODBC::GetSQLError(env, SQL_HANDLE_ENV, m_hEnv);
+    napi_throw(env, objError);
+    return;
+  }
+
+  ret = SQLSetEnvAttr(m_hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, SQL_IS_UINTEGER);
+
+  if (!SQL_SUCCEEDED(ret))
+  {
+    DEBUG_PRINTF("ODBC::New - ERROR SETTING ODBC VERSION!!\n");
+    Napi::Value objError = ODBC::GetSQLError(env, SQL_HANDLE_ENV, m_hEnv);
+    SQLFreeHandle(SQL_HANDLE_ENV, m_hEnv);
+    m_hEnv = (SQLHENV)NULL;
+    napi_throw(env, objError);
+    return;
+  }
+
+  DEBUG_PRINTF("ODBC::New - Exit\n");
+}
+
+/*
+ * CreateConnection
+ */
+Napi::Value ODBC::CreateConnection(const Napi::CallbackInfo &info)
+{
+  DEBUG_PRINTF("ODBC::CreateConnection - Entry\n");
+  Napi::Env env = info.Env();
+
+  REQ_FUN_ARG(0, cb);
+
+  uv_work_t *work_req = (uv_work_t *)(calloc(1, sizeof(uv_work_t)));
+  MEMCHECK(work_req);
+
+  create_connection_work_data *data =
+      (create_connection_work_data *)(calloc(1, sizeof(create_connection_work_data)));
+  if (!data) free(work_req);
+  MEMCHECK(data);
+
+  data->cb = new Napi::FunctionReference(Napi::Persistent(cb));
+  data->dbo = this;
+  data->env = env;
+
+  work_req->data = data;
+
+  uv_queue_work(uv_default_loop(), work_req, UV_CreateConnection, (uv_after_work_cb)UV_AfterCreateConnection);
+
+  this->Ref();
+
+  DEBUG_PRINTF("ODBC::CreateConnection - Exit\n");
+  return env.Undefined();
+}
+
+void ODBC::UV_CreateConnection(uv_work_t *req)
+{
+  DEBUG_PRINTF("ODBC::UV_CreateConnection - Entry\n");
+  create_connection_work_data *data = (create_connection_work_data *)(req->data);
+  data->result = SQLAllocHandle(SQL_HANDLE_DBC, data->dbo->m_hEnv, &data->hDBC);
+  DEBUG_PRINTF("ODBC::UV_CreateConnection - Exit: hDBC = 0x%llx\n", HandleToLogValue(data->hDBC));
+}
+
+void ODBC::UV_AfterCreateConnection(uv_work_t *req, int status)
+{
+  DEBUG_PRINTF("ODBC::UV_AfterCreateConnection - Entry\n");
+  create_connection_work_data *data = (create_connection_work_data *)(req->data);
+  Napi::Env env(data->env);
+  Napi::HandleScope scope(env);
+
+  if (!SQL_SUCCEEDED(data->result))
+  {
+    Napi::Value error = ODBC::GetSQLError(env, SQL_HANDLE_ENV, data->dbo->m_hEnv);
+    data->cb->Call({error});
+  }
+  else
+  {
+    Napi::Value args[2] = {
+      Napi::External<void>::New(env, (void *)(intptr_t)data->dbo->m_hEnv),
+      Napi::External<void>::New(env, (void *)(intptr_t)data->hDBC)
+    };
+    Napi::Object js_result = ODBCConnection::constructor.New({args[0], args[1]});
+    data->cb->Call({env.Null(), js_result});
+  }
+  PropagateCallbackException(env);
+
+  data->dbo->Unref();
+  delete data->cb;
+  free(data);
+  free(req);
+  DEBUG_PRINTF("ODBC::UV_AfterCreateConnection - Exit\n");
+}
+
+/*
+ * CreateConnectionSync
+ */
+Napi::Value ODBC::CreateConnectionSync(const Napi::CallbackInfo &info)
+{
+  DEBUG_PRINTF("ODBC::CreateConnectionSync - Entry\n");
+  Napi::Env env = info.Env();
+
+  SQLHDBC hDBC;
+  SQLRETURN ret = SQLAllocHandle(SQL_HANDLE_DBC, m_hEnv, &hDBC);
+
+  if (!SQL_SUCCEEDED(ret))
+  {
+    // TODO: do something!
+  }
+
+  Napi::Value params[2] = {
+    Napi::External<void>::New(env, (void *)(intptr_t)m_hEnv),
+    Napi::External<void>::New(env, (void *)(intptr_t)hDBC)
+  };
+  Napi::Object js_result = ODBCConnection::constructor.New({params[0], params[1]});
+
+  DEBUG_PRINTF("ODBC::CreateConnectionSync - Exit: hDBC = 0x%llx\n", HandleToLogValue(hDBC));
+  return js_result;
+}
+
+/*
+ * GetColumns
+ */
+Column *ODBC::GetColumns(SQLHSTMT hStmt, short *colCount)
+{
+  SQLRETURN ret;
+  SQLSMALLINT buflen;
+  SQLSMALLINT typebuflen;
+  DEBUG_PRINTF("ODBC::GetColumns - Entry\n");
+
+  *colCount = 0;
+  ret = SQLNumResultCols(hStmt, colCount);
+
+  if (!SQL_SUCCEEDED(ret))
+  {
+    return new Column[0];
+  }
+
+  Column *columns = new Column[*colCount];
+  char colname[MAX_FIELD_SIZE];
+
+  for (int i = 0; i < *colCount; i++)
+  {
+    columns[i].index = i + 1;
+    columns[i].getData = false;
+    columns[i].isFileBound = false;
+    colname[0] = '\0';
+    buflen = 0;
+
+    ret = SQLColAttribute(hStmt, columns[i].index,
+#ifdef STRICT_COLUMN_NAMES
+                          SQL_DESC_NAME,
+#else
+                          SQL_DESC_LABEL,
+#endif
+                          colname, (SQLSMALLINT)MAX_FIELD_SIZE, &buflen, NULL);
+
+    columns[i].name_len = buflen;
+    if (buflen > 0)
+    {
+      columns[i].name = new unsigned char[buflen + 2];
+      memcpy(columns[i].name, colname, buflen);
+      columns[i].name[buflen] = '\0';
+      columns[i].name[buflen + 1] = '\0';
+    }
+    DEBUG_PRINTF("ODBC::GetColumns index = %i, buflen=%i\n", columns[i].index, buflen);
+
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_DISPLAY_SIZE,
+                          NULL, 0, NULL, &columns[i].max_display_len);
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_PRECISION,
+                          NULL, 0, NULL, &columns[i].precision);
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_SCALE,
+                          NULL, 0, NULL, &columns[i].scale);
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_LENGTH,
+                          NULL, 0, NULL, &columns[i].field_len);
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_CONCISE_TYPE,
+                          NULL, 0, NULL, &columns[i].type);
+
+    columns[i].type_name = new unsigned char[(MAX_FIELD_SIZE)];
+    columns[i].type_name[0] = '\0';
+
+    ret = SQLColAttribute(hStmt, columns[i].index, SQL_DESC_TYPE_NAME,
+                          columns[i].type_name, (SQLSMALLINT)(MAX_FIELD_SIZE),
+                          &typebuflen, NULL);
+  }
+  DEBUG_PRINTF("ODBC::GetColumns - Exit\n");
+  return columns;
+}
+
+/*
+ * FreeColumns
+ */
+void ODBC::FreeColumns(Column *&columns, short *colCount)
+{
+  DEBUG_PRINTF("ODBC::FreeColumns - Entry\n");
+  for (int i = 0; i < *colCount; i++)
+  {
+    delete[] columns[i].name;
+    delete[] columns[i].type_name;
+  }
+  if (columns != NULL)
+  {
+    delete[] columns;
+    columns = NULL;
+  }
+  *colCount = 0;
+  DEBUG_PRINTF("ODBC::FreeColumns - Exit\n");
+}
+
+/*
+ * GetColumnValue
+ */
+Napi::Value ODBC::GetColumnValue(Napi::Env env, SQLHSTMT hStmt, Column column,
+                                  uint16_t *buffer, size_t bufferLength)
+{
+  if (column.isFileBound) {
+    return env.Null();
+  }
+
+  SQLLEN len = 0;
+  SQLLEN maxBuffSize = 0;
+  unsigned short terCharLen = 1;
+  SQLRETURN ret = SQL_SUCCESS;
+  SQLSMALLINT ctype = SQL_C_TCHAR;
+  char *errmsg = (char *)"[node-ibm_db] Error in ODBC::GetColumnValue";
+
+#ifdef UNICODE
+  terCharLen = 2;
+#endif
+
+  DEBUG_PRINTF("Column Type : %i\t%i\t%i\t%i\n", column.type, SQL_DATETIME,
+               SQL_TIMESTAMP, SQL_TYPE_TIME);
+
+  switch (column.type)
+  {
+  case SQL_BLOB:
+  case SQL_BINARY:
+  case SQL_VARBINARY:
+  case SQL_LONGVARBINARY:
+    terCharLen = 0;
+    ctype = SQL_C_BINARY;
+    break;
+  }
+
+  switch (column.type)
+  {
+  case SQL_INTEGER:
+  case SQL_SMALLINT:
+  case SQL_TINYINT:
+  {
+    SQLINTEGER value;
+    ret = SQLGetData(hStmt, column.index, SQL_C_SLONG, &value, sizeof(value), &len);
+
+    if (len == SQL_NULL_DATA) return env.Null();
+    return Napi::Number::New(env, (double)value);
+  }
+  break;
+
+  case SQL_NUMERIC:
+  case SQL_DECIMAL:
+  case SQL_DECFLOAT:
+  case SQL_FLOAT:
+  case SQL_REAL:
+  case SQL_DOUBLE:
+  {
+    double value;
+    ret = SQLGetData(hStmt, column.index, SQL_C_DOUBLE, &value, sizeof(value), &len);
+
+    if (len == SQL_NULL_DATA) return env.Null();
+    return Napi::Number::New(env, value);
+  }
+  break;
+
+  case SQL_DATETIME:
+  case SQL_TIMESTAMP:
+  {
+    SQL_TIMESTAMP_STRUCT odbcTime;
+#ifdef _WIN32
+    struct tm timeInfo = {};
+    ret = SQLGetData(hStmt, column.index, SQL_C_CHAR, &odbcTime, sizeof(odbcTime), &len);
+#else
+#if defined(_AIX) || defined(__MVS__)
+    struct tm timeInfo = {0, 0, 0, 0, 0, 0, 0, 0, 0};
+#else
+    struct tm timeInfo = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+#endif
+    ret = SQLGetData(hStmt, column.index, SQL_C_TYPE_TIMESTAMP, &odbcTime, sizeof(odbcTime), &len);
+#endif
+
+    if (len == SQL_NULL_DATA) return env.Null();
+
+    timeInfo.tm_year = odbcTime.year - 1900;
+    timeInfo.tm_mon = odbcTime.month - 1;
+    timeInfo.tm_mday = odbcTime.day;
+    timeInfo.tm_hour = odbcTime.hour;
+    timeInfo.tm_min = odbcTime.minute;
+    timeInfo.tm_sec = odbcTime.second;
+    timeInfo.tm_isdst = -1;
+
+#ifdef TIMEGM
+    return Napi::Date::New(env, (double(timegm(&timeInfo)) * 1000) + (odbcTime.fraction / 1000000));
+#else
+    return Napi::Date::New(env, (double(mktime(&timeInfo)) * 1000) + (odbcTime.fraction / 1000000));
+#endif
+  }
+  break;
+
+  case SQL_BIT:
+  {
+    char bit[4] = {'\0'};
+    ret = SQLGetData(hStmt, column.index, SQL_C_CHAR, &bit, 4, &len);
+    if (len == SQL_NULL_DATA) return env.Null();
+    return Napi::Boolean::New(env, (*bit == '0') ? false : true);
+  }
+  break;
+
+  case SQL_TYPE_TIME:
+  case SQL_BIGINT:
+    if (column.type == SQL_BIGINT) ctype = SQL_C_CHAR;
+    /* fall through */
+  case SQL_DBCLOB:
+    if (column.type == SQL_DBCLOB) ctype = SQL_C_CHAR;
+    /* fall through */
+  default:
+  {
+    uint16_t *tmp_out_ptr = NULL;
+    uint32_t bufferSize = 0;
+    uint32_t newbufflen = 0;
+    unsigned short secondGetData = 0;
+    len = 0;
+    bufferSize = bufferLength + terCharLen;
+
+    if (buffer == NULL)
+    {
+      buffer = (uint16_t *)malloc(bufferSize);
+      if (buffer == NULL)
+      {
+        errmsg = (char *)"Failed to allocate memory buffer for column data.";
+        napi_throw(env, ODBC::GetSQLError(env, SQL_HANDLE_STMT, hStmt, errmsg));
+        return env.Undefined();
+      }
+    }
+    maxBuffSize = bufferSize;
+    memset(buffer, '\0', bufferSize);
+    ret = SQLGetData(hStmt, column.index, ctype, (char *)buffer, maxBuffSize, &len);
+
+    if (column.getData) { secondGetData = 1; }
+    else if (ret == SQL_SUCCESS_WITH_INFO && len > 0)
+    {
+      if (len + terCharLen > 0x3fffffff)
+        newbufflen = 0x3fffffff;
+      else
+        newbufflen = len + terCharLen;
+
+      tmp_out_ptr = (uint16_t *)malloc(newbufflen);
+      if (tmp_out_ptr == NULL)
+      {
+        ret = (SQLRETURN)-3;
+        newbufflen = bufferSize;
+      }
+      else
+      {
+        memcpy(tmp_out_ptr, (char *)buffer, bufferLength);
+        free((uint16_t *)buffer);
+        buffer = tmp_out_ptr;
+        maxBuffSize = newbufflen - bufferLength;
+        len = 0;
+        ret = SQLGetData(hStmt, column.index, ctype, (char *)buffer + bufferLength, maxBuffSize, &len);
+        ret = SQL_SUCCESS;
+        len = newbufflen;
+        secondGetData = 1;
+      }
+    }
+    if (len >= 0) newbufflen = len;
+
+    if (len == SQL_NULL_DATA)
+    {
+      FREE(buffer);
+      return env.Null();
+    }
+    else if (SQL_SUCCEEDED(ret) || secondGetData)
+    {
+      if (ctype == SQL_C_BINARY)
+      {
+        // Return binary data as buffer - transfer ownership to Node
+        Napi::Buffer<char> buf = Napi::Buffer<char>::Copy(env, (char *)buffer, newbufflen);
+        FREE(buffer);
+        return buf;
+      }
+      else
+      {
+#ifdef UNICODE
+        Napi::Value str = Napi::String::New(env, (char16_t *)buffer);
+#else
+        Napi::Value str = Napi::String::New(env, (char *)buffer);
+#endif
+        FREE(buffer);
+        return str;
+      }
+    }
+    else
+    {
+      FREE(buffer);
+      if (ret == SQL_INVALID_HANDLE)
+      {
+        unsigned long long hstmt_value = HandleToLogValue(hStmt);
+#ifdef __MVS__
+        __fprintf_a(stdout, "Invalid Handle: SQLGetData return code = %i, stmt handle = 0x%llx"
+                ", columnType = %i, index = %i\n",
+              ret, hstmt_value, (int)column.type, column.index);
+#else
+        fprintf(stdout, "Invalid Handle: SQLGetData return code = %i, stmt handle = 0x%llx"
+            ", columnType = %i, index = %i\n",
+          ret, hstmt_value, (int)column.type, column.index);
+#endif
+        assert(ret != SQL_INVALID_HANDLE);
+      }
+      napi_throw(env, ODBC::GetSQLError(env, SQL_HANDLE_STMT, hStmt, errmsg));
+      return env.Undefined();
+    }
+  }
+  }
+}
+
+/*
+ * GetOutputParameter
+ */
+Napi::Value ODBC::GetOutputParameter(Napi::Env env, Parameter *prm)
+{
+  bool sqlTypeBinary = false;
+
+  switch (prm->type)
+  {
+  case SQL_BLOB:
+  case SQL_BINARY:
+  case SQL_VARBINARY:
+  case SQL_LONGVARBINARY:
+    sqlTypeBinary = true;
+    break;
+  }
+
+  if (((int)prm->length == SQL_NULL_DATA) || !prm->buffer)
+  {
+    return env.Null();
+  }
+
+  switch (prm->type)
+  {
+  case SQL_INTEGER:
+  case SQL_SMALLINT:
+  case SQL_TINYINT:
+  case SQL_BOOLEAN:
+  case SQL_NUMERIC:
+  case SQL_BIGINT:
+    if (prm->length == sizeof(int))
+      return Napi::Number::New(env, *(int *)prm->buffer);
+    else if (prm->length == sizeof(short))
+      return Napi::Number::New(env, *(short *)prm->buffer);
+    else if (prm->length == sizeof(long))
+      return Napi::Number::New(env, (double)*(long *)prm->buffer);
+    else if (prm->length == sizeof(long long))
+      return Napi::Number::New(env, (double)*(long long *)prm->buffer);
+    else
+      return Napi::Number::New(env, *(char *)prm->buffer);
+    break;
+
+  case SQL_DECIMAL:
+  case SQL_FLOAT:
+  case SQL_DECFLOAT:
+  case SQL_REAL:
+  case SQL_DOUBLE:
+    return Napi::Number::New(env, *(double *)prm->buffer);
+    break;
+
+  case SQL_BIT:
+    return Napi::Boolean::New(env, (*((char *)prm->buffer) == '0') ? false : true);
+    break;
+
+  default:
+    if (prm->isBuffer)
+    {
+      return Napi::Buffer<char>::Copy(env, (char *)prm->buffer, prm->length);
+    }
+    else if (sqlTypeBinary || prm->c_type == SQL_C_BINARY)
+    {
+      prm->isBuffer = true;
+      return Napi::Buffer<char>::Copy(env, (char *)prm->buffer, prm->length);
+    }
+    else
+    {
+#ifdef UNICODE
+      return Napi::String::New(env, (char16_t *)prm->buffer);
+#else
+      return Napi::String::New(env, (char *)prm->buffer);
+#endif
+    }
+  }
+}
+
+/*
+ * GetRecordTuple
+ */
+Napi::Object ODBC::GetRecordTuple(Napi::Env env, SQLHSTMT hStmt, Column *columns,
+                                   short *colCount, uint16_t *buffer, size_t bufferLength)
+{
+  Napi::Object tuple = Napi::Object::New(env);
+
+  for (int i = 0; i < *colCount; i++)
+  {
+#ifdef UNICODE
+    tuple.Set(Napi::String::New(env, (char16_t *)columns[i].name),
+              GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
+#else
+    tuple.Set(Napi::String::New(env, (const char *)columns[i].name),
+              GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
+#endif
+  }
+
+  return tuple;
+}
+
+/*
+ * GetRecordArray
+ */
+Napi::Value ODBC::GetRecordArray(Napi::Env env, SQLHSTMT hStmt, Column *columns,
+                                  short *colCount, uint16_t *buffer, size_t bufferLength)
+{
+  Napi::Array array = Napi::Array::New(env);
+
+  for (int i = 0; i < *colCount; i++)
+  {
+    array.Set(i, GetColumnValue(env, hStmt, columns[i], buffer, bufferLength));
+  }
+
+  return array;
+}
+
+/*
+ * GetParametersFromArray
+ */
+Parameter *ODBC::GetParametersFromArray(Napi::Env env, Napi::Array values, int *paramCount)
+{
+  DEBUG_PRINTF("ODBC::GetParametersFromArray\n");
+  *paramCount = values.Length();
+
+  Parameter *params = (Parameter *)malloc(*paramCount * sizeof(Parameter));
+  if (*paramCount != 0 && !params)
+  {
+    Napi::Error::New(env, "Could not allocate enough memory for params").ThrowAsJavaScriptException();
+    return params;
+  }
+  memset(params, '\0', *paramCount * sizeof(Parameter));
+
+  for (int i = 0; i < *paramCount; i++)
+  {
+    Napi::Value value = values.Get(i);
+    params[i].paramtype = SQL_PARAM_INPUT;
+    params[i].size = 0;
+    params[i].length = SQL_NULL_DATA;
+    params[i].buffer_length = 0;
+    params[i].decimals = 0;
+    params[i].isBuffer = false;
+
+    if (value.IsArray())
+    {
+      Napi::Array paramArray = value.As<Napi::Array>();
+      int arrlen = paramArray.Length();
+      if (arrlen < 4)
+      {
+        Napi::Error::New(env, "Wrong param format!").ThrowAsJavaScriptException();
+        return params;
+      }
+
+      Napi::Value val = paramArray.Get((uint32_t)0);
+      if (val.IsNumber()) params[i].paramtype = val.As<Napi::Number>().Int32Value();
+
+      val = paramArray.Get((uint32_t)1);
+      if (val.IsNumber()) params[i].c_type = val.As<Napi::Number>().Int32Value();
+      else params[i].c_type = SQL_C_CHAR;
+
+      val = paramArray.Get((uint32_t)2);
+      if (val.IsNumber()) params[i].type = val.As<Napi::Number>().Int32Value();
+      else params[i].type = SQL_CHAR;
+
+      if (arrlen == 5)
+      {
+        val = paramArray.Get((uint32_t)4);
+        if (val.IsNumber()) params[i].buffer_length = val.As<Napi::Number>().Int32Value();
+      }
+
+      val = paramArray.Get((uint32_t)3);
+      if (params[i].paramtype == DATA_AT_EXEC_PARAM && val.IsArray())
+      {
+        GetDataAtExecParam(env, val, &params[i], i + 1);
+      }
+      else if (val.IsNull() || val.IsUndefined())
+      {
+        GetNullParam(&params[i], i + 1);
+      }
+      else if (val.IsNumber() && !val.IsNull() && params[i].type != 3)
+      {
+        // Check if integer
+        double dval = val.As<Napi::Number>().DoubleValue();
+        int32_t ival = val.As<Napi::Number>().Int32Value();
+        if (dval == (double)ival && params[i].type != 3)
+          GetInt32Param(env, val, &params[i], i + 1);
+        else
+          GetNumberParam(env, val, &params[i], i + 1);
+      }
+      else if (val.IsBoolean())
+      {
+        GetBoolParam(env, val, &params[i], i + 1);
+      }
+      else if (val.IsArray())
+      {
+        GetArrayParam(env, val, &params[i], i + 1);
+      }
+      else if (val.IsBuffer())
+      {
+        GetBufferParam(val, &params[i], i + 1);
+      }
+      else
+      {
+        GetStringParam(env, val, &params[i], i + 1);
+      }
+    }
+    else if (value.IsBuffer())
+    {
+      GetBufferParam(value, &params[i], i + 1);
+    }
+    else if (value.IsString())
+    {
+      GetStringParam(env, value, &params[i], i + 1);
+    }
+    else if (value.IsNull() || value.IsUndefined())
+    {
+      GetNullParam(&params[i], i + 1);
+    }
+    else if (value.IsNumber())
+    {
+      double dval = value.As<Napi::Number>().DoubleValue();
+      int32_t ival = value.As<Napi::Number>().Int32Value();
+      if (dval == (double)ival)
+        GetInt32Param(env, value, &params[i], i + 1);
+      else
+        GetNumberParam(env, value, &params[i], i + 1);
+    }
+    else if (value.IsBoolean())
+    {
+      GetBoolParam(env, value, &params[i], i + 1);
+    }
+
+    if (env.IsExceptionPending())
+    {
+      return params;
+    }
+  }
+  return params;
+}
+
+void ODBC::GetStringParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  int length = 0;
+  int bufflen = 0;
+  int terCharLen = 1;
+  bool isBinary = (param->c_type == SQL_C_BINARY);
+
+  Napi::String stringValue = value.ToString();
+  if (stringValue.IsEmpty())
+  {
+    return;
+  }
+
+  // Determine string length using encoding that matches NAN behavior:
+  // SQL_C_BINARY -> Latin-1 (WriteOneByte), UNICODE -> UTF-16 (Write), else -> UTF-8
+  if (isBinary) {
+    size_t latin1_len = 0;
+    napi_get_value_string_latin1(env, value, NULL, 0, &latin1_len);
+    length = (int)latin1_len;
+  }
+#ifdef UNICODE
+  else {
+    size_t utf16_len = 0;
+    napi_get_value_string_utf16(env, value, NULL, 0, &utf16_len);
+    length = (int)utf16_len;
+  }
+#else
+  else {
+    std::string utf8str = stringValue.Utf8Value();
+    length = (int)utf8str.length();
+  }
+#endif
+
+  bufflen = length;
+  param->length = length;
+  if (!param->c_type || (param->c_type == SQL_CHAR))
+    param->c_type = SQL_C_TCHAR;
+#ifdef UNICODE
+  param->length = SQL_NTS;
+  if (!param->type || (param->type == SQL_CHAR))
+    param->type = (length >= 8000) ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
+  if (!isBinary)
+    bufflen = (length + 1) * sizeof(uint16_t);
+  terCharLen = 2;
+#else
+  if (!param->type || (param->type == SQL_CHAR))
+    param->type = (length >= 8000) ? SQL_LONGVARCHAR : SQL_VARCHAR;
+  if (!isBinary)
+  {
+    std::string utf8str = stringValue.Utf8Value();
+    bufflen = (int)utf8str.length() + 1;
+    param->length = bufflen - 1;
+  }
+#endif
+  if (isBinary) { bufflen = length + 1; }
+  if (bufflen <= param->buffer_length &&
+      ((param->paramtype % 2 == 0) || (param->arraySize > 0)))
+  {
+    bufflen = param->buffer_length + terCharLen;
+  }
+  param->buffer_length = bufflen;
+  param->size = bufflen;
+
+  param->buffer = malloc(param->buffer_length);
+  if (!param->buffer) return;
+  memset(param->buffer, 0, param->buffer_length);
+
+  // Copy string data using correct encoding (matching NAN behavior)
+  if (param->paramtype == FILE_PARAM) {
+    // FILE_PARAM: use UTF-8 (matches NAN's WriteUtf8)
+    std::string utf8str = stringValue.Utf8Value();
+    memcpy(param->buffer, utf8str.c_str(), utf8str.length());
+  } else if (isBinary) {
+    // SQL_C_BINARY: use Latin-1 (matches NAN's WriteOneByte)
+    size_t copied = 0;
+    napi_get_value_string_latin1(env, value, (char *)param->buffer, param->buffer_length, &copied);
+  } else {
+#ifdef UNICODE
+    // UNICODE text: use UTF-16 (matches NAN's String::Write)
+    size_t copied = 0;
+    napi_get_value_string_utf16(env, value, (char16_t *)param->buffer, length + 1, &copied);
+#else
+    // Non-UNICODE text: use UTF-8 (matches NAN's WriteUtf8)
+    std::string utf8str = stringValue.Utf8Value();
+    memcpy(param->buffer, utf8str.c_str(), utf8str.length());
+#endif
+  }
+
+#ifdef UNICODE
+  ((char *)param->buffer)[param->buffer_length - 2] = '\0';
+#endif
+  ((char *)param->buffer)[param->buffer_length - 1] = '\0';
+
+  if (param->paramtype == FILE_PARAM)
+  {
+    param->decimals = param->buffer_length;
+    param->fileOption = SQL_FILE_READ;
+    param->fileIndicator = 0;
+  }
+}
+
+void ODBC::GetBufferParam(Napi::Value value, Parameter *param, int num)
+{
+  Napi::Buffer<char> buffer = value.As<Napi::Buffer<char>>();
+  param->buffer = (char *)buffer.Data();
+  param->length = buffer.Length();
+  int bufflen = param->length;
+  param->isBuffer = true;
+
+  if (bufflen <= param->buffer_length &&
+      ((param->paramtype % 2 == 0) || (param->arraySize > 0)))
+  {
+    bufflen = param->buffer_length;
+  }
+  param->buffer_length = bufflen;
+  param->size = bufflen;
+
+  if (!param->c_type || (param->c_type == SQL_CHAR))
+    param->c_type = SQL_C_TCHAR;
+#ifdef UNICODE
+  param->length = SQL_NTS;
+  if (!param->type || (param->type == SQL_CHAR))
+    param->type = (param->length >= 8000) ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
+  if (param->c_type != SQL_C_BINARY) param->size /= 2;
+#else
+  if (!param->type || (param->type == SQL_CHAR))
+    param->type = (param->length >= 8000) ? SQL_LONGVARCHAR : SQL_VARCHAR;
+#endif
+
+  if (param->paramtype == FILE_PARAM)
+  {
+    param->decimals = param->buffer_length;
+    param->fileOption = SQL_FILE_READ;
+    param->fileIndicator = 0;
+  }
+}
+
+void ODBC::GetDataAtExecParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  Napi::Array chunkArray = value.As<Napi::Array>();
+  int numChunks = chunkArray.Length();
+
+  if (numChunks == 0)
+  {
+    Napi::Error::New(env, "DATA_AT_EXEC: Data array must not be empty").ThrowAsJavaScriptException();
+    return;
+  }
+
+  param->chunks = (void **)calloc(numChunks, sizeof(void *));
+  param->chunkLens = (SQLLEN *)calloc(numChunks, sizeof(SQLLEN));
+  if (!param->chunks || !param->chunkLens)
+  {
+    Napi::Error::New(env, "Failed to allocate chunk arrays for DATA_AT_EXEC").ThrowAsJavaScriptException();
+    return;
+  }
+  param->chunkCount = numChunks;
+
+  SQLLEN totalSize = 0;
+  for (int j = 0; j < numChunks; j++)
+  {
+    Napi::Value chunk = chunkArray.Get(j);
+    if (!chunk.IsBuffer())
+    {
+      Napi::Error::New(env, "DATA_AT_EXEC: each element in Data array must be a Buffer").ThrowAsJavaScriptException();
+      return;
+    }
+    Napi::Buffer<char> buf = chunk.As<Napi::Buffer<char>>();
+    param->chunks[j] = buf.Data();
+    param->chunkLens[j] = (SQLLEN)buf.Length();
+    totalSize += param->chunkLens[j];
+  }
+
+  if (param->buffer_length > 0)
+    param->size = param->buffer_length;
+  else
+    param->size = totalSize;
+
+  param->buffer = NULL;
+  param->buffer_length = 0;
+  param->length = SQL_LEN_DATA_AT_EXEC((SQLLEN)param->size);
+  param->isBuffer = true;
+}
+
+void ODBC::GetNullParam(Parameter *param, int num)
+{
+  param->c_type = param->c_type ? param->c_type : SQL_C_DEFAULT;
+  param->type = param->type ? param->type : SQL_VARCHAR;
+  param->length = SQL_NULL_DATA;
+
+  if (param->paramtype % 2 == 0)
+  {
+    if (param->type == SQL_BIGINT || param->type == SQL_INTEGER ||
+        param->type == SQL_BOOLEAN || param->type == SQL_SMALLINT ||
+        param->type == SQL_TINYINT)
+    {
+      param->buffer = new int64_t(0);
+    }
+    else if (param->type == SQL_DECIMAL || param->type == SQL_DOUBLE ||
+             param->type == SQL_REAL || param->type == SQL_FLOAT ||
+             param->type == SQL_NUMERIC || param->type == SQL_DECFLOAT)
+    {
+      param->buffer = new double(0);
+    }
+    else if (param->buffer_length > 0)
+    {
+      param->buffer = malloc(param->buffer_length);
+    }
+    else
+      param->buffer = malloc(8);
+  }
+}
+
+void ODBC::GetInt32Param(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  int64_t *number = new int64_t(value.As<Napi::Number>().Int32Value());
+  param->c_type = SQL_C_SBIGINT;
+  if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
+  param->buffer = number;
+  param->length = sizeof(number);
+}
+
+void ODBC::GetNumberParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  double *number = new double(value.As<Napi::Number>().DoubleValue());
+  std::string string = value.ToString().Utf8Value();
+  int length = (int)string.length();
+  char *ptr = strchr((char *)string.c_str(), '.');
+
+  if (!param->c_type || (param->c_type == SQL_C_CHAR)) param->c_type = SQL_C_DOUBLE;
+  if (!param->type || (param->type == SQL_CHAR)) param->type = SQL_DECIMAL;
+  param->buffer = number;
+  param->buffer_length = sizeof(double);
+  param->length = param->buffer_length;
+  param->size = sizeof(double);
+  if (ptr)
+  {
+    param->decimals = length - (ptr - string.c_str()) - 1;
+    if (param->type == SQL_DECIMAL) param->size = length - 1;
+  }
+  else
+  {
+    param->decimals = 0;
+    if (param->type == SQL_DECIMAL) param->size = length;
+  }
+}
+
+void ODBC::GetBoolParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  bool boolean = value.As<Napi::Boolean>().Value();
+  int64_t *number = new int64_t(boolean ? 1 : 0);
+  param->c_type = SQL_C_SBIGINT;
+  if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
+  param->buffer = number;
+  param->length = sizeof(number);
+}
+
+void ODBC::GetArrayParam(Napi::Env env, Napi::Value value, Parameter *param, int num)
+{
+  Napi::Array valueArray = value.As<Napi::Array>();
+  int arrlen = valueArray.Length();
+
+  param->arraySize = arrlen;
+  if (arrlen <= 0)
+  {
+    param->buffer = new int[0];
+    return;
+  }
+
+  param->strLenArray = new SQLINTEGER[arrlen];
+
+  for (int j = 0; j < arrlen; j++)
+  {
+    Napi::Value val = valueArray.Get(j);
+    if (val.IsNull() || val.IsUndefined())
+    {
+      param->strLenArray[j] = SQL_NULL_DATA;
+      if (j == arrlen - 1)
+      {
+        GetNullParam(param, num);
+        param->buffer = new int[arrlen];
+      }
+      continue;
+    }
+    else if (val.IsNumber())
+    {
+      double dval = val.As<Napi::Number>().DoubleValue();
+      int32_t ival = val.As<Napi::Number>().Int32Value();
+      if (dval == (double)ival && param->type != 3)
+      {
+        int64_t *number = new int64_t[arrlen];
+        for (int i = j; i < arrlen; i++)
+        {
+          if (i != j)
+          {
+            val = valueArray.Get(i);
+            if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
+          }
+          number[i] = val.As<Napi::Number>().Int64Value();
+          param->strLenArray[i] = sizeof(int64_t);
+        }
+        param->c_type = SQL_C_SBIGINT;
+        if (!param->type || (param->type == 1)) param->type = SQL_BIGINT;
+        param->buffer = number;
+      }
+      else
+      {
+        double *number = new double[arrlen];
+        int decimals = 0;
+        for (int i = j; i < arrlen; i++)
+        {
+          if (i != j)
+          {
+            val = valueArray.Get(i);
+            if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
+          }
+          GetNumberParam(env, val, param, num);
+          number[i] = *(double *)param->buffer;
+          param->strLenArray[i] = param->length;
+          delete (double *)param->buffer;
+          param->buffer = NULL;
+          decimals = (decimals < param->decimals) ? param->decimals : decimals;
+        }
+        param->decimals = decimals;
+        param->buffer = number;
+      }
+    }
+    else if (val.IsBoolean())
+    {
+      int64_t *boolean = new int64_t[arrlen];
+      for (int i = j; i < arrlen; i++)
+      {
+        if (i != j)
+        {
+          val = valueArray.Get(i);
+          if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
+        }
+        GetBoolParam(env, val, param, num);
+        boolean[i] = *(int64_t *)(param->buffer);
+        param->strLenArray[i] = (SQLINTEGER)param->length;
+        delete (int64_t *)param->buffer;
+        param->buffer = NULL;
+      }
+      param->buffer = boolean;
+    }
+    else
+    {
+      SQLPOINTER *buff = (SQLPOINTER *)NULL;
+      SQLULEN bufflen = 0;
+      SQLULEN cbValueMax = 0;
+
+      SQLPOINTER *elemBufs = new SQLPOINTER[arrlen]();
+      SQLULEN *elemLens = new SQLULEN[arrlen]();
+      SQLLEN *elemDataLens = new SQLLEN[arrlen]();
+      bool *elemIsBuf = new bool[arrlen]();
+
+      for (int i = j; i < arrlen; i++)
+      {
+        if (i != j)
+        {
+          val = valueArray.Get(i);
+          if (val.IsNull() || val.IsUndefined()) { param->strLenArray[i] = SQL_NULL_DATA; continue; }
+        }
+        if (val.IsBuffer())
+        {
+          GetBufferParam(val, param, num);
+        }
+        else
+        {
+          GetStringParam(env, val, param, num);
+          if (env.IsExceptionPending()) break;
+#ifdef UNICODE
+          param->buffer_length -= 2;
+#else
+          param->buffer_length -= 1;
+#endif
+        }
+        elemBufs[i] = param->buffer;
+        elemLens[i] = param->buffer_length;
+        elemDataLens[i] = param->length;
+        elemIsBuf[i] = param->isBuffer;
+        param->buffer = NULL;
+
+        if ((SQLULEN)param->buffer_length > cbValueMax)
+          cbValueMax = (SQLULEN)param->buffer_length;
+      }
+
+      bufflen = (SQLULEN)arrlen * cbValueMax;
+      buff = (SQLPOINTER *)malloc(bufflen);
+      memset(buff, 0, bufflen);
+
+      for (int i = j; i < arrlen; i++)
+      {
+        if (elemBufs[i] == NULL) continue;
+        SQLULEN copyLen = cbValueMax;
+        if (copyLen > (SQLULEN)elemDataLens[i]) copyLen = (SQLULEN)elemDataLens[i];
+        memcpy((char *)buff + (SQLULEN)i * cbValueMax, elemBufs[i], copyLen);
+        param->strLenArray[i] = (SQLINTEGER)copyLen;
+        if (!elemIsBuf[i]) FREE(elemBufs[i]);
+      }
+
+      delete[] elemBufs;
+      delete[] elemLens;
+      delete[] elemDataLens;
+      delete[] elemIsBuf;
+
+      param->buffer = buff;
+      param->buffer_length = cbValueMax;
+      param->size = cbValueMax;
+    }
+    break;
+  }
+}
+
+SQLRETURN ODBC::BindParameters(SQLHSTMT hSTMT, Parameter params[], int count)
+{
+  SQLRETURN ret = SQL_SUCCESS;
+  Parameter prm;
+
+  for (int i = 0; i < count; i++)
+  {
+    prm = params[i];
+
+    if (prm.paramtype == FILE_PARAM)
+    {
+      ret = SQLBindFileToParam(hSTMT, i + 1, prm.type, (SQLCHAR *)prm.buffer,
+                               NULL, &params[i].fileOption, prm.decimals, &params[i].fileIndicator);
+    }
+    else if (prm.paramtype == DATA_AT_EXEC_PARAM)
+    {
+      ret = SQLBindParameter(hSTMT, i + 1, SQL_PARAM_INPUT, prm.c_type, prm.type,
+                             prm.size, 0, (SQLPOINTER)(intptr_t)(i + 1), 0, &params[i].length);
+    }
+    else if (prm.arraySize > 0)
+    {
+      ret = SQLBindParameter(hSTMT, i + 1, prm.paramtype, prm.c_type, prm.type,
+                             prm.size, prm.decimals, prm.buffer, prm.buffer_length, prm.strLenArray);
+    }
+    else
+    {
+      ret = SQLBindParameter(hSTMT, i + 1, prm.paramtype, prm.c_type, prm.type,
+                             prm.size, prm.decimals, prm.buffer, prm.buffer_length, &params[i].length);
+    }
+
+    if (ret == SQL_ERROR) break;
+  }
+  return ret;
+}
+
+SQLRETURN ODBC::PutDataLoop(SQLHSTMT hSTMT, Parameter params[], int count)
+{
+  SQLRETURN ret;
+  SQLPOINTER token;
+
+  DEBUG_PRINTF("ODBC::PutDataLoop - Entry\n");
+
+  while ((ret = SQLParamData(hSTMT, &token)) == SQL_NEED_DATA)
+  {
+    int paramIdx = (int)(intptr_t)token - 1;
+
+    if (paramIdx < 0 || paramIdx >= count ||
+        params[paramIdx].chunks == NULL || params[paramIdx].chunkCount == 0)
+    {
+      return SQL_ERROR;
+    }
+
+    for (int j = 0; j < params[paramIdx].chunkCount; j++)
+    {
+      ret = SQLPutData(hSTMT, params[paramIdx].chunks[j], params[paramIdx].chunkLens[j]);
+      if (!SQL_SUCCEEDED(ret)) return ret;
+    }
+  }
+
+  DEBUG_PRINTF("ODBC::PutDataLoop - Exit, ret=%d\n", ret);
+  return ret;
+}
+
+/*
+ * CallbackSQLError
+ */
+Napi::Value ODBC::CallbackSQLError(Napi::Env env, SQLSMALLINT handleType,
+                                    SQLHANDLE handle, Napi::FunctionReference *cb)
+{
+  return CallbackSQLError(env, handleType, handle, (char *)"[node-ibm_db] SQL_ERROR", cb);
+}
+
+Napi::Value ODBC::CallbackSQLError(Napi::Env env, SQLSMALLINT handleType,
+                                    SQLHANDLE handle, char *message,
+                                    Napi::FunctionReference *cb)
+{
+  Napi::Value objError = ODBC::GetSQLError(env, handleType, handle, message);
+  cb->Call({objError});
+  return env.Undefined();
+}
+
+/*
+ * GetSQLError
+ */
+Napi::Value ODBC::GetSQLError(Napi::Env env, SQLSMALLINT handleType, SQLHANDLE handle)
+{
+  return GetSQLError(env, handleType, handle, (char *)"[ibm_db] SQL_ERROR");
+}
+
+Napi::Value ODBC::GetSQLError(Napi::Env env, SQLSMALLINT handleType,
+                               SQLHANDLE handle, char *message)
+{
+  DEBUG_PRINTF("ODBC::GetSQLError : handleType=%i, handle=0x%llx\n", handleType, HandleToLogValue(handle));
+
+  SQLINTEGER i = 0;
+  SQLINTEGER native;
+  SQLSMALLINT len;
+  SQLRETURN ret;
+  char errorSQLState[14];
+  char errorMessage[SQL_MAX_MESSAGE_LENGTH];
+  errorMessage[0] = '\0';
+  errorSQLState[0] = '\0';
+  native = 0;
+
+  ret = SQLGetDiagRec(handleType, handle, 1,
+                      (SQLTCHAR *)errorSQLState, &native,
+                      (SQLTCHAR *)errorMessage, sizeof(errorMessage), &len);
+
+  if (ret == -2)
+  {
+    strcpy(errorMessage, "CLI0600E Invalid connection handle or connection is closed. SQLSTATE=S1000");
+    strcpy(errorSQLState, "S1000");
+    native = -1;
+  }
+
+  // Create a proper Error object so that (err instanceof Error) === true
+#ifdef UNICODE
+  Napi::Error error = Napi::Error::New(env, Napi::String::New(env, (char16_t *)errorMessage));
+#else
+  Napi::Error error = Napi::Error::New(env, Napi::String::New(env, errorMessage));
+#endif
+  Napi::Object objError = error.Value();
+  objError.Set("error", Napi::String::New(env, message));
+  objError.Set("sqlcode", Napi::Number::New(env, (double)native));
+#ifdef UNICODE
+  objError.Set("sqlstate", Napi::String::New(env, (char16_t *)errorSQLState));
+#else
+  objError.Set("sqlstate", Napi::String::New(env, errorSQLState));
+#endif
+
+  return objError;
+}
+
+/*
+ * GetAllRecordsSync
+ */
+Napi::Array ODBC::GetAllRecordsSync(Napi::Env env, SQLHENV hENV, SQLHDBC hDBC,
+                                     SQLHSTMT hSTMT, uint16_t *buffer, size_t bufferLength)
+{
+  DEBUG_PRINTF("ODBC::GetAllRecordsSync\n");
+
+  int count = 0;
+  short colCount = 0;
+  Column *columns = GetColumns(hSTMT, &colCount);
+  Napi::Array rows = Napi::Array::New(env);
+
+  while (true)
+  {
+    SQLRETURN ret = SQLFetch(hSTMT);
+
+    if (ret == SQL_ERROR)
+    {
+      // error - break and return what we have
+      break;
+    }
+    if (ret == SQL_NO_DATA) break;
+
+    rows.Set(count, ODBC::GetRecordTuple(env, hSTMT, columns, &colCount, buffer, bufferLength));
+    count++;
+  }
+  ODBC::FreeColumns(columns, &colCount);
+  return rows;
+}
+
+#ifdef _AIX
+// On AIX, GCC's _GLOBAL__FD_node calls __cxa_finalize(NULL) during exit()
+// which crashes with SIGILL (jump to 0x0) because libdb2's __cxa_atexit
+// handlers become invalid. We install a SIGILL handler at module load time
+// so it is in place before any exit path runs module finalization.
+// Note: atexit() runs AFTER __modfini64 on AIX, and env cleanup hooks
+// are skipped by process.exit(), so neither approach works alone.
+// Installing at load time covers all exit paths. (#439, #1045)
+static void AIX_SigillHandler(int sig)
+{
+  _exit(0);
+}
+
+// GSKit v9.x throws C++ exceptions (gsk09000006::GSKException) from internal
+// threads during SSL handshake failures. Since those threads have no exception
+// handler, std::terminate() is called, leading to abort() and coredump.
+// We install a custom terminate handler to convert this to a graceful exit
+// with an error message instead of a coredump.
+static std::terminate_handler g_oldTerminateHandler = nullptr;
+
+// Helper to demangle C++ type names
+static const char* DemangleTypeName(const char* mangledName)
+{
+  int status = 0;
+  char* demangled = abi::__cxa_demangle(mangledName, nullptr, nullptr, &status);
+  if (status == 0 && demangled) {
+    return demangled; // Caller should free this
+  }
+  return mangledName;
+}
+
+static void AIX_TerminateHandler()
+{
+  // Try to get exception info
+  std::exception_ptr eptr = std::current_exception();
+  if (eptr) {
+    try {
+      std::rethrow_exception(eptr);
+    } catch (const std::exception& e) {
+      fprintf(stderr, "[ibm_db] GSKit SSL exception: %s\n", e.what());
+    } catch (...) {
+      // Try to get the exception type using GCC's internal ABI
+      std::type_info* ti = abi::__cxa_current_exception_type();
+      if (ti) {
+        const char* typeName = DemangleTypeName(ti->name());
+        fprintf(stderr, "\n[ibm_db] ERROR: GSKit v9.x SSL connection failed.\n");
+        fprintf(stderr, "Exception type: %s\n\n", typeName);
+        fprintf(stderr, "This is a known incompatibility between GSKit v9.x (compiled with IBM XLC)\n");
+        fprintf(stderr, "and GCC-compiled applications like Node.js on AIX. GSKit v9 throws C++\n");
+        fprintf(stderr, "exceptions from internal threads using XLC's exception handling ABI,\n");
+        fprintf(stderr, "which is incompatible with GCC's libstdc++ runtime.\n\n");
+        fprintf(stderr, "SOLUTION: Use a Db2 CLI driver (clidriver) that includes GSKit v8.x instead\n");
+        fprintf(stderr, "of GSKit v9.x. GSKit v8.x does not have this incompatibility.\n\n");
+        fprintf(stderr, "Db2 client from version 12.1.5.0 onwards comes with GSKit v9.x library.\n");
+        fprintf(stderr, "Use an older Db2 CLI driver (clidriver) to avoid this issue.\n\n");
+        fprintf(stderr, "To check your GSKit version:\n");
+        fprintf(stderr, "  ls $IBM_DB_HOME/lib/icc/libgsk*.so\n");
+        fprintf(stderr, "  - libgsk8*.so = GSKit v8 (compatible)\n");
+        fprintf(stderr, "  - libgsk9*.so = GSKit v9 (incompatible with GCC-compiled Node.js)\n\n");
+      } else {
+        fprintf(stderr, "[ibm_db] GSKit SSL exception (unknown type)\n");
+      }
+    }
+  } else {
+    fprintf(stderr, "[ibm_db] Terminate called without active exception\n");
+  }
+
+  // Exit without coredump - use _exit to avoid running atexit handlers
+  // which could cause additional crashes
+  _exit(1);
+}
+
+// SIGABRT handler as a fallback - catches abort() calls from GSKit threads
+static void AIX_SigabrtHandler(int sig)
+{
+  fprintf(stderr, "\n[ibm_db] ERROR: SIGABRT received - GSKit v9.x SSL connection failed.\n\n");
+  fprintf(stderr, "This is a known incompatibility between GSKit v9.x and GCC-compiled\n");
+  fprintf(stderr, "Node.js on AIX. Use a clidriver older than v12.1.5.0 instead.\n\n");
+  fprintf(stderr, "Check: ls $IBM_DB_HOME/lib/icc/libgsk*.so\n");
+  fprintf(stderr, "  - libgsk8*.so = GSKit v8 (compatible)\n");
+  fprintf(stderr, "  - libgsk9*.so = GSKit v9 (incompatible)\n\n");
+  _exit(1);
+}
+#endif
+
+// Module initialization
+Napi::Object InitAll(Napi::Env env, Napi::Object exports)
+{
+  ODBC::Init(env, exports);
+  ODBCResult::Init(env, exports);
+  ODBCConnection::Init(env, exports);
+  ODBCStatement::Init(env, exports);
+
+#ifdef _AIX
+  // Install custom terminate handler to catch GSKit v9.x exceptions thrown
+  // from internal threads. This converts coredumps to graceful error exits.
+  g_oldTerminateHandler = std::set_terminate(AIX_TerminateHandler);
+
+  // Install SIGABRT handler as fallback for abort() calls
+  struct sigaction sa_abrt;
+  memset(&sa_abrt, 0, sizeof(sa_abrt));
+  sa_abrt.sa_handler = AIX_SigabrtHandler;
+  sigemptyset(&sa_abrt.sa_mask);
+  sa_abrt.sa_flags = 0;
+  sigaction(SIGABRT, &sa_abrt, NULL);
+
+  // Install SIGILL handler early — must be in place before exit() triggers
+  // __modfini64 → _GLOBAL__FD_node → __cxa_finalize(NULL) crash.
+  struct sigaction sa;
+  memset(&sa, 0, sizeof(sa));
+  sa.sa_handler = AIX_SigillHandler;
+  sigemptyset(&sa.sa_mask);
+  sa.sa_flags = 0;
+  sigaction(SIGILL, &sa, NULL);
+#endif
+
+  return exports;
+}
+
+NODE_API_MODULE(odbc_bindings, InitAll)