@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBResultReader.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBResultReader = void 0;
+const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
+const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
+const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
+const convertRowsFromChunks_1 = require("./convertRowsFromChunks");
+const getColumnsFromChunks_1 = require("./getColumnsFromChunks");
+const getColumnsObjectFromChunks_1 = require("./getColumnsObjectFromChunks");
+const getRowObjectsFromChunks_1 = require("./getRowObjectsFromChunks");
+const getRowsFromChunks_1 = require("./getRowsFromChunks");
+const JSDuckDBValueConverter_1 = require("./JSDuckDBValueConverter");
+const JsonDuckDBValueConverter_1 = require("./JsonDuckDBValueConverter");
+class DuckDBResultReader {
+    result;
+    chunks;
+    chunkSizeRuns;
+    currentRowCount_;
+    done_;
+    constructor(result) {
+        this.result = result;
+        this.chunks = [];
+        this.chunkSizeRuns = [];
+        this.currentRowCount_ = 0;
+        this.done_ = false;
+    }
+    get returnType() {
+        return this.result.returnType;
+    }
+    get statementType() {
+        return this.result.statementType;
+    }
+    get columnCount() {
+        return this.result.columnCount;
+    }
+    columnName(columnIndex) {
+        return this.result.columnName(columnIndex);
+    }
+    columnNames() {
+        return this.result.columnNames();
+    }
+    deduplicatedColumnNames() {
+        return this.result.deduplicatedColumnNames();
+    }
+    columnTypeId(columnIndex) {
+        return this.result.columnTypeId(columnIndex);
+    }
+    columnLogicalType(columnIndex) {
+        return this.result.columnLogicalType(columnIndex);
+    }
+    columnType(columnIndex) {
+        return this.result.columnType(columnIndex);
+    }
+    columnTypeJson(columnIndex) {
+        return this.result.columnTypeJson(columnIndex);
+    }
+    columnTypes() {
+        return this.result.columnTypes();
+    }
+    columnTypesJson() {
+        return this.result.columnTypesJson();
+    }
+    columnNamesAndTypesJson() {
+        return this.result.columnNamesAndTypesJson();
+    }
+    columnNameAndTypeObjectsJson() {
+        return this.result.columnNameAndTypeObjectsJson();
+    }
+    get rowsChanged() {
+        return this.result.rowsChanged;
+    }
+    /** Total number of rows read so far. Call `readAll` or `readUntil` to read rows. */
+    get currentRowCount() {
+        return this.currentRowCount_;
+    }
+    /** Whether reading is done, that is, there are no more rows to read. */
+    get done() {
+        return this.done_;
+    }
+    /**
+     * Returns the value for the given column and row. Both are zero-indexed.
+     *
+     * Will return an error if `rowIndex` is greater than `currentRowCount`.
+     */
+    value(columnIndex, rowIndex) {
+        if (this.currentRowCount_ === 0) {
+            throw Error(`No rows have been read`);
+        }
+        let chunkIndex = 0;
+        let currentRowIndex = rowIndex;
+        // Find which run of chunks our row is in.
+        // Since chunkSizeRuns shouldn't ever be longer than 2, this should be O(1).
+        for (const run of this.chunkSizeRuns) {
+            if (currentRowIndex < run.rowCount) {
+                // The row we're looking for is in this run.
+                // Calculate the chunk index and the row index in that chunk.
+                chunkIndex += Math.floor(currentRowIndex / run.chunkSize);
+                const rowIndexInChunk = currentRowIndex % run.chunkSize;
+                const chunk = this.chunks[chunkIndex];
+                return chunk.getColumnVector(columnIndex).getItem(rowIndexInChunk);
+            }
+            // The row we're looking for is not in this run.
+            // Update our counts for this run and move to the next one.
+            chunkIndex += run.chunkCount;
+            currentRowIndex -= run.rowCount;
+        }
+        // We didn't find our row. It must have been out of range.
+        throw Error(`Row index ${rowIndex} requested, but only ${this.currentRowCount_} row have been read so far.`);
+    }
+    /** Read all rows. */
+    async readAll() {
+        return this.fetchChunks();
+    }
+    /**
+     * Read rows until at least the given target row count has been met.
+     *
+     * Note that the resulting row count could be greater than the target, since rows are read in chunks, typically of 2048 rows each.
+     */
+    async readUntil(targetRowCount) {
+        return this.fetchChunks(targetRowCount);
+    }
+    async fetchChunks(targetRowCount) {
+        while (!(this.done_ ||
+            (targetRowCount !== undefined &&
+                this.currentRowCount_ >= targetRowCount))) {
+            const chunk = await this.result.fetchChunk();
+            if (chunk && chunk.rowCount > 0) {
+                this.updateChunkSizeRuns(chunk);
+                this.chunks.push(chunk);
+                this.currentRowCount_ += chunk.rowCount;
+            }
+            else {
+                this.done_ = true;
+            }
+        }
+    }
+    updateChunkSizeRuns(chunk) {
+        if (this.chunkSizeRuns.length > 0) {
+            const lastRun = this.chunkSizeRuns[this.chunkSizeRuns.length - 1];
+            if (lastRun.chunkSize === chunk.rowCount) {
+                // If the new batch is the same size as the last one, just update our last run.
+                lastRun.chunkCount += 1;
+                lastRun.rowCount += lastRun.chunkSize;
+                return;
+            }
+        }
+        // If this is our first batch, or it's a different size, create a new run.
+        this.chunkSizeRuns.push({
+            chunkCount: 1,
+            chunkSize: chunk.rowCount,
+            rowCount: chunk.rowCount,
+        });
+    }
+    getColumns() {
+        return (0, getColumnsFromChunks_1.getColumnsFromChunks)(this.chunks);
+    }
+    convertColumns(converter) {
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(this.chunks, converter);
+    }
+    getColumnsJS() {
+        return this.convertColumns(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    getColumnsJson() {
+        return this.convertColumns(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    getColumnsObject() {
+        return (0, getColumnsObjectFromChunks_1.getColumnsObjectFromChunks)(this.chunks, this.deduplicatedColumnNames());
+    }
+    convertColumnsObject(converter) {
+        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(this.chunks, this.deduplicatedColumnNames(), converter);
+    }
+    getColumnsObjectJS() {
+        return this.convertColumnsObject(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    getColumnsObjectJson() {
+        return this.convertColumnsObject(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    getRows() {
+        return (0, getRowsFromChunks_1.getRowsFromChunks)(this.chunks);
+    }
+    convertRows(converter) {
+        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(this.chunks, converter);
+    }
+    getRowsJS() {
+        return this.convertRows(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    getRowsJson() {
+        return this.convertRows(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+    getRowObjects() {
+        return (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)(this.chunks, this.deduplicatedColumnNames());
+    }
+    convertRowObjects(converter) {
+        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(this.chunks, this.deduplicatedColumnNames(), converter);
+    }
+    getRowObjectsJS() {
+        return this.convertRowObjects(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    getRowObjectsJson() {
+        return this.convertRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
+    }
+}
+exports.DuckDBResultReader = DuckDBResultReader;

package/lib/DuckDBScalarFunction.d.ts

@@ -0,0 +1,33 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBFunctionInfo } from './DuckDBFunctionInfo';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBVector } from './DuckDBVector';
+import { DuckDBBindInfo } from './DuckDBBindInfo';
+export type DuckDBScalarBindFunction = (bindInfo: DuckDBBindInfo) => void;
+export type DuckDBScalarMainFunction = (functionInfo: DuckDBFunctionInfo, inputDataChunk: DuckDBDataChunk, outputVector: DuckDBVector) => void;
+export declare class DuckDBScalarFunction {
+    readonly scalar_function: duckdb.ScalarFunction;
+    constructor();
+    static create({ name, bindFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }: {
+        name: string;
+        bindFunction?: DuckDBScalarBindFunction;
+        mainFunction: DuckDBScalarMainFunction;
+        returnType: DuckDBType;
+        parameterTypes?: readonly DuckDBType[];
+        varArgsType?: DuckDBType;
+        specialHandling?: boolean;
+        volatile?: boolean;
+        extraInfo?: object;
+    }): DuckDBScalarFunction;
+    destroySync(): void;
+    setName(name: string): void;
+    setBindFunction(bindFunction: DuckDBScalarBindFunction): void;
+    setMainFunction(mainFunction: DuckDBScalarMainFunction): void;
+    setReturnType(returnType: DuckDBType): void;
+    addParameter(parameterType: DuckDBType): void;
+    setVarArgs(varArgsType: DuckDBType): void;
+    setSpecialHandling(): void;
+    setVolatile(): void;
+    setExtraInfo(extraInfo: object): void;
+}

package/lib/DuckDBScalarFunction.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBScalarFunction = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
+const DuckDBFunctionInfo_1 = require("./DuckDBFunctionInfo");
+const DuckDBVector_1 = require("./DuckDBVector");
+const DuckDBBindInfo_1 = require("./DuckDBBindInfo");
+class DuckDBScalarFunction {
+    scalar_function;
+    constructor() {
+        this.scalar_function = node_bindings_1.default.create_scalar_function();
+    }
+    static create({ name, bindFunction, mainFunction, returnType, parameterTypes, varArgsType, specialHandling, volatile, extraInfo, }) {
+        const scalarFunction = new DuckDBScalarFunction();
+        scalarFunction.setName(name);
+        if (bindFunction) {
+            scalarFunction.setBindFunction(bindFunction);
+        }
+        scalarFunction.setMainFunction(mainFunction);
+        scalarFunction.setReturnType(returnType);
+        if (parameterTypes) {
+            for (const parameterType of parameterTypes) {
+                scalarFunction.addParameter(parameterType);
+            }
+        }
+        if (varArgsType) {
+            scalarFunction.setVarArgs(varArgsType);
+        }
+        if (specialHandling) {
+            scalarFunction.setSpecialHandling();
+        }
+        if (volatile) {
+            scalarFunction.setVolatile();
+        }
+        if (extraInfo) {
+            scalarFunction.setExtraInfo(extraInfo);
+        }
+        return scalarFunction;
+    }
+    destroySync() {
+        node_bindings_1.default.destroy_scalar_function_sync(this.scalar_function);
+    }
+    setName(name) {
+        node_bindings_1.default.scalar_function_set_name(this.scalar_function, name);
+    }
+    setBindFunction(bindFunction) {
+        node_bindings_1.default.scalar_function_set_bind(this.scalar_function, (info) => {
+            const bindInfo = new DuckDBBindInfo_1.DuckDBBindInfo(info);
+            bindFunction(bindInfo);
+        });
+    }
+    setMainFunction(mainFunction) {
+        node_bindings_1.default.scalar_function_set_function(this.scalar_function, (info, input, output) => {
+            const functionInfo = new DuckDBFunctionInfo_1.DuckDBFunctionInfo(info);
+            const inputDataChunk = new DuckDBDataChunk_1.DuckDBDataChunk(input);
+            const outputVector = DuckDBVector_1.DuckDBVector.create(output, inputDataChunk.rowCount);
+            mainFunction(functionInfo, inputDataChunk, outputVector);
+        });
+    }
+    setReturnType(returnType) {
+        node_bindings_1.default.scalar_function_set_return_type(this.scalar_function, returnType.toLogicalType().logical_type);
+    }
+    addParameter(parameterType) {
+        node_bindings_1.default.scalar_function_add_parameter(this.scalar_function, parameterType.toLogicalType().logical_type);
+    }
+    setVarArgs(varArgsType) {
+        node_bindings_1.default.scalar_function_set_varargs(this.scalar_function, varArgsType.toLogicalType().logical_type);
+    }
+    setSpecialHandling() {
+        node_bindings_1.default.scalar_function_set_special_handling(this.scalar_function);
+    }
+    setVolatile() {
+        node_bindings_1.default.scalar_function_set_volatile(this.scalar_function);
+    }
+    setExtraInfo(extraInfo) {
+        node_bindings_1.default.scalar_function_set_extra_info(this.scalar_function, extraInfo);
+    }
+}
+exports.DuckDBScalarFunction = DuckDBScalarFunction;

package/lib/DuckDBType.d.ts

@@ -0,0 +1,373 @@
+import { DuckDBLogicalType } from './DuckDBLogicalType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { Json } from './Json';
+import { DuckDBDateValue, DuckDBTimestampMillisecondsValue, DuckDBTimestampNanosecondsValue, DuckDBTimestampSecondsValue, DuckDBTimestampTZValue, DuckDBTimestampValue, DuckDBTimeTZValue, DuckDBTimeValue, DuckDBUUIDValue } from './values';
+export declare abstract class BaseDuckDBType<T extends DuckDBTypeId> {
+    readonly typeId: T;
+    readonly alias?: string;
+    protected constructor(typeId: T, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare class DuckDBBooleanType extends BaseDuckDBType<DuckDBTypeId.BOOLEAN> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBooleanType;
+    static create(alias?: string): DuckDBBooleanType;
+}
+export declare const BOOLEAN: DuckDBBooleanType;
+export declare class DuckDBTinyIntType extends BaseDuckDBType<DuckDBTypeId.TINYINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTinyIntType;
+    static create(alias?: string): DuckDBTinyIntType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const TINYINT: DuckDBTinyIntType;
+export declare class DuckDBSmallIntType extends BaseDuckDBType<DuckDBTypeId.SMALLINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBSmallIntType;
+    static create(alias?: string): DuckDBSmallIntType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const SMALLINT: DuckDBSmallIntType;
+export declare class DuckDBIntegerType extends BaseDuckDBType<DuckDBTypeId.INTEGER> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntegerType;
+    static create(alias?: string): DuckDBIntegerType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const INTEGER: DuckDBIntegerType;
+export declare class DuckDBBigIntType extends BaseDuckDBType<DuckDBTypeId.BIGINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBigIntType;
+    static create(alias?: string): DuckDBBigIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const BIGINT: DuckDBBigIntType;
+export declare class DuckDBUTinyIntType extends BaseDuckDBType<DuckDBTypeId.UTINYINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUTinyIntType;
+    static create(alias?: string): DuckDBUTinyIntType;
+    static readonly Max: number;
+    static readonly Min = 0;
+    get max(): number;
+    get min(): number;
+}
+export declare const UTINYINT: DuckDBUTinyIntType;
+export declare class DuckDBUSmallIntType extends BaseDuckDBType<DuckDBTypeId.USMALLINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUSmallIntType;
+    static create(alias?: string): DuckDBUSmallIntType;
+    static readonly Max: number;
+    static readonly Min = 0;
+    get max(): number;
+    get min(): number;
+}
+export declare const USMALLINT: DuckDBUSmallIntType;
+export declare class DuckDBUIntegerType extends BaseDuckDBType<DuckDBTypeId.UINTEGER> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUIntegerType;
+    static create(alias?: string): DuckDBUIntegerType;
+    static readonly Max: number;
+    static readonly Min = 0;
+    get max(): number;
+    get min(): number;
+}
+export declare const UINTEGER: DuckDBUIntegerType;
+export declare class DuckDBUBigIntType extends BaseDuckDBType<DuckDBTypeId.UBIGINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUBigIntType;
+    static create(alias?: string): DuckDBUBigIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const UBIGINT: DuckDBUBigIntType;
+export declare class DuckDBFloatType extends BaseDuckDBType<DuckDBTypeId.FLOAT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBFloatType;
+    static create(alias?: string): DuckDBFloatType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const FLOAT: DuckDBFloatType;
+export declare class DuckDBDoubleType extends BaseDuckDBType<DuckDBTypeId.DOUBLE> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBDoubleType;
+    static create(alias?: string): DuckDBDoubleType;
+    static readonly Max: number;
+    static readonly Min: number;
+    get max(): number;
+    get min(): number;
+}
+export declare const DOUBLE: DuckDBDoubleType;
+export declare class DuckDBTimestampType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampType;
+    static create(alias?: string): DuckDBTimestampType;
+    get epoch(): DuckDBTimestampValue;
+    get max(): DuckDBTimestampValue;
+    get min(): DuckDBTimestampValue;
+    get posInf(): DuckDBTimestampValue;
+    get negInf(): DuckDBTimestampValue;
+}
+export declare const TIMESTAMP: DuckDBTimestampType;
+export type DuckDBTimestampMicrosecondsType = DuckDBTimestampType;
+export declare const DuckDBTimestampMicrosecondsType: typeof DuckDBTimestampType;
+export declare class DuckDBDateType extends BaseDuckDBType<DuckDBTypeId.DATE> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBDateType;
+    static create(alias?: string): DuckDBDateType;
+    get epoch(): DuckDBDateValue;
+    get max(): DuckDBDateValue;
+    get min(): DuckDBDateValue;
+    get posInf(): DuckDBDateValue;
+    get negInf(): DuckDBDateValue;
+}
+export declare const DATE: DuckDBDateType;
+export declare class DuckDBTimeType extends BaseDuckDBType<DuckDBTypeId.TIME> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimeType;
+    static create(alias?: string): DuckDBTimeType;
+    get max(): DuckDBTimeValue;
+    get min(): DuckDBTimeValue;
+}
+export declare const TIME: DuckDBTimeType;
+export declare class DuckDBIntervalType extends BaseDuckDBType<DuckDBTypeId.INTERVAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntervalType;
+    static create(alias?: string): DuckDBIntervalType;
+}
+export declare const INTERVAL: DuckDBIntervalType;
+export declare class DuckDBHugeIntType extends BaseDuckDBType<DuckDBTypeId.HUGEINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBHugeIntType;
+    static create(alias?: string): DuckDBHugeIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const HUGEINT: DuckDBHugeIntType;
+export declare class DuckDBUHugeIntType extends BaseDuckDBType<DuckDBTypeId.UHUGEINT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUHugeIntType;
+    static create(alias?: string): DuckDBUHugeIntType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const UHUGEINT: DuckDBUHugeIntType;
+export declare class DuckDBVarCharType extends BaseDuckDBType<DuckDBTypeId.VARCHAR> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBVarCharType;
+    static create(alias?: string): DuckDBVarCharType;
+}
+export declare const VARCHAR: DuckDBVarCharType;
+export declare class DuckDBBlobType extends BaseDuckDBType<DuckDBTypeId.BLOB> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBlobType;
+    static create(alias?: string): DuckDBBlobType;
+}
+export declare const BLOB: DuckDBBlobType;
+export declare class DuckDBDecimalType extends BaseDuckDBType<DuckDBTypeId.DECIMAL> {
+    readonly width: number;
+    readonly scale: number;
+    constructor(width: number, scale: number, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+    static readonly default: DuckDBDecimalType;
+}
+export declare function DECIMAL(width?: number, scale?: number, alias?: string): DuckDBDecimalType;
+export declare class DuckDBTimestampSecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_S> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampSecondsType;
+    static create(alias?: string): DuckDBTimestampSecondsType;
+    get epoch(): DuckDBTimestampSecondsValue;
+    get max(): DuckDBTimestampSecondsValue;
+    get min(): DuckDBTimestampSecondsValue;
+    get posInf(): DuckDBTimestampSecondsValue;
+    get negInf(): DuckDBTimestampSecondsValue;
+}
+export declare const TIMESTAMP_S: DuckDBTimestampSecondsType;
+export declare class DuckDBTimestampMillisecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_MS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampMillisecondsType;
+    static create(alias?: string): DuckDBTimestampMillisecondsType;
+    get epoch(): DuckDBTimestampMillisecondsValue;
+    get max(): DuckDBTimestampMillisecondsValue;
+    get min(): DuckDBTimestampMillisecondsValue;
+    get posInf(): DuckDBTimestampMillisecondsValue;
+    get negInf(): DuckDBTimestampMillisecondsValue;
+}
+export declare const TIMESTAMP_MS: DuckDBTimestampMillisecondsType;
+export declare class DuckDBTimestampNanosecondsType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_NS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimestampNanosecondsType;
+    static create(alias?: string): DuckDBTimestampNanosecondsType;
+    get epoch(): DuckDBTimestampNanosecondsValue;
+    get max(): DuckDBTimestampNanosecondsValue;
+    get min(): DuckDBTimestampNanosecondsValue;
+    get posInf(): DuckDBTimestampNanosecondsValue;
+    get negInf(): DuckDBTimestampNanosecondsValue;
+}
+export declare const TIMESTAMP_NS: DuckDBTimestampNanosecondsType;
+export declare class DuckDBEnumType extends BaseDuckDBType<DuckDBTypeId.ENUM> {
+    readonly values: readonly string[];
+    readonly valueIndexes: Readonly<Record<string, number>>;
+    readonly internalTypeId: DuckDBTypeId;
+    constructor(values: readonly string[], internalTypeId: DuckDBTypeId, alias?: string);
+    indexForValue(value: string): number;
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function ENUM8(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM16(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM32(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare function ENUM(values: readonly string[], alias?: string): DuckDBEnumType;
+export declare class DuckDBListType extends BaseDuckDBType<DuckDBTypeId.LIST> {
+    readonly valueType: DuckDBType;
+    constructor(valueType: DuckDBType, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function LIST(valueType: DuckDBType, alias?: string): DuckDBListType;
+export declare class DuckDBStructType extends BaseDuckDBType<DuckDBTypeId.STRUCT> {
+    readonly entryNames: readonly string[];
+    readonly entryTypes: readonly DuckDBType[];
+    readonly entryIndexes: Readonly<Record<string, number>>;
+    constructor(entryNames: readonly string[], entryTypes: readonly DuckDBType[], alias?: string);
+    get entryCount(): number;
+    indexForEntry(entryName: string): number;
+    typeForEntry(entryName: string): DuckDBType;
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function STRUCT(entries: Record<string, DuckDBType>, alias?: string): DuckDBStructType;
+export declare class DuckDBMapType extends BaseDuckDBType<DuckDBTypeId.MAP> {
+    readonly keyType: DuckDBType;
+    readonly valueType: DuckDBType;
+    constructor(keyType: DuckDBType, valueType: DuckDBType, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function MAP(keyType: DuckDBType, valueType: DuckDBType, alias?: string): DuckDBMapType;
+export declare class DuckDBArrayType extends BaseDuckDBType<DuckDBTypeId.ARRAY> {
+    readonly valueType: DuckDBType;
+    readonly length: number;
+    constructor(valueType: DuckDBType, length: number, alias?: string);
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function ARRAY(valueType: DuckDBType, length: number, alias?: string): DuckDBArrayType;
+export declare class DuckDBUUIDType extends BaseDuckDBType<DuckDBTypeId.UUID> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBUUIDType;
+    static create(alias?: string): DuckDBUUIDType;
+    get max(): DuckDBUUIDValue;
+    get min(): DuckDBUUIDValue;
+}
+export declare const UUID: DuckDBUUIDType;
+export declare class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION> {
+    readonly memberTags: readonly string[];
+    readonly tagMemberIndexes: Readonly<Record<string, number>>;
+    readonly memberTypes: readonly DuckDBType[];
+    constructor(memberTags: readonly string[], memberTypes: readonly DuckDBType[], alias?: string);
+    memberIndexForTag(tag: string): number;
+    memberTypeForTag(tag: string): DuckDBType;
+    get memberCount(): number;
+    toString(): string;
+    toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
+}
+export declare function UNION(members: Record<string, DuckDBType>, alias?: string): DuckDBUnionType;
+export declare class DuckDBBitType extends BaseDuckDBType<DuckDBTypeId.BIT> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBitType;
+    static create(alias?: string): DuckDBBitType;
+}
+export declare const BIT: DuckDBBitType;
+export declare class DuckDBTimeTZType extends BaseDuckDBType<DuckDBTypeId.TIME_TZ> {
+    constructor(alias?: string);
+    toString(): string;
+    static readonly instance: DuckDBTimeTZType;
+    static create(alias?: string): DuckDBTimeTZType;
+    get max(): DuckDBTimeTZValue;
+    get min(): DuckDBTimeTZValue;
+}
+export declare const TIMETZ: DuckDBTimeTZType;
+export declare class DuckDBTimestampTZType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_TZ> {
+    constructor(alias?: string);
+    toString(): string;
+    static readonly instance: DuckDBTimestampTZType;
+    static create(alias?: string): DuckDBTimestampTZType;
+    get epoch(): DuckDBTimestampTZValue;
+    get max(): DuckDBTimestampTZValue;
+    get min(): DuckDBTimestampTZValue;
+    get posInf(): DuckDBTimestampTZValue;
+    get negInf(): DuckDBTimestampTZValue;
+}
+export declare const TIMESTAMPTZ: DuckDBTimestampTZType;
+export declare class DuckDBAnyType extends BaseDuckDBType<DuckDBTypeId.ANY> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBAnyType;
+    static create(alias?: string): DuckDBAnyType;
+}
+export declare const ANY: DuckDBAnyType;
+export declare class DuckDBBigNumType extends BaseDuckDBType<DuckDBTypeId.BIGNUM> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBBigNumType;
+    static create(alias?: string): DuckDBBigNumType;
+    static readonly Max: bigint;
+    static readonly Min: bigint;
+    get max(): bigint;
+    get min(): bigint;
+}
+export declare const BIGNUM: DuckDBBigNumType;
+export declare class DuckDBSQLNullType extends BaseDuckDBType<DuckDBTypeId.SQLNULL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBSQLNullType;
+    static create(alias?: string): DuckDBSQLNullType;
+}
+export declare const SQLNULL: DuckDBSQLNullType;
+export declare class DuckDBStringLiteralType extends BaseDuckDBType<DuckDBTypeId.STRING_LITERAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBStringLiteralType;
+    static create(alias?: string): DuckDBStringLiteralType;
+}
+export declare const STRING_LITERAL: DuckDBStringLiteralType;
+export declare class DuckDBIntegerLiteralType extends BaseDuckDBType<DuckDBTypeId.INTEGER_LITERAL> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBIntegerLiteralType;
+    static create(alias?: string): DuckDBIntegerLiteralType;
+}
+export declare const INTEGER_LITERAL: DuckDBIntegerLiteralType;
+export declare class DuckDBTimeNSType extends BaseDuckDBType<DuckDBTypeId.TIME_NS> {
+    constructor(alias?: string);
+    static readonly instance: DuckDBTimeNSType;
+    static create(alias?: string): DuckDBTimeNSType;
+}
+export declare const TIME_NS: DuckDBTimeNSType;
+export type DuckDBType = DuckDBBooleanType | DuckDBTinyIntType | DuckDBSmallIntType | DuckDBIntegerType | DuckDBBigIntType | DuckDBUTinyIntType | DuckDBUSmallIntType | DuckDBUIntegerType | DuckDBUBigIntType | DuckDBFloatType | DuckDBDoubleType | DuckDBTimestampType | DuckDBDateType | DuckDBTimeType | DuckDBIntervalType | DuckDBHugeIntType | DuckDBUHugeIntType | DuckDBVarCharType | DuckDBBlobType | DuckDBDecimalType | DuckDBTimestampSecondsType | DuckDBTimestampMillisecondsType | DuckDBTimestampNanosecondsType | DuckDBEnumType | DuckDBListType | DuckDBStructType | DuckDBMapType | DuckDBArrayType | DuckDBUUIDType | DuckDBUnionType | DuckDBBitType | DuckDBTimeTZType | DuckDBTimestampTZType | DuckDBAnyType | DuckDBBigNumType | DuckDBSQLNullType | DuckDBStringLiteralType | DuckDBIntegerLiteralType | DuckDBTimeNSType;