@miatechnet/node-odbc 2.4.10-multiresult.1

package/src/odbc_connection.h

@@ -0,0 +1,114 @@
+/*
+  Copyright (c) 2019, 2021 IBM
+  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.
+*/
+
+#ifndef _SRC_ODBC_CONNECTION_H
+#define _SRC_ODBC_CONNECTION_H
+
+#include <napi.h>
+
+class ODBCConnection : public Napi::ObjectWrap<ODBCConnection> {
+
+  // ODBCConnection AsyncWorker classes
+  friend class CloseAsyncWorker;
+  friend class CreateStatementAsyncWorker;
+  friend class QueryAsyncWorker;
+  friend class BeginTransactionAsyncWorker;
+  friend class EndTransactionAsyncWorker;
+  friend class PrimaryKeysAsyncWorker;
+  friend class ForeignKeysAsyncWorker;
+  friend class TablesAsyncWorker;
+  friend class ColumnsAsyncWorker;
+  friend class GetInfoAsyncWorker;
+  friend class GetAttributeAsyncWorker;
+  friend class CallProcedureAsyncWorker;
+  friend class SetIsolationLevelAsyncWorker;
+  friend class FetchAsyncWorker;
+
+  friend class ODBCStatement;
+  friend class ODBCCursor;
+  // ODBCStatement AsyncWorker classes
+  friend class PrepareAsyncWorker;
+  friend class BindAsyncWorker;
+  friend class ExecuteAsyncWorker;
+  friend class CloseStatementAsyncWorker;
+
+  public:
+
+  static Napi::FunctionReference constructor;
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  ODBCConnection(const Napi::CallbackInfo& info);
+  ~ODBCConnection();
+
+  private:
+
+  SQLRETURN Free();
+
+  // Functions exposed to the Node.js environment
+  Napi::Value Close(const Napi::CallbackInfo& info);
+  Napi::Value CreateStatement(const Napi::CallbackInfo& info);
+  Napi::Value Query(const Napi::CallbackInfo& info);
+  Napi::Value CallProcedure(const Napi::CallbackInfo& info);
+
+  Napi::Value BeginTransaction(const Napi::CallbackInfo& info);
+  Napi::Value Commit(const Napi::CallbackInfo &info);
+  Napi::Value Rollback(const Napi::CallbackInfo &rollback);
+
+  Napi::Value GetUsername(const Napi::CallbackInfo &info);
+
+  Napi::Value Columns(const Napi::CallbackInfo& info);
+  Napi::Value Tables(const Napi::CallbackInfo& info);
+  Napi::Value PrimaryKeys(const Napi::CallbackInfo& info);
+  Napi::Value ForeignKeys(const Napi::CallbackInfo& info);
+
+  Napi::Value GetConnAttr(const Napi::CallbackInfo& info);
+  Napi::Value SetConnAttr(const Napi::CallbackInfo& info);
+
+  Napi::Value SetIsolationLevel(const Napi::CallbackInfo &info);
+
+  // Property Getter/Setterss
+  Napi::Value ConnectedGetter(const Napi::CallbackInfo& info);
+  Napi::Value ConnectionTimeoutGetter(const Napi::CallbackInfo& info);
+  Napi::Value LoginTimeoutGetter(const Napi::CallbackInfo& info);
+  Napi::Value AutocommitGetter(const Napi::CallbackInfo& info);
+
+  Napi::Value GetInfo(const Napi::Env env, const SQLUSMALLINT option);
+
+  void ParametersToArray(Napi::Reference<Napi::Array> *napiParameters, StatementData *data, unsigned char *overwriteParameters);
+
+  bool isConnected;
+  bool autocommit;
+
+  int numStatements;
+
+  SQLHENV hENV;
+  SQLHDBC hDBC;
+
+  ConnectionOptions connectionOptions;
+
+  GetInfoResults    getInfoResults;
+};
+
+Napi::Array process_data_for_napi(Napi::Env env, StatementData *data, Napi::Array napiParameters);
+SQLRETURN bind_buffers(StatementData *data);
+SQLRETURN prepare_for_fetch(StatementData *data);
+SQLRETURN fetch_and_store(StatementData *data, bool set_position, bool *alloc_error);
+SQLRETURN fetch_all_and_store(StatementData *data, bool set_position, bool *alloc_error);
+SQLRETURN set_fetch_size(StatementData *data, SQLULEN fetch_size);
+Napi::Value parse_query_options(Napi::Env env, Napi::Value options_value, QueryOptions *query_options);
+#endif

package/src/odbc_cursor.cpp

@@ -0,0 +1,265 @@
+/*
+  Copyright (c) 2021 IBM
+
+  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.
+*/
+
+#include "odbc_cursor.h"
+
+Napi::FunctionReference ODBCCursor::constructor;
+
+Napi::Object ODBCCursor::Init(Napi::Env env, Napi::Object exports)
+{
+  Napi::HandleScope scope(env);
+
+  Napi::Function constructorFunction = DefineClass(env, "ODBCCursor", {
+    InstanceMethod("fetch", &ODBCCursor::Fetch),
+    InstanceMethod("close", &ODBCCursor::Close),
+
+    InstanceAccessor("noData", &ODBCCursor::MoreResultsGetter, nullptr),
+  });
+
+  // Attach the Database Constructor to the target object
+  constructor = Napi::Persistent(constructorFunction);
+  constructor.SuppressDestruct();
+
+  return exports;
+}
+
+
+ODBCCursor::ODBCCursor(const Napi::CallbackInfo& info) : Napi::ObjectWrap<ODBCCursor>(info) {
+  this->data = info[0].As<Napi::External<StatementData>>().Data();
+  this->odbcConnection = info[1].As<Napi::External<ODBCConnection>>().Data();
+  if (info.Length() > 2 && info[2].IsArray()) {
+    this->napiParametersReference = Napi::Persistent(info[2].As<Napi::Array>());
+  } else {
+    this->napiParametersReference = Napi::Persistent(Napi::Array::New(Env()));
+  }
+  this->free_statement_on_close = info[3].As<Napi::Boolean>().Value();
+}
+
+SQLRETURN ODBCCursor::Free() {
+
+  SQLRETURN return_code = SQL_SUCCESS;
+
+  if (this->free_statement_on_close && this->data)
+  {
+    if (
+      this->data->hstmt &&
+      this->data->hstmt != SQL_NULL_HANDLE
+    )
+    {
+      uv_mutex_lock(&ODBC::g_odbcMutex);
+      return_code =
+      SQLFreeHandle
+      (
+        SQL_HANDLE_STMT,
+        this->data->hstmt
+      );
+      this->data->hstmt = SQL_NULL_HANDLE;
+      uv_mutex_unlock(&ODBC::g_odbcMutex);
+    }
+
+    napiParametersReference.Reset();
+    delete this->data;
+    this->data = NULL;
+  }
+
+  return return_code;
+}
+
+ODBCCursor::~ODBCCursor()
+{
+  this->Free();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//   FETCH   ///////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+class FetchAsyncWorker : public ODBCAsyncWorker {
+
+  private:
+    ODBCCursor    *cursor;
+    StatementData *data;
+
+  public:
+    FetchAsyncWorker
+    (
+      ODBCCursor     *cursor,
+      Napi::Function &callback
+    ) 
+    :
+    ODBCAsyncWorker(callback),
+    cursor(cursor),
+    data(cursor->data)
+    {}
+
+    ~FetchAsyncWorker() {}
+
+    void Execute() {
+      SQLRETURN return_code;
+      bool alloc_error = false;
+
+      return_code =
+      fetch_and_store
+      (
+        data,
+        true,
+        &alloc_error
+      );
+
+      if (alloc_error == true)
+      {
+        SetError("[odbc] Error allocating or reallocating memory when fetching data. No ODBC error information available.\0");
+        return;
+      }
+
+      if (!SQL_SUCCEEDED(return_code) && return_code != SQL_NO_DATA) {
+        if (return_code == SQL_INVALID_HANDLE) {
+          SetError("[odbc] Error fetching results with SQLFetch: SQL_INVALID_HANDLE\0");
+          return;
+        } else {
+          this->errors = GetODBCErrors(SQL_HANDLE_STMT, data->hstmt);
+        }
+        SetError("[odbc] Error fetching results with SQLFetch\0");
+        return;
+      }
+    }
+
+    void OnOK() {
+
+      Napi::Env env = Env();
+      Napi::HandleScope scope(env);
+
+      Napi::Array rows =
+      process_data_for_napi
+      (
+        env,
+        data,
+        cursor->napiParametersReference.Value()
+      );
+
+      std::vector<napi_value> callbackArguments
+      {
+        env.Null(),
+        rows
+      };
+
+      Callback().Call(callbackArguments);
+    }
+};
+
+Napi::Value ODBCCursor::Fetch(const Napi::CallbackInfo& info) {
+
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Function callback = info[0].As<Napi::Function>();
+
+  FetchAsyncWorker *worker = new FetchAsyncWorker(this, callback);
+  worker->Queue();
+
+  return env.Undefined();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//   Close   ///////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+class CursorCloseAsyncWorker : public ODBCAsyncWorker {
+
+  private:
+    ODBCCursor    *odbcCursor;
+    StatementData *data;
+
+  public:
+    CursorCloseAsyncWorker
+    (
+      ODBCCursor     *cursor,
+      Napi::Function &callback
+    ) 
+    :
+    ODBCAsyncWorker(callback),
+    odbcCursor(cursor),
+    data(cursor->data)
+    {}
+
+    ~CursorCloseAsyncWorker() {}
+
+    void Execute() {
+
+      SQLRETURN return_code;
+
+      return_code =
+      SQLCloseCursor
+      (
+        data->hstmt  // StatementHandle
+      );
+
+      if (!SQL_SUCCEEDED(return_code)) {
+        this->errors = GetODBCErrors(SQL_HANDLE_STMT, data->hstmt);
+        SetError("[odbc] Error closing the cursor!\0");
+        return;
+      }
+
+      if (odbcCursor->free_statement_on_close)
+      {
+        return_code = odbcCursor->Free();
+        if (!SQL_SUCCEEDED(return_code)) {
+          this->errors = GetODBCErrors(SQL_HANDLE_STMT, data->hstmt);
+          SetError("[odbc] Error closing the Statement\0");
+          return;
+        }
+      }
+      else
+      {
+        if (data != NULL)
+        {
+          data->deleteColumns();
+        }
+      }
+    }
+
+    void OnOK() {
+
+      Napi::Env env = Env();
+      Napi::HandleScope scope(env);
+
+      std::vector<napi_value> callbackArguments;
+      callbackArguments.push_back(env.Null());
+      Callback().Call(callbackArguments);
+    }
+};
+
+Napi::Value ODBCCursor::Close(const Napi::CallbackInfo& info) {
+
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Function callback = info[0].As<Napi::Function>();
+
+  CursorCloseAsyncWorker *worker = new CursorCloseAsyncWorker(this, callback);
+  worker->Queue();
+
+  return env.Undefined();
+}
+
+// Return true once SQL_NO_DATA has been returned from SQLFetch. Have to do it
+// this way, as a "moreResults" would have to return true if called before the
+// first call to SQLFetch, but there might actually not be any more results to
+// retrieve.
+Napi::Value ODBCCursor::MoreResultsGetter(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  return Napi::Boolean::New(env, data->result_set_end_reached);
+}

package/src/odbc_cursor.h

@@ -0,0 +1,52 @@
+/*
+  Copyright (c) 2021 IBM
+
+  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.
+*/
+
+#ifndef _SRC_ODBC_CURSOR_H
+#define _SRC_ODBC_CURSOR_H
+
+#include <napi.h>
+
+#include "odbc.h"
+#include "odbc_connection.h"
+#include "odbc_statement.h"
+
+class ODBCCursor : public Napi::ObjectWrap<ODBCCursor>
+{
+  friend class FetchAsyncWorker;
+
+  public:
+    static Napi::FunctionReference constructor;
+
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    ODBCConnection               *odbcConnection;
+    StatementData                *data;
+    Napi::Reference<Napi::Array>  napiParametersReference;
+    bool                          free_statement_on_close;
+
+    SQLRETURN Free();
+
+    explicit ODBCCursor(const Napi::CallbackInfo& info);
+    ~ODBCCursor();
+
+    Napi::Value Fetch(const Napi::CallbackInfo& info);
+    Napi::Value Close(const Napi::CallbackInfo& info);
+
+    // Property Getter/Setters
+    Napi::Value MoreResultsGetter(const Napi::CallbackInfo& info);
+};
+
+#endif