@haybarn/node-api 1.5.3-rc2

package/lib/convertRowObjectsFromChunks.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowObjectsFromChunks = convertRowObjectsFromChunks;
+function convertRowObjectsFromChunks(chunks, columnNames, converter) {
+    const rowObjects = [];
+    for (const chunk of chunks) {
+        const rowCount = chunk.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            const rowObject = {};
+            chunk.visitRowValues(rowIndex, (value, _rowIndex, columnIndex, type) => {
+                rowObject[columnNames[columnIndex]] = converter(value, type, converter);
+            });
+            rowObjects.push(rowObject);
+        }
+    }
+    return rowObjects;
+}

package/lib/convertRowsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function convertRowsFromChunks<T>(chunks: readonly DuckDBDataChunk[], converter: DuckDBValueConverter<T>): (T | null)[][];

package/lib/convertRowsFromChunks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowsFromChunks = convertRowsFromChunks;
+function convertRowsFromChunks(chunks, converter) {
+    const rows = [];
+    for (const chunk of chunks) {
+        const rowCount = chunk.rowCount;
+        for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+            rows.push(chunk.convertRowValues(rowIndex, converter));
+        }
+    }
+    return rows;
+}

package/lib/createConfig.d.ts

@@ -0,0 +1,2 @@
+import duckdb from '@haybarn/node-bindings';
+export declare function createConfig(options?: Record<string, string>): duckdb.Config;

package/lib/createConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = createConfig;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+function createConfig(options) {
+    const config = node_bindings_1.default.create_config();
+    // Set the default duckdb_api value for the api. Can be overridden.
+    node_bindings_1.default.set_config(config, 'duckdb_api', 'node-neo-api');
+    if (options) {
+        for (const optionName in options) {
+            const optionValue = String(options[optionName]);
+            node_bindings_1.default.set_config(config, optionName, optionValue);
+        }
+    }
+    return config;
+}

package/lib/createDuckDBValueConverter.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+export declare function createDuckDBValueConverter<T>(convertersByTypeId: Record<DuckDBTypeId, DuckDBValueConverter<T> | undefined>): DuckDBValueConverter<T>;

package/lib/createDuckDBValueConverter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDuckDBValueConverter = createDuckDBValueConverter;
+function createDuckDBValueConverter(convertersByTypeId) {
+    return (value, type, converter) => {
+        if (value == null) {
+            return null;
+        }
+        const converterForTypeId = convertersByTypeId[type.typeId];
+        if (!converterForTypeId) {
+            throw new Error(`No converter for typeId: ${type.typeId}`);
+        }
+        return converterForTypeId(value, type, converter);
+    };
+}

package/lib/createResult.d.ts

@@ -0,0 +1,3 @@
+import duckdb from '@haybarn/node-bindings';
+import { DuckDBResult } from './DuckDBResult';
+export declare function createResult(result: duckdb.Result): DuckDBResult;

package/lib/createResult.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResult = createResult;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBMaterializedResult_1 = require("./DuckDBMaterializedResult");
+const DuckDBResult_1 = require("./DuckDBResult");
+function createResult(result) {
+    if (node_bindings_1.default.result_is_streaming(result)) {
+        return new DuckDBResult_1.DuckDBResult(result);
+    }
+    else {
+        return new DuckDBMaterializedResult_1.DuckDBMaterializedResult(result);
+    }
+}

package/lib/createValue.d.ts

@@ -0,0 +1,4 @@
+import { Value } from '@haybarn/node-bindings';
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare function createValue(type: DuckDBType, input: DuckDBValue): Value;

package/lib/createValue.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValue = createValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBTypeId_1 = require("./DuckDBTypeId");
+const values_1 = require("./values");
+function createValue(type, input) {
+    if (input === null) {
+        return node_bindings_1.default.create_null_value();
+    }
+    const { typeId } = type;
+    switch (typeId) {
+        case DuckDBTypeId_1.DuckDBTypeId.BOOLEAN:
+            if (typeof input === 'boolean') {
+                return node_bindings_1.default.create_bool(input);
+            }
+            throw new Error(`input is not a boolean`);
+        case DuckDBTypeId_1.DuckDBTypeId.TINYINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int8(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.SMALLINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int16(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTEGER:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_int32(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.BIGINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_int64(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.UTINYINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint8(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.USMALLINT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint16(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.UINTEGER:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_uint32(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.UBIGINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_uint64(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.FLOAT:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_float(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.DOUBLE:
+            if (typeof input === 'number') {
+                return node_bindings_1.default.create_double(input);
+            }
+            throw new Error(`input is not a number`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP:
+            if (input instanceof values_1.DuckDBTimestampValue) {
+                return node_bindings_1.default.create_timestamp(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.DATE:
+            if (input instanceof values_1.DuckDBDateValue) {
+                return node_bindings_1.default.create_date(input);
+            }
+            throw new Error(`input is not a DuckDBDateValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME:
+            if (input instanceof values_1.DuckDBTimeValue) {
+                return node_bindings_1.default.create_time(input);
+            }
+            throw new Error(`input is not a DuckDBTimeValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTERVAL:
+            if (input instanceof values_1.DuckDBIntervalValue) {
+                return node_bindings_1.default.create_interval(input);
+            }
+            throw new Error(`input is not a DuckDBIntervalValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.HUGEINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_hugeint(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.UHUGEINT:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_uhugeint(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.VARCHAR:
+            if (typeof input === 'string') {
+                return node_bindings_1.default.create_varchar(input);
+            }
+            throw new Error(`input is not a string`);
+        case DuckDBTypeId_1.DuckDBTypeId.BLOB:
+            if (input instanceof values_1.DuckDBBlobValue) {
+                return node_bindings_1.default.create_blob(input.bytes);
+            }
+            throw new Error(`input is not a DuckDBBlobValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.DECIMAL:
+            if (input instanceof values_1.DuckDBDecimalValue) {
+                return node_bindings_1.default.create_decimal(input);
+            }
+            throw new Error(`input is not a DuckDBDecimalValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_S:
+            if (input instanceof values_1.DuckDBTimestampSecondsValue) {
+                return node_bindings_1.default.create_timestamp_s(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampSecondsValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_MS:
+            if (input instanceof values_1.DuckDBTimestampMillisecondsValue) {
+                return node_bindings_1.default.create_timestamp_ms(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampMillisecondsValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_NS:
+            if (input instanceof values_1.DuckDBTimestampNanosecondsValue) {
+                return node_bindings_1.default.create_timestamp_ns(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampNanosecondsValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.ENUM:
+            if (typeof input === 'string') {
+                return node_bindings_1.default.create_enum_value(type.toLogicalType().logical_type, type.indexForValue(input));
+            }
+            throw new Error(`input is not a string`);
+        case DuckDBTypeId_1.DuckDBTypeId.LIST:
+            if (input instanceof values_1.DuckDBListValue) {
+                if (type.valueType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create lists with item type of ANY. Specify a specific type.');
+                }
+                return node_bindings_1.default.create_list_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
+            }
+            throw new Error(`input is not a DuckDBListValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.STRUCT:
+            if (input instanceof values_1.DuckDBStructValue) {
+                if (type.entryTypes.find((entryType) => entryType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY)) {
+                    throw new Error('Cannot create structs with an entry type of ANY. Specify a specific type.');
+                }
+                return node_bindings_1.default.create_struct_value(type.toLogicalType().logical_type, Object.values(input.entries).map((value, i) => createValue(type.entryTypes[i], value)));
+            }
+            throw new Error(`input is not a DuckDBStructValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.MAP:
+            if (input instanceof values_1.DuckDBMapValue) {
+                if (type.keyType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create maps with key type of ANY. Specify a specific type.');
+                }
+                if (type.valueType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create maps with value type of ANY. Specify a specific type.');
+                }
+                return node_bindings_1.default.create_map_value(type.toLogicalType().logical_type, input.entries.map((entry) => createValue(type.keyType, entry.key)), input.entries.map((entry) => createValue(type.valueType, entry.value)));
+            }
+            throw new Error(`input is not a DuckDBMapValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.ARRAY:
+            if (input instanceof values_1.DuckDBArrayValue) {
+                if (type.valueType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create arrays with item type of ANY. Specify a specific type.');
+                }
+                return node_bindings_1.default.create_array_value(type.valueType.toLogicalType().logical_type, input.items.map((item) => createValue(type.valueType, item)));
+            }
+            throw new Error(`input is not a DuckDBArrayValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.UUID:
+            if (input instanceof values_1.DuckDBUUIDValue) {
+                return node_bindings_1.default.create_uuid(input.toUint128());
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.UNION:
+            if (input instanceof values_1.DuckDBUnionValue) {
+                const tagIndex = type.memberIndexForTag(input.tag);
+                const memberType = type.memberTypes[tagIndex];
+                if (memberType.typeId === DuckDBTypeId_1.DuckDBTypeId.ANY) {
+                    throw new Error('Cannot create union values with type of ANY.');
+                }
+                return node_bindings_1.default.create_union_value(type.toLogicalType().logical_type, tagIndex, createValue(memberType, input.value));
+            }
+            throw new Error(`input is not a DuckDBUnionValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.BIT:
+            if (input instanceof values_1.DuckDBBitValue) {
+                return node_bindings_1.default.create_bit(input.data);
+            }
+            throw new Error(`input is not a DuckDBBitValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME_TZ:
+            if (input instanceof values_1.DuckDBTimeTZValue) {
+                return node_bindings_1.default.create_time_tz_value(input);
+            }
+            throw new Error(`input is not a DuckDBTimeTZValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIMESTAMP_TZ:
+            if (input instanceof values_1.DuckDBTimestampTZValue) {
+                return node_bindings_1.default.create_timestamp_tz(input);
+            }
+            throw new Error(`input is not a DuckDBTimestampTZValue`);
+        case DuckDBTypeId_1.DuckDBTypeId.ANY:
+            throw new Error(`Cannot create values of type ANY. Specify a specific type.`);
+        case DuckDBTypeId_1.DuckDBTypeId.BIGNUM:
+            if (typeof input === 'bigint') {
+                return node_bindings_1.default.create_bignum(input);
+            }
+            throw new Error(`input is not a bigint`);
+        case DuckDBTypeId_1.DuckDBTypeId.SQLNULL:
+            return node_bindings_1.default.create_null_value();
+        case DuckDBTypeId_1.DuckDBTypeId.STRING_LITERAL:
+            throw new Error(`Cannot create values of type STRING_LITERAL.`);
+        case DuckDBTypeId_1.DuckDBTypeId.INTEGER_LITERAL:
+            throw new Error(`Cannot create values of type INTEGER_LITERAL.`);
+        case DuckDBTypeId_1.DuckDBTypeId.TIME_NS:
+            if (input instanceof values_1.DuckDBTimeNSValue) {
+                return node_bindings_1.default.create_time_ns(input);
+            }
+            throw new Error(`input is not a DuckDBTimeNSValue`);
+        default:
+            throw new Error(`unrecognized type id ${typeId}`);
+    }
+}

package/lib/duckdb.d.ts

@@ -0,0 +1,33 @@
+export { double_to_hugeint, double_to_uhugeint, hugeint_to_double, uhugeint_to_double } from '@haybarn/node-bindings';
+export * from './configurationOptionDescriptions';
+export * from './createDuckDBValueConverter';
+export * from './DuckDBAppender';
+export * from './DuckDBBindInfo';
+export * from './DuckDBClientContext';
+export * from './DuckDBConnection';
+export * from './DuckDBDataChunk';
+export * from './DuckDBExtractedStatements';
+export * from './DuckDBFunctionInfo';
+export * from './DuckDBInstance';
+export * from './DuckDBInstanceCache';
+export * from './DuckDBLogicalType';
+export * from './DuckDBMaterializedResult';
+export * from './DuckDBPendingResult';
+export * from './DuckDBPreparedStatement';
+export * from './DuckDBPreparedStatementCollection';
+export * from './DuckDBResult';
+export * from './DuckDBResultReader';
+export * from './DuckDBScalarFunction';
+export * from './DuckDBType';
+export * from './DuckDBTypeId';
+export * from './DuckDBValueConverter';
+export * from './DuckDBValueConverters';
+export * from './DuckDBVector';
+export * from './enums';
+export * from './JS';
+export * from './JSDuckDBValueConverter';
+export * from './Json';
+export * from './JsonDuckDBValueConverter';
+export * from './sql';
+export * from './values';
+export * from './version';

package/lib/duckdb.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uhugeint_to_double = exports.hugeint_to_double = exports.double_to_uhugeint = exports.double_to_hugeint = void 0;
+var node_bindings_1 = require("@haybarn/node-bindings");
+Object.defineProperty(exports, "double_to_hugeint", { enumerable: true, get: function () { return node_bindings_1.double_to_hugeint; } });
+Object.defineProperty(exports, "double_to_uhugeint", { enumerable: true, get: function () { return node_bindings_1.double_to_uhugeint; } });
+Object.defineProperty(exports, "hugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.hugeint_to_double; } });
+Object.defineProperty(exports, "uhugeint_to_double", { enumerable: true, get: function () { return node_bindings_1.uhugeint_to_double; } });
+__exportStar(require("./configurationOptionDescriptions"), exports);
+__exportStar(require("./createDuckDBValueConverter"), exports);
+__exportStar(require("./DuckDBAppender"), exports);
+__exportStar(require("./DuckDBBindInfo"), exports);
+__exportStar(require("./DuckDBClientContext"), exports);
+__exportStar(require("./DuckDBConnection"), exports);
+__exportStar(require("./DuckDBDataChunk"), exports);
+__exportStar(require("./DuckDBExtractedStatements"), exports);
+__exportStar(require("./DuckDBFunctionInfo"), exports);
+__exportStar(require("./DuckDBInstance"), exports);
+__exportStar(require("./DuckDBInstanceCache"), exports);
+__exportStar(require("./DuckDBLogicalType"), exports);
+__exportStar(require("./DuckDBMaterializedResult"), exports);
+__exportStar(require("./DuckDBPendingResult"), exports);
+__exportStar(require("./DuckDBPreparedStatement"), exports);
+__exportStar(require("./DuckDBPreparedStatementCollection"), exports);
+__exportStar(require("./DuckDBResult"), exports);
+__exportStar(require("./DuckDBResultReader"), exports);
+__exportStar(require("./DuckDBScalarFunction"), exports);
+__exportStar(require("./DuckDBType"), exports);
+__exportStar(require("./DuckDBTypeId"), exports);
+__exportStar(require("./DuckDBValueConverter"), exports);
+__exportStar(require("./DuckDBValueConverters"), exports);
+__exportStar(require("./DuckDBVector"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./JS"), exports);
+__exportStar(require("./JSDuckDBValueConverter"), exports);
+__exportStar(require("./Json"), exports);
+__exportStar(require("./JsonDuckDBValueConverter"), exports);
+__exportStar(require("./sql"), exports);
+__exportStar(require("./values"), exports);
+__exportStar(require("./version"), exports);

package/lib/enums.d.ts

@@ -0,0 +1,5 @@
+import duckdb from '@haybarn/node-bindings';
+export type ResultReturnType = duckdb.ResultType;
+export declare const ResultReturnType: typeof duckdb.ResultType;
+export type StatementType = duckdb.StatementType;
+export declare const StatementType: typeof duckdb.StatementType;

package/lib/enums.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatementType = exports.ResultReturnType = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+exports.ResultReturnType = node_bindings_1.default.ResultType;
+exports.StatementType = node_bindings_1.default.StatementType;

package/lib/getColumnsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getColumnsFromChunks(chunks: readonly DuckDBDataChunk[]): DuckDBValue[][];

package/lib/getColumnsFromChunks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnsFromChunks = getColumnsFromChunks;
+function getColumnsFromChunks(chunks) {
+    const columns = [];
+    for (const chunk of chunks) {
+        chunk.appendToColumns(columns);
+    }
+    return columns;
+}

package/lib/getColumnsObjectFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getColumnsObjectFromChunks(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[]): Record<string, DuckDBValue[]>;

package/lib/getColumnsObjectFromChunks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnsObjectFromChunks = getColumnsObjectFromChunks;
+function getColumnsObjectFromChunks(chunks, columnNames) {
+    const columnsObject = {};
+    for (const chunk of chunks) {
+        chunk.appendToColumnsObject(columnNames, columnsObject);
+    }
+    return columnsObject;
+}

package/lib/getRowObjectsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getRowObjectsFromChunks(chunks: readonly DuckDBDataChunk[], columnNames: readonly string[]): Record<string, DuckDBValue>[];

package/lib/getRowObjectsFromChunks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRowObjectsFromChunks = getRowObjectsFromChunks;
+function getRowObjectsFromChunks(chunks, columnNames) {
+    const rowObjects = [];
+    for (const chunk of chunks) {
+        chunk.appendToRowObjects(columnNames, rowObjects);
+    }
+    return rowObjects;
+}

package/lib/getRowsFromChunks.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValue } from './values';
+export declare function getRowsFromChunks(chunks: readonly DuckDBDataChunk[]): DuckDBValue[][];

package/lib/getRowsFromChunks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRowsFromChunks = getRowsFromChunks;
+function getRowsFromChunks(chunks) {
+    const rows = [];
+    for (const chunk of chunks) {
+        chunk.appendToRows(rows);
+    }
+    return rows;
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import * as duckdb from './duckdb';
+export default duckdb;
+export * from './duckdb';

package/lib/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const duckdb = __importStar(require("./duckdb"));
+exports.default = duckdb;
+__exportStar(require("./duckdb"), exports);

package/lib/sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/sleep.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = sleep;
+async function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/lib/sql.d.ts

@@ -0,0 +1,2 @@
+export declare function quotedString(input: string): string;
+export declare function quotedIdentifier(input: string): string;

package/lib/sql.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quotedString = quotedString;
+exports.quotedIdentifier = quotedIdentifier;
+function quotedString(input) {
+    return `'${input.replaceAll(`'`, `''`)}'`;
+}
+function quotedIdentifier(input) {
+    return `"${input.replaceAll(`"`, `""`)}"`;
+}

package/lib/typeForValue.d.ts

@@ -0,0 +1,3 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValue } from './values';
+export declare function typeForValue(value: DuckDBValue): DuckDBType;