ts-hdb/lib/HDBClient.d.ts

hdb driver with typescript

/// <reference types="node" />
import { ResultSet } from "./ResultSet";
import { CUDStatement, DCL, DDL, DMLStatement, DQL, DQLStatement, NoParamMatcher, NoParamStatement, ProceduralStatement, ProcedureStatement, TransactionStatement } from "./Statement";
import { ExtractArguments, ExtractSelect, HDBClientOption, ReadyState } from "./types";
/**
 * HDB Client
 */
export declare class HDBClient {
    #private;
    constructor(options: HDBClientOption);
    private _connect;
    /**
     * read state of connection
     */
    get readyState(): ReadyState;
    /**
     * client of connection
     */
    get clientId(): Buffer;
    /**
     * Direct statement execution is the simplest way to execute SQL statements.
     *
     * data definition language, defined table sequence or procedure
     *
     * @param sql
     *
     * @example
     *
     * ```ts
     * await client.exec('create table t_1 (ID bigint)')
     * ```
     *
     *
     */
    exec(sql: DDL | TransactionStatement | DCL): Promise<void>;
    /**
     * execute SQL query `SELECT` statements
     *
     * @param sql
     * @returns the extracted data, if the column is blob type, will return the `Buffer` object
     *
     * @example
     *
     * ```ts
     * await client.exec('select A, B from TEST.NUMBERS order by A') // => [{A:1,B:2},{A:3,B:4}]
     * ```
     *
     */
    exec<T extends DQL>(sql: T): Promise<Array<ExtractSelect<T>>>;
    /**
     * execute DML like `INSERT`/`UPDATE`/`DELETE`
     *
     * @param sql insert/update/delete statement
     * @returns the number of affected rows
     */
    exec(sql: CUDStatement): Promise<number>;
    /**
     * call procedure directly
     *
     * if you want to get the output set, please use the `client.prepare()` and `statement.call()`
     *
     * @param sql
     * @returns none, you can not receive any out parameters from direct execution
     *
     * @example
     *
     * ```ts
     * await client.exec(`call cal_number (102,3,?,?,?)`); // => empty object
     * ```
     */
    exec(sql: ProceduralStatement): Promise<object>;
    exec(sql: string): Promise<any>;
    /**
     * The client returns a statement object which can be executed multiple times
     *
     * prepare SELECT, INSERT or PROCEDURE
     *
     * @param sql
     * @template ST statement entity type
     * @template P query parameters type
     * @returns
     *
     * @example
     *
     * ```ts
     * await client.prepare('SELECT * FROM DUMMY WHERE DUMMY = ?')
     * await client.prepare('INSERT INTO PERSON VALUES (?,?)')
     * await client.prepare('CALL proc_xxxxx (?,?)')
     * ```
     */
    prepare<SQL extends DQL>(sql: SQL): Promise<DQLStatement<ExtractSelect<SQL>, ExtractArguments<SQL>>>;
    prepare<SQL extends CUDStatement>(sql: SQL): Promise<DMLStatement<any, ExtractArguments<SQL>>>;
    prepare<ST = any, P extends Array<any> = Array<any>>(sql: NoParamMatcher): Promise<NoParamStatement>;
    /**
     * create procedure statement
     *
     * @template ST parameter type
     * @template P return type
     * @param sql
     */
    prepare<ST = any, P extends Array<any> = Array<any>>(sql: ProceduralStatement): Promise<ProcedureStatement<ST, P>>;
    /**
     * If you use the execute function of the client or statement instead of the exec function,
     * a resultSet object is returned in the callback instead of an array of all rows.
     *
     * The resultSet object allows you to create an object based row stream or an array based stream of rows which can be piped to an writer object.
     *
     * Don't forget to **close** the resultSet if you use the execute function
     *
     * @param query
     * @returns
     */
    streamQuery<SQL extends DQL>(query: SQL): Promise<ResultSet<ExtractSelect<SQL>>>;
    /**
     * query object stream
     *
     * @param query
     * @returns async object iterator
     *
     *
     * @example
     *
     * ```ts
     * for await (const row of client.streamQueryObject(`SELECT ID, NAME FROM t1`)) {
     *   expect(row.ID).not.toBeUndefined();
     *   expect(row.NAME).not.toBeUndefined();
     * }
     * ```
     *
     */
    streamQueryObject<SQL extends DQL>(query: SQL): AsyncIterable<ExtractSelect<SQL>>;
    /**
     * query object list stream
     *
     * @param query
     * @returns async object iterator
     *
     * @example
     *
     * ```ts
     * for await (const rows of client.streamQueryObject(`SELECT ID, NAME FROM t1`)) {
     *   expect(rows[0].ID).not.toBeUndefined();
     *   expect(rows[0].NAME).not.toBeUndefined();
     * }
     * ```
     *
     */
    streamQueryList<SQL extends DQL>(query: SQL): AsyncIterable<Array<ExtractSelect<SQL>>>;
    /**
     * set auto commit
     *
     * @param autoCommit
     */
    setAutoCommit(autoCommit: boolean): Promise<void>;
    /**
     * commit transaction
     *
     * @returns
     */
    commit(): Promise<void>;
    /**
     * rollback transaction
     *
     * @returns
     */
    rollback(): Promise<void>;
    /**
     * disconnect form HANA server
     *
     * @returns
     */
    disconnect(): Promise<unknown>;
    /**
     * close TCP connection
     */
    close(): void;
}