@miatechnet/node-odbc 2.4.13 → 2.4.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@miatechnet/node-odbc",
   "description": "unixodbc bindings for node - Fork with multi-result set support for stored procedures",
-  "version": "2.4.13",
+  "version": "2.4.16",
   "homepage": "https://github.com/ppimentela/node-odbc/",
   "main": "lib/odbc.js",
   "types": "lib/odbc.d.ts",

package/src/odbc.h

@@ -185,6 +185,16 @@ typedef struct QueryOptions {
 
 } QueryOptions;
 
+// ResultSetData - holds a complete result set with its column metadata
+typedef struct ResultSetData {
+  std::vector<ColumnData*> rows;
+  Column **columns = NULL;
+  SQLSMALLINT column_count = 0;
+  ColumnBuffer *bound_columns = NULL;
+  SQLLEN rowCount = 0;
+  SQLUSMALLINT *row_status_array = NULL;
+} ResultSetData;
+
 // StatementData
 typedef struct StatementData {
 
@@ -209,7 +219,7 @@ typedef struct StatementData {
   SQLLEN                      rowCount;
 
   // Multiple result sets support (added by Pablo Pimentel)
-  std::vector<std::vector<ColumnData*>> allResultSets;
+  std::vector<ResultSetData> allResultSets;
 
   SQLSMALLINT                 maxColumnNameLength;
 
@@ -234,6 +244,7 @@ typedef struct StatementData {
 
   ~StatementData() {
     deleteColumns();
+    deleteAllResultSets();
 
     for (int i = 0; i < this->parameterCount; i++) {
       Parameter* parameter = this->parameters[i];
@@ -273,39 +284,106 @@ typedef struct StatementData {
     delete[] this->procedure; this->procedure = NULL;
   }
   
+  
+  // Static helper method to free columns and bound_columns arrays
+  // Parameters:
+  //   columns - Array of Column pointers to free
+  //   column_count - Number of columns in the array
+  //   bound_columns - Array of ColumnBuffer to free
+  //   row_status_array - Array of row status to free
+  // Note: This method takes ownership of the pointers and frees them
+  static void freeColumnsAndBuffers(Column **columns, SQLSMALLINT column_count, ColumnBuffer *bound_columns, SQLUSMALLINT *row_status_array) {
+    if (columns != NULL && bound_columns != NULL) {
+      for (int i = 0; i < column_count; i++) {
+        switch (columns[i]->bind_type) {
+          case SQL_C_CHAR:
+          case SQL_C_UTINYINT:
+          case SQL_C_BINARY:
+            delete[] (SQLCHAR *)bound_columns[i].buffer;
+            break;
+          case SQL_C_WCHAR:
+            delete[] (SQLWCHAR *)bound_columns[i].buffer;
+            break;
+          case SQL_C_DOUBLE:
+            delete[] (SQLDOUBLE *)bound_columns[i].buffer;
+            break;
+          case SQL_C_USHORT:
+            delete[] (SQLUSMALLINT *)bound_columns[i].buffer;
+            break;
+          case SQL_C_SLONG:
+            delete[] (SQLUINTEGER *)bound_columns[i].buffer;
+            break;
+          case SQL_C_UBIGINT:
+            delete[] (SQLUBIGINT *)bound_columns[i].buffer;
+            break;
+        }
+
+        delete[] columns[i]->ColumnName;
+        delete[] bound_columns[i].length_or_indicator_array;
+        delete columns[i];
+      }
+      delete[] columns;
+      delete[] bound_columns;
+    }
+
+    delete[] row_status_array;
+  }
+
+  // Clean up all stored result sets in allResultSets
+  // This method frees all rows, columns, and buffers for each result set
+  // Called by the destructor to ensure all memory is properly released
+  void deleteAllResultSets() {
+    for (size_t rs_index = 0; rs_index < allResultSets.size(); rs_index++) {
+      ResultSetData &rsData = allResultSets[rs_index];
+      
+      // Free rows
+      for (size_t h = 0; h < rsData.rows.size(); h++) {
+        delete[] rsData.rows[h];
+      }
+      rsData.rows.clear();
+      
+      // Free columns and buffers
+      freeColumnsAndBuffers(rsData.columns, rsData.column_count, rsData.bound_columns, rsData.row_status_array);
+    }
+    allResultSets.clear();
+  }
+
   void deleteColumns() {
     for (size_t h = 0; h < this->storedRows.size(); h++) {
       delete[] storedRows[h];
     }
     this->storedRows.clear();
 
-    for (int i = 0; i < this->column_count; i++) {
-      switch (this->columns[i]->bind_type) {
-        case SQL_C_CHAR:
-        case SQL_C_UTINYINT:
-        case SQL_C_BINARY:
-          delete[] (SQLCHAR *)this->bound_columns[i].buffer;
-          break;
-        case SQL_C_WCHAR:
-          delete[] (SQLWCHAR *)this->bound_columns[i].buffer;
-          break;
-        case SQL_C_DOUBLE:
-          delete[] (SQLDOUBLE *)this->bound_columns[i].buffer;
-          break;
-        case SQL_C_USHORT:
-          delete[] (SQLUSMALLINT *)this->bound_columns[i].buffer;
-          break;
-        case SQL_C_SLONG:
-          delete[] (SQLUINTEGER *)this->bound_columns[i].buffer;
-          break;
-        case SQL_C_UBIGINT:
-          delete[] (SQLUBIGINT *)this->bound_columns[i].buffer;
-          break;
-      }
+    // NULL guard for columns and bound_columns pointers
+    if (this->columns != NULL && this->bound_columns != NULL) {
+      for (int i = 0; i < this->column_count; i++) {
+        switch (this->columns[i]->bind_type) {
+          case SQL_C_CHAR:
+          case SQL_C_UTINYINT:
+          case SQL_C_BINARY:
+            delete[] (SQLCHAR *)this->bound_columns[i].buffer;
+            break;
+          case SQL_C_WCHAR:
+            delete[] (SQLWCHAR *)this->bound_columns[i].buffer;
+            break;
+          case SQL_C_DOUBLE:
+            delete[] (SQLDOUBLE *)this->bound_columns[i].buffer;
+            break;
+          case SQL_C_USHORT:
+            delete[] (SQLUSMALLINT *)this->bound_columns[i].buffer;
+            break;
+          case SQL_C_SLONG:
+            delete[] (SQLUINTEGER *)this->bound_columns[i].buffer;
+            break;
+          case SQL_C_UBIGINT:
+            delete[] (SQLUBIGINT *)this->bound_columns[i].buffer;
+            break;
+        }
 
-      delete[] this->columns[i]->ColumnName;
-      delete[] this->bound_columns[i].length_or_indicator_array;
-      delete this->columns[i];
+        delete[] this->columns[i]->ColumnName;
+        delete[] this->bound_columns[i].length_or_indicator_array;
+        delete this->columns[i];
+      }
     }
     this->column_count = 0;
 

package/src/odbc_connection.cpp

@@ -1905,20 +1905,23 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker {
           return;
         }
 
-        // Guardar el result set actual en allResultSets
-        //if (data->storedRows.size() > 0) {
-          std::vector<ColumnData*> currentResultSet;
-          for (size_t i = 0; i < data->storedRows.size(); i++) {
-            currentResultSet.push_back(data->storedRows[i]);
-          }
-          data->allResultSets.push_back(currentResultSet);
-        //}
+        // Save the result set with column metadata to allResultSets
+        ResultSetData rsData;
+        rsData.rows = data->storedRows;
+        rsData.columns = data->columns;
+        rsData.column_count = data->column_count;
+        rsData.bound_columns = data->bound_columns;
+        rsData.rowCount = data->rowCount;
+        rsData.row_status_array = data->row_status_array;
+        
+        data->allResultSets.push_back(rsData);
 
-        // Limpiar storedRows para el próximo result set (sin liberar memoria)
+        // Clear storedRows and reset pointers (don't free, they're now in allResultSets)
         data->storedRows.clear();
-        
-        // Limpiar columnas para el próximo result set
-        data->deleteColumns();
+        data->columns = NULL;
+        data->column_count = 0;
+        data->bound_columns = NULL;
+        data->row_status_array = NULL;
 
         // Intentar obtener el siguiente result set
         return_code = SQLMoreResults(data->hstmt);
@@ -1946,8 +1949,14 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker {
       
       // Procesar cada result set almacenado
       for (size_t rs_index = 0; rs_index < data->allResultSets.size(); rs_index++) {
-        // Restaurar temporalmente storedRows para procesarlo
-        data->storedRows = data->allResultSets[rs_index];
+        ResultSetData &rsData = data->allResultSets[rs_index];
+        
+        // Restore column metadata and rows for this result set
+        data->storedRows = rsData.rows;
+        data->columns = rsData.columns;
+        data->column_count = rsData.column_count;
+        data->bound_columns = rsData.bound_columns;
+        data->rowCount = rsData.rowCount;
         
         Napi::Array singleResult = process_data_for_napi(
           env,
@@ -1957,9 +1966,22 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker {
         
         allResults.Set(rs_index, singleResult);
         
-        // Limpiar storedRows después de procesar
-        data->storedRows.clear();
+        // Mark rows as processed (process_data_for_napi frees them internally)
+        data->allResultSets[rs_index].rows.clear();
+        // Mark columns as processed to prevent double-free
+        data->allResultSets[rs_index].columns = NULL;
+        data->allResultSets[rs_index].bound_columns = NULL;
+        data->allResultSets[rs_index].row_status_array = NULL;
       }
+      
+      // Clear allResultSets to prevent deleteAllResultSets from attempting to free already-processed memory
+      data->allResultSets.clear();
+      
+      // Reset pointers to avoid double-free (deleteColumns is called in destructor)
+      data->columns = NULL;
+      data->column_count = 0;
+      data->bound_columns = NULL;
+      data->row_status_array = NULL;
 
       std::vector<napi_value> callbackArguments;
       callbackArguments.push_back(env.Null());