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

package/node_modules/ibm_db/test/test-block-fetch.js

@@ -0,0 +1,364 @@
+// Test for issue #977:
+// When SQL_ATTR_ROW_ARRAY_SIZE > 1, ibm_db should use SQLBindCol-based
+// block fetch to correctly return all rows. With 20 rows and
+// ROW_ARRAY_SIZE=5, all 20 rows must be returned.
+
+var common = require("./common")
+  , ibmdb = require("../")
+  , assert = require("assert")
+  , cn = common.connectionString
+  ;
+
+var tableName = "TEST_ISSUE977";
+
+ibmdb.open(cn, function(err, conn) {
+  if (err) { console.log(err); return; }
+  console.log("Connection opened successfully.");
+
+  // Drop table if exists
+  try { conn.querySync("DROP TABLE " + tableName); } catch(e) {}
+
+  // Create table and insert 20 rows
+  conn.querySync("CREATE TABLE " + tableName +
+    " (ID INTEGER, NAME VARCHAR(20))");
+  for (var i = 1; i <= 20; i++) {
+    conn.querySync("INSERT INTO " + tableName +
+      " VALUES (" + i + ", 'Row" + i + "')");
+  }
+  console.log("Inserted 20 rows into " + tableName);
+
+  // Verify all 20 rows exist using normal querySync (no ROW_ARRAY_SIZE)
+  var allRows = conn.querySync("SELECT * FROM " + tableName + " ORDER BY ID");
+  console.log("\nTest 0: querySync without ROW_ARRAY_SIZE = " +
+    allRows.length + " rows (expected 20)");
+  assert.equal(allRows.length, 20);
+
+  testFetchAllSync();
+
+  function testFetchAllSync() {
+    // Test 1: prepare + setAttrSync(ROW_ARRAY_SIZE, 5) + fetchAllSync
+    console.log("\nTest 1: fetchAllSync with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result = stmt.executeSync();
+    var data = result.fetchAllSync();
+    console.log("  Returned " + data.length + " rows (expected 20)");
+    assert.equal(data.length, 20, "fetchAllSync should return 20 rows");
+    // Verify all rows are present and in order
+    for (var i = 0; i < 20; i++) {
+      assert.equal(data[i].ID, i + 1,
+        "Row " + i + " should have ID=" + (i + 1));
+      assert.equal(data[i].NAME, "Row" + (i + 1));
+    }
+    console.log("  Data = ", data);
+    console.log("  PASS: All 20 rows correctly returned with proper data.");
+    result.closeSync();
+    stmt.closeSync();
+
+    testFetchAll();
+  }
+
+  function testFetchAll() {
+    // Test 2: prepare + setAttrSync(ROW_ARRAY_SIZE, 5) + async fetchAll
+    console.log("\nTest 2: async fetchAll with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt2 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt2.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result2 = stmt2.executeSync();
+
+    result2.fetchAll(function(err, data2) {
+      if (err) {
+        console.log("  ERROR:", err);
+        assert.fail("fetchAll should not error");
+      }
+      console.log("  Returned " + data2.length + " rows (expected 20)");
+      assert.equal(data2.length, 20, "fetchAll should return 20 rows");
+      for (var i = 0; i < 20; i++) {
+        assert.equal(data2[i].ID, i + 1);
+      }
+      console.log("  PASS: All 20 rows correctly returned.");
+      result2.closeSync();
+      stmt2.closeSync();
+
+      testFetchSync();
+    });
+  }
+
+  function testFetchSync() {
+    // Test 3: prepare + setAttrSync(ROW_ARRAY_SIZE, 5) + fetchSync loop
+    // fetchSync returns an array of up to ROW_ARRAY_SIZE rows per call
+    console.log("\nTest 3: fetchSync loop with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt3 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt3.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result3 = stmt3.executeSync();
+
+    var allRows = [];
+    var blockCount = 0;
+    var block;
+    while ((block = result3.fetchSync()) !== null) {
+      blockCount++;
+      assert.ok(Array.isArray(block), "fetchSync should return an array when ROW_ARRAY_SIZE > 1");
+      assert.ok(block.length <= 5, "Block should have at most ROW_ARRAY_SIZE rows");
+      console.log("  Block " + blockCount + ": " + block.length + " rows");
+      console.log("  Block data = ", block);
+      for (var i = 0; i < block.length; i++) {
+        allRows.push(block[i]);
+      }
+    }
+    console.log("  Total: " + allRows.length + " rows in " + blockCount + " blocks (expected 20 rows, 4 blocks)");
+    assert.equal(allRows.length, 20, "fetchSync should return 20 total rows");
+    assert.equal(blockCount, 4, "Should fetch 4 blocks of 5 rows each");
+    for (var i = 0; i < 20; i++) {
+      assert.equal(allRows[i].ID, i + 1);
+    }
+    console.log("  PASS: All 20 rows correctly returned in 4 blocks of 5.");
+    result3.closeSync();
+    stmt3.closeSync();
+
+    testFetchNSync();
+  }
+
+  function testFetchNSync() {
+    // Test 4: prepare + setAttrSync(ROW_ARRAY_SIZE, 5) + fetchNSync
+    console.log("\nTest 4: fetchNSync(10) with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt4 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt4.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result4 = stmt4.executeSync();
+
+    var batch1 = result4.fetchNSync(10);
+    console.log("  Batch 1: " + batch1.length + " rows (expected 10)");
+    assert.equal(batch1.length, 10, "fetchNSync(10) should return 10 rows");
+    console.log("  Batch 1 data = ", batch1);
+    for (var i = 0; i < 10; i++) {
+      assert.equal(batch1[i].ID, i + 1);
+    }
+
+    var batch2 = result4.fetchNSync(10);
+    console.log("  Batch 2: " + batch2.length + " rows (expected 10)");
+    assert.equal(batch2.length, 10, "fetchNSync(10) should return 10 rows");
+    console.log("  Batch 2 data = ", batch2);
+    for (var i = 0; i < 10; i++) {
+      assert.equal(batch2[i].ID, i + 11);
+    }
+
+    var batch3 = result4.fetchNSync(10);
+    console.log("  Batch 3: " + batch3.length + " rows (expected 0)");
+    assert.equal(batch3.length, 0, "fetchNSync(10) after all rows should return 0");
+
+    console.log("  PASS: fetchNSync correctly batched all 20 rows.");
+    result4.closeSync();
+    stmt4.closeSync();
+
+    testFetchArrayMode();
+  }
+
+  function testFetchArrayMode() {
+    // Test 5: fetchAllSync with FETCH_ARRAY mode and ROW_ARRAY_SIZE=5
+    console.log("\nTest 5: fetchAllSync FETCH_ARRAY with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt5 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt5.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result5 = stmt5.executeSync();
+    var data5 = result5.fetchAllSync({fetchMode: 3}); // FETCH_ARRAY = 3
+    console.log("  Returned " + data5.length + " rows (expected 20)");
+    assert.equal(data5.length, 20, "fetchAllSync FETCH_ARRAY should return 20 rows");
+    assert.equal(data5[0][0], 1, "First row ID should be 1");
+    assert.equal(data5[0][1], "Row1", "First row NAME should be 'Row1'");
+    assert.equal(data5[19][0], 20, "Last row ID should be 20");
+    console.log("  PASS: All 20 rows correctly returned as arrays.");
+    result5.closeSync();
+    stmt5.closeSync();
+
+    testFetchAsync();
+  }
+
+  function testFetchAsync() {
+    // Test 6: async fetch() (callback) with ROW_ARRAY_SIZE=5
+    // fetch() returns an array of up to ROW_ARRAY_SIZE rows per callback
+    console.log("\nTest 6: async fetch() callback with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt6 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt6.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result6 = stmt6.executeSync();
+    var allRows6 = [];
+    var blockCount6 = 0;
+
+    function fetchNext() {
+      result6.fetch(function(err, block) {
+        if (err) {
+          console.log("  ERROR:", err);
+          assert.fail("fetch() should not error");
+          return;
+        }
+        if (block) {
+          blockCount6++;
+          assert.ok(Array.isArray(block), "fetch() should return an array when ROW_ARRAY_SIZE > 1");
+          assert.ok(block.length <= 5, "Block should have at most ROW_ARRAY_SIZE rows");
+          console.log("  Block " + blockCount6 + ": " + block.length + " rows");
+          console.log("  Block data = ", block);
+          for (var i = 0; i < block.length; i++) {
+            allRows6.push(block[i]);
+          }
+          fetchNext();
+        } else {
+          console.log("  Total: " + allRows6.length + " rows in " + blockCount6 + " blocks (expected 20 rows, 4 blocks)");
+          assert.equal(allRows6.length, 20, "fetch() should return 20 total rows");
+          assert.equal(blockCount6, 4, "Should fetch 4 blocks of 5 rows each");
+          for (var i = 0; i < 20; i++) {
+            assert.equal(allRows6[i].ID, i + 1);
+          }
+          console.log("  PASS: All 20 rows correctly returned via async fetch() in 4 blocks.");
+          result6.closeSync();
+          stmt6.closeSync();
+
+          testFetchNAsync();
+        }
+      });
+    }
+    fetchNext();
+  }
+
+  function testFetchNAsync() {
+    // Test 7: async fetchN() (callback) with ROW_ARRAY_SIZE=5
+    console.log("\nTest 7: async fetchN() callback with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    var stmt7 = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt7.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result7 = stmt7.executeSync();
+
+    result7.fetchN(10, function(err, batch1) {
+      if (err) { console.log("  ERROR:", err); assert.fail("fetchN should not error"); }
+      console.log("  Batch 1: " + batch1.length + " rows (expected 10)");
+      assert.equal(batch1.length, 10, "fetchN(10) should return 10 rows");
+      for (var i = 0; i < 10; i++) {
+        assert.equal(batch1[i].ID, i + 1);
+      }
+
+      result7.fetchN(10, function(err, batch2) {
+        if (err) { console.log("  ERROR:", err); assert.fail("fetchN should not error"); }
+        console.log("  Batch 2: " + batch2.length + " rows (expected 10)");
+        assert.equal(batch2.length, 10, "fetchN(10) should return 10 rows");
+        for (var i = 0; i < 10; i++) {
+          assert.equal(batch2[i].ID, i + 11);
+        }
+
+        result7.fetchN(10, function(err, batch3) {
+          if (err) { console.log("  ERROR:", err); assert.fail("fetchN should not error"); }
+          console.log("  Batch 3: " + batch3.length + " rows (expected 0)");
+          assert.equal(batch3.length, 0, "fetchN(10) after all rows should return 0");
+
+          console.log("  PASS: async fetchN() correctly batched all 20 rows.");
+          result7.closeSync();
+          stmt7.closeSync();
+
+          testAsyncAwait();
+        });
+      });
+    });
+  }
+
+  function testAsyncAwait() {
+    // Test 8: async/await with all APIs and ROW_ARRAY_SIZE=5
+    console.log("\nTest 8: async/await with SQL_ATTR_ROW_ARRAY_SIZE = 5");
+    asyncAwaitTests().then(function() {
+      cleanup();
+    }).catch(function(err) {
+      console.log("  async/await test error:", err);
+      assert.fail("async/await tests should not error");
+    });
+  }
+
+  async function asyncAwaitTests() {
+    // 8a: fetchAll via Promise/await
+    console.log("  8a: await fetchAll()");
+    var stmt8a = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt8a.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result8a = stmt8a.executeSync();
+    var data8a = await result8a.fetchAll();
+    console.log("    Returned " + data8a.length + " rows (expected 20)");
+    assert.equal(data8a.length, 20, "await fetchAll() should return 20 rows");
+    for (var i = 0; i < 20; i++) {
+      assert.equal(data8a[i].ID, i + 1);
+    }
+    console.log("    PASS");
+    result8a.closeSync();
+    stmt8a.closeSync();
+
+    // 8b: fetch via Promise/await loop - returns array of rows per block
+    console.log("  8b: await fetch() blocks");
+    var stmt8b = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt8b.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result8b = stmt8b.executeSync();
+    var rows8b = [];
+    var blockCount8b = 0;
+    var block8b;
+    while ((block8b = await result8b.fetch()) !== null) {
+      blockCount8b++;
+      assert.ok(Array.isArray(block8b), "await fetch() should return an array when ROW_ARRAY_SIZE > 1");
+      console.log("    Block data = ", block8b);
+      for (var i = 0; i < block8b.length; i++) {
+        rows8b.push(block8b[i]);
+      }
+    }
+    console.log("    Returned " + rows8b.length + " rows in " + blockCount8b + " blocks (expected 20 rows, 4 blocks)");
+    assert.equal(rows8b.length, 20, "await fetch() should return 20 total rows");
+    assert.equal(blockCount8b, 4, "Should fetch 4 blocks of 5 rows each");
+    for (var i = 0; i < 20; i++) {
+      assert.equal(rows8b[i].ID, i + 1);
+    }
+    console.log("    PASS");
+    result8b.closeSync();
+    stmt8b.closeSync();
+
+    // 8c: fetchN via Promise/await batches
+    console.log("  8c: await fetchN() batches");
+    var stmt8c = conn.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt8c.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result8c = stmt8c.executeSync();
+    var b1 = await result8c.fetchN(7);
+    console.log("    Batch 1: " + b1.length + " rows (expected 7)");
+    assert.equal(b1.length, 7, "await fetchN(7) should return 7 rows");
+    assert.equal(b1[0].ID, 1);
+    assert.equal(b1[6].ID, 7);
+
+    var b2 = await result8c.fetchN(7);
+    console.log("    Batch 2: " + b2.length + " rows (expected 7)");
+    assert.equal(b2.length, 7, "await fetchN(7) should return 7 rows");
+    assert.equal(b2[0].ID, 8);
+    assert.equal(b2[6].ID, 14);
+
+    var b3 = await result8c.fetchN(7);
+    console.log("    Batch 3: " + b3.length + " rows (expected 6)");
+    assert.equal(b3.length, 6, "await fetchN(7) should return remaining 6 rows");
+    assert.equal(b3[0].ID, 15);
+    assert.equal(b3[5].ID, 20);
+
+    var b4 = await result8c.fetchN(7);
+    console.log("    Batch 4: " + b4.length + " rows (expected 0)");
+    assert.equal(b4.length, 0, "await fetchN(7) after all rows should return 0");
+
+    console.log("    PASS");
+    result8c.closeSync();
+    stmt8c.closeSync();
+
+    // 8d: full async/await using ibmdb.open Promise
+    console.log("  8d: full async/await with ibmdb.open");
+    var conn2 = await ibmdb.open(cn);
+    var stmt8d = conn2.prepareSync("SELECT * FROM " + tableName + " ORDER BY ID");
+    stmt8d.setAttrSync(ibmdb.SQL_ATTR_ROW_ARRAY_SIZE, 5);
+    var result8d = stmt8d.executeSync();
+    var data8d = await result8d.fetchAll();
+    assert.equal(data8d.length, 20, "full async/await should return 20 rows");
+    for (var i = 0; i < 20; i++) {
+      assert.equal(data8d[i].ID, i + 1);
+      assert.equal(data8d[i].NAME, "Row" + (i + 1));
+    }
+    console.log("    Returned " + data8d.length + " rows - PASS");
+    result8d.closeSync();
+    stmt8d.closeSync();
+    await conn2.close();
+    console.log("  PASS: All async/await tests passed.");
+  }
+
+  function cleanup() {
+    conn.querySync("DROP TABLE " + tableName);
+    conn.closeSync();
+    console.log("\nAll tests passed! Connection closed.");
+  }
+});

package/node_modules/ibm_db/test/test-blocking-issue210.js

@@ -0,0 +1,123 @@
+var common = require("./common")
+	, ibmdb = require("../")
+	, pool = new ibmdb.Pool()
+	, connectionString = common.connectionString
+    , iszos = common.isZOS
+    , assert = require("assert")
+	, connections = []
+	, connectCount = 2;
+
+var startTime1, startTime2, totalTime1, totalTime2, dropTable = 0;
+var elapsedTime = ibmdb.getElapsedTime;
+var ret = pool.init(connectCount, connectionString);
+if(typeof ret === 'object') assert.equal(ret.message, undefined);
+
+//moment().format("YYYY-MM-DD HH:mm:ss.SSS"));
+console.log(elapsedTime(), "Started pool.open, populate a table MTAB1 of 2330 rows.");
+pool.open(connectionString, function( err, conn) {
+    try { conn.querySync("drop table mtab1");
+          conn.querySync("drop table mtab2"); } catch(e) {};
+    conn.querySync("create table mtab1(c1 varchar(30), c2 varchar(20))");
+    conn.querySync("create table mtab2(c1 varchar(30), c2 varchar(20))");
+    if (iszos) {
+      // Db2 on z/OS does not support multi-row inserts
+      conn.querySync("Insert into mtab1 values ('1', 'bimal')");
+      conn.querySync("Insert into mtab1 values ('2', 'kumar')");
+      conn.querySync("Insert into mtab1 values ('3', 'jha')");
+      conn.querySync("Insert into mtab1 values ('4', 'kamal')");
+      conn.querySync("Insert into mtab1 values ('5', 'ibm')");
+
+      conn.querySync("Insert into mtab1 values ('1', 'bimal')");
+      conn.querySync("Insert into mtab1 values ('2', 'kumar')");
+      conn.querySync("Insert into mtab1 values ('3', 'jha')");
+      conn.querySync("Insert into mtab1 values ('4', 'kamal')");
+      conn.querySync("Insert into mtab1 values ('5', 'ibm')");
+    } else {
+      conn.querySync("Insert into mtab1 values ('1', 'bimal'),('2','kumar'),('3', 'jha'), ('4', 'kamal'), ('5', 'ibm')");
+      conn.querySync("Insert into mtab1 values ('1', 'bimal'),('2','kumar'),('3', 'jha'), ('4', 'kamal'), ('5', 'ibm')");
+    }
+    for(var i = 0; i < 6 ; i++) {
+      conn.querySync("insert into mtab2 (select * from mtab1)");
+      conn.querySync("insert into mtab1 (select * from mtab2)");
+      }
+    conn.querySync("drop table mtab2");
+    console.log(elapsedTime(), "Inserted rows in mtab1 = ", conn.querySync("select count(*) from mtab1")[0]['1']);
+    conn.close(function(err){});
+});
+
+ibmdb.debug(true);
+var q1time, q2time;
+console.log(elapsedTime(), "Opening connection #1");
+pool.open(connectionString, function (err, connection) {
+        console.log(elapsedTime(), "Connection 1 opened. Start execution of Query1");
+        startTime1 = new Date();
+        connection.query("select * from mtab1", function(err, data) {
+            if(err) console.log(err);
+            totalTime1 = (new Date() - startTime1)/1000;
+            q1time = parseInt(totalTime1%60);
+            console.log(elapsedTime(), "Total execution time for Query1 = ", q1time, "sec.");
+            dropTable++;
+            if(dropTable == 2) {
+                if( q2time > 1 ) {
+                    assert.equal(q1time >= 2 * q2time , false); // Do queries executed in sequence?
+                }
+                testLongTime(connection);
+            }
+        });
+});
+pool.open(connectionString, function (err, connection) {
+        console.log(elapsedTime(), "Connection 2 opened. Start execution of Query2");
+        startTime2 = new Date();
+        connection.query("select c1, c2 from mtab1", function(err, data) {
+            if(err) console.log(err);
+            totalTime2 = (new Date() - startTime2)/1000;
+            q2time = parseInt(totalTime2%60);
+            console.log(elapsedTime(), "Total execution time for Query2 = ", q2time, "sec.");
+            dropTable++;
+            if(dropTable == 2) {
+                if( q1time > 1 ) {
+                    assert.equal(q2time >= 2 * q1time, false); // Do queries executed in sequence?
+                }
+                testLongTime(connection);
+            }
+        });
+});
+
+// Test case for issue #230 - ? takes long time. Found a server issue.
+var testLongTime = function(conn) {
+    if (iszos) {
+      // Db2 on z/OS does not support multi-row inserts
+      conn.querySync("insert into mtab1 values ('330107196906080910', '330107196906080910')");
+      conn.querySync("insert into mtab1 values ('330107196906080910', '330107196906080910')");
+      conn.querySync("insert into mtab1 values ('330107196906080910', '')");
+    } else {
+      conn.querySync("insert into mtab1 values ('330107196906080910', '330107196906080910'), "+
+                   "('330107196906080910', '330107196906080910'), ('330107196906080910', '')");
+
+    }
+    var query1 = "select c1, c2 from mtab1 where (c1 in (?, ?) or c2 in (?, ?) and (? is null or c2 = ?))";
+    var query2 = "select c1, c2 from mtab1 where (c1 in ('330107196906080910', '330107196906080910') " +
+                 "or c2 in ('330107196906080910', '330107196906080910') and ('' is null or c2 = ''))";
+    var params = ['330107196906080910', '330107196906080910', '330107196906080910','330107196906080910', '', ''];
+    startTime1 = new Date();
+    conn.query(query1, params, function(err, rows) {
+        if(err) console.log(err);
+        else console.log(rows);
+        totalTime1 = (new Date() - startTime1)/1000;
+        console.log(elapsedTime(), "Total execution time for Query3 = ", totalTime1, "sec. **** <<==");
+        startTime2 = new Date();
+        conn.query(query2, function(err, rows) {
+            if(err) console.log(err);
+            else console.log(rows);
+            totalTime2 = (new Date() - startTime2)/1000;
+            console.log(elapsedTime(), "Total execution time for Query4 = ", totalTime2, "sec. **** <<==");
+
+            // Clean up
+            conn.querySync("drop table mtab1");
+            ibmdb.debug(false);
+            pool.close();
+        });
+    });
+}
+console.log(elapsedTime(), " **** All lines of test file executed, waiting for callback functions to finish. ");
+

package/node_modules/ibm_db/test/test-call-async.js

@@ -0,0 +1,64 @@
+// Test case to verify result of OUT and INOUT Parameters in a Strored Procedure.
+// When SP is called using conn.query() assynchronously.
+
+var common = require("./common")
+  , ibmdb = require("../")
+  , assert = require("assert")
+  , cn = common.connectionString
+  , iszos = common.isZOS
+  , schema = common.connectionObject.CURRENTSCHEMA;
+
+ibmdb.open(cn, function (err, conn)
+{
+    if(err) console.log(err);
+    assert.equal(err, null);
+    var query = "CaLL " + schema + ".PROC1(?, ?, ?)";
+    var proc1 = "create procedure " + schema + ".PROC1 " +
+               "(IN v1 INTEGER, OUT v2 INTEGER, INOUT v3 VARCHAR(20)) " +
+               "BEGIN set v2 = v1 + 1; set v3 = 'verygood'; END";
+    var proc2 = "create or replace procedure " + schema + ".PROC2 (IN v1 INTEGER) BEGIN END";
+    var dropProc1 = "drop procedure " + schema + ".PROC1(INT, INT, VARCHAR(20))";
+    var dropProc2 = "drop procedure " + schema + ".PROC2(INT)";
+
+    if (iszos) {
+        // The DROP PROCEDURE syntax on z/OS can only specify the name of the procedure to drop.
+        dropProc1 = "drop procedure " + schema + ".PROC1";
+        dropProc2 = "drop procedure " + schema + ".PROC2";
+        proc1 = common.sanitizeSP(proc1);
+        proc2 = common.sanitizeSP(proc2);
+    }
+    try {
+        conn.querySync(dropProc1);
+        console.log("PROC1 dropped.\n");
+    } catch(e) { }
+
+    conn.querySync(proc1);
+    console.log("created PROC1...\n");
+    conn.commitTransactionSync();
+    var param1 = {ParamType:"INPUT", DataType:1, Data:3};
+    var param2 = {ParamType:"OUTPUT", DataType:1, Data:0};
+    var param3 = {ParamType:"INOUT", DataType:1, Data:"abc", Length:30};
+
+    conn.query(query, [param1, param2, param3], function(err, result){
+        if(err) console.log(err);
+        else {
+            console.log("return value = ", result[0], result[1]);
+        }
+        conn.querySync(dropProc1);
+        assert.deepEqual(result, [ 4, 'verygood' ]);
+    });
+
+    try {
+        conn.querySync(dropProc2);
+        console.log("PROC2 dropped.\n");
+    } catch(e) { }
+    conn.querySync(proc2);
+    query = "call " + schema + ".PROC2(?)";
+    conn.query({"sql":query, "params" : [param1]}, function(err, result){
+        if(err) console.log(err);
+        conn.querySync(dropProc2);
+        conn.closeSync();
+        assert.equal(result.length, 0);
+        console.log('done');
+    });
+});

package/node_modules/ibm_db/test/test-call-stmt.js

@@ -0,0 +1,53 @@
+// Test case to verify result of OUT and INOUT Parameters in a Strored Procedure.
+
+var common = require("./common")
+  , ibmdb = require("../")
+  , assert = require("assert")
+  , cn = common.connectionString
+  , iszos = common.isZOS
+  , schema = common.connectionObject.CURRENTSCHEMA;
+
+var query = "CaLL " + schema + ".PROC1(?, ?, ?)";
+ibmdb.open(cn, function (err, conn)
+{
+    if(err) console.log(err);
+    assert.equal(err, null);
+    let proc1 = "create or replace procedure " + schema + ".PROC1 " +
+                "(IN v1 INTEGER, OUT v2 INTEGER, INOUT v3 VARCHAR(20)) " +
+                "BEGIN set v2 = v1 + 1; set v3 = 'verygood'; END";
+    let proc2 = "create or replace procedure " + schema + ".PROC2 (IN v1 INTEGER) BEGIN END";
+    let dropProc1 = "drop procedure " + schema + ".PROC1(INT, INT, VARCHAR(20))";
+    let dropProc2 = "drop procedure " + schema + ".PROC2(INT)";
+
+    if (iszos) {
+        proc1 = common.sanitizeSP(proc1);
+        proc2 = common.sanitizeSP(proc2);
+        dropProc1 = "drop procedure " + schema + ".PROC1";
+        dropProc2 = "drop procedure " + schema + ".PROC2";
+    }
+
+    try {
+        conn.querySync(dropProc1);
+    } catch(e) {}
+    conn.querySync(proc1);
+
+    var param1 = {ParamType:"INPUT", DataType:1, Data:0};
+    var param2 = {ParamType:"OUTPUT", DataType:1, Data:0};
+    var param3 = {ParamType:"INOUT", DataType:1, Data:"abc", Length:30};
+
+    result = conn.querySync(query, [param1, param2, param3]);
+    assert.deepEqual(result, [ 1, 'verygood' ]);
+    console.log("Output Parameters V2 = ", result[0], ", V3 = ", result[1]);
+    conn.querySync(dropProc1);
+
+    try {
+        conn.querySync(dropProc2);
+    } catch(e) {}
+    conn.querySync(proc2);
+
+    result = conn.querySync("call " + schema + ".PROC2(?)", [param1]);
+    assert.deepEqual(result, []);
+    conn.querySync(dropProc2);
+    conn.closeSync();
+    console.log('done');
+});