1021 lines
28 KiB
JavaScript
1021 lines
28 KiB
JavaScript
/* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. */
|
|
|
|
/******************************************************************************
|
|
*
|
|
* You may not use the identified files except in compliance with the Apache
|
|
* License, Version 2.0 (the "License.")
|
|
*
|
|
* You may obtain a copy of the License at
|
|
* http://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
*
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* The node-oracledb test suite uses 'mocha', 'should' and 'async'.
|
|
* See LICENSE.md for relevant licenses.
|
|
*
|
|
* NAME
|
|
* 72. lobBind2.js
|
|
*
|
|
* DESCRIPTION
|
|
* Testing connection.createLob() function.
|
|
*
|
|
* NUMBERING RULE
|
|
* Test numbers follow this numbering rule:
|
|
* 1 - 20 are reserved for basic functional tests
|
|
* 21 - 50 are reserved for data type supporting tests
|
|
* 51 onwards are for other tests
|
|
*
|
|
*****************************************************************************/
|
|
'use strict';
|
|
|
|
var oracledb = require('oracledb');
|
|
var fs = require('fs');
|
|
var should = require('should');
|
|
var async = require('async');
|
|
var dbConfig = require('./dbconfig.js');
|
|
|
|
describe("72. lobBind2.js", function() {
|
|
|
|
var connection = null;
|
|
var node6plus = false; // assume node runtime version is lower than 6
|
|
|
|
before(function(done) {
|
|
oracledb.getConnection(dbConfig, function(err, conn) {
|
|
should.not.exist(err);
|
|
connection = conn;
|
|
|
|
// Check whether node runtime version is >= 6 or not
|
|
if ( process.versions["node"].substring (0, 1) >= "6")
|
|
node6plus = true;
|
|
|
|
done();
|
|
});
|
|
}); // before
|
|
|
|
after(function(done) {
|
|
connection.release(function(err) {
|
|
should.not.exist(err);
|
|
done();
|
|
});
|
|
}); // after
|
|
|
|
var executeSQL = function(sql, callback) {
|
|
connection.execute(
|
|
sql,
|
|
function(err) {
|
|
should.not.exist(err);
|
|
callback();
|
|
}
|
|
);
|
|
};
|
|
|
|
describe("72.1 CLOB", function() {
|
|
|
|
before(function(done) {
|
|
|
|
var proc = "BEGIN \n" +
|
|
" DECLARE \n" +
|
|
" e_table_missing EXCEPTION; \n" +
|
|
" PRAGMA EXCEPTION_INIT(e_table_missing, -00942); \n" +
|
|
" BEGIN \n" +
|
|
" EXECUTE IMMEDIATE('DROP TABLE nodb_tab_clob72 PURGE'); \n" +
|
|
" EXCEPTION \n" +
|
|
" WHEN e_table_missing \n" +
|
|
" THEN NULL; \n" +
|
|
" END; \n" +
|
|
" EXECUTE IMMEDIATE (' \n" +
|
|
" CREATE TABLE nodb_tab_clob72 ( \n" +
|
|
" id NUMBER, \n" +
|
|
" content CLOB \n" +
|
|
" ) \n" +
|
|
" '); \n" +
|
|
"END; ";
|
|
|
|
executeSQL(proc, done);
|
|
|
|
}); // before
|
|
|
|
after(function(done) {
|
|
|
|
var sql = "DROP TABLE nodb_tab_clob72 PURGE";
|
|
executeSQL(sql, done);
|
|
|
|
}); // after
|
|
|
|
var verifyClobValue = function(sequence, expectLob, callback) {
|
|
|
|
var sql = "select content from nodb_tab_clob72 where id = :i";
|
|
|
|
connection.execute(
|
|
sql,
|
|
{ i: sequence },
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
var lob = result.rows[0][0];
|
|
should.exist(lob);
|
|
|
|
lob.setEncoding("utf8");
|
|
var clobData = "";
|
|
|
|
lob.on("data", function(chunk) {
|
|
clobData += chunk;
|
|
});
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("end", function() {
|
|
|
|
fs.readFile(expectLob, { encoding: "utf8"}, function(err, originalData) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(clobData, originalData);
|
|
return callback();
|
|
});
|
|
|
|
}); // end event
|
|
}
|
|
);
|
|
|
|
}; // verifyClobValue
|
|
|
|
var inFileName = './test/clobexample.txt';
|
|
|
|
it("72.1.1 BIND_IN, DML, a txt file", function(done) {
|
|
|
|
var seq = 1;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
connection.createLob(oracledb.CLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_clob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob},
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(inFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyClobValue(seq, inFileName, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.1.1
|
|
|
|
it("72.1.2 BIND_IN, PL/SQL, a txt file", function(done) {
|
|
|
|
var seq = 2;
|
|
var proc = "CREATE OR REPLACE PROCEDURE nodb_proc_clob_in (p_num IN NUMBER, p_lob IN CLOB) \n" +
|
|
"AS \n" +
|
|
"BEGIN \n" +
|
|
" insert into nodb_tab_clob72 (id, content) VALUES (p_num, p_lob); \n" +
|
|
"END nodb_proc_clob_in;";
|
|
|
|
async.series([
|
|
function(cb) {
|
|
executeSQL(proc, cb);
|
|
},
|
|
function dotest(cb) {
|
|
connection.createLob(oracledb.CLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"begin nodb_proc_clob_in(:1, :2); end;",
|
|
[seq, lob],
|
|
function(err) {
|
|
should.not.exist(err);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(inFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyClobValue(seq, inFileName, cb);
|
|
},
|
|
function(cb) {
|
|
var sql = "DROP PROCEDURE nodb_proc_clob_in";
|
|
executeSQL(sql, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.1.2
|
|
|
|
it("72.1.3 Negative - invalid type", function(done) {
|
|
|
|
try {
|
|
connection.createLob('CLOB', function(err, lob) {
|
|
should.exist(err);
|
|
should.not.exist(lob);
|
|
done();
|
|
});
|
|
} catch (err) {
|
|
should.exist(err);
|
|
(err.message).should.startWith('NJS-006:');
|
|
// NJS-006: invalid type for parameter 1
|
|
done();
|
|
}
|
|
}); // 72.1.3
|
|
|
|
it("72.1.4 Negative - invalid value", function(done) {
|
|
|
|
try {
|
|
connection.createLob(oracledb.STRING, function(err, lob) {
|
|
should.exist(err);
|
|
should.not.exist(lob);
|
|
done();
|
|
});
|
|
} catch (err) {
|
|
should.exist(err);
|
|
(err.message).should.startWith('NJS-005:');
|
|
// NJS-005: invalid value for parameter 1
|
|
done();
|
|
}
|
|
|
|
}); // 72.1.4
|
|
|
|
|
|
it("72.1.5 DML - UPDATE statement", function(done) {
|
|
|
|
var seq = 5;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
var proc = "begin \n" +
|
|
" insert into nodb_tab_clob72 (id, content) values ( :1, to_clob('This is clob data.') ); \n" +
|
|
"end; ";
|
|
|
|
connection.execute(
|
|
proc,
|
|
[seq],
|
|
function(err) {
|
|
should.not.exist(err);
|
|
cb();
|
|
}
|
|
);
|
|
},
|
|
function(cb) {
|
|
connection.createLob(oracledb.CLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"update nodb_tab_clob72 set content = :bindvar where id = :id",
|
|
{ id: seq, bindvar: lob},
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(inFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyClobValue(seq, inFileName, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.1.5
|
|
|
|
it("72.1.6 promise test of createLob()", function(done) {
|
|
|
|
var seq = 6;
|
|
|
|
if (oracledb.Promise) {
|
|
connection.createLob(oracledb.CLOB)
|
|
.then(function(lob) {
|
|
should.exist(lob);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit()
|
|
.then(function() {
|
|
verifyClobValue(seq, inFileName, done);
|
|
});
|
|
});
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_clob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob}
|
|
).then(function(result) {
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
var lobClosePromise = lob.close();
|
|
lobClosePromise.should.be.an.instanceOf(oracledb.Promise);
|
|
});
|
|
});
|
|
|
|
var inStream = fs.createReadStream(inFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
})
|
|
.catch(function(err) {
|
|
should.not.exist(err);
|
|
return done();
|
|
});
|
|
}
|
|
else {
|
|
// This version of Node.js does not support Promise
|
|
return done();
|
|
}
|
|
|
|
}); // 72.1.6
|
|
|
|
it("72.1.7 BIND_INOUT, PL/SQL, IN LOB gets closed automatically", function(done) {
|
|
|
|
var seq = 7;
|
|
var outStr = "This is a out bind string.";
|
|
var proc = "CREATE OR REPLACE PROCEDURE nodb_proc_clob_inout1 \n" +
|
|
" (p_num IN NUMBER, p_inout IN OUT CLOB) \n" +
|
|
"AS \n" +
|
|
"BEGIN \n" +
|
|
" insert into nodb_tab_clob72 (id, content) values (p_num, p_inout); \n" +
|
|
" select to_clob('" + outStr + "') into p_inout from dual; \n" +
|
|
"END nodb_proc_clob_inout1;";
|
|
|
|
async.series([
|
|
function(cb) {
|
|
executeSQL(proc, cb);
|
|
},
|
|
function(cb) {
|
|
connection.createLob(oracledb.CLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"begin nodb_proc_clob_inout1(:id, :io); end;",
|
|
{
|
|
id: seq,
|
|
io: { type: oracledb.CLOB, dir: oracledb.BIND_INOUT, val: lob}
|
|
},
|
|
{ autoCommit: true },
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
// The IN LOB closed automatically after execute call, need
|
|
// close the OUT LOB
|
|
|
|
var lobout = result.outBinds.io;
|
|
|
|
lobout.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
}); // close event of lobout
|
|
|
|
lobout.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lobout.setEncoding("utf8");
|
|
var clobData;
|
|
lobout.on("data", function(chunk) {
|
|
clobData += chunk;
|
|
});
|
|
|
|
lobout.on("finish", function() {
|
|
|
|
should.strictEqual(clobData, outStr);
|
|
|
|
lobout.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
});
|
|
|
|
}
|
|
);
|
|
}); // finish event of lob
|
|
|
|
var inStream = fs.createReadStream(inFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
});
|
|
|
|
},
|
|
function(cb) {
|
|
verifyClobValue(seq, inFileName, cb);
|
|
},
|
|
function(cb) {
|
|
var sql = "DROP PROCEDURE nodb_proc_clob_inout1";
|
|
executeSQL(sql, cb);
|
|
}
|
|
], done);
|
|
}); // 72.1.7
|
|
|
|
}); // 72.1
|
|
|
|
describe("72.2 BLOB", function() {
|
|
|
|
before(function(done) {
|
|
|
|
var proc = "BEGIN \n" +
|
|
" DECLARE \n" +
|
|
" e_table_missing EXCEPTION; \n" +
|
|
" PRAGMA EXCEPTION_INIT(e_table_missing, -00942); \n" +
|
|
" BEGIN \n" +
|
|
" EXECUTE IMMEDIATE('DROP TABLE nodb_tab_blob72 PURGE'); \n" +
|
|
" EXCEPTION \n" +
|
|
" WHEN e_table_missing \n" +
|
|
" THEN NULL; \n" +
|
|
" END; \n" +
|
|
" EXECUTE IMMEDIATE (' \n" +
|
|
" CREATE TABLE nodb_tab_blob72 ( \n" +
|
|
" id NUMBER, \n" +
|
|
" content BLOB \n" +
|
|
" ) \n" +
|
|
" '); \n" +
|
|
"END; ";
|
|
|
|
executeSQL(proc, done);
|
|
|
|
}); // before
|
|
|
|
after(function(done) {
|
|
|
|
var sql = "DROP TABLE nodb_tab_blob72 PURGE";
|
|
executeSQL(sql, done);
|
|
|
|
}); // after
|
|
|
|
var jpgFileName = './test/fuzzydinosaur.jpg';
|
|
|
|
var verifyBlobValue = function(sequence, expectLob, callback) {
|
|
|
|
var sql = "select content from nodb_tab_blob72 where id = :i";
|
|
|
|
connection.execute(
|
|
sql,
|
|
{ i: sequence },
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
var lob = result.rows[0][0];
|
|
should.exist(lob);
|
|
|
|
var blobData,
|
|
totalLength = 0;
|
|
|
|
blobData = node6plus ? Buffer.alloc(0) : new Buffer(0);
|
|
|
|
lob.on("data", function(chunk) {
|
|
totalLength = totalLength + chunk.length;
|
|
blobData = Buffer.concat([blobData, chunk], totalLength);
|
|
});
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("end", function() {
|
|
|
|
fs.readFile(expectLob, function(err, originalData) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(totalLength, originalData.length);
|
|
originalData.should.eql(blobData);
|
|
|
|
return callback();
|
|
});
|
|
|
|
}); // end event
|
|
}
|
|
);
|
|
|
|
}; // verifyBlobValue
|
|
|
|
it("72.2.1 BIND_IN, DML, a jpg file", function(done) {
|
|
|
|
var seq = 1;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
connection.createLob(oracledb.BLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_blob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob},
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyBlobValue(seq, jpgFileName, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.2.1
|
|
|
|
it("72.2.2 BIND_IN, PL/SQL, a jpg file", function(done) {
|
|
|
|
var seq = 2;
|
|
var proc = "CREATE OR REPLACE PROCEDURE nodb_proc_blob_in (p_num IN NUMBER, p_lob IN BLOB) \n" +
|
|
"AS \n" +
|
|
"BEGIN \n" +
|
|
" insert into nodb_tab_blob72 (id, content) VALUES (p_num, p_lob); \n" +
|
|
"END nodb_proc_blob_in;";
|
|
|
|
async.series([
|
|
function(cb) {
|
|
executeSQL(proc, cb);
|
|
},
|
|
function dotest(cb) {
|
|
connection.createLob(oracledb.BLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"begin nodb_proc_blob_in(:1, :2); end;",
|
|
[seq, lob],
|
|
function(err) {
|
|
should.not.exist(err);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyBlobValue(seq, jpgFileName, cb);
|
|
},
|
|
function(cb) {
|
|
var sql = "DROP PROCEDURE nodb_proc_blob_in";
|
|
executeSQL(sql, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.2.2
|
|
|
|
it("72.2.3 Negative - inconsistent datatypes", function(done) {
|
|
|
|
var seq = 3;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
connection.createLob(oracledb.CLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_blob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob},
|
|
function(err) {
|
|
should.exist(err);
|
|
(err.message).should.startWith("ORA-00932:");
|
|
// ORA-00932: inconsistent datatypes: expected BLOB got CLOB
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
}
|
|
], done);
|
|
|
|
}); // 72.2.3
|
|
|
|
it("72.2.4 Negative - not providing first parameter", function(done) {
|
|
|
|
try {
|
|
connection.createLob(function(err, lob) {
|
|
should.not.exist(err);
|
|
should.not.exist(lob);
|
|
|
|
});
|
|
} catch(error) {
|
|
should.exist(error);
|
|
(error.message).should.startWith("NJS-009:");
|
|
// NJS-009: invalid number of parameters
|
|
|
|
return done();
|
|
}
|
|
|
|
}); // 72.2.4
|
|
|
|
it("72.2.5 promise test of createLob()", function(done) {
|
|
|
|
var seq = 5;
|
|
|
|
if (oracledb.Promise) {
|
|
connection.createLob(oracledb.BLOB)
|
|
.then(function(lob) {
|
|
should.exist(lob);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
connection.commit()
|
|
.then(function() {
|
|
verifyBlobValue(seq, jpgFileName, done);
|
|
});
|
|
});
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_blob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob}
|
|
).then(function(result) {
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
var lobClosePromise = lob.close();
|
|
lobClosePromise.should.be.an.instanceOf(oracledb.Promise);
|
|
});
|
|
});
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
})
|
|
.catch(function(err) {
|
|
should.not.exist(err);
|
|
return done();
|
|
});
|
|
}
|
|
else {
|
|
// This version of Node.js does not support Promise
|
|
return done();
|
|
}
|
|
|
|
}); // 72.2.5
|
|
|
|
it("72.2.6 call lob.close() multiple times sequentially", function(done) {
|
|
|
|
var seq = 7000;
|
|
|
|
async.series([
|
|
function(cb) {
|
|
connection.createLob(oracledb.BLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on("close", function(err) {
|
|
should.not.exist(err);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
connection.commit(function(err) {
|
|
should.not.exist(err);
|
|
|
|
return cb();
|
|
});
|
|
}); // close event
|
|
|
|
lob.on("error", function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on("finish", function() {
|
|
connection.execute(
|
|
"insert into nodb_tab_blob72 (id, content) values (:id, :bindvar)",
|
|
{ id: seq, bindvar: lob},
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
|
|
should.strictEqual(result.rowsAffected, 1);
|
|
|
|
lob.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
|
|
}
|
|
);
|
|
}); // finish event
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
|
|
inStream.on("error", function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
inStream.pipe(lob);
|
|
|
|
}); // createLob()
|
|
},
|
|
function(cb) {
|
|
verifyBlobValue(seq, jpgFileName, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.2.6
|
|
|
|
it("72.2.7 BIND_INOUT, PL/SQL, needs to close out lob explicitly", function(done) {
|
|
|
|
var seq = 7, outLobId = 77;
|
|
var outFileName = './test/tree.jpg';
|
|
var proc = "CREATE OR REPLACE PROCEDURE nodb_proc_blob_inout1 \n" +
|
|
" (p_num IN NUMBER, p_from IN NUMBER, p_inout IN OUT BLOB) \n" +
|
|
"AS \n" +
|
|
"BEGIN \n" +
|
|
" insert into nodb_tab_blob72 (id, content) values (p_num, p_inout); \n" +
|
|
" select content into p_inout from nodb_tab_blob72 where id = p_from; \n" +
|
|
"END nodb_proc_blob_inout1;";
|
|
|
|
var prepareOutBlob = function(callback) {
|
|
|
|
var buf = fs.readFileSync(outFileName);
|
|
connection.execute(
|
|
"INSERT INTO nodb_tab_blob72 (id, content) VALUES (:id, :b)",
|
|
{ id: outLobId, b: buf },
|
|
{ autoCommit: true },
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
(result.rowsAffected).should.be.exactly(1);
|
|
return callback();
|
|
}
|
|
);
|
|
|
|
};
|
|
|
|
var dotest = function(callback) {
|
|
|
|
connection.createLob(oracledb.BLOB, function(err, lob) {
|
|
should.not.exist(err);
|
|
|
|
lob.on('error', function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
lob.on('finish', function() {
|
|
|
|
connection.execute(
|
|
"begin nodb_proc_blob_inout1(:id, :oid, :io); end;",
|
|
{
|
|
id: seq,
|
|
oid: outLobId,
|
|
io: { type: oracledb.BLOB, dir: oracledb.BIND_INOUT, val: lob }
|
|
},
|
|
{ autoCommit: true },
|
|
function(err, result) {
|
|
should.not.exist(err);
|
|
var lobout = result.outBinds.io;
|
|
|
|
lobout.on('close', function(err) {
|
|
should.not.exist(err);
|
|
|
|
return callback();
|
|
});
|
|
|
|
lobout.on('error', function(err) {
|
|
should.not.exist(err, "lob.on 'error' event.");
|
|
});
|
|
|
|
var blobData;
|
|
lobout.on('data', function(chunk) {
|
|
blobData += chunk;
|
|
});
|
|
|
|
lobout.on('finish', function() {
|
|
|
|
var buf = fs.readFileSync(outFileName);
|
|
(blobData).should.eql(buf);
|
|
|
|
lobout.close(function(err) {
|
|
should.not.exist(err);
|
|
});
|
|
});
|
|
|
|
}
|
|
);
|
|
|
|
}); // finish event of lob
|
|
|
|
var inStream = fs.createReadStream(jpgFileName);
|
|
inStream.pipe(lob);
|
|
|
|
inStream.on('error', function(err) {
|
|
should.not.exist(err, "inStream.on 'error' event.");
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
async.series([
|
|
function(cb) {
|
|
executeSQL(proc, cb);
|
|
},
|
|
prepareOutBlob,
|
|
dotest,
|
|
function(cb) {
|
|
verifyBlobValue(seq, jpgFileName, cb);
|
|
},
|
|
function(cb) {
|
|
var sql = "DROP PROCEDURE nodb_proc_blob_inout1";
|
|
executeSQL(sql, cb);
|
|
}
|
|
], done);
|
|
|
|
}); // 72.2.7
|
|
|
|
}); // 72.2
|
|
|
|
});
|