nodejs-jdbc/dist/Statement.js

JDBC wrapper for Node

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Statement = void 0;
const ResultSet_1 = require("./ResultSet");
const ResultSetMetadata_1 = require("./ResultSetMetadata");
const jinst_1 = require("./jinst");
const java = (0, jinst_1.getInstance)();
class Statement {
    constructor(statement) {
        this.s = statement;
    }
    addBatch(sql) {
        return this.s.addBatchPromise(sql);
    }
    addBatchSync(sql) {
        return this.s.addBatchSync(sql);
    }
    clearBatchSync() {
        return this.s.clearBatchSync();
    }
    clearBatch() {
        return this.s.clearBatchPromise();
    }
    executeBatch() {
        return this.s.executeBatchPromise();
    }
    executeBatchSync() {
        return this.s.executeBatchSync();
    }
    async cancel() {
        return new Promise((resolve, reject) => {
            this.s
                .cancelPromise()
                .then(() => {
                resolve();
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    async close() {
        return this.s.closePromise();
    }
    async executeUpdate(sql) {
        return this.s.executeUpdatePromise(sql);
    }
    async executeQuery(sql) {
        return new Promise((resolve, reject) => {
            this.s
                .executeQueryPromise(sql)
                .then((result) => resolve(new ResultSet_1.ResultSet(result)))
                .catch((err) => reject(err));
        });
    }
    async execute(sql) {
        return new Promise((resolve, reject) => {
            this.s
                .executePromise(sql)
                .then((result) => {
                resolve(result);
            })
                .catch((error) => {
                reject(error);
            });
        });
    }
    getFetchSize() {
        return this.s.getFetchSizeSync();
    }
    setFetchSize(rows) {
        return this.s.setFetchSizeSync(rows);
    }
    getMaxRows() {
        return this.s.getMaxRowsSync();
    }
    setMaxRows(max) {
        return this.s.setMaxRowsSync(max);
    }
    getQueryTimeout() {
        return this.s.getQueryTimeoutSync();
    }
    setQueryTimeout(seconds) {
        return this.s.setQueryTimeoutSync(seconds);
    }
    async getGeneratedKeys() {
        return new Promise((resolve, reject) => {
            this.s
                .getGeneratedKeysPromise()
                .then((resultset) => {
                resolve(new ResultSet_1.ResultSet(resultset));
            })
                .catch((error) => {
                reject(error);
            });
        });
    }
    clearParameters() {
        return this.s.clearParametersSync();
    }
    setTime(index, value) {
        const time = value
            ? java.callStaticMethodSync('java.sql.Time', 'valueOf', value)
            : null;
        return this.s.setTimeSync(index, time);
    }
    setTimestamp(index, value) {
        const timestamp = value
            ? java.callStaticMethodSync('java.sql.Timestamp', 'valueOf', value)
            : null;
        return this.s.setTimestampSync(index, timestamp);
    }
    setString(index, value) {
        return this.s.setStringSync(index, value);
    }
    setLong(index, value) {
        const longValue = value ? java.newInstanceSync('java.lang.Long', value) : 0;
        return this.s.setLongSync(index, longValue);
    }
    setInt(index, value) {
        return this.s.setIntSync(index, value);
    }
    setDouble(index, value) {
        return this.s.setDoubleSync(index, value);
    }
    setFloat(index, value) {
        return this.s.setFloatSync(index, value);
    }
    setDate(index, value) {
        const date = value
            ? java.callStaticMethodSync('java.sql.Date', 'valueOf', value)
            : null;
        return this.s.setDateSync(index, date);
    }
    setByte(index, val) {
        return this.s.setByteSync(index, val);
    }
    setBytes(index, val) {
        return this.s.setBytesSync(index, val);
    }
    setBoolean(index, val) {
        return this.s.setBooleanSync(index, val);
    }
    async getMetaData() {
        return new Promise((resolve, reject) => {
            this.s
                .getMetaDataPromise()
                .then((result) => {
                return resolve(new ResultSetMetadata_1.ResultSetMetaData(result));
            })
                .catch((err) => {
                reject(err);
            });
        });
    }
    setBigDecimal(index, value) {
        const bigdecimalValue = value
            ? java.newInstanceSync('java.math.BigDecimal', value)
            : 0;
        return this.s.setBigDecimalSync(index, bigdecimalValue);
    }
}
exports.Statement = Statement;
jinst_1.events.once('initialized', () => {
    Statement.CLOSE_CURRENT_RESULT = java.getStaticFieldValue('java.sql.Statement', 'CLOSE_CURRENT_RESULT');
    Statement.KEEP_CURRENT_RESULT = java.getStaticFieldValue('java.sql.Statement', 'KEEP_CURRENT_RESULT');
    Statement.CLOSE_ALL_RESULTS = java.getStaticFieldValue('java.sql.Statement', 'CLOSE_ALL_RESULTS');
    Statement.SUCCESS_NO_INFO = java.getStaticFieldValue('java.sql.Statement', 'SUCCESS_NO_INFO');
    Statement.EXECUTE_FAILED = java.getStaticFieldValue('java.sql.Statement', 'EXECUTE_FAILED');
    Statement.RETURN_GENERATED_KEYS = java.getStaticFieldValue('java.sql.Statement', 'RETURN_GENERATED_KEYS');
    Statement.NO_GENERATED_KEYS = java.getStaticFieldValue('java.sql.Statement', 'NO_GENERATED_KEYS');
});
//# sourceMappingURL=Statement.js.map