nodejs-jdbc/dist/PreparedStatement.js

JDBC wrapper for Node

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PreparedStatement = void 0;
const ResultSet_1 = require("./ResultSet");
const ResultSetMetadata_1 = require("./ResultSetMetadata");
const Helper_1 = require("./Helper");
const jinst_1 = require("./jinst");
const java = (0, jinst_1.getInstance)();
class PreparedStatement {
    constructor(ps) {
        this.ps = ps;
    }
    async addBatch() {
        return new Promise((resolve, reject) => {
            this.ps
                .addBatchPromise()
                .then(() => {
                resolve();
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async clearParameters() {
        return new Promise((resolve, reject) => {
            this.ps
                .clearParametersPromise()
                .then(() => {
                resolve();
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async execute() {
        return new Promise((resolve, reject) => {
            this.ps
                .executePromise()
                .then((result) => {
                resolve(new ResultSet_1.ResultSet(result));
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async executeBatch() {
        return new Promise((resolve, reject) => {
            this.ps
                .executeBatchPromise()
                .then(() => {
                resolve();
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async executeQuery() {
        return new Promise((resolve, reject) => {
            this.ps
                .executeQueryPromise()
                .then((result) => {
                return resolve(new ResultSet_1.ResultSet(result));
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async executeUpdate() {
        return new Promise((resolve, reject) => {
            this.ps
                .executeUpdatePromise()
                .then((result) => {
                return resolve(result);
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async getMetaData() {
        return new Promise((resolve, reject) => {
            this.ps
                .getMetaDataPromise()
                .then((result) => {
                return resolve(new ResultSetMetadata_1.ResultSetMetaData(result));
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    async getParameterMetaData() {
        return new Promise((resolve, reject) => {
            this.ps
                .getParameterMetaDataPromise()
                .then((result) => {
                return resolve(new ResultSetMetadata_1.ResultSetMetaData(result));
            })
                .catch((err) => {
                Helper_1.logger.error(err);
                reject(err);
            });
        });
    }
    setArray(index, val, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setAsciiStream(index, val, length, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setBigDecimal(index, value) {
        const bigdecimalValue = value
            ? java.newInstanceSync('java.math.BigDecimal', value)
            : 0;
        return this.ps.setBigDecimalSync(index, bigdecimalValue);
    }
    setBinaryStream(index, val, length, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setBlob(index, val, length, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setBoolean(index, val) {
        return this.ps.setBooleanSync(index, val);
    }
    setByte(index, val) {
        return this.ps.setByteSync(index, val);
    }
    setBytes(index, val) {
        return this.ps.setBytesSync(index, val);
    }
    setCharacterStream(index, val, length, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setClob(index, val, length, callback) {
        callback(new Error('NOT IMPLEMENTED'));
    }
    setDate(index, value) {
        const date = value
            ? java.callStaticMethodSync('java.sql.Date', 'valueOf', value)
            : null;
        return this.ps.setDateSync(index, date);
    }
    setDouble(index, value) {
        return this.ps.setDoubleSync(index, value);
    }
    setFloat(index, value) {
        return this.ps.setFloatSync(index, value);
    }
    setInt(index, value) {
        return this.ps.setIntSync(index, value);
    }
    setLong(index, value) {
        const longValue = value ? java.newInstanceSync('java.lang.Long', value) : 0;
        return this.ps.setLongSync(index, longValue);
    }
    setString(index, value) {
        return this.ps.setStringSync(index, value);
    }
    setTime(index, value) {
        const time = value
            ? java.callStaticMethodSync('java.sql.Time', 'valueOf', value)
            : null;
        return this.ps.setTimeSync(index, time);
    }
    setTimestamp(index, value) {
        const timestamp = value
            ? java.callStaticMethodSync('java.sql.Timestamp', 'valueOf', value)
            : null;
        return this.ps.setTimestampSync(index, timestamp);
    }
}
exports.PreparedStatement = PreparedStatement;
//# sourceMappingURL=PreparedStatement.js.map