function JDBC(config) {
Pool.call(this, config);
}n/a
function CallableStatement(cs) {
PreparedStatement.call(this, cs);
this._cs = cs;
}n/a
function Connection(conn) {
this._conn = conn;
this._txniso = (function() {
var txniso = [];
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_NONE")] = "TRANSACTION_NONE";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_READ_COMMITTED")] = "TRANSACTION_READ_COMMITTED";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_READ_UNCOMMITTED")] = "TRANSACTION_READ_UNCOMMITTED";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_REPEATABLE_READ")] = "TRANSACTION_REPEATABLE_READ";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_SERIALIZABLE")] = "TRANSACTION_SERIALIZABLE";
return txniso;
})();
}n/a
function DatabaseMetaData(dbm) {
this._dbm = dbm;
}n/a
function Pool(config) {
this._url = config.url;
this._props = (function (config) {
var Properties = java.import('java.util.Properties');
var properties = new Properties();
for(var name in config.properties) {
properties.putSync(name, config.properties[name]);
}
if (config.user && properties.getPropertySync('user') === undefined) {
properties.putSync('user', config.user);
}
if (config.password && properties.getPropertySync('password') === undefined) {
properties.putSync('password', config.password);
}
return properties;
})(config);
this._drivername = config.drivername ? config.drivername : '';
this._minpoolsize = config.minpoolsize ? config.minpoolsize : 1;
this._maxpoolsize = config.maxpoolsize ? config.maxpoolsize : 1;
this._keepalive = config.keepalive ? config.keepalive : {
interval: 60000,
query: 'select 1',
enabled: false
};
this._maxidle = (!this._keepalive.enabled && config.maxidle) || null;
this._logging = config.logging ? config.logging : {
level: 'error'
};
this._pool = [];
this._reserved = [];
}n/a
function PreparedStatement(ps) {
Statement.call(this, ps);
this._ps = ps;
}n/a
function ResultSet(rs) {
this._rs = rs;
this._holdability = (function() {
var h = [];
h[java.getStaticFieldValue('java.sql.ResultSet', 'CLOSE_CURSORS_AT_COMMIT')] = 'CLOSE_CURSORS_AT_COMMIT';
h[java.getStaticFieldValue('java.sql.ResultSet', 'HOLD_CURSORS_OVER_COMMIT')] = 'HOLD_CURSORS_OVER_COMMIT';
return h;
})();
this._types = (function() {
var typeNames = [];
typeNames[java.getStaticFieldValue("java.sql.Types", "BIT")] = "Boolean";
typeNames[java.getStaticFieldValue("java.sql.Types", "TINYINT")] = "Short";
typeNames[java.getStaticFieldValue("java.sql.Types", "SMALLINT")] = "Short";
typeNames[java.getStaticFieldValue("java.sql.Types", "INTEGER")] = "Int";
typeNames[java.getStaticFieldValue("java.sql.Types", "BIGINT")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "FLOAT")] = "Float";
typeNames[java.getStaticFieldValue("java.sql.Types", "REAL")] = "Float";
typeNames[java.getStaticFieldValue("java.sql.Types", "DOUBLE")] = "Double";
typeNames[java.getStaticFieldValue("java.sql.Types", "NUMERIC")] = "BigDecimal";
typeNames[java.getStaticFieldValue("java.sql.Types", "DECIMAL")] = "BigDecimal";
typeNames[java.getStaticFieldValue("java.sql.Types", "CHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "VARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "DATE")] = "Date";
typeNames[java.getStaticFieldValue("java.sql.Types", "TIME")] = "Time";
typeNames[java.getStaticFieldValue("java.sql.Types", "TIMESTAMP")] = "Timestamp";
typeNames[java.getStaticFieldValue("java.sql.Types", "BOOLEAN")] = "Boolean";
typeNames[java.getStaticFieldValue("java.sql.Types", "NCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "NVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGNVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "BINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "VARBINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGVARBINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "BLOB")] = "Bytes";
return typeNames;
})();
}n/a
function ResultSetMetaData(rsmd) {
this._rsmd = rsmd;
}n/a
function Statement(s) {
this._s = s;
}n/a
function CallableStatement(cs) {
PreparedStatement.call(this, cs);
this._cs = cs;
}n/a
function CallableStatement(cs) {
PreparedStatement.call(this, cs);
this._cs = cs;
}n/a
getArray = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getArray(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
}
CallableStatement.prototype = Object.create(PreparedStatement.prototype);
CallableStatement.prototype.constructor = CallableStatement;
CallableStatement.prototype.getArray = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getArray(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getBigDecimal = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBigDecimal(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getBigDecimal = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBigDecimal(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getBlob = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBlob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getBlob = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBlob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getBoolean = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBoolean(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getBoolean = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBoolean(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getByte = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getByte(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getByte = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getByte(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getBytes = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBytes(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getBytes = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getBytes(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getCharacterStream = function (arg1, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
getClob = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getClob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
CallableStatement.prototype.getCharacterStream = function(arg1, callback) {
return callback(new Error("NOT IMPLEMENTED"));
};
CallableStatement.prototype.getClob = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getClob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getDate = function (arg1, arg2, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
var validArgs = (
(_.isNumber(args[0]) || _.isString(args[0])) &&
(_.isUndefined(args[1]) || _.isObject(args[1]))
);
if (! validArgs) {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
// Forward modified arguments to _cs.getDate
this._cs.getDate.apply(this._cs, args);
}n/a
getDouble = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getDouble(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
// Forward modified arguments to _cs.getDate
this._cs.getDate.apply(this._cs, args);
};
CallableStatement.prototype.getDouble = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getDouble(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getFloat = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getFloat(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getFloat = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getFloat(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getInt = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getInt(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getInt = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getInt(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getLong = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getLong(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getLong = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getLong(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getNCharacterStream = function (arg1, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
getNClob = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getNClob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
CallableStatement.prototype.getNCharacterStream = function(arg1, callback) {
return callback(new Error("NOT IMPLEMENTED"));
};
CallableStatement.prototype.getNClob = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getNClob(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getNString = function (arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getNString(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}...
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
};
CallableStatement.prototype.getNString = function(arg1, callback) {
if (typeof arg1 === 'number' || typeof arg1 === 'string') {
this._cs.getNString(arg1, function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
} else {
...getObject = function (arg1, arg2, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
registerOutParameter = function () {
var args = Array.prototype.slice.call(arguments);
var callback = args.pop();
if ((typeof args[0] == 'number' && typeof args[1] == 'number') ||
(typeof args[0] == 'number' && typeof args[1] == 'number' && typeof args[2] == 'number') ||
(typeof args[0] == 'number' && typeof args[1] == 'number' && typeof args[2] == 'string') ||
(typeof args[0] == 'string' && typeof args[1] == 'number') ||
(typeof args[0] == 'string' && typeof args[1] == 'number' && typeof args[2] == 'number') ||
(typeof args[0] == 'string' && typeof args[1] == 'number' && typeof args[2] == 'string')) {
args.push(callback);
this._cs.registerOutParameter.apply(this._cs, args);
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
}n/a
function Connection(conn) {
this._conn = conn;
this._txniso = (function() {
var txniso = [];
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_NONE")] = "TRANSACTION_NONE";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_READ_COMMITTED")] = "TRANSACTION_READ_COMMITTED";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_READ_UNCOMMITTED")] = "TRANSACTION_READ_UNCOMMITTED";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_REPEATABLE_READ")] = "TRANSACTION_REPEATABLE_READ";
txniso[java.getStaticFieldValue("java.sql.Connection", "TRANSACTION_SERIALIZABLE")] = "TRANSACTION_SERIALIZABLE";
return txniso;
})();
}n/a
abort = function (executor, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
clearWarnings = function (callback) {
this._conn.clearWarnings(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
}
Connection.prototype.abort = function(executor, callback) {
return callback(new Error("NOT IMPLEMENTED"));
};
Connection.prototype.clearWarnings = function(callback) {
this._conn.clearWarnings(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...close = function (callback) {
var self = this;
if (self._conn === null) {
return callback(null);
}
self._conn.close(function(err) {
if (err) {
return callback(err);
} else {
self._conn = null;
return callback(null);
}
});
}...
Connection.prototype.close = function(callback) {
var self = this;
if (self._conn === null) {
return callback(null);
}
self._conn.close(function(err) {
if (err) {
return callback(err);
} else {
self._conn = null;
return callback(null);
}
});
...commit = function (callback) {
this._conn.commit(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
self._conn = null;
return callback(null);
}
});
};
Connection.prototype.commit = function(callback) {
this._conn.commit(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...createArrayOf = function (typename, objarr, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
createBlob = function (callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
createClob = function (callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
createNClob = function (callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
createSQLXML = function (callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
createStatement = function (arg1, arg2, arg3, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
var invalidArgs = false;
_.forEach(args, function(arg) {
if (! _.isNumber(arg)) {
invalidArgs = true;
// Lodash break
return false;
}
});
if (invalidArgs) {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err, statement) {
if (err) {
return callback(err);
} else {
return callback(null, new Statement(statement));
}
});
// Forward modified arguments to _conn.createStatement
this._conn.createStatement.apply(this._conn, args);
}...
<p>ResultSet processing has been separated from statement execution to allow for
more flexibility. The ResultSet returned from executing a select query can
still be processed into an object array using the *toObjArray()* function on the
resultset object.</p>
```javascript
// Select statement example.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
statement.executeQuery("SELECT * FROM blah;", function(err, resultset) {
if (err) {
callback(err)
} else {
...createStruct = function (typename, attrarr, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
getAutoCommit = function (callback) {
this._conn.getAutoCommit(function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
}...
};
Connection.prototype.createStruct = function(typename, attrarr, callback) {
return callback(new Error("NOT IMPLEMENTED"));
};
Connection.prototype.getAutoCommit = function(callback) {
this._conn.getAutoCommit(function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
};
...getCatalog = function (callback) {
this._conn.getCatalog(function(err, catalog) {
if (err) {
return callback(err);
} else {
return callback(null, catalog);
}
});
}...
} else {
return callback(null, result);
}
});
};
Connection.prototype.getCatalog = function(callback) {
this._conn.getCatalog(function(err, catalog) {
if (err) {
return callback(err);
} else {
return callback(null, catalog);
}
});
};
...getClientInfo = function (name, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Push a callback handler onto the arguments
args.push(function(err, result) {
if (err) {
return callback(err);
} else {
return callback(null, result);
}
});
// Forward modified arguments to _conn.getClientInfo
this._conn.getClientInfo.apply(this._conn, args);
}...
});
// Forward modified arguments to _conn.getClientInfo
this._conn.getClientInfo.apply(this._conn, args);
};
Connection.prototype.getHoldability = function(callback) {
this._conn.getClientInfo(function(err, holdability) {
if (err) {
return callback(err);
} else {
return callback(null, holdability);
}
});
};
...getHoldability = function (callback) {
this._conn.getClientInfo(function(err, holdability) {
if (err) {
return callback(err);
} else {
return callback(null, holdability);
}
});
}n/a
getMetaData = function (callback) {
this._conn.getMetaData(function(err, dbm) {
if (err) {
return callback(err);
} else {
return callback(null, new DatabaseMetaData(dbm));
}
});
}...
} else {
return callback(null, holdability);
}
});
};
Connection.prototype.getMetaData = function(callback) {
this._conn.getMetaData(function(err, dbm) {
if (err) {
return callback(err);
} else {
return callback(null, new DatabaseMetaData(dbm));
}
});
};
...getNetworkTimeout = function (callback) {
this._conn.getNetworkTimeout(function(err, ms) {
if (err) {
return callback(err);
} else {
return callback(null, ms);
}
});
}...
} else {
return callback(null, new DatabaseMetaData(dbm));
}
});
};
Connection.prototype.getNetworkTimeout = function(callback) {
this._conn.getNetworkTimeout(function(err, ms) {
if (err) {
return callback(err);
} else {
return callback(null, ms);
}
});
};
...getSchema = function (callback) {
this._conn.getSchema(function(err, schema) {
if (err) {
return callback(err);
} else {
return callback(null, schema);
}
});
}...
} else {
return callback(null, ms);
}
});
};
Connection.prototype.getSchema = function(callback) {
this._conn.getSchema(function(err, schema) {
if (err) {
return callback(err);
} else {
return callback(null, schema);
}
});
};
...getTransactionIsolation = function (callback) {
var self = this;
self._conn.getTransactionIsolation(function(err, txniso) {
if (err) {
return callback(err);
} else {
return callback(null, self._txniso[txniso]);
}
});
}...
}
});
};
Connection.prototype.getTransactionIsolation = function(callback) {
var self = this;
self._conn.getTransactionIsolation(function(err, txniso) {
if (err) {
return callback(err);
} else {
return callback(null, self._txniso[txniso]);
}
});
};
...getTypeMap = function (callback) {
this._conn.getTypeMap(function(err, map) {
if (err) {
return callback(err);
} else {
return callback(null, map);
}
});
}...
} else {
return callback(null, self._txniso[txniso]);
}
});
};
Connection.prototype.getTypeMap = function(callback) {
this._conn.getTypeMap(function(err, map) {
if (err) {
return callback(err);
} else {
return callback(null, map);
}
});
};
...getWarnings = function (callback) {
this._conn.getWarnings(function(err, sqlwarning) {
if (err) {
return callback(err);
} else {
return callback(null, new SQLWarning(sqlwarning));
}
});
}...
} else {
return callback(null, map);
}
});
};
Connection.prototype.getWarnings = function(callback) {
this._conn.getWarnings(function(err, sqlwarning) {
if (err) {
return callback(err);
} else {
return callback(null, new SQLWarning(sqlwarning));
}
});
};
...isClosed = function (callback) {
this._conn.isClosed(function(err, closed) {
if (err) return callback(err);
callback(null, closed);
});
}...
} else {
return callback(null, new SQLWarning(sqlwarning));
}
});
};
Connection.prototype.isClosed = function(callback) {
this._conn.isClosed(function(err, closed) {
if (err) return callback(err);
callback(null, closed);
});
};
Connection.prototype.isClosedSync = function() {
return this._conn.isClosedSync();
...isClosedSync = function () {
return this._conn.isClosedSync();
}...
this._conn.isClosed(function(err, closed) {
if (err) return callback(err);
callback(null, closed);
});
};
Connection.prototype.isClosedSync = function() {
return this._conn.isClosedSync();
};
Connection.prototype.isReadOnly = function(callback) {
this._conn.isReadOnly(function(err, readonly) {
if (err) {
return callback(err);
} else {
...isReadOnly = function (callback) {
this._conn.isReadOnly(function(err, readonly) {
if (err) {
return callback(err);
} else {
return callback(null, readonly);
}
});
}...
};
Connection.prototype.isClosedSync = function() {
return this._conn.isClosedSync();
};
Connection.prototype.isReadOnly = function(callback) {
this._conn.isReadOnly(function(err, readonly) {
if (err) {
return callback(err);
} else {
return callback(null, readonly);
}
});
};
...isReadOnlySync = function () {
return this._conn.isReadOnlySync();
}...
} else {
return callback(null, readonly);
}
});
};
Connection.prototype.isReadOnlySync = function() {
return this._conn.isReadOnlySync();
};
Connection.prototype.isValid = function(timeout, callback) {
this._conn.isValid(timeout, function(err, valid) {
if (err) {
return callback(err);
} else {
...isValid = function (timeout, callback) {
this._conn.isValid(timeout, function(err, valid) {
if (err) {
return callback(err);
} else {
return callback(null, valid);
}
});
}...
};
Connection.prototype.isReadOnlySync = function() {
return this._conn.isReadOnlySync();
};
Connection.prototype.isValid = function(timeout, callback) {
this._conn.isValid(timeout, function(err, valid) {
if (err) {
return callback(err);
} else {
return callback(null, valid);
}
});
};
...isValidSync = function (timeout) {
return this._conn.isValidSync(timeout);
}...
} else {
return callback(null, valid);
}
});
};
Connection.prototype.isValidSync = function(timeout) {
return this._conn.isValidSync(timeout);
};
Connection.prototype.nativeSQL = function(sql, callback) {
return callback(new Error("NOT IMPLEMENTED"));
};
Connection.prototype.prepareCall = function(sql, rstype, rsconcurrency, rsholdability, callback) {
...nativeSQL = function (sql, callback) {
return callback(new Error("NOT IMPLEMENTED"));
}n/a
prepareCall = function (sql, rstype, rsconcurrency, rsholdability, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
if (! args[0] || (args[1] && ! args[2])) {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err, callablestatement) {
if (err) {
return callback(err);
} else {
return callback(null, new CallableStatement(callablestatement));
}
});
// Forward modified arguments to _conn.prepareCall
this._conn.prepareCall.apply(this._conn, args);
}n/a
prepareStatement = function (sql, arg1, arg2, arg3, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Error to return if arguments are invalid
var errMsg = 'INVALID ARGUMENTS';
// The first arg (sql) must be present
if (! args[0]) {
return callback(new Error(errMsg));
}
// Check arg1, arg2, and arg3 for validity. These arguments must
// be numbers if given, except for the special case when the first
// of these arguments is an array and no other arguments are given.
// In this special case, the array must be a string or number array.
//
// NOTE: _.tail returns all but the first argument, so we are only
// processing arg1, arg2, and arg3; and not sql (or callback, which
// was already removed from the args array).
var invalidArgs = false;
_.forEach(_.tail(args), function(arg, idx) {
// Check for the special case where arg1 can be an array of strings or numbers
// if arg2 and arg3 are not given
if (idx === 0 && _.isArray(arg) && _.isUndefined(args[2]) && _.isUndefined(args[3])) {
if (! (allType(arg, 'string') || allType(arg, 'number'))) {
invalidArgs = true;
// Lodash break
return false;
}
// Lodash continue
return;
}
// Other than the special case above, these args must be numbers
if (! _.isNumber(arg)) {
invalidArgs = true;
// Lodash break
return false;
}
});
if (invalidArgs) {
return callback(new Error(errMsg));
}
// Push a callback handler onto the arguments
args.push(function(err, ps) {
if (err) {
return callback(err);
} else {
return callback(null, new PreparedStatement(ps));
}
});
// Forward modified arguments to _conn.prepareStatement
this._conn.prepareStatement.apply(this._conn, args);
}n/a
releaseSavepoint = function (savepoint, callback) {
this._conn.releaseSavepoint(savepoint, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
});
// Forward modified arguments to _conn.prepareStatement
this._conn.prepareStatement.apply(this._conn, args);
};
Connection.prototype.releaseSavepoint = function(savepoint, callback) {
this._conn.releaseSavepoint(savepoint, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...rollback = function (savepoint, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
// if (! _.isObject(args[0])) {
// return callback(new Error("INVALID ARGUMENTS"));
// }
// Push a callback handler onto the arguments
args.push(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
// Forward modified arguments to _conn.rollback
this._conn.rollback.apply(this._conn, args);
}n/a
setAutoCommit = function (autocommit, callback) {
this._conn.setAutoCommit(autocommit, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
- **Fully Wrapped Connection API**
<p>The Java Connection API has almost been completely wrapped. See
[connection.js](https://github.com/CraZySacX/node-jdbc/blob/master/lib/connection.js)
for a full list of functions.</p>
```javascript
conn.setAutoCommit(false, function(err) {
if (err) {
callback(err);
} else {
callback(null);
}
});
```
...setCatalog = function (catalog, callback) {
this._conn.setCatalog(catalog, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
} else {
return callback(null);
}
});
};
Connection.prototype.setCatalog = function(catalog, callback) {
this._conn.setCatalog(catalog, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...setClientInfo = function (props, name, value, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, manipulate the args array appropriately,
// and return error if invalid
if (_.isObject(args[0]) && _.isUndefined(args[1]) && _.isUndefined(args[2])) {
// Do nothing
} else if (_.isNull(args[0]) && _.isString(args[1]) && _.isString(args[2])) {
// Remove first argument (props) from args array
args.shift();
} else {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
// Forward modified arguments to _conn.setClientInfo
this._conn.setClientInfo.apply(this._conn, args);
}n/a
setHoldability = function (holdability, callback) {
this._conn.setHoldability(holdability, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
});
// Forward modified arguments to _conn.setClientInfo
this._conn.setClientInfo.apply(this._conn, args);
};
Connection.prototype.setHoldability = function(holdability, callback) {
this._conn.setHoldability(holdability, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...setNetworkTimeout = function (executor, ms, callback) {
return callback(new Error('NOT IMPLEMENTED'));
}n/a
setReadOnly = function (readonly, callback) {
this._conn.setReadOnly(readonly, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
};
Connection.prototype.setNetworkTimeout = function(executor, ms, callback) {
return callback(new Error('NOT IMPLEMENTED'));
};
Connection.prototype.setReadOnly = function(readonly, callback) {
this._conn.setReadOnly(readonly, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...setSavepoint = function (name, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
if (! (_.isUndefined(args[0]) || _.isString(args[0]))) {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err, savepoint) {
if (err) {
return callback(err);
} else {
return callback(null, savepoint);
}
});
// Forward modified arguments to _conn.setSavepoint
this._conn.setSavepoint.apply(this._conn, args);
}n/a
setSchema = function (schema, callback) {
this._conn.setSchema(schema, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
callback(err);
} else {
callback(null);
}
});
},
function(callback) {
conn.setSchema("test", function(err) {
if (err) {
callback(err);
} else {
callback(null);
}
});
}
...setTransactionIsolation = function (txniso, callback) {
this._conn.setTransactionIsolation(txniso, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
} else {
return callback(null);
}
});
};
Connection.prototype.setTransactionIsolation = function(txniso, callback) {
this._conn.setTransactionIsolation(txniso, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...setTypeMap = function (map, callback) {
return callback(new Error('NOT IMPLEMENTED'));
}n/a
function DatabaseMetaData(dbm) {
this._dbm = dbm;
}n/a
allProceduresAreCallable = function (callback) {
this._dbm.allProceduresAreCallable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether the current user can call all the procedures returned by
* the method getProcedures.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.allProceduresAreCallable = function(callback) {
this._dbm.allProceduresAreCallable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...allTablesAreSelectable = function (callback) {
this._dbm.allTablesAreSelectable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether the current user can use all the tables returned by the
* method getTables in a SELECT statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.allTablesAreSelectable = function(callback) {
this._dbm.allTablesAreSelectable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...autoCommitFailureClosesAllResultSets = function (callback) {
this._dbm.autoCommitFailureClosesAllResultSets(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a SQLException while autoCommit is true inidcates that all
* open ResultSets are closed, even ones that are holdable.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.autoCommitFailureClosesAllResultSets = function(callback) {
this._dbm.autoCommitFailureClosesAllResultSets(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...dataDefinitionCausesTransactionCommit = function (callback) {
this._dbm.dataDefinitionCausesTransactionCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a data definition statement within a transaction forces
* the transaction to commit.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.dataDefinitionCausesTransactionCommit = function(callback) {
this._dbm.dataDefinitionCausesTransactionCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...dataDefinitionIgnoredInTransactions = function (callback) {
this._dbm.dataDefinitionIgnoredInTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database ignores a data definition statement within a
* transaction.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.dataDefinitionIgnoredInTransactions = function(callback) {
this._dbm.dataDefinitionIgnoredInTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...deletesAreDetected = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.deletesAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
*/
DatabaseMetaData.prototype.deletesAreDetected = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.deletesAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...doesMaxRowSizeIncludeBlobs = function (callback) {
this._dbm.doesMaxRowSizeIncludeBlobs(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether the return value for the method getMaxRowSize includes the
* SQL data types LONGVARCHAR and LONGVARBINARY.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.doesMaxRowSizeIncludeBlobs = function(callback) {
this._dbm.doesMaxRowSizeIncludeBlobs(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...generatedKeyAlwaysReturned = function (callback) {
this._dbm.generatedKeyAlwaysReturned(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* name(s) or index(es) specified for the auto generated key column(s) are
* valid and the statement succeeds.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.generatedKeyAlwaysReturned = function(callback) {
this._dbm.generatedKeyAlwaysReturned(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getAttributes = function (catalog, schemaPattern, typeNamePattern, attributeNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(typeNamePattern) || _.isUndefined(typeNamePattern) || _.isString(typeNamePattern)) &&
(_.isNull(attributeNamePattern) || _.isUndefined(attributeNamePattern) || _.isString(attributeNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(attributeNamePattern) || _.isUndefined(attributeNamePattern) || _.isString(attributeNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getAttributes(catalog, schemaPattern, typeNamePattern, attributeNamePattern
, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getBestRowIdentifier = function (catalog, schema, table, scope, nullable, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table) &&
_.isInteger(scope) &&
_.isBoolean(nullable)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getBestRowIdentifier(catalog, schema, table, scope, nullable, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isBoolean(nullable)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getBestRowIdentifier(catalog, schema, table, scope, nullable, function(err
, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getCatalogSeparator = function (callback) {
this._dbm.getCatalogSeparator(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the String that this database uses as the separator between a
* catalog and table name.
*
* @param {Function} callback
* @returns {String} Via callback: the separator string
*/
DatabaseMetaData.prototype.getCatalogSeparator = function(callback) {
this._dbm.getCatalogSeparator(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getCatalogTerm = function (callback) {
this._dbm.getCatalogTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the database vendor's preferred term for "catalog".
*
* @param {Function} callback
* @returns {String} Via callback: the vendor term for "catalog"
*/
DatabaseMetaData.prototype.getCatalogTerm = function(callback) {
this._dbm.getCatalogTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getCatalogs = function (callback) {
this._dbm.getCatalogs(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
/**
* Retrieves the catalog names available in this database.
*
* @param {Function} callback
* @returns {ResultSet} Via callback: a ResultSet object in which each row has a single String column that is a catalog name
*/
DatabaseMetaData.prototype.getCatalogs = function(callback) {
this._dbm.getCatalogs(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getClientInfoProperties = function (callback) {
this._dbm.getClientInfoProperties(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
/**
* Retrieves a list of the client info properties that the driver supports.
*
* @param {Function} callback
* @returns {ResultSet} Via callback: A ResultSet object; each row is a supported client info property
*/
DatabaseMetaData.prototype.getClientInfoProperties = function(callback) {
this._dbm.getClientInfoProperties(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getColumnPrivileges = function (catalog, schema, table, columnNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table) &&
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getColumnPrivileges(catalog, schema, table, columnNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getColumnPrivileges(catalog, schema, table, columnNamePattern, function(err
, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getColumns = function (catalog, schemaPattern, tableNamePattern, columnNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern)) &&
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern, function
(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getConnection = function (callback) {
this._dbm.getConnection(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new Connection(result));
});
}...
/**
* Retrieves the connection that produced this metadata object.
*
* @param {Function} callback
* @returns {Connection} Via callback: the connection that produced this metadata object
*/
DatabaseMetaData.prototype.getConnection = function(callback) {
this._dbm.getConnection(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new Connection(result));
});
};
...getCrossReference = function (parentCatalog, parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable, callback) {
var validParams = (
(_.isNull(parentCatalog) || _.isUndefined(parentCatalog) || _.isString(parentCatalog)) &&
(_.isNull(parentSchema) || _.isUndefined(parentSchema) || _.isString(parentSchema)) &&
_.isString(parentTable) &&
(_.isNull(foreignCatalog) || _.isUndefined(foreignCatalog) || _.isString(foreignCatalog)) &&
(_.isNull(foreignSchema) || _.isUndefined(foreignSchema) || _.isString(foreignSchema)) &&
_.isString(foreignTable)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getCrossReference(parentCatalog, parentSchema, parentTable, foreignCatalog, foreignSchema, foreignTable, function(err
, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isString(foreignTable)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getCrossReference(parentCatalog, parentSchema, parentTable, foreignCatalog
, foreignSchema, foreignTable, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getDatabaseMajorVersion = function (callback) {
this._dbm.getDatabaseMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the major version number of the underlying database.
*
* @param {Function} callback
* @returns {Number} Via callback: the underlying database's major version
*/
DatabaseMetaData.prototype.getDatabaseMajorVersion = function(callback) {
this._dbm.getDatabaseMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDatabaseMinorVersion = function (callback) {
this._dbm.getDatabaseMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the minor version number of the underlying database.
*
* @param {Function} callback
* @returns {Number} Via callback: underlying database's minor version
*/
DatabaseMetaData.prototype.getDatabaseMinorVersion = function(callback) {
this._dbm.getDatabaseMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDatabaseProductName = function (callback) {
this._dbm.getDatabaseProductName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the name of this database product.
*
* @param {Function} callback
* @returns {String} Via callback: database product name
*/
DatabaseMetaData.prototype.getDatabaseProductName = function(callback) {
this._dbm.getDatabaseProductName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDatabaseProductVersion = function (callback) {
this._dbm.getDatabaseProductVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the version number of this database product.
*
* @param {Function} callback
* @returns {String} Via callback: database version number
*/
DatabaseMetaData.prototype.getDatabaseProductVersion = function(callback) {
this._dbm.getDatabaseProductVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDefaultTransactionIsolation = function (callback) {
this._dbm.getDefaultTransactionIsolation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves this database's default transaction isolation level.
*
* @param {Function} callback
* @returns {Number} Via callback: the default isolation level
*/
DatabaseMetaData.prototype.getDefaultTransactionIsolation = function(callback) {
this._dbm.getDefaultTransactionIsolation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDriverMajorVersion = function (callback) {
this._dbm.getDriverMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves this JDBC driver's major version number.
*
* @param {Function} callback
* @returns {Number} Via callback: JDBC driver major version
*/
DatabaseMetaData.prototype.getDriverMajorVersion = function(callback) {
this._dbm.getDriverMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDriverMinorVersion = function (callback) {
this._dbm.getDriverMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves this JDBC driver's minor version number.
*
* @param {Function} callback
* @returns {Number} Via callback: JDBC driver minor version
*/
DatabaseMetaData.prototype.getDriverMinorVersion = function(callback) {
this._dbm.getDriverMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDriverName = function (callback) {
this._dbm.getDriverName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the name of this JDBC driver.
*
* @param {Function} callback
* @returns {String} Via callback: JDBC driver name
*/
DatabaseMetaData.prototype.getDriverName = function(callback) {
this._dbm.getDriverName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getDriverVersion = function (callback) {
this._dbm.getDriverVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the version number of this JDBC driver as a String.
*
* @param {Function} callback
* @returns {String} Via callback: JDBC driver version
*/
DatabaseMetaData.prototype.getDriverVersion = function(callback) {
this._dbm.getDriverVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getExportedKeys = function (catalog, schema, table, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getExportedKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getExportedKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getExtraNameCharacters = function (callback) {
this._dbm.getExtraNameCharacters(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves all the "extra" characters that can be used in unquoted identifier
* names (those beyond a-z, A-Z, 0-9 and _).
*
* @param {Function} callback
* @returns {String} Via callback: the string containing the extra characters
*/
DatabaseMetaData.prototype.getExtraNameCharacters = function(callback) {
this._dbm.getExtraNameCharacters(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getFunctionColumns = function (catalog, schemaPattern, functionNamePattern, columnNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(functionNamePattern) || _.isUndefined(functionNamePattern) || _.isString(functionNamePattern)) &&
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getFunctionColumns(catalog, schemaPattern, functionNamePattern, columnNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getFunctionColumns(catalog, schemaPattern, functionNamePattern, columnNamePattern
, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getFunctions = function (catalog, schemaPattern, functionNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(functionNamePattern) || _.isUndefined(functionNamePattern) || _.isString(functionNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getFunctions(catalog, schemaPattern, functionNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(functionNamePattern) || _.isUndefined(functionNamePattern) || _.isString(functionNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getFunctions(catalog, schemaPattern, functionNamePattern, function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getIdentifierQuoteString = function (callback) {
this._dbm.getIdentifierQuoteString(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the string used to quote SQL identifiers.
*
* @param {Function} callback
* @returns {String} Via callback: the quoting string or a space if quoting is not supported
*/
DatabaseMetaData.prototype.getIdentifierQuoteString = function(callback) {
this._dbm.getIdentifierQuoteString(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getImportedKeys = function (catalog, schema, table, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getImportedKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getImportedKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getIndexInfo = function (catalog, schema, table, unique, approximate, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table) &&
_.isBoolean(unique) &&
_.isBoolean(approximate)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getIndexInfo(catalog, schema, table, unique, approximate, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isBoolean(approximate)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getIndexInfo(catalog, schema, table, unique, approximate, function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getJDBCMajorVersion = function (callback) {
this._dbm.getJDBCMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the major JDBC version number for this driver.
*
* @param {Function} callback
* @returns {Number} Via callback: JDBC version major number
*/
DatabaseMetaData.prototype.getJDBCMajorVersion = function(callback) {
this._dbm.getJDBCMajorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getJDBCMinorVersion = function (callback) {
this._dbm.getJDBCMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the minor JDBC version number for this driver.
*
* @param {Function} callback
* @returns {Number} Via callback: JDBC version minor number
*/
DatabaseMetaData.prototype.getJDBCMinorVersion = function(callback) {
this._dbm.getJDBCMinorVersion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxBinaryLiteralLength = function (callback) {
this._dbm.getMaxBinaryLiteralLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of hex characters this database allows in an
* inline binary literal.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum length (in hex characters) for a binary literal; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxBinaryLiteralLength = function(callback) {
this._dbm.getMaxBinaryLiteralLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxCatalogNameLength = function (callback) {
this._dbm.getMaxCatalogNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters that this database allows in a
* catalog name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed in a catalog name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxCatalogNameLength = function(callback) {
this._dbm.getMaxCatalogNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxCharLiteralLength = function (callback) {
this._dbm.getMaxCharLiteralLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters this database allows for a
* character literal.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed for a character literal; a result of zero means that
there is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxCharLiteralLength = function(callback) {
this._dbm.getMaxCharLiteralLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnNameLength = function (callback) {
this._dbm.getMaxColumnNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters this database allows for a column
* name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed for a column name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxColumnNameLength = function(callback) {
this._dbm.getMaxColumnNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnsInGroupBy = function (callback) {
this._dbm.getMaxColumnsInGroupBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of columns this database allows in a GROUP BY
* clause.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of columns allowed; a result of zero means that there is no limit or the limit
is not known
*/
DatabaseMetaData.prototype.getMaxColumnsInGroupBy = function(callback) {
this._dbm.getMaxColumnsInGroupBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnsInIndex = function (callback) {
this._dbm.getMaxColumnsInIndex(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the maximum number of columns this database allows in an index.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of columns allowed; a result of zero means that there is no limit or the limit
is not known
*/
DatabaseMetaData.prototype.getMaxColumnsInIndex = function(callback) {
this._dbm.getMaxColumnsInIndex(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnsInOrderBy = function (callback) {
this._dbm.getMaxColumnsInOrderBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of columns this database allows in an ORDER BY
* clause.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of columns allowed; a result of zero means that there is no limit or the limit
is not known
*/
DatabaseMetaData.prototype.getMaxColumnsInOrderBy = function(callback) {
this._dbm.getMaxColumnsInOrderBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnsInSelect = function (callback) {
this._dbm.getMaxColumnsInSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of columns this database allows in a SELECT
* list.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of columns allowed; a result of zero means that there is no limit or the limit
is not known
*/
DatabaseMetaData.prototype.getMaxColumnsInSelect = function(callback) {
this._dbm.getMaxColumnsInSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxColumnsInTable = function (callback) {
this._dbm.getMaxColumnsInTable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the maximum number of columns this database allows in a table.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of columns allowed; a result of zero means that there is no limit or the limit
is not known
*/
DatabaseMetaData.prototype.getMaxColumnsInTable = function(callback) {
this._dbm.getMaxColumnsInTable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxConnections = function (callback) {
this._dbm.getMaxConnections(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of concurrent connections to this database that
* are possible.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of active connections possible at one time; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxConnections = function(callback) {
this._dbm.getMaxConnections(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxCursorNameLength = function (callback) {
this._dbm.getMaxCursorNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters that this database allows in a
* cursor name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed in a cursor name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxCursorNameLength = function(callback) {
this._dbm.getMaxCursorNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxIndexLength = function (callback) {
this._dbm.getMaxIndexLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of bytes this database allows for an index,
* including all of the parts of the index.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of bytes allowed; this limit includes the composite of all the constituent
parts of the index; a result of zero means that there is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxIndexLength = function(callback) {
this._dbm.getMaxIndexLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxProcedureNameLength = function (callback) {
this._dbm.getMaxProcedureNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters that this database allows in a
* procedure name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed in a procedure name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxProcedureNameLength = function(callback) {
this._dbm.getMaxProcedureNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxRowSize = function (callback) {
this._dbm.getMaxRowSize(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the maximum number of bytes this database allows in a single row.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of bytes allowed for a row; a result of zero means that there is no limit
or the limit is not known
*/
DatabaseMetaData.prototype.getMaxRowSize = function(callback) {
this._dbm.getMaxRowSize(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxSchemaNameLength = function (callback) {
this._dbm.getMaxSchemaNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters that this database allows in a
* schema name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed in a schema name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxSchemaNameLength = function(callback) {
this._dbm.getMaxSchemaNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxStatementLength = function (callback) {
this._dbm.getMaxStatementLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters this database allows in an SQL
* statement.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed for an SQL statement; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxStatementLength = function(callback) {
this._dbm.getMaxStatementLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxStatements = function (callback) {
this._dbm.getMaxStatements(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of active statements to this database that can
* be open at the same time.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of statements that can be open at one time; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxStatements = function(callback) {
this._dbm.getMaxStatements(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxTableNameLength = function (callback) {
this._dbm.getMaxTableNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters this database allows in a table
* name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed for a table name; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxTableNameLength = function(callback) {
this._dbm.getMaxTableNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxTablesInSelect = function (callback) {
this._dbm.getMaxTablesInSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of tables this database allows in a SELECT
* statement.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of tables allowed in a SELECT statement; a result of zero means that there
is no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxTablesInSelect = function(callback) {
this._dbm.getMaxTablesInSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getMaxUserNameLength = function (callback) {
this._dbm.getMaxUserNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves the maximum number of characters this database allows in a user
* name.
*
* @param {Function} callback
* @returns {Number} Via callback: the maximum number of characters allowed for a user name; a result of zero means that there is
no limit or the limit is not known
*/
DatabaseMetaData.prototype.getMaxUserNameLength = function(callback) {
this._dbm.getMaxUserNameLength(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getNumericFunctions = function (callback) {
this._dbm.getNumericFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves a comma-separated list of math functions available with this
* database.
*
* @param {Function} callback
* @returns {String} Via callback: the list of math functions supported by this database
*/
DatabaseMetaData.prototype.getNumericFunctions = function(callback) {
this._dbm.getNumericFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getPrimaryKeys = function (catalog, schema, table, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getPrimaryKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getPrimaryKeys(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getProcedureColumns = function (catalog, schemaPattern, procedureNamePattern, columnNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(procedureNamePattern) || _.isUndefined(procedureNamePattern) || _.isString(procedureNamePattern)) &&
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getProcedureColumns(catalog, schemaPattern, procedureNamePattern, columnNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getProcedureColumns(catalog, schemaPattern, procedureNamePattern, columnNamePattern
, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getProcedureTerm = function (callback) {
this._dbm.getProcedureTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the database vendor's preferred term for "procedure".
*
* @param {Function} callback
* @returns {String} Via callback: the vendor term for "procedure"
*/
DatabaseMetaData.prototype.getProcedureTerm = function(callback) {
this._dbm.getProcedureTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getProcedures = function (catalog, schemaPattern, procedureNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(procedureNamePattern) || _.isUndefined(procedureNamePattern) || _.isString(procedureNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getProcedures(catalog, schemaPattern, procedureNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(procedureNamePattern) || _.isUndefined(procedureNamePattern) || _.isString(procedureNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getProcedures(catalog, schemaPattern, procedureNamePattern, function(err,
result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getPseudoColumns = function (catalog, schemaPattern, tableNamePattern, columnNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern)) &&
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getPseudoColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(columnNamePattern) || _.isUndefined(columnNamePattern) || _.isString(columnNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getPseudoColumns(catalog, schemaPattern, tableNamePattern, columnNamePattern
, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getResultSetHoldability = function (callback) {
this._dbm.getResultSetHoldability(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves this database's default holdability for ResultSet objects.
*
* @param {Function} callback
* @returns {Number} Via callback: the default holdability; either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
*/
DatabaseMetaData.prototype.getResultSetHoldability = function(callback) {
this._dbm.getResultSetHoldability(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getRowIdLifetime = function (callback) {
this._dbm.getRowIdLifetime(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* NOTE: This method should be used with caution for now. The RowIdLifetime object
* returned is a Java object and is not wrapped by the node-jdbc library.
*
* @param {Function} callback
* @returns {RowIdLifetime} Via callback: the status indicating the lifetime of a RowId
*/
DatabaseMetaData.prototype.getRowIdLifetime = function(callback) {
this._dbm.getRowIdLifetime(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getSQLKeywords = function (callback) {
this._dbm.getSQLKeywords(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves a comma-separated list of all of this database's SQL keywords that
* are NOT also SQL:2003 keywords.
*
* @param {Function} callback
* @returns {String} Via callback: the list of this database's keywords that are not also SQL:2003 keywords
*/
DatabaseMetaData.prototype.getSQLKeywords = function(callback) {
this._dbm.getSQLKeywords(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getSQLStateType = function (callback) {
this._dbm.getSQLStateType(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Indicates whether the SQLSTATE returned by SQLException.getSQLState is
* X/Open (now known as Open Group) SQL CLI or SQL:2003.
*
* @param {Function} callback
* @returns {Number} Via callback: the type of SQLSTATE; one of: sqlStateXOpen or sqlStateSQL
*/
DatabaseMetaData.prototype.getSQLStateType = function(callback) {
this._dbm.getSQLStateType(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getSchemaTerm = function (callback) {
this._dbm.getSchemaTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the database vendor's preferred term for "schema".
*
* @param {Function} callback
* @returns {String} Via callback: the vendor term for "schema"
*/
DatabaseMetaData.prototype.getSchemaTerm = function(callback) {
this._dbm.getSchemaTerm(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getSchemas = function (catalog, schemaPattern, callback) {
if(_.isFunction(catalog)) {
callback = catalog;
catalog = null;
} else if(_.isFunction(schemaPattern)) {
callback = schemaPattern;
schemaPattern = null;
}
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSchemas(catalog, schemaPattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSchemas(catalog, schemaPattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getSearchStringEscape = function (callback) {
this._dbm.getSearchStringEscape(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the string that can be used to escape wildcard characters.
*
* @param {Function} callback
* @returns {String} Via callback: the string used to escape wildcard characters
*/
DatabaseMetaData.prototype.getSearchStringEscape = function(callback) {
this._dbm.getSearchStringEscape(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getStringFunctions = function (callback) {
this._dbm.getStringFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves a comma-separated list of string functions available with this
* database.
*
* @param {Function} callback
* @returns {String} Via callback: the list of string functions supported by this database
*/
DatabaseMetaData.prototype.getStringFunctions = function(callback) {
this._dbm.getStringFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getSuperTables = function (catalog, schemaPattern, tableNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSuperTables(catalog, schemaPattern, tableNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSuperTables(catalog, schemaPattern, tableNamePattern, function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getSuperTypes = function (catalog, schemaPattern, typeNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(typeNamePattern) || _.isUndefined(typeNamePattern) || _.isString(typeNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSuperTypes(catalog, schemaPattern, typeNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(typeNamePattern) || _.isUndefined(typeNamePattern) || _.isString(typeNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getSuperTypes(catalog, schemaPattern, typeNamePattern, function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getSystemFunctions = function (callback) {
this._dbm.getSystemFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves a comma-separated list of system functions available with this
* database.
*
* @param {Function} callback
* @returns {String} Via callback: a list of system functions supported by this database
*/
DatabaseMetaData.prototype.getSystemFunctions = function(callback) {
this._dbm.getSystemFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getTablePrivileges = function (catalog, schemaPattern, tableNamePattern, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getTablePrivileges(catalog, schemaPattern, tableNamePattern, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern))
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getTablePrivileges(catalog, schemaPattern, tableNamePattern, function(err
, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getTableTypes = function (callback) {
this._dbm.getTableTypes(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
/**
* Retrieves the table types available in this database.
*
* @param {Function} callback
* @returns {ResultSet} Via callback: a ResultSet object in which each row has a single String column that is a table type
*/
DatabaseMetaData.prototype.getTableTypes = function(callback) {
this._dbm.getTableTypes(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getTables = function (catalog, schemaPattern, tableNamePattern, types, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(tableNamePattern) || _.isUndefined(tableNamePattern) || _.isString(tableNamePattern)) &&
(_.isNull(types) || _.isUndefined(types) || _.isArray(types))
);
if(_.isArray(types)) {
_.forEach(types, function(type) {
if(_.isString(type)) return;
validParams = false;
return false;
});
}
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getTables(catalog, schemaPattern, tableNamePattern, types, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
});
}
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getTables(catalog, schemaPattern, tableNamePattern, types, function(err,
result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getTimeDateFunctions = function (callback) {
this._dbm.getTimeDateFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves a comma-separated list of the time and date functions available
* with this database.
*
* @param {Function} callback
* @returns {String} Via callback: the list of time and date functions supported by this database
*/
DatabaseMetaData.prototype.getTimeDateFunctions = function(callback) {
this._dbm.getTimeDateFunctions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getTypeInfo = function (callback) {
this._dbm.getTypeInfo(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
/**
* Retrieves a description of all the data types supported by this database.
*
* @param {Function} callback
* @returns {ResultSet} Via callback: a ResultSet object in which each row is an SQL type description
*/
DatabaseMetaData.prototype.getTypeInfo = function(callback) {
this._dbm.getTypeInfo(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getUDTs = function (catalog, schemaPattern, typeNamePattern, types, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schemaPattern) || _.isUndefined(schemaPattern) || _.isString(schemaPattern)) &&
(_.isNull(typeNamePattern) || _.isUndefined(typeNamePattern) || _.isString(typeNamePattern)) &&
(_.isNull(types) || _.isUndefined(types) || _.isArray(types))
);
if(_.isArray(types)) {
_.forEach(types, function(type) {
if(_.isInteger(type)) return;
validParams = false;
return false;
});
}
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getUDTs(catalog, schemaPattern, typeNamePattern, types, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
});
}
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getUDTs(catalog, schemaPattern, typeNamePattern, types, function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...getURL = function (callback) {
this._dbm.getURL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the URL for this DBMS.
*
* @param {Function} callback
* @returns {String} Via callback: the URL for this DBMS or null if it cannot be generated
*/
DatabaseMetaData.prototype.getURL = function(callback) {
this._dbm.getURL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getUserName = function (callback) {
this._dbm.getUserName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves the user name as known to this database.
*
* @param {Function} callback
* @returns {String} Via callback: Retrieves the user name as known to this database
*/
DatabaseMetaData.prototype.getUserName = function(callback) {
this._dbm.getUserName(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getVersionColumns = function (catalog, schema, table, callback) {
var validParams = (
(_.isNull(catalog) || _.isUndefined(catalog) || _.isString(catalog)) &&
(_.isNull(schema) || _.isUndefined(schema) || _.isString(schema)) &&
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getVersionColumns(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
}...
_.isString(table)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.getVersionColumns(catalog, schema, table, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(result));
});
};
...insertsAreDetected = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.insertsAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.insertsAreDetected = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.insertsAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...isCatalogAtStart = function (callback) {
this._dbm.isCatalogAtStart(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a catalog appears at the start of a fully qualified table
* name.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.isCatalogAtStart = function(callback) {
this._dbm.isCatalogAtStart(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...isReadOnly = function (callback) {
this._dbm.isReadOnly(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
};
Connection.prototype.isClosedSync = function() {
return this._conn.isClosedSync();
};
Connection.prototype.isReadOnly = function(callback) {
this._conn.isReadOnly(function(err, readonly) {
if (err) {
return callback(err);
} else {
return callback(null, readonly);
}
});
};
...locatorsUpdateCopy = function (callback) {
this._dbm.locatorsUpdateCopy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Indicates whether updates made to a LOB are made on a copy or directly to
* the LOB.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if updates are made to a copy of the LOB; false if updates are made directly to the LOB
*/
DatabaseMetaData.prototype.locatorsUpdateCopy = function(callback) {
this._dbm.locatorsUpdateCopy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...nullPlusNonNullIsNull = function (callback) {
this._dbm.nullPlusNonNullIsNull(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports concatenations between NULL and
* non-NULL values being NULL.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.nullPlusNonNullIsNull = function(callback) {
this._dbm.nullPlusNonNullIsNull(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...nullsAreSortedAtEnd = function (callback) {
this._dbm.nullsAreSortedAtEnd(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether NULL values are sorted at the end regardless of sort
* order.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.nullsAreSortedAtEnd = function(callback) {
this._dbm.nullsAreSortedAtEnd(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...nullsAreSortedAtStart = function (callback) {
this._dbm.nullsAreSortedAtStart(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether NULL values are sorted at the start regardless of sort
* order.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.nullsAreSortedAtStart = function(callback) {
this._dbm.nullsAreSortedAtStart(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...nullsAreSortedHigh = function (callback) {
this._dbm.nullsAreSortedHigh(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether NULL values are sorted high.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.nullsAreSortedHigh = function(callback) {
this._dbm.nullsAreSortedHigh(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...nullsAreSortedLow = function (callback) {
this._dbm.nullsAreSortedLow(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether NULL values are sorted low.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.nullsAreSortedLow = function(callback) {
this._dbm.nullsAreSortedLow(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...othersDeletesAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersDeletesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.othersDeletesAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersDeletesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...othersInsertsAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersInsertsAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.othersInsertsAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersInsertsAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...othersUpdatesAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersUpdatesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.othersUpdatesAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.othersUpdatesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...ownDeletesAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownDeletesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.ownDeletesAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownDeletesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...ownInsertsAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownInsertsAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.ownInsertsAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownInsertsAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...ownUpdatesAreVisible = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownUpdatesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.ownUpdatesAreVisible = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.ownUpdatesAreVisible(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesLowerCaseIdentifiers = function (callback) {
this._dbm.storesLowerCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case unquoted SQL identifiers
* as case insensitive and stores them in lower case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesLowerCaseIdentifiers = function(callback) {
this._dbm.storesLowerCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesLowerCaseQuotedIdentifiers = function (callback) {
this._dbm.storesLowerCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case quoted SQL identifiers as
* case insensitive and stores them in lower case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesLowerCaseQuotedIdentifiers = function(callback) {
this._dbm.storesLowerCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesMixedCaseIdentifiers = function (callback) {
this._dbm.storesMixedCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case unquoted SQL identifiers
* as case insensitive and stores them in mixed case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesMixedCaseIdentifiers = function(callback) {
this._dbm.storesMixedCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesMixedCaseQuotedIdentifiers = function (callback) {
this._dbm.storesMixedCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case quoted SQL identifiers as
* case insensitive and stores them in mixed case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesMixedCaseQuotedIdentifiers = function(callback) {
this._dbm.storesMixedCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesUpperCaseIdentifiers = function (callback) {
this._dbm.storesUpperCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case unquoted SQL identifiers
* as case insensitive and stores them in upper case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesUpperCaseIdentifiers = function(callback) {
this._dbm.storesUpperCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...storesUpperCaseQuotedIdentifiers = function (callback) {
this._dbm.storesUpperCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case quoted SQL identifiers as
* case insensitive and stores them in upper case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.storesUpperCaseQuotedIdentifiers = function(callback) {
this._dbm.storesUpperCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsANSI92EntryLevelSQL = function (callback) {
this._dbm.supportsANSI92EntryLevelSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports the ANSI92 entry level SQL grammar.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsANSI92EntryLevelSQL = function(callback) {
this._dbm.supportsANSI92EntryLevelSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsANSI92FullSQL = function (callback) {
this._dbm.supportsANSI92FullSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports the ANSI92 full SQL grammar
* supported.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsANSI92FullSQL = function(callback) {
this._dbm.supportsANSI92FullSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsANSI92IntermediateSQL = function (callback) {
this._dbm.supportsANSI92IntermediateSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports the ANSI92 intermediate SQL grammar
* supported.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsANSI92IntermediateSQL = function(callback) {
this._dbm.supportsANSI92IntermediateSQL(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsAlterTableWithAddColumn = function (callback) {
this._dbm.supportsAlterTableWithAddColumn(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports ALTER TABLE with add column.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsAlterTableWithAddColumn = function(callback) {
this._dbm.supportsAlterTableWithAddColumn(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsAlterTableWithDropColumn = function (callback) {
this._dbm.supportsAlterTableWithDropColumn(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports ALTER TABLE with drop column.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsAlterTableWithDropColumn = function(callback) {
this._dbm.supportsAlterTableWithDropColumn(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsBatchUpdates = function (callback) {
this._dbm.supportsBatchUpdates(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports batch updates.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if this database supports batch upcates; false otherwise
*/
DatabaseMetaData.prototype.supportsBatchUpdates = function(callback) {
this._dbm.supportsBatchUpdates(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCatalogsInDataManipulation = function (callback) {
this._dbm.supportsCatalogsInDataManipulation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a catalog name can be used in a data manipulation
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCatalogsInDataManipulation = function(callback) {
this._dbm.supportsCatalogsInDataManipulation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCatalogsInIndexDefinitions = function (callback) {
this._dbm.supportsCatalogsInIndexDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a catalog name can be used in an index definition
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCatalogsInIndexDefinitions = function(callback) {
this._dbm.supportsCatalogsInIndexDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCatalogsInPrivilegeDefinitions = function (callback) {
this._dbm.supportsCatalogsInPrivilegeDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a catalog name can be used in a privilege definition
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCatalogsInPrivilegeDefinitions = function(callback) {
this._dbm.supportsCatalogsInPrivilegeDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCatalogsInProcedureCalls = function (callback) {
this._dbm.supportsCatalogsInProcedureCalls(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether a catalog name can be used in a procedure call statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCatalogsInProcedureCalls = function(callback) {
this._dbm.supportsCatalogsInProcedureCalls(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCatalogsInTableDefinitions = function (callback) {
this._dbm.supportsCatalogsInTableDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a catalog name can be used in a table definition
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCatalogsInTableDefinitions = function(callback) {
this._dbm.supportsCatalogsInTableDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsColumnAliasing = function (callback) {
this._dbm.supportsColumnAliasing(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports column aliasing.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsColumnAliasing = function(callback) {
this._dbm.supportsColumnAliasing(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsConvert = function (fromType, toType, callback) {
var validParams = (
_.isInteger(fromType) &&
_.isInteger(toType)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsConvert(fromType, toType, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
_.isInteger(toType)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsConvert(fromType, toType, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCoreSQLGrammar = function (callback) {
this._dbm.supportsCoreSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports the ODBC Core SQL grammar.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCoreSQLGrammar = function(callback) {
this._dbm.supportsCoreSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsCorrelatedSubqueries = function (callback) {
this._dbm.supportsCorrelatedSubqueries(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports correlated subqueries.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsCorrelatedSubqueries = function(callback) {
this._dbm.supportsCorrelatedSubqueries(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsDataDefinitionAndDataManipulationTransactions = function (callback) {
this._dbm.supportsDataDefinitionAndDataManipulationTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports both data definition and data
* manipulation statements within a transaction.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsDataDefinitionAndDataManipulationTransactions = function(callback) {
this._dbm.supportsDataDefinitionAndDataManipulationTransactions(function(err, result
) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsDataManipulationTransactionsOnly = function (callback) {
this._dbm.supportsDataManipulationTransactionsOnly(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports only data manipulation statements
* within a transaction.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsDataManipulationTransactionsOnly = function(callback) {
this._dbm.supportsDataManipulationTransactionsOnly(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsDifferentTableCorrelationNames = function (callback) {
this._dbm.supportsDifferentTableCorrelationNames(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether, when table correlation names are supported, they are
* restricted to being different from the names of the tables.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsDifferentTableCorrelationNames = function(callback) {
this._dbm.supportsDifferentTableCorrelationNames(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsExpressionsInOrderBy = function (callback) {
this._dbm.supportsExpressionsInOrderBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports expressions in ORDER BY lists.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsExpressionsInOrderBy = function(callback) {
this._dbm.supportsExpressionsInOrderBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsExtendedSQLGrammar = function (callback) {
this._dbm.supportsExtendedSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports the ODBC Extended SQL grammar.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsExtendedSQLGrammar = function(callback) {
this._dbm.supportsExtendedSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsFullOuterJoins = function (callback) {
this._dbm.supportsFullOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports full nested outer joins.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsFullOuterJoins = function(callback) {
this._dbm.supportsFullOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsGetGeneratedKeys = function (callback) {
this._dbm.supportsGetGeneratedKeys(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether auto-generated keys can be retrieved after a statement has
* been executed
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsGetGeneratedKeys = function(callback) {
this._dbm.supportsGetGeneratedKeys(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsGroupBy = function (callback) {
this._dbm.supportsGroupBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports some form of GROUP BY clause.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsGroupBy = function(callback) {
this._dbm.supportsGroupBy(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsGroupByBeyondSelect = function (callback) {
this._dbm.supportsGroupByBeyondSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* SELECT statement in a GROUP BY clause provided that all of the columns in
* the SELECT statement are included in the GROUP BY clause.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsGroupByBeyondSelect = function(callback) {
this._dbm.supportsGroupByBeyondSelect(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsGroupByUnrelated = function (callback) {
this._dbm.supportsGroupByUnrelated(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports using a column that is not in the
* SELECT statement in a GROUP BY clause.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsGroupByUnrelated = function(callback) {
this._dbm.supportsGroupByUnrelated(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsIntegrityEnhancementFacility = function (callback) {
this._dbm.supportsIntegrityEnhancementFacility(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports the SQL Integrity Enhancement
* Facility.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsIntegrityEnhancementFacility = function(callback) {
this._dbm.supportsIntegrityEnhancementFacility(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsLikeEscapeClause = function (callback) {
this._dbm.supportsLikeEscapeClause(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports specifying a LIKE escape clause.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsLikeEscapeClause = function(callback) {
this._dbm.supportsLikeEscapeClause(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsLimitedOuterJoins = function (callback) {
this._dbm.supportsLimitedOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database provides limited support for outer joins.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsLimitedOuterJoins = function(callback) {
this._dbm.supportsLimitedOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMinimumSQLGrammar = function (callback) {
this._dbm.supportsMinimumSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports the ODBC Minimum SQL grammar.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMinimumSQLGrammar = function(callback) {
this._dbm.supportsMinimumSQLGrammar(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMixedCaseIdentifiers = function (callback) {
this._dbm.supportsMixedCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case unquoted SQL identifiers
* as case sensitive and as a result stores them in mixed case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMixedCaseIdentifiers = function(callback) {
this._dbm.supportsMixedCaseIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMixedCaseQuotedIdentifiers = function (callback) {
this._dbm.supportsMixedCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database treats mixed case quoted SQL identifiers as
* case sensitive and as a result stores them in mixed case.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMixedCaseQuotedIdentifiers = function(callback) {
this._dbm.supportsMixedCaseQuotedIdentifiers(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMultipleOpenResults = function (callback) {
this._dbm.supportsMultipleOpenResults(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether it is possible to have multiple ResultSet objects returned
* from a CallableStatement object simultaneously.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMultipleOpenResults = function(callback) {
this._dbm.supportsMultipleOpenResults(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMultipleResultSets = function (callback) {
this._dbm.supportsMultipleResultSets(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports getting multiple ResultSet objects
* from a single call to the method execute.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMultipleResultSets = function(callback) {
this._dbm.supportsMultipleResultSets(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsMultipleTransactions = function (callback) {
this._dbm.supportsMultipleTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database allows having multiple transactions open at
* once (on different connections).
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsMultipleTransactions = function(callback) {
this._dbm.supportsMultipleTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsNamedParameters = function (callback) {
this._dbm.supportsNamedParameters(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports named parameters to callable
* statements.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsNamedParameters = function(callback) {
this._dbm.supportsNamedParameters(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsNonNullableColumns = function (callback) {
this._dbm.supportsNonNullableColumns(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether columns in this database may be defined as non-nullable.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsNonNullableColumns = function(callback) {
this._dbm.supportsNonNullableColumns(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOpenCursorsAcrossCommit = function (callback) {
this._dbm.supportsOpenCursorsAcrossCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports keeping cursors open across
* commits.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOpenCursorsAcrossCommit = function(callback) {
this._dbm.supportsOpenCursorsAcrossCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOpenCursorsAcrossRollback = function (callback) {
this._dbm.supportsOpenCursorsAcrossRollback(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports keeping cursors open across
* rollbacks.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOpenCursorsAcrossRollback = function(callback) {
this._dbm.supportsOpenCursorsAcrossRollback(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOpenStatementsAcrossCommit = function (callback) {
this._dbm.supportsOpenStatementsAcrossCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports keeping statements open across
* commits.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOpenStatementsAcrossCommit = function(callback) {
this._dbm.supportsOpenStatementsAcrossCommit(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOpenStatementsAcrossRollback = function (callback) {
this._dbm.supportsOpenStatementsAcrossRollback(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports keeping statements open across
* rollbacks.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOpenStatementsAcrossRollback = function(callback) {
this._dbm.supportsOpenStatementsAcrossRollback(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOrderByUnrelated = function (callback) {
this._dbm.supportsOrderByUnrelated(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports using a column that is not in the
* SELECT statement in an ORDER BY clause.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOrderByUnrelated = function(callback) {
this._dbm.supportsOrderByUnrelated(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsOuterJoins = function (callback) {
this._dbm.supportsOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports some form of outer join.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsOuterJoins = function(callback) {
this._dbm.supportsOuterJoins(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsPositionedDelete = function (callback) {
this._dbm.supportsPositionedDelete(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports positioned DELETE statements.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsPositionedDelete = function(callback) {
this._dbm.supportsPositionedDelete(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsPositionedUpdate = function (callback) {
this._dbm.supportsPositionedUpdate(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports positioned UPDATE statements.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsPositionedUpdate = function(callback) {
this._dbm.supportsPositionedUpdate(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsResultSetConcurrency = function (type, concurrency, callback) {
var validParams = (
_.isInteger(type) &&
_.isInteger(concurrency)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetConcurrency(type, concurrency, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
_.isInteger(concurrency)
);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetConcurrency(type, concurrency, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsResultSetHoldability = function (holdability, callback) {
var validParams = _.isInteger(holdability);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetHoldability(holdability, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.supportsResultSetHoldability = function(holdability, callback) {
var validParams = _.isInteger(holdability);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetHoldability(holdability, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsResultSetType = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetType(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.supportsResultSetType = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsResultSetType(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSavepoints = function (callback) {
this._dbm.supportsSavepoints(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports savepoints.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSavepoints = function(callback) {
this._dbm.supportsSavepoints(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSchemasInDataManipulation = function (callback) {
this._dbm.supportsSchemasInDataManipulation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a schema name can be used in a data manipulation
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSchemasInDataManipulation = function(callback) {
this._dbm.supportsSchemasInDataManipulation(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSchemasInIndexDefinitions = function (callback) {
this._dbm.supportsSchemasInIndexDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a schema name can be used in an index definition
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSchemasInIndexDefinitions = function(callback) {
this._dbm.supportsSchemasInIndexDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSchemasInPrivilegeDefinitions = function (callback) {
this._dbm.supportsSchemasInPrivilegeDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether a schema name can be used in a privilege definition
* statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSchemasInPrivilegeDefinitions = function(callback) {
this._dbm.supportsSchemasInPrivilegeDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSchemasInProcedureCalls = function (callback) {
this._dbm.supportsSchemasInProcedureCalls(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether a schema name can be used in a procedure call statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSchemasInProcedureCalls = function(callback) {
this._dbm.supportsSchemasInProcedureCalls(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSchemasInTableDefinitions = function (callback) {
this._dbm.supportsSchemasInTableDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether a schema name can be used in a table definition statement.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSchemasInTableDefinitions = function(callback) {
this._dbm.supportsSchemasInTableDefinitions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSelectForUpdate = function (callback) {
this._dbm.supportsSelectForUpdate(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports SELECT FOR UPDATE statements.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSelectForUpdate = function(callback) {
this._dbm.supportsSelectForUpdate(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsStatementPooling = function (callback) {
this._dbm.supportsStatementPooling(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports statement pooling.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsStatementPooling = function(callback) {
this._dbm.supportsStatementPooling(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsStoredFunctionsUsingCallSyntax = function (callback) {
this._dbm.supportsStoredFunctionsUsingCallSyntax(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports invoking user-defined or vendor
* functions using the stored procedure escape syntax.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsStoredFunctionsUsingCallSyntax = function(callback) {
this._dbm.supportsStoredFunctionsUsingCallSyntax(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsStoredProcedures = function (callback) {
this._dbm.supportsStoredProcedures(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports stored procedure calls that use the
* stored procedure escape syntax.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsStoredProcedures = function(callback) {
this._dbm.supportsStoredProcedures(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSubqueriesInComparisons = function (callback) {
this._dbm.supportsSubqueriesInComparisons(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports subqueries in comparison
* expressions.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSubqueriesInComparisons = function(callback) {
this._dbm.supportsSubqueriesInComparisons(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSubqueriesInExists = function (callback) {
this._dbm.supportsSubqueriesInExists(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports subqueries in EXISTS expressions.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSubqueriesInExists = function(callback) {
this._dbm.supportsSubqueriesInExists(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSubqueriesInIns = function (callback) {
this._dbm.supportsSubqueriesInIns(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports subqueries in IN expressions.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSubqueriesInIns = function(callback) {
this._dbm.supportsSubqueriesInIns(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsSubqueriesInQuantifieds = function (callback) {
this._dbm.supportsSubqueriesInQuantifieds(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
* Retrieves whether this database supports subqueries in quantified
* expressions.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsSubqueriesInQuantifieds = function(callback) {
this._dbm.supportsSubqueriesInQuantifieds(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsTableCorrelationNames = function (callback) {
this._dbm.supportsTableCorrelationNames(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports table correlation names.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsTableCorrelationNames = function(callback) {
this._dbm.supportsTableCorrelationNames(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsTransactionIsolationLevel = function (level, callback) {
var validParams = _.isInteger(level);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsTransactionIsolationLevel(level, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.supportsTransactionIsolationLevel = function(level, callback) {
var validParams = _.isInteger(level);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.supportsTransactionIsolationLevel(level, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsTransactions = function (callback) {
this._dbm.supportsTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports transactions.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsTransactions = function(callback) {
this._dbm.supportsTransactions(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsUnion = function (callback) {
this._dbm.supportsUnion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports SQL UNION.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsUnion = function(callback) {
this._dbm.supportsUnion(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...supportsUnionAll = function (callback) {
this._dbm.supportsUnionAll(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database supports SQL UNION ALL.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.supportsUnionAll = function(callback) {
this._dbm.supportsUnionAll(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...updatesAreDetected = function (type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.updatesAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
DatabaseMetaData.prototype.updatesAreDetected = function(type, callback) {
var validParams = _.isInteger(type);
if(! validParams) {
return callback(new Error('INVALID ARGUMENTS'));
}
this._dbm.updatesAreDetected(type, function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...usesLocalFilePerTable = function (callback) {
this._dbm.usesLocalFilePerTable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database uses a file for each table.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.usesLocalFilePerTable = function(callback) {
this._dbm.usesLocalFilePerTable(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...usesLocalFiles = function (callback) {
this._dbm.usesLocalFiles(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
}...
/**
* Retrieves whether this database stores tables in a local file.
*
* @param {Function} callback
* @returns {Boolean} Via callback: true if so; false otherwise
*/
DatabaseMetaData.prototype.usesLocalFiles = function(callback) {
this._dbm.usesLocalFiles(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, result);
});
};
...getConnection = function (url, propsoruser, password, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
var validArgs = args[0] && (
// args[1] (propsoruser) and args[2] (password) can both be falsey
! (args[1] || args[2]) ||
// args[1] (propsoruser) and args[2] (password) can both be strings
(_.isString(args[1]) && _.isString(args[2])) ||
// args[1] (propsoruser) can be an object if args[2] (password) is falsey
(_.isObject(args[1]) && ! args[2])
);
if(! validArgs) {
return callback(new Error("INVALID ARGUMENTS"));
}
// Push a callback handler onto the arguments
args.push(function(err, conn) {
if (err) {
return callback(err);
} else {
return callback(null, conn);
}
});
// Add DM and 'getConnection' string onto beginning of args
// (unshift in reverse order of desired order)
args.unshift('getConnection');
args.unshift(DM);
// Forward modified arguments to java.callStaticMethod
java.callStaticMethod.apply(java, args);
}...
/**
* Retrieves the connection that produced this metadata object.
*
* @param {Function} callback
* @returns {Connection} Via callback: the connection that produced this metadata object
*/
DatabaseMetaData.prototype.getConnection = function(callback) {
this._dbm.getConnection(function(err, result) {
if (err) {
return callback(err);
}
return callback(null, new Connection(result));
});
};
...getConnectionSync = function (url, propsoruser, password) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Check arguments for validity, and return error if invalid
var validArgs = args[0] && (
// args[1] (propsoruser) and args[2] (password) can both be falsey
! (args[1] || args[2]) ||
// args[1] (propsoruser) and args[2] (password) can both be strings
(_.isString(args[1]) && _.isString(args[2])) ||
// args[1] (propsoruser) can be an object if args[2] (password) is falsey
(_.isObject(args[1]) && ! args[2])
);
if(! validArgs) {
return new Error("INVALID ARGUMENTS");
}
// Add DM and 'getConnection' string onto beginning of args
// (unshift in reverse order of desired order)
args.unshift('getConnection');
args.unshift(DM);
// Forward modified arguments to java.callStaticMethod
return java.callStaticMethodSync.apply(java, args);
}...
return callback(null, connobj);
}
});
};
var addConnectionSync = function(url, props, ka, maxIdle) {
var conn = dm.getConnectionSync(url, props);
var connobj = {
uuid: uuid.v4(),
conn: new Connection(conn),
keepalive: ka.enabled ? setInterval(keepalive, ka.interval, conn, ka.query) : false
};
if (maxIdle) {
...getLoginTimeout = function (callback) {
java.callStaticMethod(DM, 'getLoginTimeout', function(err, seconds) {
if (err) {
return callback(err);
} else {
return callback(null, seconds);
}
});
}n/a
registerDriver = function (driver, callback) {
java.callStaticMethod(DM, 'registerDriver', driver, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
// If a drivername is supplied, initialize the via the old method,
// Class.forName()
if (this._drivername) {
java.newInstance(this._drivername, function(err, driver) {
if (err) {
return callback(err);
} else {
dm.registerDriver(driver, function(err) {
if (err) {
return callback(err);
}
});
}
});
}
...setLoginTimeout = function (seconds, callback) {
java.callStaticMethod(DM, 'setLoginTimeout', seconds, function(err) {
if (err) {
return callback(err);
} else {
return callback(null, true);
}
});
}n/a
function JDBC(config) {
Pool.call(this, config);
}n/a
function JDBC(config) {
Pool.call(this, config);
}n/a
addOption = function (option) {
if (!isJvmCreated() && option) {
java.options.push(option);
} else if (isJvmCreated()) {
winston.error("You've tried to add an option to an already running JVM!");
winston.error("This isn't currently supported. Please add all option entries before calling any java methods");
winston.error("You can test for a running JVM with the isJvmCreated funtion.");
}
}...
var jinst = require('jdbc/lib/jinst');
// isJvmCreated will be true after the first java call. When this happens, the
// options and classpath cannot be adjusted.
if (!jinst.isJvmCreated()) {
// Add all java options required by your project here. You get one chance to
// setup the options before the first java call.
jinst.addOption("-Xrs");
// Add all jar files required by your project here. You get one chance to
// setup the classpath before the first java call.
jinst.setupClasspath(['./drivers/hsqldb.jar',
'./drivers/derby.jar',
'./drivers/derbyclient.jar',
'./drivers/derbytools.jar']);
}
...getInstance = function () {
return java;
}...
var _ = require("lodash");
var jinst = require("./jinst");
var CallableStatement = require('./callablestatement');
var PreparedStatement = require('./preparedstatement');
var DatabaseMetaData = require('./databasemetadata');
var Statement = require('./statement');
var SQLWarning = require('./sqlwarning');
var java = jinst.getInstance();
if (!jinst.isJvmCreated()) {
jinst.addOption("-Xrs");
}
function Connection(conn) {
this._conn = conn;
...isJvmCreated = function () {
return isJvmCreated();
}...
are setup like this due to the fact that order can't be guaranteed.</p>
```javascript
var jinst = require('jdbc/lib/jinst');
// isJvmCreated will be true after the first java call. When this happens, the
// options and classpath cannot be adjusted.
if (!jinst.isJvmCreated()) {
// Add all java options required by your project here. You get one chance to
// setup the options before the first java call.
jinst.addOption("-Xrs");
// Add all jar files required by your project here. You get one chance to
// setup the classpath before the first java call.
jinst.setupClasspath(['./drivers/hsqldb.jar',
'./drivers/derby.jar',
...setupClasspath = function (dependencyArr) {
if (!isJvmCreated() && dependencyArr) {
java.classpath.push.apply(java.classpath, dependencyArr);
} else if (isJvmCreated()) {
winston.error("You've tried to add an entry to the classpath of an already running JVM!");
winston.error("This isn't currently supported. Please add all classpath entries before calling any java methods");
winston.error("You can test for a running JVM with the isJvmCreated funtion.");
}
}...
// options and classpath cannot be adjusted.
if (!jinst.isJvmCreated()) {
// Add all java options required by your project here. You get one chance to
// setup the options before the first java call.
jinst.addOption("-Xrs");
// Add all jar files required by your project here. You get one chance to
// setup the classpath before the first java call.
jinst.setupClasspath(['./drivers/hsqldb.jar',
'./drivers/derby.jar',
'./drivers/derbyclient.jar',
'./drivers/derbytools.jar']);
}
```
- **Connection Pooling**
...function Pool(config) {
this._url = config.url;
this._props = (function (config) {
var Properties = java.import('java.util.Properties');
var properties = new Properties();
for(var name in config.properties) {
properties.putSync(name, config.properties[name]);
}
if (config.user && properties.getPropertySync('user') === undefined) {
properties.putSync('user', config.user);
}
if (config.password && properties.getPropertySync('password') === undefined) {
properties.putSync('password', config.password);
}
return properties;
})(config);
this._drivername = config.drivername ? config.drivername : '';
this._minpoolsize = config.minpoolsize ? config.minpoolsize : 1;
this._maxpoolsize = config.maxpoolsize ? config.maxpoolsize : 1;
this._keepalive = config.keepalive ? config.keepalive : {
interval: 60000,
query: 'select 1',
enabled: false
};
this._maxidle = (!this._keepalive.enabled && config.maxidle) || null;
this._logging = config.logging ? config.logging : {
level: 'error'
};
this._pool = [];
this._reserved = [];
}n/a
_closeIdleConnections = function () {
if (! this._maxidle) {
return;
}
var self = this;
closeIdleConnectionsInArray(self._pool, this._maxidle);
closeIdleConnectionsInArray(self._reserved, this._maxidle);
}...
jinst.events.emit('initialized');
};
Pool.prototype.reserve = function(callback) {
var self = this;
var conn = null;
self._closeIdleConnections();
if (self._pool.length > 0 ) {
conn = self._pool.shift();
if (conn.lastIdle) {
conn.lastIdle = new Date().getTime();
}
...initialize = function (callback) {
var self = this;
winston.level = this._logging.level;
// If a drivername is supplied, initialize the via the old method,
// Class.forName()
if (this._drivername) {
java.newInstance(this._drivername, function(err, driver) {
if (err) {
return callback(err);
} else {
dm.registerDriver(driver, function(err) {
if (err) {
return callback(err);
}
});
}
});
}
asyncjs.times(self._minpoolsize, function(n, next){
addConnection(self._url, self._props, self._keepalive, self._maxidle, function(err, conn) {
next(err, conn);
});
}, function(err, conns) {
if (err) {
return callback(err);
} else {
_.each(conns, function(conn) {
self._pool.push(conn);
});
return callback(null);
}
});
jinst.events.emit('initialized');
}...
if (testpool === null) {
testpool = new Pool(config);
}
callback();
},
testinitialize: function(test) {
// Initialize the pool (create minpoolsize connections)
testpool.initialize(function(err) {
test.expect(1);
test.equal(null, err);
test.done();
});
},
testreserve: function(test) {
// Reserve a connection.
...purge = function (callback) {
var self = this;
var conns = self._pool.concat(self._reserved);
asyncjs.each(conns,
function(conn, done) {
if (typeof conn === 'object' && conn.conn !== null) {
conn.conn.close(function(err) {
//we don't want to prevent other connections from being closed
done();
});
} else {
done();
}
},
function() {
self._pool = [];
self._reserved = [];
callback();
}
);
}n/a
release = function (conn, callback) {
var self = this;
if (typeof conn === 'object') {
var uuid = conn.uuid;
self._reserved = _.reject(self._reserved, function(conn) {
return conn.uuid === uuid;
});
if (conn.lastIdle) {
conn.lastIdle = new Date().getTime();
}
self._pool.unshift(conn);
return callback(null);
} else {
return callback(new Error("INVALID CONNECTION"));
}
}...
test.equal(testpool._reserved.length, 1);
testconn = conn;
test.done();
});
},
testrelease: function(test) {
// Release a connection.
testpool.release(testconn, function(err, conn) {
test.expect(3);
test.equal(null, err);
test.equal(testpool._pool.length, 2);
test.equal(testpool._reserved.length, 0);
testconn = null;
test.done();
});
...reserve = function (callback) {
var self = this;
var conn = null;
self._closeIdleConnections();
if (self._pool.length > 0 ) {
conn = self._pool.shift();
if (conn.lastIdle) {
conn.lastIdle = new Date().getTime();
}
self._reserved.unshift(conn);
} else if (self._reserved.length < self._maxpoolsize) {
try {
conn = addConnectionSync(self._url, self._props, self._keepalive, self._maxidle);
self._reserved.unshift(conn);
} catch (err) {
winston.error(err);
conn = null;
return callback(err);
}
}
if (conn === null) {
callback(new Error("No more pool connections available"));
} else {
callback(null, conn);
}
}...
test.expect(1);
test.equal(null, err);
test.done();
});
},
testreserve: function(test) {
// Reserve a connection.
testpool.reserve(function(err, conn) {
test.expect(4);
test.equal(null, err);
test.ok(conn && typeof conn == 'object');
test.equal(testpool._pool.length, 1);
test.equal(testpool._reserved.length, 1);
testconn = conn;
test.done();
...status = function (callback) {
var self = this;
var status = {};
status.available = self._pool.length;
status.reserved = self._reserved.length;
status.pool = connStatus([], self._pool);
status.rpool = connStatus([], self._reserved);
callback(null, status);
}n/a
function PreparedStatement(ps) {
Statement.call(this, ps);
this._ps = ps;
}n/a
addBatch = function (callback) {
this._ps.addBatch(function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps = ps;
}
PreparedStatement.prototype = Object.create(Statement.prototype);
PreparedStatement.prototype.constructor = PreparedStatement;
PreparedStatement.prototype.addBatch = function(callback) {
this._ps.addBatch(function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.clearParameters = function(callback) {
this._ps.clearParameters(function(err) {
...clearParameters = function (callback) {
this._ps.clearParameters(function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.addBatch(function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.clearParameters = function(callback) {
this._ps.clearParameters(function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.execute = function(callback) {
this._ps.execute(function(err, result) {
...function PreparedStatement(ps) {
Statement.call(this, ps);
this._ps = ps;
}n/a
execute = function (callback) {
this._ps.execute(function(err, result) {
if (err) { winston.error(err); return callback(err); }
callback(null, result);
});
}...
jinst.addOption("-Xrs");
}
var keepalive = function(conn, query) {
var self = this;
conn.createStatement(function(err, statement) {
if (err) return winston.error(err);
statement.execute(query, function(err, result) {
if (err) return winston.error(err);
winston.silly("%s - Keep-Alive", new Date().toUTCString());
});
});
};
var addConnection = function(url, props, ka, maxIdle, callback) {
...executeQuery = function (callback) {
this._ps.executeQuery(function(err, resultset) {
if (err) { winston.error(err); return callback(err); }
callback(null, new ResultSet(resultset));
});
}...
```javascript
// Select statement example.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
statement.executeQuery("SELECT * FROM blah;", function(err, resultset) {
if (err) {
callback(err)
} else {
// Convert the result set to an object array.
resultset.toObjArray(function(err, results) {
if (results.length > 0) {
console.log("ID: " + results[0].ID);
...executeUpdate = function (callback) {
this._ps.executeUpdate(function(err, result) {
if (err) { winston.error(err); return callback(err); }
callback(null, result);
});
}...
asyncjs.series([
function(callback) {
// CREATE SQL.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
statement.executeUpdate("CREATE TABLE blah "
+ "(id int, name varchar(10), date DATE, "
+ " time TIME, timestamp TIMESTAMP);",
function(err, count) {
if (err) {
callback(err);
} else {
callback(null, count);
...getMetaData = function (callback) {
this._ps.getMetaData(function(err, result) {
if (err) return callback(err);
callback(null, new ResultSetMetaData(result));
});
}...
} else {
return callback(null, holdability);
}
});
};
Connection.prototype.getMetaData = function(callback) {
this._conn.getMetaData(function(err, dbm) {
if (err) {
return callback(err);
} else {
return callback(null, new DatabaseMetaData(dbm));
}
});
};
...getParameterMetaData = function (callback) {
callback(new Error("NOT IMPLEMENTED"));
// this._ps.getParameterMetaData(function(err, result) {
// if (err) callback(err);
// callback(null, result);
// });
}...
if (err) return callback(err);
callback(null, new ResultSetMetaData(result));
});
};
PreparedStatement.prototype.getParameterMetaData = function(callback) {
callback(new Error("NOT IMPLEMENTED"));
// this._ps.getParameterMetaData(function(err, result) {
// if (err) callback(err);
// callback(null, result);
// });
};
PreparedStatement.prototype.setArray = function(index, val, callback) {
callback(new Error("NOT IMPLEMENTED"));
...setArray = function (index, val, callback) {
callback(new Error("NOT IMPLEMENTED"));
}n/a
setAsciiStream = function (index, val, length, callback) {
// length is optional, or can be int or long.
callback(new Error("NOT IMPLEMENTED"));
}n/a
setBigDecimal = function (index, val, callback) {
this._ps.setBigDecimal(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
PreparedStatement.prototype.setAsciiStream = function(index, val, length, callback) {
// length is optional, or can be int or long.
callback(new Error("NOT IMPLEMENTED"));
};
// val must be a java.math.BigDecimal
PreparedStatement.prototype.setBigDecimal = function(index, val, callback) {
this._ps.setBigDecimal(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setBinaryStream = function(index, val, length, callback) {
// length is optional, or can be int or long.
...setBinaryStream = function (index, val, length, callback) {
// length is optional, or can be int or long.
callback(new Error("NOT IMPLEMENTED"));
}n/a
setBlob = function (index, val, length, callback) {
// length is optional. Must be java.lang.Long if supplied, only valid with
// InputStream.
// val can be java.sql.Blob or java.io.InputStream
callback(new Error("NOT IMPLEMENTED"));
}n/a
setBoolean = function (index, val, callback) {
this._ps.setBoolean(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
// length is optional. Must be java.lang.Long if supplied, only valid with
// InputStream.
// val can be java.sql.Blob or java.io.InputStream
callback(new Error("NOT IMPLEMENTED"));
};
PreparedStatement.prototype.setBoolean = function(index, val, callback) {
this._ps.setBoolean(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setByte = function(index, val, callback) {
this._ps.setByte(index, val, function(err) {
...setByte = function (index, val, callback) {
this._ps.setByte(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setBoolean(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setByte = function(index, val, callback) {
this._ps.setByte(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setBytes = function(index, val, callback) {
this._ps.setBytes(index, val, function(err) {
...setBytes = function (index, val, callback) {
this._ps.setBytes(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setByte(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setBytes = function(index, val, callback) {
this._ps.setBytes(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setCharacterStream = function(index, val, length, callback) {
// length is optional, or can be int or long.
...setCharacterStream = function (index, val, length, callback) {
// length is optional, or can be int or long.
// val must be a java.io.Reader
callback(new Error("NOT IMPLEMENTED"));
}n/a
setClob = function (index, val, length, callback) {
// length is optional, must be a long, only valid with a java.io.Reader.
// val can be a java.io.Reader or a java.sql.Clob
callback(new Error("NOT IMPLEMENTED"));
}n/a
setDate = function (index, val, calendar, callback) {
if (calendar === null) {
this._ps.setDate(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setDate(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
});
}
}...
// length is optional, must be a long, only valid with a java.io.Reader.
// val can be a java.io.Reader or a java.sql.Clob
callback(new Error("NOT IMPLEMENTED"));
};
PreparedStatement.prototype.setDate = function(index, val, calendar, callback) {
if (calendar === null) {
this._ps.setDate(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setDate(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
...setDouble = function (index, val, callback) {
this._ps.setDouble(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
if (err) return callback(err);
callback(null);
});
}
};
PreparedStatement.prototype.setDouble = function(index, val, callback) {
this._ps.setDouble(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setFloat = function(index, val, callback) {
this._ps.setFloat(index, val, function(err) {
...setFloat = function (index, val, callback) {
this._ps.setFloat(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setDouble(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setFloat = function(index, val, callback) {
this._ps.setFloat(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setInt = function(index, val, callback) {
this._ps.setInt(index, val, function(err) {
...setInt = function (index, val, callback) {
this._ps.setInt(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setFloat(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setInt = function(index, val, callback) {
this._ps.setInt(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setLong = function(index, val, callback) {
this._ps.setLong(index, val, function(err) {
...setLong = function (index, val, callback) {
this._ps.setLong(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setInt(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setLong = function(index, val, callback) {
this._ps.setLong(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setString = function(index, val, callback) {
this._ps.setString(index, val, function(err) {
...setString = function (index, val, callback) {
this._ps.setString(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
}...
this._ps.setLong(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setString = function(index, val, callback) {
this._ps.setString(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setTime = function(index, val, calendar, callback) {
if (calendar === null) {
...setTime = function (index, val, calendar, callback) {
if (calendar === null) {
this._ps.setTime(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setTime(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
});
}
}...
if (err) return callback(err);
callback(null);
});
};
PreparedStatement.prototype.setTime = function(index, val, calendar, callback) {
if (calendar === null) {
this._ps.setTime(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setTime(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
...setTimestamp = function (index, val, calendar, callback) {
if (calendar === null) {
this._ps.setTimestamp(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setTimestamp(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
});
}
}...
callback(null);
});
}
};
PreparedStatement.prototype.setTimestamp = function(index, val, calendar, callback) {
if (calendar === null) {
this._ps.setTimestamp(index, val, function(err) {
if (err) return callback(err);
callback(null);
});
} else {
this._ps.setTimestamp(index, val, calendar, function(err) {
if (err) return callback(err);
callback(null);
...function ResultSet(rs) {
this._rs = rs;
this._holdability = (function() {
var h = [];
h[java.getStaticFieldValue('java.sql.ResultSet', 'CLOSE_CURSORS_AT_COMMIT')] = 'CLOSE_CURSORS_AT_COMMIT';
h[java.getStaticFieldValue('java.sql.ResultSet', 'HOLD_CURSORS_OVER_COMMIT')] = 'HOLD_CURSORS_OVER_COMMIT';
return h;
})();
this._types = (function() {
var typeNames = [];
typeNames[java.getStaticFieldValue("java.sql.Types", "BIT")] = "Boolean";
typeNames[java.getStaticFieldValue("java.sql.Types", "TINYINT")] = "Short";
typeNames[java.getStaticFieldValue("java.sql.Types", "SMALLINT")] = "Short";
typeNames[java.getStaticFieldValue("java.sql.Types", "INTEGER")] = "Int";
typeNames[java.getStaticFieldValue("java.sql.Types", "BIGINT")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "FLOAT")] = "Float";
typeNames[java.getStaticFieldValue("java.sql.Types", "REAL")] = "Float";
typeNames[java.getStaticFieldValue("java.sql.Types", "DOUBLE")] = "Double";
typeNames[java.getStaticFieldValue("java.sql.Types", "NUMERIC")] = "BigDecimal";
typeNames[java.getStaticFieldValue("java.sql.Types", "DECIMAL")] = "BigDecimal";
typeNames[java.getStaticFieldValue("java.sql.Types", "CHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "VARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "DATE")] = "Date";
typeNames[java.getStaticFieldValue("java.sql.Types", "TIME")] = "Time";
typeNames[java.getStaticFieldValue("java.sql.Types", "TIMESTAMP")] = "Timestamp";
typeNames[java.getStaticFieldValue("java.sql.Types", "BOOLEAN")] = "Boolean";
typeNames[java.getStaticFieldValue("java.sql.Types", "NCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "NVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGNVARCHAR")] = "String";
typeNames[java.getStaticFieldValue("java.sql.Types", "BINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "VARBINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "LONGVARBINARY")] = "Bytes";
typeNames[java.getStaticFieldValue("java.sql.Types", "BLOB")] = "Bytes";
return typeNames;
})();
}n/a
close = function (callback) {
this._rs.close(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
Connection.prototype.close = function(callback) {
var self = this;
if (self._conn === null) {
return callback(null);
}
self._conn.close(function(err) {
if (err) {
return callback(err);
} else {
self._conn = null;
return callback(null);
}
});
...getMetaData = function (callback) {
this._rs.getMetaData(function(err, rsmd) {
if (err) {
return callback(err);
} else {
return callback(null, new ResultSetMetaData(rsmd));
}
});
}...
} else {
return callback(null, holdability);
}
});
};
Connection.prototype.getMetaData = function(callback) {
this._conn.getMetaData(function(err, dbm) {
if (err) {
return callback(err);
} else {
return callback(null, new DatabaseMetaData(dbm));
}
});
};
...toObjArray = function (callback) {
this.toObject(function(err, result) {
if (err) return callback(err);
callback(null, result.rows);
});
}...
callback(err);
} else {
statement.executeQuery("SELECT * FROM blah;", function(err, resultset) {
if (err) {
callback(err)
} else {
// Convert the result set to an object array.
resultset.toObjArray(function(err, results) {
if (results.length > 0) {
console.log("ID: " + results[0].ID);
}
callback(null, resultset);
});
}
});
...toObject = function (callback) {
this.toObjectIter(function(err, rs) {
if (err) return callback(err);
var rowIter = rs.rows;
var rows = [];
var row = rowIter.next();
while (!row.done) {
rows.push(row.value);
row = rowIter.next();
}
rs.rows = rows;
return callback(null, rs);
});
}...
typeNames[java.getStaticFieldValue("java.sql.Types", "BLOB")] = "Bytes";
return typeNames;
})();
}
ResultSet.prototype.toObjArray = function(callback) {
this.toObject(function(err, result) {
if (err) return callback(err);
callback(null, result.rows);
});
};
ResultSet.prototype.toObject = function(callback) {
this.toObjectIter(function(err, rs) {
...toObjectIter = function (callback) {
var self = this;
self.getMetaData(function(err, rsmd) {
if (err) {
return callback(err);
} else {
var colsmetadata = [];
rsmd.getColumnCount(function(err, colcount) {
// Get some column metadata.
_.each(_.range(1, colcount + 1), function(i) {
colsmetadata.push({
label: rsmd._rsmd.getColumnLabelSync(i),
type: rsmd._rsmd.getColumnTypeSync(i)
});
});
callback(null, {
labels: _.map(colsmetadata, 'label'),
types: _.map(colsmetadata, 'type'),
rows: {
next: function() {
var nextRow = self._rs.nextSync();
if (! nextRow) {
return {done: true};
}
var result = {};
// loop through each column
_.each(_.range(1, colcount + 1), function(i) {
var cmd = colsmetadata[i-1];
var type = self._types[cmd.type] || 'String';
var getter = 'get' + type + 'Sync';
if (type === 'Date' || type === 'Time' || type === 'Timestamp') {
var dateVal = self._rs[getter](i);
result[cmd.label] = dateVal ? dateVal.toString() : null;
} else {
// If the column is an integer and is null, set result to null and continue
if (type === 'Int' && _.isNull(self._rs.getObjectSync(i))) {
result[cmd.label] = null;
return;
}
result[cmd.label] = self._rs[getter](i);
}
});
return {value: result, done: false};
}
}
});
});
}
});
}...
this.toObject(function(err, result) {
if (err) return callback(err);
callback(null, result.rows);
});
};
ResultSet.prototype.toObject = function(callback) {
this.toObjectIter(function(err, rs) {
if (err) return callback(err);
var rowIter = rs.rows;
var rows = [];
var row = rowIter.next();
while (!row.done) {
...function ResultSetMetaData(rsmd) {
this._rsmd = rsmd;
}n/a
getColumnCount = function (callback) {
this._rsmd.getColumnCount(function(err, count) {
if (err) {
return callback(err);
} else {
return callback(null, count);
}
});
}...
self.getMetaData(function(err, rsmd) {
if (err) {
return callback(err);
} else {
var colsmetadata = [];
rsmd.getColumnCount(function(err, colcount) {
// Get some column metadata.
_.each(_.range(1, colcount + 1), function(i) {
colsmetadata.push({
label: rsmd._rsmd.getColumnLabelSync(i),
type: rsmd._rsmd.getColumnTypeSync(i)
});
});
...function Statement(s) {
this._s = s;
}n/a
close = function (callback) {
this._s.close(function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
Connection.prototype.close = function(callback) {
var self = this;
if (self._conn === null) {
return callback(null);
}
self._conn.close(function(err) {
if (err) {
return callback(err);
} else {
self._conn = null;
return callback(null);
}
});
...execute = function (sql, callback) {
var s = this._s;
if (typeof sql === 'string') {
s.execute(sql, function(err, isResultSet) {
if (err) {
return callback(err);
}
if (isResultSet) {
s.getResultSet(function(err, resultset) {
if (err) {
return callback(err);
}
return callback(null, new ResultSet(resultset));
});
} else {
s.getUpdateCount(function(err, count) {
if (err) {
return callback(err);
}
return callback(null, count);
});
}
});
} else {
return callback(new Error('INVALID ARGUMENTS'));
}
}...
jinst.addOption("-Xrs");
}
var keepalive = function(conn, query) {
var self = this;
conn.createStatement(function(err, statement) {
if (err) return winston.error(err);
statement.execute(query, function(err, result) {
if (err) return winston.error(err);
winston.silly("%s - Keep-Alive", new Date().toUTCString());
});
});
};
var addConnection = function(url, props, ka, maxIdle, callback) {
...executeQuery = function (sql, callback) {
if (typeof sql === 'string') {
this._s.executeQuery(sql, function(err, resultset) {
if (err) {
return callback(err);
} else {
return callback(null, new ResultSet(resultset));
}
});
} else {
return callback(new Error('INVALID ARGUMENTS'));
}
}...
```javascript
// Select statement example.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
statement.executeQuery("SELECT * FROM blah;", function(err, resultset) {
if (err) {
callback(err)
} else {
// Convert the result set to an object array.
resultset.toObjArray(function(err, results) {
if (results.length > 0) {
console.log("ID: " + results[0].ID);
...executeUpdate = function (sql, arg1, callback) {
// Get arguments as an array
var args = Array.prototype.slice.call(arguments);
// Pull the callback off the end of the arguments
callback = args.pop();
// Check arguments for validity, and return error if invalid
if(! (_.isString(args[0]) && _.isUndefined(args[1]))) {
return callback(new Error('INVALID ARGUMENTS'));
}
// Push a callback handler onto the arguments
args.push(function(err, count) {
if (err) {
return callback(err);
}
return callback(null, count);
});
// Forward modified arguments to _s.executeUpdate
this._s.executeUpdate.apply(this._s, args);
}...
asyncjs.series([
function(callback) {
// CREATE SQL.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
statement.executeUpdate("CREATE TABLE blah "
+ "(id int, name varchar(10), date DATE, "
+ " time TIME, timestamp TIMESTAMP);",
function(err, count) {
if (err) {
callback(err);
} else {
callback(null, count);
...getFetchSize = function (callback) {
this._s.getFetchSize(function(err, fetchSize) {
if (err) {
return callback(err);
} else {
return callback(null, fetchSize);
}
});
}...
});
} else {
return callback(new Error('INVALID ARGUMENTS'));
}
};
Statement.prototype.getFetchSize = function(callback) {
this._s.getFetchSize(function(err, fetchSize) {
if (err) {
return callback(err);
} else {
return callback(null, fetchSize);
}
});
};
...getGeneratedKeys = function (callback) {
this._s.getGeneratedKeys(function(err, resultset) {
if(err) {
return callback(err);
}
return callback(null, new ResultSet(resultset));
});
}...
} else {
return callback(null);
}
});
};
Statement.prototype.getGeneratedKeys = function(callback) {
this._s.getGeneratedKeys(function(err, resultset) {
if(err) {
return callback(err);
}
return callback(null, new ResultSet(resultset));
});
};
...getMaxRows = function (callback) {
this._s.getMaxRows(function(err, max) {
if (err) {
return callback(err);
} else {
return callback(null, max);
}
});
}...
} else {
return callback(null);
}
});
};
Statement.prototype.getMaxRows = function(callback) {
this._s.getMaxRows(function(err, max) {
if (err) {
return callback(err);
} else {
return callback(null, max);
}
});
};
...getQueryTimeout = function (callback) {
this._s.getQueryTimeout(function(err, queryTimeout) {
if (err) {
return callback(err);
} else {
return callback(null, queryTimeout);
}
});
}...
} else {
return callback(null);
}
});
};
Statement.prototype.getQueryTimeout = function(callback) {
this._s.getQueryTimeout(function(err, queryTimeout) {
if (err) {
return callback(err);
} else {
return callback(null, queryTimeout);
}
});
};
...setFetchSize = function (rows, callback) {
this._s.setFetchSize(rows, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
// Select statement example.
conn.createStatement(function(err, statement) {
if (err) {
callback(err);
} else {
// Adjust some statement options before use. See statement.js for
// a full listing of supported options.
statement.setFetchSize(100, function(err) {
if (err) {
callback(err);
} else {
statement.executeQuery("SELECT * FROM blah;",
function(err, resultset) {
if (err) {
callback(err)
...setMaxRows = function (max, callback) {
this._s.setMaxRows(max, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
} else {
return callback(null, max);
}
});
};
Statement.prototype.setMaxRows = function(max, callback) {
this._s.setMaxRows(max, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...setQueryTimeout = function (seconds, callback) {
this._s.setQueryTimeout(seconds, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
}...
} else {
return callback(null, queryTimeout);
}
});
};
Statement.prototype.setQueryTimeout = function(seconds, callback) {
this._s.setQueryTimeout(seconds, function(err) {
if (err) {
return callback(err);
} else {
return callback(null);
}
});
};
...