@miatechnet/node-odbc 2.4.10-multiresult.1

package/lib/odbc.d.ts

@@ -0,0 +1,210 @@
+declare namespace odbc {
+
+  class ColumnDefinition {
+    name: string;
+    dataType: number;
+    dataTypeName: string;
+    columnSize: number;
+    decimalDigits: number;
+    nullable: boolean;
+  }
+
+  class Result<T> extends Array<T> {
+    count: number;
+    columns: Array<ColumnDefinition>;
+    statement: string;
+    parameters: Array<number|string>;
+    return: number;
+  }
+
+  class OdbcError {
+    message: string;
+    code: number;
+    state: string;
+  }
+
+  class NodeOdbcError extends Error {
+    odbcErrors: Array<OdbcError>;
+  }
+
+  class Statement {
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Callbacks   ///////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    prepare(sql: string, callback: (error: NodeOdbcError) => undefined): undefined;
+
+    bind(parameters: Array<number|string>, callback: (error: NodeOdbcError) => undefined): undefined;
+
+    execute<T>(callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    close(callback: (error: NodeOdbcError) => undefined): undefined;
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Promises   ////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    prepare(sql: string): Promise<void>;
+
+    bind(parameters: Array<number|string>): Promise<void>;
+
+    execute<T>(): Promise<Result<T>>;
+
+    close(): Promise<void>;
+  }
+
+  interface ConnectionParameters {
+    connectionString: string;
+    connectionTimeout?: number;
+    loginTimeout?: number;
+  }
+  interface PoolParameters {
+    connectionString: string;
+    connectionTimeout?: number;
+    loginTimeout?: number;
+    initialSize?: number;
+    incrementSize?: number;
+    maxSize?: number;
+    reuseConnections?: boolean;
+    shrink?: boolean;
+  }
+
+  interface QueryOptions {
+    cursor?: boolean|string;
+    fetchSize?: number;
+    timeout?: number;
+    initialBufferSize?: number;
+  }
+
+  interface CursorQueryOptions extends QueryOptions {
+    cursor: boolean|string
+  }
+
+  class Connection {
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Callbacks   ///////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+    query<T>(sql: string, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+    query<T>(sql: string, parameters: Array<number|string>, callback: (error: NodeOdbcError, result: Result<T> | Cursor) => undefined): undefined;
+    query<T, O extends QueryOptions>(sql: string, options: O, callback: (error: NodeOdbcError, result: O extends CursorQueryOptions ? Cursor : Result<T>) => undefined): undefined;
+    query<T, O extends QueryOptions>(sql: string, parameters: Array<number|string>, options: O, callback: (error: NodeOdbcError, result: O extends CursorQueryOptions ? Cursor : Result<T>) => undefined): undefined;
+
+    callProcedure<T>(catalog: string|null, schema: string|null, name: string, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+    callProcedure<T>(catalog: string|null, schema: string|null, name: string, parameters: Array<number|string>, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    createStatement(callback: (error: NodeOdbcError, statement: Statement) => undefined): undefined;
+
+    primaryKeys<T>(catalog: string|null, schema: string|null, table: string|null, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    foreignKeys<T>(pkCatalog: string|null, pkSchema: string|null, pkTable: string|null, fkCatalog: string|null, fkSchema: string|null, fkTable: string|null, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    tables<T>(catalog: string|null, schema: string|null, table: string|null, type: string|null, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    columns<T>(catalog: string|null, schema: string|null, table: string|null, column: string|null, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+
+    setIsolationLevel(level: number, callback: (error: NodeOdbcError) => undefined): undefined;
+
+    beginTransaction(callback: (error: NodeOdbcError) => undefined): undefined;
+
+    commit(callback: (error: NodeOdbcError) => undefined): undefined;
+
+    rollback(callback: (error: NodeOdbcError) => undefined): undefined;
+
+    close(callback: (error: NodeOdbcError) => undefined): undefined;
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Promises   ////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+    query<T>(sql: string): Promise<Result<T>>;
+    query<T>(sql: string, parameters: Array<number|string>): Promise<Result<T>>;
+    query<T, O extends QueryOptions>(sql: string, options: O): O extends CursorQueryOptions ? Promise<Cursor> : Promise<Result<T>>;
+    query<T, O extends QueryOptions>(sql: string, parameters: Array<number|string>, options: O): O extends CursorQueryOptions ? Promise<Cursor> : Promise<Result<T>>;
+
+    callProcedure<T>(catalog: string|null, schema: string|null, name: string, parameters?: Array<number|string>): Promise<Result<T>>;
+
+    createStatement(): Promise<Statement>;
+
+    primaryKeys<T>(catalog: string|null, schema: string|null, table: string|null):  Promise<Result<T>>;
+
+    foreignKeys<T>(pkCatalog: string|null, pkSchema: string|null, pkTable: string|null, fkCatalog: string|null, fkSchema: string|null, fkTable: string|null):  Promise<Result<T>>;
+
+    tables<T>(catalog: string|null, schema: string|null, table: string|null, type: string|null): Promise<Result<T>>;
+
+    columns<T>(catalog: string|null, schema: string|null, table: string|null, column: string|null): Promise<Result<T>>;
+
+    setIsolationLevel(level: number): Promise<void>;
+
+    beginTransaction(): Promise<void>;
+
+    commit(): Promise<void>;
+
+    rollback(): Promise<void>;
+
+    close(): Promise<void>;
+  }
+
+  class Pool {
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Callbacks   ///////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+    connect(callback: (error: NodeOdbcError, connection: Connection) => undefined): undefined;
+
+    query<T>(sql: string, callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined;
+    query<T>(sql: string, parameters: Array<number|string>, callback: (error: NodeOdbcError, result: Result<T> | Cursor) => undefined): undefined;
+    query<T, O extends QueryOptions>(sql: string, options: O, callback: (error: NodeOdbcError, result: O extends CursorQueryOptions ? Cursor : Result<T>) => undefined): undefined;
+    query<T, O extends QueryOptions>(sql: string, parameters: Array<number|string>, options: O, callback: (error: NodeOdbcError, result: O extends CursorQueryOptions ? Cursor : Result<T>) => undefined): undefined;
+
+    close(callback: (error: NodeOdbcError) => undefined): undefined;
+
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Promises   ////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+    connect(): Promise<Connection>;
+
+    query<T>(sql: string): Promise<Result<T>>;
+    query<T>(sql: string, parameters: Array<number|string>): Promise<Result<T>>;
+    query<T, O extends QueryOptions>(sql: string, options: O): O extends CursorQueryOptions ? Promise<Cursor> : Promise<Result<T>>;
+    query<T, O extends QueryOptions>(sql: string, parameters: Array<number|string>, options: O): O extends CursorQueryOptions ? Promise<Cursor> : Promise<Result<T>>;
+
+    close(): Promise<void>;
+  }
+
+  class Cursor {
+    noData: boolean
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Promises   ////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    fetch<T>(): Promise<Result<T>>
+
+    close(): Promise<void>
+
+    ////////////////////////////////////////////////////////////////////////////
+    //   Callbacks   ///////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////
+
+    fetch<T>(callback: (error: NodeOdbcError, result: Result<T>) => undefined): undefined
+
+    close(callback: (error: NodeOdbcError) => undefined): undefined
+  }
+
+  function connect(connectionString: string, callback: (error: NodeOdbcError, connection: Connection) => undefined): undefined;
+  function connect(connectionObject: ConnectionParameters, callback: (error: NodeOdbcError, connection: Connection) => undefined): undefined;
+
+  function connect(connectionString: string): Promise<Connection>;
+  function connect(connectionObject: ConnectionParameters): Promise<Connection>;
+
+
+  function pool(connectionString: string, callback: (error: NodeOdbcError, pool: Pool) => undefined): undefined;
+  function pool(connectionObject: PoolParameters, callback: (error: NodeOdbcError, pool: Pool) => undefined): undefined;
+
+  function pool(connectionString: string): Promise<Pool>;
+  function pool(connectionObject: PoolParameters): Promise<Pool>;
+}
+
+export = odbc;

package/lib/odbc.js

@@ -0,0 +1,56 @@
+const binary = require('@mapbox/node-pre-gyp');
+const path = require('path');
+
+const bindingPath = binary.find(path.resolve(path.join(__dirname, '../package.json')));
+
+const nativeOdbc = require(bindingPath);
+
+const { Connection } = require('./Connection');
+const { Pool } = require('./Pool');
+
+function connect(connectionString, callback) {
+  if (typeof callback !== 'function') {
+    return new Promise((resolve, reject) => {
+      nativeOdbc.connect(connectionString, (error, odbcConnection) => {
+        if (error) {
+          reject(error);
+        } else {
+          const connection = new Connection(odbcConnection);
+          resolve(connection);
+        }
+      });
+    });
+  }
+
+  return nativeOdbc.connect(connectionString, (error, odbcConnection) => {
+    if (!error) {
+      return callback(error, new Connection(odbcConnection));
+    }
+    return callback(error, null);
+  });
+}
+
+function pool(options, callback) {
+  const poolObj = new Pool(options);
+
+  if (typeof callback !== 'function') {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await poolObj.init();
+        resolve(poolObj);
+      } catch(e) {
+        reject(e);
+      }
+    });
+  }
+
+  return poolObj.init((error) => {
+    callback(error, poolObj);
+  });
+}
+
+module.exports = {
+  pool,
+  connect,
+  ...nativeOdbc.odbcConstants,
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@miatechnet/node-odbc",
+  "description": "unixodbc bindings for node - Fork with multi-result set support for stored procedures",
+  "version": "2.4.10-multiresult.1",
+  "homepage": "https://github.com/ppimentela/node-odbc/",
+  "main": "lib/odbc.js",
+  "types": "lib/odbc.d.ts",
+  "files": [
+    "src/",
+    "lib/",
+    "CHANGELOG.md",
+    "binding.gyp"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ppimentela/node-odbc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ppimentela/node-odbc/issues"
+  },
+  "contributors": [
+    {
+      "name": "Mark Irish",
+      "email": "mirish@ibm.com"
+    },
+    {
+      "name": "Dan VerWeire",
+      "email": "dverweire@gmail.com"
+    },
+    {
+      "name": "Lee Smith",
+      "email": "notwink@gmail.com"
+    }
+  ],
+  "license": "MIT",
+  "directories": {
+    "lib": "."
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "build": "node-pre-gyp install --build-from-source",
+    "install": "node-pre-gyp install --fallback-to-build",
+    "test": "echo \"Warning: no test specified\" && exit 0"
+  },
+  "dependencies": {
+    "@mapbox/node-pre-gyp": "^2.0.0",
+    "async": "^3.0.1",
+    "node-addon-api": "^3.0.2"
+  },
+  "gypfile": true,
+  "devDependencies": {
+    "dotenv": "^6.2.0",
+    "eslint": "^8.11.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-plugin-import": "^2.25.4",
+    "mocha": "^11.7.4"
+  },
+  "binary": {
+    "module_name": "odbc",
+    "module_path": "./lib/bindings/napi-v{napi_build_version}",
+    "host": "https://github.com/ppimentela/node-odbc/releases/download/v{version}",
+    "package_name": "{module_name}-v{version}-{platform}-{arch}-napi-v{napi_build_version}.tar.gz",
+    "napi_versions": [
+      8
+    ]
+  }
+}

package/src/dynodbc.cpp

@@ -0,0 +1,189 @@
+#ifdef dynodbc
+
+#include "dynodbc.h"
+#include <stdio.h>
+
+#ifdef _WIN32
+  #include <windows.h>
+#elif defined(__GNUC__) // GNU compiler
+  #include <dlfcn.h>
+#else
+#error define your copiler
+#endif
+
+#include<string>
+/*
+#define RTLD_LAZY   1
+#define RTLD_NOW    2
+#define RTLD_GLOBAL 4
+*/
+
+void* LoadSharedLibrary(char *pcDllname, int iMode = 2)
+{
+  std::string sDllName = pcDllname;
+#ifdef _WIN32
+  sDllName += ".dll";
+  return (void*)LoadLibraryA(pcDllname);
+#elif defined(__GNUC__) // GNU compiler
+  sDllName += ".so";
+  void* handle = dlopen(sDllName.c_str(),iMode);
+
+  if (!handle) {
+    printf("node-odbc: error loading ODBC library: %s\n", dlerror());
+  }
+
+  return handle;
+#endif
+}
+
+void* GetFunction(void *Lib, char *Fnname)
+{
+#if defined(_MSC_VER) // Microsoft compiler
+  return (void*)GetProcAddress((HINSTANCE)Lib,Fnname);
+#elif defined(__GNUC__) // GNU compiler
+  void * tmp = dlsym(Lib, Fnname);
+  if (!tmp) {
+    printf("node-odbc: error loading function: %s\n", Fnname);
+  }
+  return tmp;
+#endif
+}
+
+bool FreeSharedLibrary(void *hDLL)
+{
+#if defined(_MSC_VER) // Microsoft compiler
+  return (FreeLibrary((HINSTANCE)hDLL)!=0);
+#elif defined(__GNUC__) // GNU compiler
+  return dlclose(hDLL);
+#endif
+}
+
+pfnSQLGetData           pSQLGetData;
+pfnSQLGetFunctions      pSQLGetFunctions;
+pfnSQLAllocConnect      pSQLAllocConnect;
+pfnSQLAllocEnv          pSQLAllocEnv;
+pfnSQLAllocStmt         pSQLAllocStmt;
+pfnSQLBindCol           pSQLBindCol;
+pfnSQLCancel            pSQLCancel;
+pfnSQLColAttributes     pSQLColAttributes;
+pfnSQLConnect           pSQLConnect;
+pfnSQLDescribeCol       pSQLDescribeCol;
+pfnSQLDisconnect        pSQLDisconnect;
+pfnSQLError             pSQLError;
+pfnSQLExecDirect        pSQLExecDirect;
+pfnSQLExecute           pSQLExecute;
+pfnSQLFetch             pSQLFetch;
+pfnSQLGetDiagRec        pSQLGetDiagRec;
+pfnSQLGetDiagField      pSQLGetDiagField;
+pfnSQLFreeHandle        pSQLFreeHandle;
+pfnSQLFetchScroll       pSQLFetchScroll;
+pfnSQLColAttribute      pSQLColAttribute;
+pfnSQLSetConnectAttr    pSQLSetConnectAttr;
+pfnSQLDriverConnect     pSQLDriverConnect;
+pfnSQLAllocHandle       pSQLAllocHandle;
+pfnSQLRowCount          pSQLRowCount;
+pfnSQLNumResultCols     pSQLNumResultCols;
+pfnSQLEndTran           pSQLEndTran;
+pfnSQLTables            pSQLTables;
+pfnSQLColumns           pSQLColumns;
+pfnSQLBindParameter     pSQLBindParameter;
+pfnSQLPrimaryKeys       pSQLPrimaryKeys;
+pfnSQLSetEnvAttr        pSQLSetEnvAttr  ;
+pfnSQLFreeConnect       pSQLFreeConnect;
+pfnSQLFreeEnv           pSQLFreeEnv;
+pfnSQLFreeStmt          pSQLFreeStmt;
+pfnSQLGetCursorName     pSQLGetCursorName;
+pfnSQLPrepare           pSQLPrepare;
+pfnSQLSetCursorName     pSQLSetCursorName;
+pfnSQLTransact          pSQLTransact;
+pfnSQLSetConnectOption  pSQLSetConnectOption;
+pfnSQLDrivers           pSQLDrivers;
+pfnSQLDataSources       pSQLDataSources;
+pfnSQLGetInfo           pSQLGetInfo;
+pfnSQLMoreResults       pSQLMoreResults;
+
+//#define LOAD_ENTRY( hMod, Name ) (p##Name = (pfn##Name) GetProcAddress( (hMod), #Name ))
+#define LOAD_ENTRY( hMod, Name ) (p##Name = (pfn##Name) GetFunction( (hMod), #Name ))
+
+static BOOL  s_fODBCLoaded = false;
+
+BOOL DynLoadODBC( char* odbcModuleName )
+{
+#ifdef _WIN32
+    HMODULE hMod;
+#elif defined(__GNUC__) // GNU compiler
+    void* hMod;
+#endif
+
+    if ( s_fODBCLoaded )
+      return true;
+
+ //   if ( (hMod = (HMODULE) LoadLibrary( odbcModuleName ))) {
+#ifdef _WIN32
+  if ( (hMod = (HMODULE) LoadSharedLibrary( odbcModuleName ))) {
+#elif defined(__GNUC__) // GNU compiler
+  if ( (hMod = (void *) LoadSharedLibrary( odbcModuleName ))) {
+#endif
+
+//#if (ODBCVER < 0x0300)
+  if (LOAD_ENTRY( hMod, SQLGetData   )  )
+  if (LOAD_ENTRY( hMod, SQLGetFunctions   )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLAllocConnect   )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLAllocEnv       )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLAllocStmt      )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLColAttributes  )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLError          )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLFreeConnect    )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLFreeEnv        )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLTransact       )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLSetConnectOption )  )
+/*
+ * NOTE: This is commented out because it wouldn't be used
+ * in a direct-to-driver situation and we currently never
+ * call SQLDrivers. But if we ever do we may need to have
+ * some type of flag to determine if we should try to load
+ * this function if the user is not doing a direct-to-driver
+ * and is specifying a specific libodbc library.
+ */
+//Unused-> if (LOAD_ENTRY( hMod, SQLDrivers        )  )
+
+  //Unused-> if (LOAD_ENTRY( hMod, SQLDataSources    )  )
+//#endif
+  //Unused-> if (LOAD_ENTRY( hMod, SQLBindCol        )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLCancel         )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLConnect       )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLDescribeCol    )  )
+  if (LOAD_ENTRY( hMod, SQLDisconnect     )  )
+  if (LOAD_ENTRY( hMod, SQLExecDirect     )  )
+  if (LOAD_ENTRY( hMod, SQLExecute        )  )
+  if (LOAD_ENTRY( hMod, SQLFetch          )  )
+  if (LOAD_ENTRY( hMod, SQLGetDiagRec     )  )
+  if (LOAD_ENTRY( hMod, SQLGetDiagField   )  )
+  if (LOAD_ENTRY( hMod, SQLFreeHandle     )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLFetchScroll    )  )
+  if (LOAD_ENTRY( hMod, SQLColAttribute   )  )
+  if (LOAD_ENTRY( hMod, SQLSetConnectAttr )  )
+  if (LOAD_ENTRY( hMod, SQLDriverConnect  )  )
+  if (LOAD_ENTRY( hMod, SQLAllocHandle    )  )
+  if (LOAD_ENTRY( hMod, SQLRowCount       )  )
+  if (LOAD_ENTRY( hMod, SQLNumResultCols  )  )
+  if (LOAD_ENTRY( hMod, SQLEndTran        )  )
+  if (LOAD_ENTRY( hMod, SQLTables         )  )
+  if (LOAD_ENTRY( hMod, SQLColumns        )  )
+  if (LOAD_ENTRY( hMod, SQLBindParameter  )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLPrimaryKeys)  )
+  if (LOAD_ENTRY( hMod, SQLSetEnvAttr     )  )
+  if (LOAD_ENTRY( hMod, SQLFreeStmt       )  )
+  if (LOAD_ENTRY( hMod, SQLPrepare        )  )
+  //Unused-> if (LOAD_ENTRY( hMod, SQLGetInfo        )  )
+  if (LOAD_ENTRY( hMod, SQLBindParameter  )  )
+  if (LOAD_ENTRY( hMod, SQLMoreResults    )
+          ) {
+
+          s_fODBCLoaded = true;
+      }
+  }
+
+  return (s_fODBCLoaded);
+}
+#endif