@miatechnet/node-odbc 2.4.10-multiresult.1

package/binding.gyp

@@ -0,0 +1,100 @@
+{
+  'targets' : [
+    {
+      'target_name' : 'odbc',
+      'sources' : [
+        'src/odbc.cpp',
+        'src/odbc_connection.cpp',
+        'src/odbc_statement.cpp',
+        'src/odbc_cursor.cpp',
+        'src/dynodbc.cpp'
+      ],
+      'cflags' : ['-Wall', '-Wextra', '-Wno-unused-parameter', '-DNAPI_DISABLE_CPP_EXCEPTIONS'],
+      'include_dirs': [
+        '<!@(node -p "require(\'node-addon-api\').include")'
+      ],
+      'defines' : [
+        'NAPI_VERSION=<(napi_build_version)'
+      ],
+      'conditions' : [
+        [ 'OS == "linux"', {
+          'libraries' : [
+            '-lodbc'
+          ],
+          'cflags' : [
+            '-g'
+          ]
+        }],
+        [ 'OS == "mac"', {
+          'conditions': [
+            [ 'target_arch=="arm64"', {
+              'include_dirs': [
+                '/opt/homebrew/include'
+              ],
+              'libraries' : [
+                '-L/opt/homebrew/lib',
+                '-lodbc'
+              ],
+            }], ['target_arch=="x64"', {
+              'include_dirs': [
+                '/usr/local/include',
+              ],
+              'libraries' : [
+                '-L/usr/local/lib',
+                '-lodbc'
+              ],
+            }],
+          ],
+          'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ]
+        }],
+        [ 'OS == "freebsd"', {
+          'include_dirs': [
+            '/usr/local/include'
+          ],
+          'libraries' : [
+            '-L/usr/local/lib',
+            '-lodbc'
+          ],
+          'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ]
+        }],
+        [ 'OS=="win"', {
+          'sources' : [
+            'src/odbc.cpp'
+          ],
+          'libraries' : [
+            '-lodbccp32.lib'
+          ],
+          'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS', 'UNICODE' ]
+        }],
+        [ 'OS=="aix"', {
+          'variables': {
+            'os_name': '<!(uname -s)',
+          },
+          'conditions': [
+             [ '"<(os_name)"=="OS400"', {
+               'ldflags': [
+                  '-Wl,-brtl,-blibpath:/QOpenSys/pkgs/lib,-lodbc'
+                ],
+                'cflags' : ['-std=c++0x', '-DNAPI_DISABLE_CPP_EXCEPTIONS', '-Wall', '-Wextra', '-Wno-unused-parameter', '-I/QOpenSys/usr/include', '-I/QOpenSys/pkgs/include']
+             }]
+          ]
+        }],
+        [ 'OS=="os400"', {
+          'ldflags': ['-Wl,-blibpath:/QOpenSys/pkgs/lib', '-lodbc'],
+          'cflags' : ['-std=c++0x', '-DNAPI_DISABLE_CPP_EXCEPTIONS', '-Wall', '-Wextra', '-Wno-unused-parameter', '-I/QOpenSys/usr/include', '-I/QOpenSys/pkgs/include']
+        }]
+      ]
+    },
+    {
+      "target_name": "action_after_build",
+      "type": "none",
+      "dependencies": [ "<(module_name)" ],
+      "copies": [
+        {
+          "files": [ "<(PRODUCT_DIR)/<(module_name).node" ],
+          "destination": "<(module_path)"
+        }
+      ]
+    }
+  ]
+}

package/lib/Connection.js

@@ -0,0 +1,521 @@
+const { Statement } = require('./Statement');
+const { Cursor }    = require('./Cursor');
+
+class Connection {
+
+  CONNECTION_CLOSED_ERROR = 'Connection has already been closed!';
+
+  /**
+   * An open connection to the database made through an ODBC driver
+   * @constructor
+   * @param {string|object} connectionString - The connection string to connect using the DSN
+   * defined in odbc.ini, or an odbcConnection object
+   */
+  constructor(odbcConnection) {
+    this.odbcConnection = odbcConnection;
+  }
+
+  get connected() {
+    if (!this.odbcConnection)
+    {
+      return false;
+    }
+    return this.odbcConnection.connected;
+  }
+
+  get autocommit() {
+    if (!this.odbcConnection)
+    {
+      throw new Error(CONNECTION_CLOSED_ERROR);
+    }
+    return this.odbcConnection.autocommit;
+  }
+
+  // TODO: Write the documentation
+  /**
+   *
+   * @param {*} sql
+   * @param {*} params
+   * @param {*} cb
+   */
+  query(sql, params, opts, cb) {
+    // accepted parameter signatures:
+    // sql
+    // sql, params
+    // sql, opts
+    // sql, params, opts
+    // sql, cb
+    // sql, params, cb
+    // sql, opts, cb
+    // sql, params, opts, cb
+
+    let callback = cb;
+    let parameters = params;
+    let options = opts;
+
+    // If callback is undefined, search for a function in another position
+    if (typeof callback === 'undefined')
+    {
+      if (typeof options === 'function')
+      {
+        callback = options;
+        options = undefined;
+      }
+      else if(typeof parameters === 'function')
+      {
+        callback = parameters;
+        options = undefined;
+        parameters = undefined;
+      }
+    }
+
+    if (typeof options === 'undefined')
+    {
+      if (typeof parameters === 'object' && parameters !== null && !Array.isArray(parameters))
+      {
+        options = parameters;
+        parameters = null;
+      } else {
+        options = null;
+      }
+    }
+
+    // if explicitly passing undefined into parameters, need to change to null
+    if (typeof parameters === 'undefined') {
+      parameters = null;
+    }
+
+    if (
+      typeof sql !== 'string' ||
+      (parameters !== null && !Array.isArray(parameters)) ||
+      (options !== null && typeof options !== 'object') ||
+      (typeof callback !== 'function' && typeof callback !== 'undefined')
+    ) 
+    {
+      throw new TypeError('[node-odbc]: Incorrect function signature for call to connection.query({string}, {array}[optional], {object}[optional], {function}[optional]).');
+    }
+
+    if (typeof callback !== 'function') {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.query(sql, parameters, options, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            if (options && 
+              (
+                options.hasOwnProperty('fetchSize') || 
+                options.hasOwnProperty('cursor')
+              )
+            )
+            {
+              const cursor = new Cursor(result);
+              resolve(cursor);
+            }
+            else
+            {
+              resolve(result);
+            }
+          }
+        });
+      });
+    }
+
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      process.nextTick(() => {
+        if (options &&
+          (
+            options.hasOwnProperty('fetchSize') ||
+            options.hasOwnProperty('cursor')
+          )
+        )
+        {
+          this.odbcConnection.query(sql, parameters, options, (error, result) => {
+            if (error) {
+              return callback(error);
+            }
+
+            const cursor = new Cursor(result);
+            return callback(error, cursor);
+          });
+        }
+        else
+        {
+          this.odbcConnection.query(sql, parameters, options, callback);
+        }
+      });
+    }
+  }
+
+  /**
+   *
+   * @param {string} name
+   * @param {Array} parameters
+   * @param {function} [cb]
+   */
+  callProcedure(catalog, schema, name, params = undefined, cb = undefined) {
+    // name
+    // name, params
+    // name, cb
+    // name, params, cb
+
+    let callback = cb;
+    let parameters = params;
+
+    if (typeof callback === 'undefined') {
+      if (typeof parameters === 'function') {
+        callback = parameters;
+        parameters = null;
+      } else if (typeof parameters === 'undefined') {
+        parameters = null;
+      }
+    }
+
+    // if explicitly passing undefined into parameters, need to change to null
+    if (typeof parameters === 'undefined') {
+      parameters = null;
+    }
+
+    if (typeof name !== 'string'
+    || (parameters !== null && !Array.isArray(parameters))
+    || (typeof callback !== 'function' && typeof callback !== 'undefined')) {
+      throw new TypeError('[node-odbc]: Incorrect function signature for call to connection.query({string}, {array}[optional], {function}[optional]).');
+    }
+
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.callProcedure(catalog, schema, name, parameters, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.callProcedure(catalog, schema, name, parameters, callback);
+    }
+  }
+
+  // TODO: Write the documentation
+  /**
+   *
+   * @param {*} callback
+   */
+  createStatement(callback = undefined) {
+    // type-checking
+    if (typeof callback !== 'function' && typeof callback !== 'undefined') {
+      throw new TypeError('[node-odbc]: Incorrect function signature for call to connection.createStatement({function}[optional]).');
+    }
+
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.createStatement((error, odbcStatement) => {
+          if (error) {
+            reject(error);
+          } else {
+            const statement = new Statement(odbcStatement);
+            resolve(statement);
+          }
+        });
+      });
+    }
+
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.createStatement((error, odbcStatement) => {
+        if (error) { return callback(error, null); }
+
+        const statement = new Statement(odbcStatement);
+        callback(null, statement);
+      });
+    }
+  }
+
+  /** TODO:
+   * Get the value of the passed attribute from the connection. Asynchronous, can be used either
+   * with a callback function or a Promise.
+   * @param {string} attribute - The title of the book.
+   * @param {function} [callback] - Callback function. If not passed, a Promise will be returned.
+   */
+  close(callback = undefined) {
+    // type-checking
+    if (typeof callback !== 'function' && typeof callback !== 'undefined') {
+      throw new TypeError('[node-odbc]: Incorrect function signature for call to connection.close({function}[optional]).');
+    }
+
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.close((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            this.odbcConnection = null;
+            resolve();
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    return this.odbcConnection.close((error) => {
+      if (!error)
+      {
+        this.odbcConnection = null;
+      }
+      return callback(error);
+    });
+  }
+
+  // TODO: Documentation
+  primaryKeys(catalog, schema, table, callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.primaryKeys(catalog, schema, table, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.primaryKeys(catalog, schema, table, callback);
+    }
+  }
+
+  // TODO: Documentation
+  foreignKeys(catalog, schema, table, fkCatalog, fkSchema, fkTable, callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.foreignKeys(catalog, schema, table, fkCatalog, fkSchema, fkTable, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.foreignKeys(catalog, schema, table, fkCatalog, fkSchema, fkTable, callback);
+    }
+  }
+
+  // TODO: Documentation
+  columns(catalog, schema, table, type, callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.columns(catalog, schema, table, type, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.columns(catalog, schema, table, type, callback);
+    }
+  }
+
+  // TODO: Documentation
+  tables(catalog, schema, table, type, callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.tables(catalog, schema, table, type, (error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.tables(catalog, schema, table, type, callback);
+    }
+  }
+
+  // TODO: Documentation
+  setIsolationLevel(isolationLevel, callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.setIsolationLevel(isolationLevel, (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.setIsolationLevel(isolationLevel, callback);
+    }
+  }
+
+  /**
+   * Begins a transaction, turning off auto-commit. Transaction is ended with commit() or
+   * rollback().
+   * @param {function} [callback] - Callback function. If not passed, a Promise will be returned.
+   */
+  beginTransaction(callback = undefined) {
+    // promise...
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.beginTransaction((error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.beginTransaction(callback);
+    }
+  }
+
+  /**
+   * Asynchronously ends the transaction with a commit.
+   * @param {function} [callback] - Callback function. If not passed, a Promise will be returned.
+   */
+  commit(callback = undefined) {
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.commit((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.commit(callback);
+    }
+  }
+
+  /**
+   * Asynchronously ends the transaction with a rollback.
+   * @param {function} [callback] - Callback function. If not passed, a Promise will be returned.
+   */
+  rollback(callback = undefined) {
+    if (callback === undefined) {
+      if (!this.odbcConnection)
+      {
+        throw new Error(Connection.CONNECTION_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcConnection.rollback((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+
+    if (!this.odbcConnection) {
+      callback(new Error(Connection.CONNECTION_CLOSED_ERROR));
+    } else {
+      this.odbcConnection.rollback(callback);
+    }
+  }
+}
+
+module.exports.Connection = Connection;

package/lib/Cursor.js

@@ -0,0 +1,92 @@
+class Cursor {
+
+  static CURSOR_CLOSED_ERROR = 'Cursor has already been closed!';
+
+  /**
+   * An cursor created following the execution of query that is ready to return a result set
+   * @constructor
+   * @param {object} odbcCursor - an odbcCursor object, defined in src/odbc_cursor.h/.cpp
+   */
+  constructor(odbcCursor) {
+    this.odbcCursor = odbcCursor;
+  }
+
+  /**
+   * Return whether or not a call to SQLFetch has returned SQL_NO_DATA
+   * @returns {boolean}
+   *
+   */
+  get noData() {
+    if (!this.odbcCursor)
+    {
+      throw new Error(Cursor.CURSOR_CLOSED_ERROR);
+    }
+    return this.odbcCursor.noData;
+  }
+
+  /**
+   * Calls SQL_FETCH and returns the next result set
+   * @param {function} [cb] - The callback function to return an error and a result. If the callback is ommited, a Promise is returned.
+   * @returns {undefined|Promise}
+   */
+  fetch(cb) {
+
+    let callback = cb;
+
+    if (typeof callback !== 'function') {
+      if (!this.odbcCursor) {
+        throw new Error(Cursor.CURSOR_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcCursor.fetch((error, result) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(result);
+          }
+        });
+      });
+    }
+
+    if (!this.odbcCursor) {
+      callback(new Error(Cursor.CURSOR_CLOSED_ERROR));
+    } else {
+      this.odbcCursor.fetch(callback);
+    }
+  }
+
+  /**
+   * Closes the cursor and the underlying SQLHSTMT, freeing all memory
+   * @param {function} [callback] - The callback function to return an error. If the callback is ommited, a Promise is returned.
+   * @returns {undefined|Promise}
+   */
+  close(callback = undefined) {
+
+    // promise...
+    if (typeof callback !== 'function') {
+      if (!this.odbcCursor) {
+        throw new Error(Cursor.CURSOR_CLOSED_ERROR);
+      }
+      return new Promise((resolve, reject) => {
+        this.odbcCursor.close((error) => {
+          if (error) {
+            reject(error);
+          } else {
+            this.odbcCursor = null;
+            resolve();
+          }
+        });
+      });
+    }
+
+    // ...or callback
+    this.odbcCursor.close((error) => {
+      if (!error) {
+        this.odbcCursor = null;
+      }
+      callback(error);
+    });
+  }
+}
+
+module.exports.Cursor = Cursor;