@avidian/duckdb-bun 0.0.0-stage → 1.0.1

package/vendor/node-api/src/types/BaseDuckDBType.ts

@@ -0,0 +1,31 @@
+import duckdb from "../../../../src/bindings/index.ts";
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+
+export abstract class BaseDuckDBType<T extends DuckDBTypeId> {
+  public readonly typeId: T;
+  public readonly alias?: string;
+  protected constructor(typeId: T, alias?: string) {
+    this.typeId = typeId;
+    this.alias = alias;
+  }
+  public toString(): string {
+    return DuckDBTypeId[this.typeId];
+  }
+  public toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.create(
+      duckdb.create_logical_type(this.typeId as number as duckdb.Type)
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public toJson(): Json {
+    return {
+      typeId: this.typeId,
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}

package/vendor/node-api/src/types/DuckDBAnyType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBAnyType extends BaseDuckDBType<DuckDBTypeId.ANY> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.ANY, alias);
+  }
+  public static readonly instance = new DuckDBAnyType();
+  public static create(alias?: string): DuckDBAnyType {
+    return alias ? new DuckDBAnyType(alias) : DuckDBAnyType.instance;
+  }
+}
+export const ANY = DuckDBAnyType.instance;

package/vendor/node-api/src/types/DuckDBArrayType.ts

@@ -0,0 +1,43 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+
+export class DuckDBArrayType extends BaseDuckDBType<DuckDBTypeId.ARRAY> {
+  public readonly valueType: DuckDBType;
+  public readonly length: number;
+  public constructor(valueType: DuckDBType, length: number, alias?: string) {
+    super(DuckDBTypeId.ARRAY, alias);
+    this.valueType = valueType;
+    this.length = length;
+  }
+  public toString(): string {
+    return `${this.valueType}[${this.length}]`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createArray(
+      this.valueType.toLogicalType(),
+      this.length
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      valueType: this.valueType.toJson(),
+      length: this.length,
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function ARRAY(
+  valueType: DuckDBType,
+  length: number,
+  alias?: string
+): DuckDBArrayType {
+  return new DuckDBArrayType(valueType, length, alias);
+}

package/vendor/node-api/src/types/DuckDBBigIntType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBBigIntType extends BaseDuckDBType<DuckDBTypeId.BIGINT> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.BIGINT, alias);
+  }
+  public static readonly instance = new DuckDBBigIntType();
+  public static create(alias?: string): DuckDBBigIntType {
+    return alias ? new DuckDBBigIntType(alias) : DuckDBBigIntType.instance;
+  }
+  public static readonly Max: bigint = 2n ** 63n - 1n;
+  public static readonly Min: bigint = -(2n ** 63n);
+  public get max() {
+    return DuckDBBigIntType.Max;
+  }
+  public get min() {
+    return DuckDBBigIntType.Min;
+  }
+}
+export const BIGINT = DuckDBBigIntType.instance;

package/vendor/node-api/src/types/DuckDBBigNumType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBBigNumType extends BaseDuckDBType<DuckDBTypeId.BIGNUM> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.BIGNUM, alias);
+  }
+  public static readonly instance = new DuckDBBigNumType();
+  public static create(alias?: string): DuckDBBigNumType {
+    return alias ? new DuckDBBigNumType(alias) : DuckDBBigNumType.instance;
+  }
+  public static readonly Max: bigint = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368n;
+  public static readonly Min: bigint = -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368n;
+  public get max() {
+    return DuckDBBigNumType.Max;
+  }
+  public get min() {
+    return DuckDBBigNumType.Min;
+  }
+}
+export const BIGNUM = DuckDBBigNumType.instance;

package/vendor/node-api/src/types/DuckDBBitType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBBitType extends BaseDuckDBType<DuckDBTypeId.BIT> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.BIT, alias);
+  }
+  public static readonly instance = new DuckDBBitType();
+  public static create(alias?: string): DuckDBBitType {
+    return alias ? new DuckDBBitType(alias) : DuckDBBitType.instance;
+  }
+}
+export const BIT = DuckDBBitType.instance;

package/vendor/node-api/src/types/DuckDBBlobType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBBlobType extends BaseDuckDBType<DuckDBTypeId.BLOB> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.BLOB, alias);
+  }
+  public static readonly instance = new DuckDBBlobType();
+  public static create(alias?: string): DuckDBBlobType {
+    return alias ? new DuckDBBlobType(alias) : DuckDBBlobType.instance;
+  }
+}
+export const BLOB = DuckDBBlobType.instance;

package/vendor/node-api/src/types/DuckDBBooleanType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBBooleanType extends BaseDuckDBType<DuckDBTypeId.BOOLEAN> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.BOOLEAN, alias);
+  }
+  public static readonly instance = new DuckDBBooleanType();
+  public static create(alias?: string): DuckDBBooleanType {
+    return alias ? new DuckDBBooleanType(alias) : DuckDBBooleanType.instance;
+  }
+}
+export const BOOLEAN = DuckDBBooleanType.instance;

package/vendor/node-api/src/types/DuckDBDateType.ts

@@ -0,0 +1,29 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBDateValue } from '../values';
+
+export class DuckDBDateType extends BaseDuckDBType<DuckDBTypeId.DATE> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.DATE, alias);
+  }
+  public static readonly instance = new DuckDBDateType();
+  public static create(alias?: string): DuckDBDateType {
+    return alias ? new DuckDBDateType(alias) : DuckDBDateType.instance;
+  }
+  public get epoch() {
+    return DuckDBDateValue.Epoch;
+  }
+  public get max() {
+    return DuckDBDateValue.Max;
+  }
+  public get min() {
+    return DuckDBDateValue.Min;
+  }
+  public get posInf() {
+    return DuckDBDateValue.PosInf;
+  }
+  public get negInf() {
+    return DuckDBDateValue.NegInf;
+  }
+}
+export const DATE = DuckDBDateType.instance;

package/vendor/node-api/src/types/DuckDBDecimalType.ts

@@ -0,0 +1,46 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+
+export class DuckDBDecimalType extends BaseDuckDBType<DuckDBTypeId.DECIMAL> {
+  public readonly width: number;
+  public readonly scale: number;
+  public constructor(width: number, scale: number, alias?: string) {
+    super(DuckDBTypeId.DECIMAL, alias);
+    this.width = width;
+    this.scale = scale;
+  }
+  public toString(): string {
+    return `DECIMAL(${this.width},${this.scale})`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createDecimal(this.width, this.scale);
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      width: this.width,
+      scale: this.scale,
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+  public static readonly default = new DuckDBDecimalType(18, 3);
+}
+export function DECIMAL(
+  width?: number,
+  scale?: number,
+  alias?: string
+): DuckDBDecimalType {
+  if (width === undefined) {
+    return DuckDBDecimalType.default;
+  }
+  if (scale === undefined) {
+    return new DuckDBDecimalType(width, 0);
+  }
+  return new DuckDBDecimalType(width, scale, alias);
+}

package/vendor/node-api/src/types/DuckDBDoubleType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBDoubleType extends BaseDuckDBType<DuckDBTypeId.DOUBLE> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.DOUBLE, alias);
+  }
+  public static readonly instance = new DuckDBDoubleType();
+  public static create(alias?: string): DuckDBDoubleType {
+    return alias ? new DuckDBDoubleType(alias) : DuckDBDoubleType.instance;
+  }
+  public static readonly Max = Number.MAX_VALUE;
+  public static readonly Min = -Number.MAX_VALUE;
+  public get max() {
+    return DuckDBDoubleType.Max;
+  }
+  public get min() {
+    return DuckDBDoubleType.Min;
+  }
+}
+export const DOUBLE = DuckDBDoubleType.instance;

package/vendor/node-api/src/types/DuckDBEnumType.ts

@@ -0,0 +1,111 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+import { quotedString } from '../sql';
+
+export class DuckDBEnumType extends BaseDuckDBType<DuckDBTypeId.ENUM> {
+  public readonly values: readonly string[];
+  public readonly valueIndexes: Readonly<Record<string, number>>;
+  public readonly internalTypeId: DuckDBTypeId;
+  public constructor(
+    values: readonly string[],
+    internalTypeId: DuckDBTypeId,
+    alias?: string
+  ) {
+    super(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: Record<string, number> = 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.
+   */
+  public indexForValue(value: string): number {
+    const index = this.valueIndexes[value];
+    if (index === undefined) {
+      throw new Error(
+        `${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.
+   */
+  private toStringForError(): string {
+    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(quotedString).join(', ');
+    return `ENUM(${listed}, and ${this.values.length - shown} more)`;
+  }
+  public toString(): string {
+    return `ENUM(${this.values.map(quotedString).join(', ')})`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createEnum(this.values);
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      values: [...this.values],
+      internalTypeId: this.internalTypeId,
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function ENUM8(
+  values: readonly string[],
+  alias?: string
+): DuckDBEnumType {
+  return new DuckDBEnumType(values, DuckDBTypeId.UTINYINT, alias);
+}
+export function ENUM16(
+  values: readonly string[],
+  alias?: string
+): DuckDBEnumType {
+  return new DuckDBEnumType(values, DuckDBTypeId.USMALLINT, alias);
+}
+export function ENUM32(
+  values: readonly string[],
+  alias?: string
+): DuckDBEnumType {
+  return new DuckDBEnumType(values, DuckDBTypeId.UINTEGER, alias);
+}
+export function ENUM(
+  values: readonly string[],
+  alias?: string
+): DuckDBEnumType {
+  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}`
+    );
+  }
+}

package/vendor/node-api/src/types/DuckDBFloatType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBFloatType extends BaseDuckDBType<DuckDBTypeId.FLOAT> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.FLOAT, alias);
+  }
+  public static readonly instance = new DuckDBFloatType();
+  public static create(alias?: string): DuckDBFloatType {
+    return alias ? new DuckDBFloatType(alias) : DuckDBFloatType.instance;
+  }
+  public static readonly Max = Math.fround(3.4028235e38);
+  public static readonly Min = Math.fround(-3.4028235e38);
+  public get max() {
+    return DuckDBFloatType.Max;
+  }
+  public get min() {
+    return DuckDBFloatType.Min;
+  }
+}
+export const FLOAT = DuckDBFloatType.instance;

package/vendor/node-api/src/types/DuckDBGeometryType.ts

@@ -0,0 +1,36 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+import { quotedString } from '../sql';
+
+export class DuckDBGeometryType extends BaseDuckDBType<DuckDBTypeId.GEOMETRY> {
+  /**
+   * Coordinate Reference System (e.g. a WKT2 string) attached to the type.
+   *
+   * Read-only: setting `crs` on a `DuckDBGeometryType` is not propagated by
+   * `toLogicalType()`. To produce a GEOMETRY logical type carrying a CRS,
+   * construct it via SQL (e.g. `'POINT(1 2)'::GEOMETRY('<crs>')`).
+   */
+  public readonly crs?: string;
+  public constructor(alias?: string, crs?: string) {
+    super(DuckDBTypeId.GEOMETRY, alias);
+    this.crs = crs;
+  }
+  public override toString(): string {
+    return this.crs ? `GEOMETRY(${quotedString(this.crs)})` : 'GEOMETRY';
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      ...(this.crs ? { crs: this.crs } : {}),
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+  public static readonly instance = new DuckDBGeometryType();
+  public static create(alias?: string, crs?: string): DuckDBGeometryType {
+    return alias || crs
+      ? new DuckDBGeometryType(alias, crs)
+      : DuckDBGeometryType.instance;
+  }
+}
+export const GEOMETRY = DuckDBGeometryType.instance;

package/vendor/node-api/src/types/DuckDBHugeIntType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBHugeIntType extends BaseDuckDBType<DuckDBTypeId.HUGEINT> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.HUGEINT, alias);
+  }
+  public static readonly instance = new DuckDBHugeIntType();
+  public static create(alias?: string): DuckDBHugeIntType {
+    return alias ? new DuckDBHugeIntType(alias) : DuckDBHugeIntType.instance;
+  }
+  public static readonly Max: bigint = 2n ** 127n - 1n;
+  public static readonly Min: bigint = -(2n ** 127n);
+  public get max() {
+    return DuckDBHugeIntType.Max;
+  }
+  public get min() {
+    return DuckDBHugeIntType.Min;
+  }
+}
+export const HUGEINT = DuckDBHugeIntType.instance;

package/vendor/node-api/src/types/DuckDBIntegerLiteralType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBIntegerLiteralType extends BaseDuckDBType<DuckDBTypeId.INTEGER_LITERAL> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.INTEGER_LITERAL, alias);
+  }
+  public static readonly instance = new DuckDBIntegerLiteralType();
+  public static create(alias?: string): DuckDBIntegerLiteralType {
+    return alias ? new DuckDBIntegerLiteralType(alias) : DuckDBIntegerLiteralType.instance;
+  }
+}
+export const INTEGER_LITERAL = DuckDBIntegerLiteralType.instance;

package/vendor/node-api/src/types/DuckDBIntegerType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBIntegerType extends BaseDuckDBType<DuckDBTypeId.INTEGER> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.INTEGER, alias);
+  }
+  public static readonly instance = new DuckDBIntegerType();
+  public static create(alias?: string): DuckDBIntegerType {
+    return alias ? new DuckDBIntegerType(alias) : DuckDBIntegerType.instance;
+  }
+  public static readonly Max = 2 ** 31 - 1;
+  public static readonly Min = -(2 ** 31);
+  public get max() {
+    return DuckDBIntegerType.Max;
+  }
+  public get min() {
+    return DuckDBIntegerType.Min;
+  }
+}
+export const INTEGER = DuckDBIntegerType.instance;

package/vendor/node-api/src/types/DuckDBIntervalType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBIntervalType extends BaseDuckDBType<DuckDBTypeId.INTERVAL> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.INTERVAL, alias);
+  }
+  public static readonly instance = new DuckDBIntervalType();
+  public static create(alias?: string): DuckDBIntervalType {
+    return alias ? new DuckDBIntervalType(alias) : DuckDBIntervalType.instance;
+  }
+}
+export const INTERVAL = DuckDBIntervalType.instance;

package/vendor/node-api/src/types/DuckDBListType.ts

@@ -0,0 +1,35 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+
+export class DuckDBListType extends BaseDuckDBType<DuckDBTypeId.LIST> {
+  public readonly valueType: DuckDBType;
+  public constructor(valueType: DuckDBType, alias?: string) {
+    super(DuckDBTypeId.LIST, alias);
+    this.valueType = valueType;
+  }
+  public toString(): string {
+    return `${this.valueType}[]`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createList(
+      this.valueType.toLogicalType()
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      valueType: this.valueType.toJson(),
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function LIST(valueType: DuckDBType, alias?: string): DuckDBListType {
+  return new DuckDBListType(valueType, alias);
+}

package/vendor/node-api/src/types/DuckDBMapType.ts

@@ -0,0 +1,47 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+
+export class DuckDBMapType extends BaseDuckDBType<DuckDBTypeId.MAP> {
+  public readonly keyType: DuckDBType;
+  public readonly valueType: DuckDBType;
+  public constructor(
+    keyType: DuckDBType,
+    valueType: DuckDBType,
+    alias?: string
+  ) {
+    super(DuckDBTypeId.MAP, alias);
+    this.keyType = keyType;
+    this.valueType = valueType;
+  }
+  public toString(): string {
+    return `MAP(${this.keyType}, ${this.valueType})`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createMap(
+      this.keyType.toLogicalType(),
+      this.valueType.toLogicalType()
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      keyType: this.keyType.toJson(),
+      valueType: this.valueType.toJson(),
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function MAP(
+  keyType: DuckDBType,
+  valueType: DuckDBType,
+  alias?: string
+): DuckDBMapType {
+  return new DuckDBMapType(keyType, valueType, alias);
+}

package/vendor/node-api/src/types/DuckDBSQLNullType.ts

@@ -0,0 +1,17 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBSQLNullType extends BaseDuckDBType<DuckDBTypeId.SQLNULL> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.SQLNULL, alias);
+  }
+  /** DuckDB's name for the type, quoted because NULL is a keyword. */
+  public toString(): string {
+    return '"NULL"';
+  }
+  public static readonly instance = new DuckDBSQLNullType();
+  public static create(alias?: string): DuckDBSQLNullType {
+    return alias ? new DuckDBSQLNullType(alias) : DuckDBSQLNullType.instance;
+  }
+}
+export const SQLNULL = DuckDBSQLNullType.instance;

package/vendor/node-api/src/types/DuckDBSmallIntType.ts

@@ -0,0 +1,21 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBSmallIntType extends BaseDuckDBType<DuckDBTypeId.SMALLINT> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.SMALLINT, alias);
+  }
+  public static readonly instance = new DuckDBSmallIntType();
+  public static create(alias?: string): DuckDBSmallIntType {
+    return alias ? new DuckDBSmallIntType(alias) : DuckDBSmallIntType.instance;
+  }
+  public static readonly Max = 2 ** 15 - 1;
+  public static readonly Min = -(2 ** 15);
+  public get max() {
+    return DuckDBSmallIntType.Max;
+  }
+  public get min() {
+    return DuckDBSmallIntType.Min;
+  }
+}
+export const SMALLINT = DuckDBSmallIntType.instance;

package/vendor/node-api/src/types/DuckDBStringLiteralType.ts

@@ -0,0 +1,13 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+
+export class DuckDBStringLiteralType extends BaseDuckDBType<DuckDBTypeId.STRING_LITERAL> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.STRING_LITERAL, alias);
+  }
+  public static readonly instance = new DuckDBStringLiteralType();
+  public static create(alias?: string): DuckDBStringLiteralType {
+    return alias ? new DuckDBStringLiteralType(alias) : DuckDBStringLiteralType.instance;
+  }
+}
+export const STRING_LITERAL = DuckDBStringLiteralType.instance;