@haybarn/node-api 1.5.5-rc1 → 2.0.0-rc3

package/lib/readValue.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readValue = readValue;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBVector_1 = require("./DuckDBVector");
+/**
+ * Converts a `duckdb.Value` into a `DuckDBValue`.
+ *
+ * Results normally arrive as vectors rather than values, so this is for the
+ * places that hand back a value instead: table function parameters, and
+ * `duckdb_get_table_names`.
+ *
+ * It works by referencing the value into a vector of its own and reading the one
+ * element back, which reuses the vector reading path rather than duplicating it.
+ * That matters for more than tidiness: the value accessors cannot reach inside an
+ * ARRAY or a UNION at all, because `duckdb_get_list_child` and
+ * `duckdb_get_struct_child` guard on the exact logical type id and return null
+ * for both. Going through a vector covers every type, and leaves one
+ * implementation of how each type is represented rather than two that can drift.
+ *
+ * The cost is roughly an extra microsecond per scalar value, which is fine here
+ * and would not be in a per-row path. Per-row data already arrives as vectors and
+ * never comes through here.
+ */
+function readValue(value) {
+    // Capacity of one: the vector exists only to hold this single value. It is
+    // destroyed when collected, and getItem materializes what it returns, so
+    // nothing handed back keeps a reference to the vector's memory.
+    const vector = node_bindings_1.default.create_vector(node_bindings_1.default.get_value_type(value), 1);
+    node_bindings_1.default.vector_reference_value(vector, value);
+    return DuckDBVector_1.DuckDBVector.create(vector, 1).getItem(0);
+}

package/lib/typeForValue.js

@@ -12,8 +12,11 @@ function typeForValue(value) {
             case 'boolean':
                 return DuckDBType_1.BOOLEAN;
             case 'number':
-                if (Math.round(value) === value) {
-                    return DuckDBType_1.INTEGER;
+                if (Number.isInteger(value)) {
+                    if (value >= -2_147_483_648 && value <= 2_147_483_647) {
+                        return DuckDBType_1.INTEGER;
+                    }
+                    return DuckDBType_1.BIGINT;
                 }
                 else {
                     return DuckDBType_1.DOUBLE;
@@ -45,6 +48,13 @@ function typeForValue(value) {
                     return (0, DuckDBType_1.LIST)(typeForValue(value.items[0]));
                 }
                 else if (value instanceof values_1.DuckDBMapValue) {
+                    if (value.entries.length === 0) {
+                        // An empty map carries no entries to infer key/value types from.
+                        // Mirror the empty-list path (LIST(ANY)) so createValue raises the
+                        // same "Cannot create maps with key type of ANY" error, instead of
+                        // a cryptic "Cannot read properties of undefined (reading 'key')".
+                        return (0, DuckDBType_1.MAP)(DuckDBType_1.ANY, DuckDBType_1.ANY);
+                    }
                     return (0, DuckDBType_1.MAP)(typeForValue(value.entries[0].key), typeForValue(value.entries[0].value));
                 }
                 else if (value instanceof values_1.DuckDBStructValue) {
@@ -66,6 +76,9 @@ function typeForValue(value) {
                 else if (value instanceof values_1.DuckDBTimestampTZValue) {
                     return DuckDBType_1.TIMESTAMPTZ;
                 }
+                else if (value instanceof values_1.DuckDBTimestampTZNanosecondsValue) {
+                    return DuckDBType_1.TIMESTAMPTZ_NS;
+                }
                 else if (value instanceof values_1.DuckDBTimestampValue) {
                     return DuckDBType_1.TIMESTAMP;
                 }
@@ -78,12 +91,18 @@ function typeForValue(value) {
                 else if (value instanceof values_1.DuckDBTimeNSValue) {
                     return DuckDBType_1.TIME_NS;
                 }
+                else if (value instanceof values_1.DuckDBTupleValue) {
+                    return (0, DuckDBType_1.TUPLE)(value.items.map(typeForValue));
+                }
                 else if (value instanceof values_1.DuckDBUnionValue) {
                     return (0, DuckDBType_1.UNION)({ [value.tag]: typeForValue(value.value) });
                 }
                 else if (value instanceof values_1.DuckDBUUIDValue) {
                     return DuckDBType_1.UUID;
                 }
+                else if (value instanceof values_1.DuckDBVariantValue) {
+                    return DuckDBType_1.VARIANT;
+                }
                 break;
         }
     }

package/lib/types/BaseDuckDBType.d.ts

@@ -0,0 +1,11 @@
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+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;
+}

package/lib/types/BaseDuckDBType.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDuckDBType = void 0;
+const node_bindings_1 = __importDefault(require("@haybarn/node-bindings"));
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class BaseDuckDBType {
+    typeId;
+    alias;
+    constructor(typeId, alias) {
+        this.typeId = typeId;
+        this.alias = alias;
+    }
+    toString() {
+        return DuckDBTypeId_1.DuckDBTypeId[this.typeId];
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.create(node_bindings_1.default.create_logical_type(this.typeId));
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        return logicalType;
+    }
+    toJson() {
+        return {
+            typeId: this.typeId,
+            ...(this.alias ? { alias: this.alias } : {}),
+        };
+    }
+}
+exports.BaseDuckDBType = BaseDuckDBType;

package/lib/types/DuckDBAnyType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBAnyType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANY = exports.DuckDBAnyType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBAnyType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.ANY, alias);
+    }
+    static instance = new DuckDBAnyType();
+    static create(alias) {
+        return alias ? new DuckDBAnyType(alias) : DuckDBAnyType.instance;
+    }
+}
+exports.DuckDBAnyType = DuckDBAnyType;
+exports.ANY = DuckDBAnyType.instance;

package/lib/types/DuckDBArrayType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+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;

package/lib/types/DuckDBArrayType.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBArrayType = void 0;
+exports.ARRAY = ARRAY;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBArrayType extends BaseDuckDBType_1.BaseDuckDBType {
+    valueType;
+    length;
+    constructor(valueType, length, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.ARRAY, alias);
+        this.valueType = valueType;
+        this.length = length;
+    }
+    toString() {
+        return `${this.valueType}[${this.length}]`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createArray(this.valueType.toLogicalType(), this.length);
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        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) {
+    return new DuckDBArrayType(valueType, length, alias);
+}

package/lib/types/DuckDBBigIntType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBBigIntType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIGINT = exports.DuckDBBigIntType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBBigIntType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.BIGINT, alias);
+    }
+    static instance = new DuckDBBigIntType();
+    static create(alias) {
+        return alias ? new DuckDBBigIntType(alias) : DuckDBBigIntType.instance;
+    }
+    static Max = 2n ** 63n - 1n;
+    static Min = -(2n ** 63n);
+    get max() {
+        return DuckDBBigIntType.Max;
+    }
+    get min() {
+        return DuckDBBigIntType.Min;
+    }
+}
+exports.DuckDBBigIntType = DuckDBBigIntType;
+exports.BIGINT = DuckDBBigIntType.instance;

package/lib/types/DuckDBBigNumType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBBigNumType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIGNUM = exports.DuckDBBigNumType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBBigNumType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.BIGNUM, alias);
+    }
+    static instance = new DuckDBBigNumType();
+    static create(alias) {
+        return alias ? new DuckDBBigNumType(alias) : DuckDBBigNumType.instance;
+    }
+    static Max = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368n;
+    static Min = -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368n;
+    get max() {
+        return DuckDBBigNumType.Max;
+    }
+    get min() {
+        return DuckDBBigNumType.Min;
+    }
+}
+exports.DuckDBBigNumType = DuckDBBigNumType;
+exports.BIGNUM = DuckDBBigNumType.instance;

package/lib/types/DuckDBBitType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBBitType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BIT = exports.DuckDBBitType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBBitType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.BIT, alias);
+    }
+    static instance = new DuckDBBitType();
+    static create(alias) {
+        return alias ? new DuckDBBitType(alias) : DuckDBBitType.instance;
+    }
+}
+exports.DuckDBBitType = DuckDBBitType;
+exports.BIT = DuckDBBitType.instance;

package/lib/types/DuckDBBlobType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBBlobType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOB = exports.DuckDBBlobType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBBlobType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.BLOB, alias);
+    }
+    static instance = new DuckDBBlobType();
+    static create(alias) {
+        return alias ? new DuckDBBlobType(alias) : DuckDBBlobType.instance;
+    }
+}
+exports.DuckDBBlobType = DuckDBBlobType;
+exports.BLOB = DuckDBBlobType.instance;

package/lib/types/DuckDBBooleanType.d.ts

@@ -0,0 +1,8 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBBooleanType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOOLEAN = exports.DuckDBBooleanType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBBooleanType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.BOOLEAN, alias);
+    }
+    static instance = new DuckDBBooleanType();
+    static create(alias) {
+        return alias ? new DuckDBBooleanType(alias) : DuckDBBooleanType.instance;
+    }
+}
+exports.DuckDBBooleanType = DuckDBBooleanType;
+exports.BOOLEAN = DuckDBBooleanType.instance;

package/lib/types/DuckDBDateType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBDateValue } from '../values';
+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;

package/lib/types/DuckDBDateType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE = exports.DuckDBDateType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const values_1 = require("../values");
+class DuckDBDateType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.DATE, alias);
+    }
+    static instance = new DuckDBDateType();
+    static create(alias) {
+        return alias ? new DuckDBDateType(alias) : DuckDBDateType.instance;
+    }
+    get epoch() {
+        return values_1.DuckDBDateValue.Epoch;
+    }
+    get max() {
+        return values_1.DuckDBDateValue.Max;
+    }
+    get min() {
+        return values_1.DuckDBDateValue.Min;
+    }
+    get posInf() {
+        return values_1.DuckDBDateValue.PosInf;
+    }
+    get negInf() {
+        return values_1.DuckDBDateValue.NegInf;
+    }
+}
+exports.DuckDBDateType = DuckDBDateType;
+exports.DATE = DuckDBDateType.instance;

package/lib/types/DuckDBDecimalType.d.ts

@@ -0,0 +1,14 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+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;

package/lib/types/DuckDBDecimalType.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBDecimalType = void 0;
+exports.DECIMAL = DECIMAL;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBDecimalType extends BaseDuckDBType_1.BaseDuckDBType {
+    width;
+    scale;
+    constructor(width, scale, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.DECIMAL, alias);
+        this.width = width;
+        this.scale = scale;
+    }
+    toString() {
+        return `DECIMAL(${this.width},${this.scale})`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createDecimal(this.width, this.scale);
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        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;
+function DECIMAL(width, scale, alias) {
+    if (width === undefined) {
+        return DuckDBDecimalType.default;
+    }
+    if (scale === undefined) {
+        return new DuckDBDecimalType(width, 0);
+    }
+    return new DuckDBDecimalType(width, scale, alias);
+}

package/lib/types/DuckDBDoubleType.d.ts

@@ -0,0 +1,12 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+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;

package/lib/types/DuckDBDoubleType.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOUBLE = exports.DuckDBDoubleType = void 0;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+class DuckDBDoubleType extends BaseDuckDBType_1.BaseDuckDBType {
+    constructor(alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.DOUBLE, alias);
+    }
+    static instance = new DuckDBDoubleType();
+    static create(alias) {
+        return alias ? new DuckDBDoubleType(alias) : DuckDBDoubleType.instance;
+    }
+    static Max = Number.MAX_VALUE;
+    static Min = -Number.MAX_VALUE;
+    get max() {
+        return DuckDBDoubleType.Max;
+    }
+    get min() {
+        return DuckDBDoubleType.Min;
+    }
+}
+exports.DuckDBDoubleType = DuckDBDoubleType;
+exports.DOUBLE = DuckDBDoubleType.instance;

package/lib/types/DuckDBEnumType.d.ts

@@ -0,0 +1,29 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+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);
+    /**
+     * The index of the given value in this enum.
+     *
+     * Throws if the value is not a member: storing an unknown value would
+     * otherwise write index 0, silently substituting the enum's first member.
+     */
+    indexForValue(value: string): number;
+    /**
+     * Like toString, but bounded: an enum can have millions of members, and all of
+     * them in an error message would bury the part that matters.
+     */
+    private toStringForError;
+    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;

package/lib/types/DuckDBEnumType.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDBEnumType = void 0;
+exports.ENUM8 = ENUM8;
+exports.ENUM16 = ENUM16;
+exports.ENUM32 = ENUM32;
+exports.ENUM = ENUM;
+const BaseDuckDBType_1 = require("./BaseDuckDBType");
+const DuckDBLogicalType_1 = require("../DuckDBLogicalType");
+const DuckDBTypeId_1 = require("../DuckDBTypeId");
+const sql_1 = require("../sql");
+class DuckDBEnumType extends BaseDuckDBType_1.BaseDuckDBType {
+    values;
+    valueIndexes;
+    internalTypeId;
+    constructor(values, internalTypeId, alias) {
+        super(DuckDBTypeId_1.DuckDBTypeId.ENUM, alias);
+        this.values = values;
+        // Null prototype: with a plain object literal, a lookup of an inherited key
+        // such as 'toString' or 'constructor' returns a function instead of
+        // undefined, so neither this map nor indexForValue could tell a member from
+        // an Object.prototype property.
+        const valueIndexes = Object.create(null);
+        for (let i = 0; i < values.length; i++) {
+            valueIndexes[values[i]] = i;
+        }
+        this.valueIndexes = valueIndexes;
+        this.internalTypeId = internalTypeId;
+    }
+    /**
+     * The index of the given value in this enum.
+     *
+     * Throws if the value is not a member: storing an unknown value would
+     * otherwise write index 0, silently substituting the enum's first member.
+     */
+    indexForValue(value) {
+        const index = this.valueIndexes[value];
+        if (index === undefined) {
+            throw new Error(`${(0, sql_1.quotedString)(value)} is not a member of ${this.toStringForError()}`);
+        }
+        return index;
+    }
+    /**
+     * Like toString, but bounded: an enum can have millions of members, and all of
+     * them in an error message would bury the part that matters.
+     */
+    toStringForError() {
+        if (this.alias) {
+            return this.alias;
+        }
+        const shown = 8;
+        if (this.values.length <= shown) {
+            return this.toString();
+        }
+        const listed = this.values.slice(0, shown).map(sql_1.quotedString).join(', ');
+        return `ENUM(${listed}, and ${this.values.length - shown} more)`;
+    }
+    toString() {
+        return `ENUM(${this.values.map(sql_1.quotedString).join(', ')})`;
+    }
+    toLogicalType() {
+        const logicalType = DuckDBLogicalType_1.DuckDBLogicalType.createEnum(this.values);
+        if (this.alias) {
+            logicalType.alias = this.alias;
+        }
+        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) {
+    return new DuckDBEnumType(values, DuckDBTypeId_1.DuckDBTypeId.UTINYINT, alias);
+}
+function ENUM16(values, alias) {
+    return new DuckDBEnumType(values, DuckDBTypeId_1.DuckDBTypeId.USMALLINT, alias);
+}
+function ENUM32(values, alias) {
+    return new DuckDBEnumType(values, DuckDBTypeId_1.DuckDBTypeId.UINTEGER, alias);
+}
+function ENUM(values, alias) {
+    if (values.length < 256) {
+        return ENUM8(values, alias);
+    }
+    else if (values.length < 65536) {
+        return ENUM16(values, alias);
+    }
+    else if (values.length < 4294967296) {
+        return ENUM32(values, alias);
+    }
+    else {
+        throw new Error(`ENUM types cannot have more than 4294967295 values; received ${values.length}`);
+    }
+}