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

package/node_modules/ibm_db/src/odbc.cpp

@@ -0,0 +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>
+#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)