@haybarn/node-api 1.5.3-rc2

package/lib/DuckDBDataChunk.js

@@ -0,0 +1,223 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDataChunk = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBVector_1 = require("./DuckDBVector");
+class DuckDBDataChunk {
+    chunk;
+    vectors = [];
+    constructor(chunk) {
+        this.chunk = chunk;
+    }
+    static create(types, rowCount) {
+        const chunk = new DuckDBDataChunk(node_bindings_1.default.create_data_chunk(types.map((t) => t.toLogicalType().logical_type)));
+        if (rowCount != undefined) {
+            chunk.rowCount = rowCount;
+        }
+        return chunk;
+    }
+    reset() {
+        node_bindings_1.default.data_chunk_reset(this.chunk);
+    }
+    get columnCount() {
+        return node_bindings_1.default.data_chunk_get_column_count(this.chunk);
+    }
+    get rowCount() {
+        return node_bindings_1.default.data_chunk_get_size(this.chunk);
+    }
+    set rowCount(count) {
+        const maxRowCount = node_bindings_1.default.vector_size();
+        if (count > maxRowCount) {
+            throw new Error(`A data chunk cannot have more than ${maxRowCount} rows`);
+        }
+        node_bindings_1.default.data_chunk_set_size(this.chunk, count);
+    }
+    getColumnVector(columnIndex) {
+        if (this.vectors[columnIndex]) {
+            return this.vectors[columnIndex];
+        }
+        const vector = DuckDBVector_1.DuckDBVector.create(node_bindings_1.default.data_chunk_get_vector(this.chunk, columnIndex), this.rowCount);
+        this.vectors[columnIndex] = vector;
+        return vector;
+    }
+    visitColumnValues(columnIndex, visitValue) {
+        const vector = this.getColumnVector(columnIndex);
+        const type = vector.type;
+        for (let rowIndex = 0; rowIndex < vector.itemCount; rowIndex++) {
+            visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, type);
+        }
+    }
+    appendColumnValues(columnIndex, values) {
+        this.visitColumnValues(columnIndex, (value) => values.push(value));
+    }
+    getColumnValues(columnIndex) {
+        const values = [];
+        this.appendColumnValues(columnIndex, values);
+        return values;
+    }
+    convertColumnValues(columnIndex, converter) {
+        const convertedValues = [];
+        this.visitColumnValues(columnIndex, (value, _r, _c, type) => convertedValues.push(converter(value, type, converter)));
+        return convertedValues;
+    }
+    setColumnValues(columnIndex, values) {
+        const vector = this.getColumnVector(columnIndex);
+        if (vector.itemCount !== values.length) {
+            throw new Error(`number of values must equal chunk row count`);
+        }
+        for (let i = 0; i < values.length; i++) {
+            vector.setItem(i, values[i]);
+        }
+        vector.flush();
+    }
+    visitColumns(visitColumn) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            visitColumn(this.getColumnValues(columnIndex), columnIndex, this.getColumnVector(columnIndex).type);
+        }
+    }
+    appendToColumns(columns) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            let column = columns[columnIndex];
+            if (!column) {
+                column = [];
+                columns[columnIndex] = column;
+            }
+            this.appendColumnValues(columnIndex, column);
+        }
+    }
+    getColumns() {
+        const columns = [];
+        this.visitColumns((column) => columns.push(column));
+        return columns;
+    }
+    convertColumns(converter) {
+        const convertedColumns = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            convertedColumns.push(this.convertColumnValues(columnIndex, converter));
+        }
+        return convertedColumns;
+    }
+    setColumns(columns) {
+        if (columns.length > 0) {
+            this.rowCount = columns[0].length;
+        }
+        for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
+            this.setColumnValues(columnIndex, columns[columnIndex]);
+        }
+    }
+    appendToColumnsObject(columnNames, columnsObject) {
+        const columnCount = this.columnCount;
+        if (columnNames.length !== columnCount) {
+            throw new Error(`Provided number of column names (${columnNames.length}) does not match column count (${this.columnCount})`);
+        }
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            const columnName = columnNames[columnIndex];
+            let columnValues = columnsObject[columnName];
+            if (!columnValues) {
+                columnValues = [];
+                columnsObject[columnName] = columnValues;
+            }
+            this.appendColumnValues(columnIndex, columnValues);
+        }
+    }
+    getColumnsObject(columnNames) {
+        const columnsObject = {};
+        this.appendToColumnsObject(columnNames, columnsObject);
+        return columnsObject;
+    }
+    visitColumnMajor(visitValue) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            this.visitColumnValues(columnIndex, visitValue);
+        }
+    }
+    visitRowValues(rowIndex, visitValue) {
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            const vector = this.getColumnVector(columnIndex);
+            visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, vector.type);
+        }
+    }
+    appendRowValues(rowIndex, values) {
+        this.visitRowValues(rowIndex, (value) => values.push(value));
+    }
+    getRowValues(rowIndex) {
+        const values = [];
+        this.appendRowValues(rowIndex, values);
+        return values;
+    }
+    convertRowValues(rowIndex, converter) {
+        const convertedValues = [];
+        this.visitRowValues(rowIndex, (value, _, columnIndex) => convertedValues.push(converter(value, this.getColumnVector(columnIndex).type, converter)));
+        return convertedValues;
+    }
+    visitRows(visitRow) {
+        const rowCount = this.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            visitRow(this.getRowValues(rowIndex), rowIndex);
+        }
+    }
+    appendToRows(rows) {
+        this.visitRows((row) => rows.push(row));
+    }
+    getRows() {
+        const rows = [];
+        this.appendToRows(rows);
+        return rows;
+    }
+    convertRows(converter) {
+        const convertedRows = [];
+        const rowCount = this.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            convertedRows.push(this.convertRowValues(rowIndex, converter));
+        }
+        return convertedRows;
+    }
+    setRows(rows) {
+        this.rowCount = rows.length;
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            const vector = this.getColumnVector(columnIndex);
+            for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+                vector.setItem(rowIndex, rows[rowIndex][columnIndex]);
+            }
+            vector.flush();
+        }
+    }
+    appendToRowObjects(columnNames, rowObjects) {
+        const columnCount = this.columnCount;
+        if (columnNames.length !== columnCount) {
+            throw new Error(`Provided number of column names (${columnNames.length}) does not match column count (${this.columnCount})`);
+        }
+        const rowCount = this.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            let rowObject = {};
+            this.visitRowValues(rowIndex, (value, _, columnIndex) => {
+                rowObject[columnNames[columnIndex]] = value;
+            });
+            rowObjects.push(rowObject);
+        }
+    }
+    getRowObjects(columnNames) {
+        const rowObjects = [];
+        this.appendToRowObjects(columnNames, rowObjects);
+        return rowObjects;
+    }
+    visitRowMajor(visitValue) {
+        const rowCount = this.rowCount;
+        const columnCount = this.columnCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+                const vector = this.getColumnVector(columnIndex);
+                visitValue(vector.getItem(rowIndex), rowIndex, columnIndex, vector.type);
+            }
+        }
+    }
+}
+exports.DuckDBDataChunk = DuckDBDataChunk;

package/lib/DuckDBExtractedStatements.d.ts

@@ -0,0 +1,12 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBPreparedStatement } from './DuckDBPreparedStatement';
+import { DuckDBPreparedStatementCollection } from './DuckDBPreparedStatementCollection';
+export declare class DuckDBExtractedStatements {
+    private readonly connection;
+    private readonly extracted_statements;
+    private readonly statement_count;
+    private readonly preparedStatements?;
+    constructor(connection: duckdb.Connection, extracted_statements: duckdb.ExtractedStatements, statement_count: number, preparedStatements?: DuckDBPreparedStatementCollection);
+    get count(): number;
+    prepare(index: number): Promise<DuckDBPreparedStatement>;
+}

package/lib/DuckDBExtractedStatements.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBExtractedStatements = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBPreparedStatement_1 = require("./DuckDBPreparedStatement");
+class DuckDBExtractedStatements {
+    connection;
+    extracted_statements;
+    statement_count;
+    preparedStatements;
+    constructor(connection, extracted_statements, statement_count, preparedStatements) {
+        this.connection = connection;
+        this.extracted_statements = extracted_statements;
+        this.statement_count = statement_count;
+        this.preparedStatements = preparedStatements;
+    }
+    get count() {
+        return this.statement_count;
+    }
+    async prepare(index) {
+        const prepared = new DuckDBPreparedStatement_1.DuckDBPreparedStatement(await node_bindings_1.default.prepare_extracted_statement(this.connection, this.extracted_statements, index));
+        if (this.preparedStatements) {
+            this.preparedStatements.add(prepared);
+        }
+        return prepared;
+    }
+}
+exports.DuckDBExtractedStatements = DuckDBExtractedStatements;

package/lib/DuckDBFunctionInfo.d.ts

@@ -0,0 +1,10 @@
+import duckdb from '@haybarn/node-bindings';
+export declare class DuckDBFunctionInfo {
+    private readonly function_info;
+    constructor(function_info: duckdb.FunctionInfo);
+    get bindData(): object | undefined;
+    getBindData(): object | undefined;
+    get extraInfo(): object | undefined;
+    getExtraInfo(): object | undefined;
+    setError(error: string): void;
+}

package/lib/DuckDBFunctionInfo.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBFunctionInfo = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+class DuckDBFunctionInfo {
+    function_info;
+    constructor(function_info) {
+        this.function_info = function_info;
+    }
+    get bindData() {
+        return this.getBindData();
+    }
+    getBindData() {
+        return node_bindings_1.default.scalar_function_get_bind_data(this.function_info);
+    }
+    get extraInfo() {
+        return this.getExtraInfo();
+    }
+    getExtraInfo() {
+        return node_bindings_1.default.scalar_function_get_extra_info(this.function_info);
+    }
+    setError(error) {
+        node_bindings_1.default.scalar_function_set_error(this.function_info, error);
+    }
+}
+exports.DuckDBFunctionInfo = DuckDBFunctionInfo;

package/lib/DuckDBInstance.d.ts

@@ -0,0 +1,10 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBConnection } from './DuckDBConnection';
+export declare class DuckDBInstance {
+    private readonly db;
+    constructor(db: duckdb.Database);
+    static create(path?: string, options?: Record<string, string>): Promise<DuckDBInstance>;
+    static fromCache(path?: string, options?: Record<string, string>): Promise<DuckDBInstance>;
+    connect(): Promise<DuckDBConnection>;
+    closeSync(): void;
+}

package/lib/DuckDBInstance.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBInstance = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const createConfig_1 = require("./createConfig");
+const DuckDBConnection_1 = require("./DuckDBConnection");
+const DuckDBInstanceCache_1 = require("./DuckDBInstanceCache");
+class DuckDBInstance {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(path, options) {
+        const config = (0, createConfig_1.createConfig)(options);
+        return new DuckDBInstance(await node_bindings_1.default.open(path, config));
+    }
+    static async fromCache(path, options) {
+        return DuckDBInstanceCache_1.DuckDBInstanceCache.singleton.getOrCreateInstance(path, options);
+    }
+    async connect() {
+        return new DuckDBConnection_1.DuckDBConnection(await node_bindings_1.default.connect(this.db));
+    }
+    closeSync() {
+        node_bindings_1.default.close_sync(this.db);
+    }
+}
+exports.DuckDBInstance = DuckDBInstance;

package/lib/DuckDBInstanceCache.d.ts

@@ -0,0 +1,8 @@
+import { DuckDBInstance } from './DuckDBInstance';
+export declare class DuckDBInstanceCache {
+    private readonly cache;
+    constructor();
+    getOrCreateInstance(path?: string, options?: Record<string, string>): Promise<DuckDBInstance>;
+    private static singletonInstance;
+    static get singleton(): DuckDBInstanceCache;
+}

package/lib/DuckDBInstanceCache.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBInstanceCache = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBInstance_1 = require("./DuckDBInstance");
+const createConfig_1 = require("./createConfig");
+class DuckDBInstanceCache {
+    cache;
+    constructor() {
+        this.cache = node_bindings_1.default.create_instance_cache();
+    }
+    async getOrCreateInstance(path, options) {
+        const config = (0, createConfig_1.createConfig)(options);
+        const db = await node_bindings_1.default.get_or_create_from_cache(this.cache, path, config);
+        return new DuckDBInstance_1.DuckDBInstance(db);
+    }
+    static singletonInstance;
+    static get singleton() {
+        if (!DuckDBInstanceCache.singletonInstance) {
+            DuckDBInstanceCache.singletonInstance = new DuckDBInstanceCache();
+        }
+        return DuckDBInstanceCache.singletonInstance;
+    }
+}
+exports.DuckDBInstanceCache = DuckDBInstanceCache;

package/lib/DuckDBLogicalType.d.ts

@@ -0,0 +1,66 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBArrayType, DuckDBDecimalType, DuckDBEnumType, DuckDBListType, DuckDBMapType, DuckDBStructType, DuckDBType, DuckDBUnionType } from './DuckDBType';
+import { DuckDBTypeId } from './DuckDBTypeId';
+export declare class DuckDBLogicalType {
+    readonly logical_type: duckdb.LogicalType;
+    protected constructor(logical_type: duckdb.LogicalType);
+    static create(logical_type: duckdb.LogicalType): DuckDBLogicalType;
+    static createDecimal(width: number, scale: number): DuckDBDecimalLogicalType;
+    static createEnum(member_names: readonly string[]): DuckDBEnumLogicalType;
+    static createList(valueType: DuckDBLogicalType): DuckDBListLogicalType;
+    static createStruct(entryNames: readonly string[], entryLogicalTypes: readonly DuckDBLogicalType[]): DuckDBStructLogicalType;
+    static createMap(keyType: DuckDBLogicalType, valueType: DuckDBLogicalType): DuckDBMapLogicalType;
+    static createArray(valueType: DuckDBLogicalType, length: number): DuckDBArrayLogicalType;
+    static createUnion(memberTags: readonly string[], memberLogicalTypes: readonly DuckDBLogicalType[]): DuckDBUnionLogicalType;
+    get typeId(): DuckDBTypeId;
+    get alias(): string | undefined;
+    set alias(newAlias: string | null | undefined);
+    asType(): DuckDBType;
+}
+export declare class DuckDBDecimalLogicalType extends DuckDBLogicalType {
+    get width(): number;
+    get scale(): number;
+    get internalTypeId(): DuckDBTypeId;
+    asType(): DuckDBDecimalType;
+}
+export declare class DuckDBEnumLogicalType extends DuckDBLogicalType {
+    get valueCount(): number;
+    value(index: number): string;
+    values(): readonly string[];
+    get internalTypeId(): DuckDBTypeId;
+    asType(): DuckDBEnumType;
+}
+export declare class DuckDBListLogicalType extends DuckDBLogicalType {
+    get valueType(): DuckDBLogicalType;
+    asType(): DuckDBListType;
+}
+export declare class DuckDBStructLogicalType extends DuckDBLogicalType {
+    get entryCount(): number;
+    entryName(index: number): string;
+    entryLogicalType(index: number): DuckDBLogicalType;
+    entryType(index: number): DuckDBType;
+    entryNames(): string[];
+    entryLogicalTypes(): DuckDBLogicalType[];
+    entryTypes(): DuckDBType[];
+    asType(): DuckDBStructType;
+}
+export declare class DuckDBMapLogicalType extends DuckDBLogicalType {
+    get keyType(): DuckDBLogicalType;
+    get valueType(): DuckDBLogicalType;
+    asType(): DuckDBMapType;
+}
+export declare class DuckDBArrayLogicalType extends DuckDBLogicalType {
+    get valueType(): DuckDBLogicalType;
+    get length(): number;
+    asType(): DuckDBArrayType;
+}
+export declare class DuckDBUnionLogicalType extends DuckDBLogicalType {
+    get memberCount(): number;
+    memberTag(index: number): string;
+    memberLogicalType(index: number): DuckDBLogicalType;
+    memberType(index: number): DuckDBType;
+    memberTags(): string[];
+    memberLogicalTypes(): DuckDBLogicalType[];
+    memberTypes(): DuckDBType[];
+    asType(): DuckDBUnionType;
+}