nodejs-jdbc/dist/Connection.js

JDBC wrapper for Node

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Connection = void 0;
const CallableStatement_1 = require("./CallableStatement");
const jinst_1 = require("./jinst");
const PreparedStatement_1 = require("./PreparedStatement");
const Statement_1 = require("./Statement");
const sqlwarning_1 = require("./sqlwarning");
const DatabaseMetadata_1 = require("./DatabaseMetadata");
const java = (0, jinst_1.getInstance)();
if (!(0, jinst_1.isJvmCreated)()) {
    (0, jinst_1.addOption)('-Xrs');
}
class Connection {
    constructor(connection) {
        this.conn = connection;
        this.txniso = (function () {
            const 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;
        })();
    }
    async abort(executor) {
        return this.conn.abortPromise(executor);
    }
    clearWarnings() {
        return this.conn.clearWarningsSync();
    }
    async close() {
        return this.conn.closePromise();
    }
    async commit() {
        return this.conn.commitPromise();
    }
    createArrayOf(typename, objarr, callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    createBlob(callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    createClob(callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    createNClob(callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    createSQLXML(callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    async createStatement() {
        return this.conn
            .createStatementPromise()
            .then((statement) => new Statement_1.Statement(statement));
    }
    createStruct(typename, attrarr, callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    getAutoCommit() {
        return this.conn.getAutoCommitSync();
    }
    async getCatalog() {
        return new Promise((resolve, reject) => {
            this.conn
                .getCatalogPromise()
                .then((result) => {
                resolve(result);
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    async getClientInfo(name) {
        return new Promise((resolve, reject) => {
            this.conn
                .getClientInfoPromise()
                .then((result) => {
                if (name) {
                    resolve(result[name]);
                }
                else {
                    resolve(result);
                }
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    async getHoldability() {
        return this.conn.getHoldabilityPromise();
    }
    async getMetaData() {
        return new Promise((resolve, reject) => {
            this.conn
                .getMetaDataPromise()
                .then((dbm) => {
                resolve(new DatabaseMetadata_1.DatabaseMetaData(dbm));
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    getNetworkTimeout() {
        return this.conn.getNetworkTimeoutSync();
    }
    async getSchema() {
        return this.conn.getSchemaSync();
    }
    async getTransactionIsolation() {
        return new Promise((resolve, reject) => {
            this.conn
                .getTransactionIsolationPromise()
                .then((txniso) => {
                resolve(this.txniso[txniso]);
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    async getTypeMap() {
        return this.conn.getTypeMapPromise();
    }
    async getWarnings() {
        return new Promise((resolve, reject) => {
            this.conn
                .getWarnings()
                .then((sqlwarning) => {
                resolve(new sqlwarning_1.SQLWarning(sqlwarning));
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    isClosed() {
        return this.conn.isClosedSync();
    }
    isClosedSync() {
        return this.conn.isClosedSync();
    }
    isReadOnly() {
        return this.conn.isReadOnlySync();
    }
    isReadOnlySync() {
        return this.conn.isReadOnlySync();
    }
    async isValid(timeout) {
        return this.conn.isValidPromise(timeout);
    }
    isValidSync(timeout) {
        return this.conn.isValidSync(timeout);
    }
    nativeSQL(sql, callback) {
        return callback(new Error('NOT IMPLEMENTED'));
    }
    async prepareCall(call) {
        return this.conn
            .prepareCallPromise(call)
            .then((callableStatement) => new CallableStatement_1.CallableStatement(callableStatement));
    }
    async prepareStatement(sql) {
        return this.conn
            .prepareStatementPromise(sql)
            .then((prepareStatement) => new PreparedStatement_1.PreparedStatement(prepareStatement));
    }
    async releaseSavepoint(savepoint) {
        return this.conn.releaseSavepointPromise(savepoint);
    }
    async rollback(savepoint) {
        return this.conn.rollbackPromise(savepoint);
    }
    setAutoCommit(autoCommit) {
        return this.conn.setAutoCommitSync(autoCommit);
    }
    setCatalog(catalog) {
        return this.conn.setCatalogSync(catalog);
    }
    async setClientInfo(props, name, value) {
        return this.conn.setClientInfoPromise(props, name, value);
    }
    setHoldability(holdability) {
        return this.conn.setHoldabilitySync(holdability);
    }
    setNetworkTimeout(executor, ms) {
        return this.conn.setNetworkTimeoutSync(executor, ms);
    }
    setReadOnly(readonly) {
        return this.conn.setReadOnlySync(readonly);
    }
    setSavepoint(name) {
        this.conn.setSavepointSync(name);
    }
    setSchema(schema) {
        return this.conn.setSchemaSync(schema);
    }
    setTransactionIsolation(txniso) {
        return this.conn.setTransactionIsolationSync(txniso);
    }
    setTypeMap(map) {
        return this.conn.setTypeMapSync(map);
    }
}
exports.Connection = Connection;
//# sourceMappingURL=Connection.js.map