@duckdb/node-api 1.2.1-alpha.16 → 1.2.2-alpha.18

package/lib/DuckDBResult.d.ts

@@ -3,7 +3,9 @@ import { DuckDBDataChunk } from './DuckDBDataChunk';
 import { DuckDBLogicalType } from './DuckDBLogicalType';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
-import { Json } from './DuckDBValueToJsonConverter';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { JS } from './JS';
+import { Json } from './Json';
 import { ResultReturnType, StatementType } from './enums';
 import { DuckDBValue } from './values';
 export declare class DuckDBResult {
@@ -18,17 +20,29 @@ export declare class DuckDBResult {
     columnTypeId(columnIndex: number): DuckDBTypeId;
     columnLogicalType(columnIndex: number): DuckDBLogicalType;
     columnType(columnIndex: number): DuckDBType;
+    columnTypeJson(columnIndex: number): Json;
     columnTypes(): DuckDBType[];
+    columnTypesJson(): Json;
+    columnNamesAndTypesJson(): Json;
+    columnNameAndTypeObjectsJson(): Json;
     get isStreaming(): boolean;
     get rowsChanged(): number;
     fetchChunk(): Promise<DuckDBDataChunk | null>;
     fetchAllChunks(): Promise<DuckDBDataChunk[]>;
     getColumns(): Promise<DuckDBValue[][]>;
+    convertColumns<T>(converter: DuckDBValueConverter<T>): Promise<(T | null)[][]>;
+    getColumnsJS(): Promise<JS[][]>;
     getColumnsJson(): Promise<Json[][]>;
     getColumnsObject(): Promise<Record<string, DuckDBValue[]>>;
+    convertColumnsObject<T>(converter: DuckDBValueConverter<T>): Promise<Record<string, (T | null)[]>>;
+    getColumnsObjectJS(): Promise<Record<string, JS[]>>;
     getColumnsObjectJson(): Promise<Record<string, Json[]>>;
     getRows(): Promise<DuckDBValue[][]>;
+    convertRows<T>(converter: DuckDBValueConverter<T>): Promise<(T | null)[][]>;
+    getRowsJS(): Promise<JS[][]>;
     getRowsJson(): Promise<Json[][]>;
     getRowObjects(): Promise<Record<string, DuckDBValue>[]>;
+    convertRowObjects<T>(converter: DuckDBValueConverter<T>): Promise<Record<string, T | null>[]>;
+    getRowObjectsJS(): Promise<Record<string, JS>[]>;
     getRowObjectsJson(): Promise<Record<string, Json>[]>;
 }

package/lib/DuckDBResult.js

@@ -7,7 +7,8 @@ exports.DuckDBResult = void 0;
 const node_bindings_1 = __importDefault(require("@duckdb/node-bindings"));
 const DuckDBDataChunk_1 = require("./DuckDBDataChunk");
 const DuckDBLogicalType_1 = require("./DuckDBLogicalType");
-const DuckDBValueToJsonConverter_1 = require("./DuckDBValueToJsonConverter");
+const JSDuckDBValueConverter_1 = require("./JSDuckDBValueConverter");
+const JsonDuckDBValueConverter_1 = require("./JsonDuckDBValueConverter");
 const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
 const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
 const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
@@ -67,6 +68,9 @@ class DuckDBResult {
     columnType(columnIndex) {
         return DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.column_logical_type(this.result, columnIndex)).asType();
     }
+    columnTypeJson(columnIndex) {
+        return this.columnType(columnIndex).toJson();
+    }
     columnTypes() {
         const columnTypes = [];
         const columnCount = this.columnCount;
@@ -75,6 +79,31 @@ class DuckDBResult {
         }
         return columnTypes;
     }
+    columnTypesJson() {
+        const columnTypesJson = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnTypesJson.push(this.columnTypeJson(columnIndex));
+        }
+        return columnTypesJson;
+    }
+    columnNamesAndTypesJson() {
+        return {
+            columnNames: this.columnNames(),
+            columnTypes: this.columnTypesJson(),
+        };
+    }
+    columnNameAndTypeObjectsJson() {
+        const columnNameAndTypeObjects = [];
+        const columnCount = this.columnCount;
+        for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+            columnNameAndTypeObjects.push({
+                columnName: this.columnName(columnIndex),
+                columnType: this.columnTypeJson(columnIndex),
+            });
+        }
+        return columnNameAndTypeObjects;
+    }
     get isStreaming() {
         return node_bindings_1.default.result_is_streaming(this.result);
     }
@@ -99,33 +128,57 @@ class DuckDBResult {
         const chunks = await this.fetchAllChunks();
         return (0, getColumnsFromChunks_1.getColumnsFromChunks)(chunks);
     }
-    async getColumnsJson() {
+    async convertColumns(converter) {
         const chunks = await this.fetchAllChunks();
-        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        return (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(chunks, converter);
+    }
+    async getColumnsJS() {
+        return this.convertColumns(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getColumnsJson() {
+        return this.convertColumns(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
     async getColumnsObject() {
         const chunks = await this.fetchAllChunks();
         return (0, getColumnsObjectFromChunks_1.getColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames());
     }
-    async getColumnsObjectJson() {
+    async convertColumnsObject(converter) {
         const chunks = await this.fetchAllChunks();
-        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        return (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(chunks, this.deduplicatedColumnNames(), converter);
+    }
+    async getColumnsObjectJS() {
+        return this.convertColumnsObject(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getColumnsObjectJson() {
+        return this.convertColumnsObject(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
     async getRows() {
         const chunks = await this.fetchAllChunks();
         return (0, getRowsFromChunks_1.getRowsFromChunks)(chunks);
     }
-    async getRowsJson() {
+    async convertRows(converter) {
         const chunks = await this.fetchAllChunks();
-        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        return (0, convertRowsFromChunks_1.convertRowsFromChunks)(chunks, converter);
+    }
+    async getRowsJS() {
+        return this.convertRows(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getRowsJson() {
+        return this.convertRows(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
     async getRowObjects() {
         const chunks = await this.fetchAllChunks();
         return (0, getRowObjectsFromChunks_1.getRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames());
     }
-    async getRowObjectsJson() {
+    async convertRowObjects(converter) {
         const chunks = await this.fetchAllChunks();
-        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        return (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(chunks, this.deduplicatedColumnNames(), converter);
+    }
+    async getRowObjectsJS() {
+        return this.convertRowObjects(JSDuckDBValueConverter_1.JSDuckDBValueConverter);
+    }
+    async getRowObjectsJson() {
+        return this.convertRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
 }
 exports.DuckDBResult = DuckDBResult;

package/lib/DuckDBResultReader.d.ts

@@ -2,8 +2,10 @@ import { DuckDBLogicalType } from './DuckDBLogicalType';
 import { DuckDBResult } from './DuckDBResult';
 import { DuckDBType } from './DuckDBType';
 import { DuckDBTypeId } from './DuckDBTypeId';
-import { Json } from './DuckDBValueToJsonConverter';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
 import { ResultReturnType, StatementType } from './enums';
+import { JS } from './JS';
+import { Json } from './Json';
 import { DuckDBValue } from './values';
 export declare class DuckDBResultReader {
     private readonly result;
@@ -21,7 +23,11 @@ export declare class DuckDBResultReader {
     columnTypeId(columnIndex: number): DuckDBTypeId;
     columnLogicalType(columnIndex: number): DuckDBLogicalType;
     columnType(columnIndex: number): DuckDBType;
+    columnTypeJson(columnIndex: number): Json;
     columnTypes(): DuckDBType[];
+    columnTypesJson(): Json;
+    columnNamesAndTypesJson(): Json;
+    columnNameAndTypeObjectsJson(): Json;
     get rowsChanged(): number;
     /** Total number of rows read so far. Call `readAll` or `readUntil` to read rows. */
     get currentRowCount(): number;
@@ -44,11 +50,19 @@ export declare class DuckDBResultReader {
     private fetchChunks;
     private updateChunkSizeRuns;
     getColumns(): DuckDBValue[][];
+    convertColumns<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    getColumnsJS(): JS[][];
     getColumnsJson(): Json[][];
     getColumnsObject(): Record<string, DuckDBValue[]>;
+    convertColumnsObject<T>(converter: DuckDBValueConverter<T>): Record<string, (T | null)[]>;
+    getColumnsObjectJS(): Record<string, JS[]>;
     getColumnsObjectJson(): Record<string, Json[]>;
     getRows(): DuckDBValue[][];
+    convertRows<T>(converter: DuckDBValueConverter<T>): (T | null)[][];
+    getRowsJS(): JS[][];
     getRowsJson(): Json[][];
     getRowObjects(): Record<string, DuckDBValue>[];
+    convertRowObjects<T>(converter: DuckDBValueConverter<T>): Record<string, T | null>[];
+    getRowObjectsJS(): Record<string, JS>[];
     getRowObjectsJson(): Record<string, Json>[];
 }

package/lib/DuckDBResultReader.js

@@ -5,11 +5,12 @@ const convertColumnsFromChunks_1 = require("./convertColumnsFromChunks");
 const convertColumnsObjectFromChunks_1 = require("./convertColumnsObjectFromChunks");
 const convertRowObjectsFromChunks_1 = require("./convertRowObjectsFromChunks");
 const convertRowsFromChunks_1 = require("./convertRowsFromChunks");
-const DuckDBValueToJsonConverter_1 = require("./DuckDBValueToJsonConverter");
 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;
@@ -50,9 +51,21 @@ class DuckDBResultReader {
     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;
     }
@@ -141,26 +154,50 @@ class DuckDBResultReader {
     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 (0, convertColumnsFromChunks_1.convertColumnsFromChunks)(this.chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        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 (0, convertColumnsObjectFromChunks_1.convertColumnsObjectFromChunks)(this.chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        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 (0, convertRowsFromChunks_1.convertRowsFromChunks)(this.chunks, DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        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 (0, convertRowObjectsFromChunks_1.convertRowObjectsFromChunks)(this.chunks, this.deduplicatedColumnNames(), DuckDBValueToJsonConverter_1.DuckDBValueToJsonConverter.default);
+        return this.convertRowObjects(JsonDuckDBValueConverter_1.JsonDuckDBValueConverter);
     }
 }
 exports.DuckDBResultReader = DuckDBResultReader;

package/lib/DuckDBType.d.ts

@@ -1,5 +1,6 @@
 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;
@@ -7,6 +8,7 @@ export declare abstract class BaseDuckDBType<T extends DuckDBTypeId> {
     protected constructor(typeId: T, alias?: string);
     toString(): string;
     toLogicalType(): DuckDBLogicalType;
+    toJson(): Json;
 }
 export declare class DuckDBBooleanType extends BaseDuckDBType<DuckDBTypeId.BOOLEAN> {
     constructor(alias?: string);
@@ -190,6 +192,7 @@ export declare class DuckDBDecimalType extends BaseDuckDBType<DuckDBTypeId.DECIM
     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;
@@ -234,6 +237,7 @@ export declare class DuckDBEnumType extends BaseDuckDBType<DuckDBTypeId.ENUM> {
     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;
@@ -244,6 +248,7 @@ export declare class DuckDBListType extends BaseDuckDBType<DuckDBTypeId.LIST> {
     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> {
@@ -256,6 +261,7 @@ export declare class DuckDBStructType extends BaseDuckDBType<DuckDBTypeId.STRUCT
     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> {
@@ -264,6 +270,7 @@ export declare class DuckDBMapType extends BaseDuckDBType<DuckDBTypeId.MAP> {
     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> {
@@ -272,6 +279,7 @@ export declare class DuckDBArrayType extends BaseDuckDBType<DuckDBTypeId.ARRAY>
     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> {
@@ -292,6 +300,7 @@ export declare class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION>
     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> {

package/lib/DuckDBType.js

@@ -37,6 +37,12 @@ class BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.BaseDuckDBType = BaseDuckDBType;
 class DuckDBBooleanType extends BaseDuckDBType {
@@ -403,6 +409,14 @@ class DuckDBDecimalType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            width: this.width,
+            scale: this.scale,
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
     static default = new DuckDBDecimalType(18, 3);
 }
 exports.DuckDBDecimalType = DuckDBDecimalType;
@@ -526,6 +540,14 @@ class DuckDBEnumType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            values: [...this.values],
+            internalTypeId: this.internalTypeId,
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBEnumType = DuckDBEnumType;
 function ENUM8(values, alias) {
@@ -567,6 +589,13 @@ class DuckDBListType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            valueType: this.valueType.toJson(),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBListType = DuckDBListType;
 function LIST(valueType, alias) {
@@ -613,6 +642,14 @@ class DuckDBStructType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            entryNames: [...this.entryNames],
+            entryTypes: this.entryTypes.map(t => t.toJson()),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBStructType = DuckDBStructType;
 function STRUCT(entries, alias) {
@@ -638,6 +675,14 @@ class DuckDBMapType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            keyType: this.keyType.toJson(),
+            valueType: this.valueType.toJson(),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBMapType = DuckDBMapType;
 function MAP(keyType, valueType, alias) {
@@ -661,6 +706,14 @@ class DuckDBArrayType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            valueType: this.valueType.toJson(),
+            length: this.length,
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBArrayType = DuckDBArrayType;
 function ARRAY(valueType, length, alias) {
@@ -724,6 +777,14 @@ class DuckDBUnionType extends BaseDuckDBType {
         }
         return logicalType;
     }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            memberTags: [...this.memberTags],
+            memberTypes: this.memberTypes.map(t => t.toJson()),
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
 }
 exports.DuckDBUnionType = DuckDBUnionType;
 function UNION(members, alias) {

package/lib/DuckDBValueConverter.d.ts

@@ -1,5 +1,3 @@
 import { DuckDBType } from './DuckDBType';
 import { DuckDBValue } from './values';
-export interface DuckDBValueConverter<T> {
-    convertValue(value: DuckDBValue, type: DuckDBType): T;
-}
+export type DuckDBValueConverter<T> = (value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>) => T | null;

package/lib/DuckDBValueConverters.d.ts

@@ -0,0 +1,47 @@
+import { DuckDBType } from './DuckDBType';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+import { DuckDBValue } from './values';
+export declare function unsupportedConverter(_: DuckDBValue, type: DuckDBType): null;
+export declare function nullConverter(_: DuckDBValue): null;
+export declare function booleanFromValue(value: DuckDBValue): boolean;
+export declare function numberFromValue(value: DuckDBValue): number;
+export declare function jsonNumberFromValue(value: DuckDBValue): number | string;
+export declare function bigintFromBigIntValue(value: DuckDBValue, type: DuckDBType): bigint;
+export declare function stringFromValue(value: DuckDBValue): string;
+export declare function bytesFromBlobValue(value: DuckDBValue): Uint8Array;
+export declare function bytesFromBitValue(value: DuckDBValue): Uint8Array;
+export declare function dateFromDateValue(value: DuckDBValue): Date;
+export declare function bigintFromTimeValue(value: DuckDBValue): bigint;
+export declare function dateFromTimestampValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampSecondsValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampMillisecondsValue(value: DuckDBValue): Date;
+export declare function dateFromTimestampNanosecondsValue(value: DuckDBValue): Date;
+export declare function objectFromTimeTZValue(value: DuckDBValue): {
+    micros: bigint;
+    offset: number;
+};
+export declare function dateFromTimestampTZValue(value: DuckDBValue): Date;
+export declare function objectFromIntervalValue(value: DuckDBValue): {
+    months: number;
+    days: number;
+    micros: bigint;
+};
+export declare function jsonObjectFromIntervalValue(value: DuckDBValue): {
+    months: number;
+    days: number;
+    micros: string;
+};
+export declare function doubleFromDecimalValue(value: DuckDBValue): number;
+export declare function arrayFromListValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): (T | null)[];
+export declare function objectFromStructValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    [key: string]: T | null;
+};
+export declare function objectArrayFromMapValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    key: T | null;
+    value: T | null;
+}[];
+export declare function arrayFromArrayValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): (T | null)[];
+export declare function objectFromUnionValue<T>(value: DuckDBValue, type: DuckDBType, converter: DuckDBValueConverter<T>): {
+    tag: string;
+    value: T | null;
+};