/// <reference types="node" />
import { Readable } from "stream";
import { IExecuteOptions } from "../addon-types";
import { DuckDB } from "./duckdb";
import { ResultIterator } from "./result-iterator";
/**
 * Represents a DuckDB connection.
 *
 * @remarks
 * A single db instance can have multiple connections. Having more than one connection instance is required when executing concurrent queries.
 *
 * @public
 */
export declare class Connection {
    private duckdb;
    /**
     * Connection constructor.
     * @param duckdb - {@link DuckDB | DuckDB} instance to connect to.
     *
     *
     * @example
     * Initializing a connection:
     * ```ts
     * import { DuckDB } from "node-duckdb";
     * const db = new DuckDB();
     * const connection = new Connection(db);
     * ```
     *
     * @public
     */
    constructor(duckdb: DuckDB);
    private connectionBinding;
    /**
     * Asynchronously executes the query and returns a {@link https://nodejs.org/api/stream.html#stream_class_stream_readable | Readable stream} that wraps the result set.
     * @param command - SQL command to execute
     * @param options - optional options object of type {@link IExecuteOptions | IExecuteOptions}
     *
     * @example
     * Streaming results of a DuckDB query into a CSV file:
     * ```ts
     * import { Connection, DuckDB, RowResultFormat } from "node-duckdb";
     * import { createWriteStream } from "fs";
     * import { Transform } from "stream";
     * class ArrayToCsvTransform extends Transform {
     *     constructor() {
     *        super({objectMode: true})
     *    }
     *    _transform(chunk: any[], _encoding: string, callback: any) {
     *        this.push(chunk.join(",") + '\n');
     *        callback();
     *    }
     * }
     *
     * async function outputToFileAsCsv() {
     *     const db = new DuckDB();
     *     const connection = new Connection(db);
     *     await connection.execute("CREATE TABLE people(id INTEGER, name VARCHAR);");
     *     await connection.execute("INSERT INTO people VALUES (1, 'Mark'), (2, 'Hannes'), (3, 'Bob');");
     *     const resultStream = await connection.execute("SELECT * FROM people;", {rowResultFormat: RowResultFormat.Array});
     *     const transformToCsvStream = new ArrayToCsvTransform();
     *     const writeStream = createWriteStream("my-people-output");
     *     resultStream.pipe(transformToCsvStream).pipe(writeStream);
     * }
     * outputToFileAsCsv();
     * ```
     */
    execute<T>(command: string, options?: IExecuteOptions): Promise<Readable>;
    /**
     * Asynchronously executes the query and returns an iterator that points to the first result in the result set.
     * @param command - SQL command to execute
     * @param options - optional options object of type {@link IExecuteOptions | IExecuteOptions}
     *
     * @example
     * Printing rows:
     * ```ts
     * import { Connection, DuckDB, RowResultFormat } from "node-duckdb";
     * async function queryDatabaseWithIterator() {
     *   const db = new DuckDB();
     *   const connection = new Connection(db);
     *   await connection.executeIterator("CREATE TABLE people(id INTEGER, name VARCHAR);");
     *   await connection.executeIterator("INSERT INTO people VALUES (1, 'Mark'), (2, 'Hannes'), (3, 'Bob');");
     *   const result = await connection.executeIterator("SELECT * FROM people;");
     *   // print the first row
     *   console.log(result.fetchRow());
     *   // print the rest of the rows
     *   console.log(result.fetchAllRows());
     *   const result2 = await connection.executeIterator("SELECT * FROM people;", {rowResultFormat: RowResultFormat.Array});
     *   console.log(result2.fetchAllRows());
     *   connection.close();
     *   db.close();
     * }
     * queryDatabaseWithIterator();
     * ```
     *
     * @example
     * Providing generics type:
     * ```ts
     * const result = await connection.executeIterator<number[]>(`SELECT CAST(1 AS TINYINT)`, {
     *  rowResultFormat: RowResultFormat.Array,
     * });
     * expect(result.fetchRow()).toMatchObject([1]);
     * ```
     */
    executeIterator<T>(command: string, options?: IExecuteOptions): Promise<ResultIterator<T>>;
    /**
     * Close the connection (also closes all {@link https://nodejs.org/api/stream.html#stream_class_stream_readable | Readable} or {@link ResultIterator | ResultIterator} objects associated with this connection).
     * @remarks
     * Even though GC will automatically destroy the Connection object at some point, DuckDB data is stored in the native address space, not the V8 heap, meaning you can easily have a Node.js process taking gigabytes of memory (more than the default heap size for Node.js) with V8 not triggering GC. So, definitely think about manually calling `close()`.
     */
    close(): void;
    /**
     * If the connection is closed returns true, otherwise false.
     */
    get isClosed(): boolean;
}
//# sourceMappingURL=connection.d.ts.map