@avidian/duckdb-bun 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,104 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+import { quotedIdentifier } from '../sql';
+
+export class DuckDBStructType extends BaseDuckDBType<DuckDBTypeId.STRUCT> {
+  public readonly entryNames: readonly string[];
+  public readonly entryTypes: readonly DuckDBType[];
+  public readonly entryIndexes: Readonly<Record<string, number>>;
+  public constructor(
+    entryNames: readonly string[],
+    entryTypes: readonly DuckDBType[],
+    alias?: string
+  ) {
+    super(DuckDBTypeId.STRUCT, alias);
+    if (entryNames.length !== entryTypes.length) {
+      throw new Error(`Could not create DuckDBStructType: \
+        entryNames length (${entryNames.length}) does not match entryTypes length (${entryTypes.length})`);
+    }
+    this.entryNames = entryNames;
+    this.entryTypes = entryTypes;
+    const entryIndexes: Record<string, number> = {};
+    for (let i = 0; i < entryNames.length; i++) {
+      entryIndexes[entryNames[i]] = i;
+    }
+    this.entryIndexes = entryIndexes;
+  }
+  public get entryCount() {
+    return this.entryNames.length;
+  }
+  /**
+   * Whether this is an unnamed struct, i.e. a tuple, such as the type of
+   * `(1, 'a')` or `row(1, 'a')`. DuckDB reports these as STRUCTs whose entry
+   * names are all empty. A STRUCT with no entries is not a tuple.
+   *
+   * Values of a tuple type are `DuckDBTupleValue`s, whose items are
+   * positional, rather than `DuckDBStructValue`s.
+   */
+  public get isTuple(): boolean {
+    return (
+      this.entryNames.length > 0 && this.entryNames.every((name) => name === '')
+    );
+  }
+  public indexForEntry(entryName: string): number {
+    return this.entryIndexes[entryName];
+  }
+  public typeForEntry(entryName: string): DuckDBType {
+    return this.entryTypes[this.entryIndexes[entryName]];
+  }
+  public toString(): string {
+    if (this.entryNames.length === 0) {
+      return 'STRUCT';
+    }
+    if (this.isTuple) {
+      return `TUPLE(${this.entryTypes.join(', ')})`;
+    }
+    const parts: string[] = [];
+    for (let i = 0; i < this.entryNames.length; i++) {
+      parts.push(
+        `${quotedIdentifier(this.entryNames[i])} ${this.entryTypes[i]}`
+      );
+    }
+    return `STRUCT(${parts.join(', ')})`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createStruct(
+      this.entryNames,
+      this.entryTypes.map((t) => t.toLogicalType())
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      entryNames: [...this.entryNames],
+      entryTypes: this.entryTypes.map(t => t.toJson()),
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function STRUCT(
+  entries: Record<string, DuckDBType>,
+  alias?: string
+): DuckDBStructType {
+  const entryNames = Object.keys(entries);
+  const entryTypes = Object.values(entries);
+  return new DuckDBStructType(entryNames, entryTypes, alias);
+}
+/** Creates a tuple type: an unnamed STRUCT with the given entry types. */
+export function TUPLE(
+  entryTypes: readonly DuckDBType[],
+  alias?: string
+): DuckDBStructType {
+  return new DuckDBStructType(
+    entryTypes.map(() => ''),
+    entryTypes,
+    alias
+  );
+}

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

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

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

@@ -0,0 +1,23 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimeTZValue } from '../values';
+
+export class DuckDBTimeTZType extends BaseDuckDBType<DuckDBTypeId.TIME_TZ> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.TIME_TZ, alias);
+  }
+  public toString(): string {
+    return 'TIME WITH TIME ZONE';
+  }
+  public static readonly instance = new DuckDBTimeTZType();
+  public static create(alias?: string): DuckDBTimeTZType {
+    return alias ? new DuckDBTimeTZType(alias) : DuckDBTimeTZType.instance;
+  }
+  public get max() {
+    return DuckDBTimeTZValue.Max;
+  }
+  public get min() {
+    return DuckDBTimeTZValue.Min;
+  }
+}
+export const TIMETZ = DuckDBTimeTZType.instance;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { DuckDBTimestampTZValue } from '../values';
+
+export class DuckDBTimestampTZType extends BaseDuckDBType<DuckDBTypeId.TIMESTAMP_TZ> {
+  public constructor(alias?: string) {
+    super(DuckDBTypeId.TIMESTAMP_TZ, alias);
+  }
+  public toString(): string {
+    return 'TIMESTAMP WITH TIME ZONE';
+  }
+  public static readonly instance = new DuckDBTimestampTZType();
+  public static create(alias?: string): DuckDBTimestampTZType {
+    return alias ? new DuckDBTimestampTZType(alias) : DuckDBTimestampTZType.instance;
+  }
+  public get epoch() {
+    return DuckDBTimestampTZValue.Epoch;
+  }
+  public get max() {
+    return DuckDBTimestampTZValue.Max;
+  }
+  public get min() {
+    return DuckDBTimestampTZValue.Min;
+  }
+  public get posInf() {
+    return DuckDBTimestampTZValue.PosInf;
+  }
+  public get negInf() {
+    return DuckDBTimestampTZValue.NegInf;
+  }
+}
+export const TIMESTAMPTZ = DuckDBTimestampTZType.instance;

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

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

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

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

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

@@ -0,0 +1,86 @@
+import type { DuckDBAnyType } from './DuckDBAnyType';
+import type { DuckDBArrayType } from './DuckDBArrayType';
+import type { DuckDBBigIntType } from './DuckDBBigIntType';
+import type { DuckDBBigNumType } from './DuckDBBigNumType';
+import type { DuckDBBitType } from './DuckDBBitType';
+import type { DuckDBBlobType } from './DuckDBBlobType';
+import type { DuckDBBooleanType } from './DuckDBBooleanType';
+import type { DuckDBDateType } from './DuckDBDateType';
+import type { DuckDBDecimalType } from './DuckDBDecimalType';
+import type { DuckDBDoubleType } from './DuckDBDoubleType';
+import type { DuckDBEnumType } from './DuckDBEnumType';
+import type { DuckDBFloatType } from './DuckDBFloatType';
+import type { DuckDBGeometryType } from './DuckDBGeometryType';
+import type { DuckDBHugeIntType } from './DuckDBHugeIntType';
+import type { DuckDBIntegerLiteralType } from './DuckDBIntegerLiteralType';
+import type { DuckDBIntegerType } from './DuckDBIntegerType';
+import type { DuckDBIntervalType } from './DuckDBIntervalType';
+import type { DuckDBListType } from './DuckDBListType';
+import type { DuckDBMapType } from './DuckDBMapType';
+import type { DuckDBSQLNullType } from './DuckDBSQLNullType';
+import type { DuckDBSmallIntType } from './DuckDBSmallIntType';
+import type { DuckDBStringLiteralType } from './DuckDBStringLiteralType';
+import type { DuckDBStructType } from './DuckDBStructType';
+import type { DuckDBTimeNSType } from './DuckDBTimeNSType';
+import type { DuckDBTimeTZType } from './DuckDBTimeTZType';
+import type { DuckDBTimeType } from './DuckDBTimeType';
+import type { DuckDBTimestampMillisecondsType } from './DuckDBTimestampMillisecondsType';
+import type { DuckDBTimestampNanosecondsType } from './DuckDBTimestampNanosecondsType';
+import type { DuckDBTimestampSecondsType } from './DuckDBTimestampSecondsType';
+import type { DuckDBTimestampTZType } from './DuckDBTimestampTZType';
+import type { DuckDBTimestampTZNanosecondsType } from './DuckDBTimestampTZNanosecondsType';
+import type { DuckDBTimestampType } from './DuckDBTimestampType';
+import type { DuckDBTinyIntType } from './DuckDBTinyIntType';
+import type { DuckDBUnionType } from './DuckDBUnionType';
+import type { DuckDBUBigIntType } from './DuckDBUBigIntType';
+import type { DuckDBUHugeIntType } from './DuckDBUHugeIntType';
+import type { DuckDBUIntegerType } from './DuckDBUIntegerType';
+import type { DuckDBUSmallIntType } from './DuckDBUSmallIntType';
+import type { DuckDBUTinyIntType } from './DuckDBUTinyIntType';
+import type { DuckDBUUIDType } from './DuckDBUUIDType';
+import type { DuckDBVarCharType } from './DuckDBVarCharType';
+import type { DuckDBVariantType } from './DuckDBVariantType';
+
+export type DuckDBType =
+  | DuckDBBooleanType
+  | DuckDBTinyIntType
+  | DuckDBSmallIntType
+  | DuckDBIntegerType
+  | DuckDBBigIntType
+  | DuckDBUTinyIntType
+  | DuckDBUSmallIntType
+  | DuckDBUIntegerType
+  | DuckDBUBigIntType
+  | DuckDBFloatType
+  | DuckDBDoubleType
+  | DuckDBTimestampType
+  | DuckDBDateType
+  | DuckDBTimeType
+  | DuckDBIntervalType
+  | DuckDBHugeIntType
+  | DuckDBUHugeIntType
+  | DuckDBVarCharType
+  | DuckDBBlobType
+  | DuckDBDecimalType
+  | DuckDBTimestampSecondsType
+  | DuckDBTimestampMillisecondsType
+  | DuckDBTimestampNanosecondsType
+  | DuckDBEnumType
+  | DuckDBListType
+  | DuckDBStructType
+  | DuckDBMapType
+  | DuckDBArrayType
+  | DuckDBUUIDType
+  | DuckDBUnionType
+  | DuckDBBitType
+  | DuckDBTimeTZType
+  | DuckDBTimestampTZType
+  | DuckDBAnyType
+  | DuckDBBigNumType
+  | DuckDBSQLNullType
+  | DuckDBStringLiteralType
+  | DuckDBIntegerLiteralType
+  | DuckDBTimeNSType
+  | DuckDBGeometryType
+  | DuckDBVariantType
+  | DuckDBTimestampTZNanosecondsType;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,74 @@
+import { BaseDuckDBType } from './BaseDuckDBType';
+import type { DuckDBType } from './DuckDBType';
+import { DuckDBLogicalType } from '../DuckDBLogicalType';
+import { DuckDBTypeId } from '../DuckDBTypeId';
+import { Json } from '../Json';
+import { quotedIdentifier } from '../sql';
+
+export class DuckDBUnionType extends BaseDuckDBType<DuckDBTypeId.UNION> {
+  public readonly memberTags: readonly string[];
+  public readonly tagMemberIndexes: Readonly<Record<string, number>>;
+  public readonly memberTypes: readonly DuckDBType[];
+  public constructor(
+    memberTags: readonly string[],
+    memberTypes: readonly DuckDBType[],
+    alias?: string
+  ) {
+    super(DuckDBTypeId.UNION, alias);
+    if (memberTags.length !== memberTypes.length) {
+      throw new Error(`Could not create DuckDBUnionType: \
+        tags length (${memberTags.length}) does not match valueTypes length (${memberTypes.length})`);
+    }
+    this.memberTags = memberTags;
+    const tagMemberIndexes: Record<string, number> = {};
+    for (let i = 0; i < memberTags.length; i++) {
+      tagMemberIndexes[memberTags[i]] = i;
+    }
+    this.tagMemberIndexes = tagMemberIndexes;
+    this.memberTypes = memberTypes;
+  }
+  public memberIndexForTag(tag: string): number {
+    return this.tagMemberIndexes[tag];
+  }
+  public memberTypeForTag(tag: string): DuckDBType {
+    return this.memberTypes[this.tagMemberIndexes[tag]];
+  }
+  public get memberCount() {
+    return this.memberTags.length;
+  }
+  public toString(): string {
+    const parts: string[] = [];
+    for (let i = 0; i < this.memberTags.length; i++) {
+      parts.push(
+        `${quotedIdentifier(this.memberTags[i])} ${this.memberTypes[i]}`
+      );
+    }
+    return `UNION(${parts.join(', ')})`;
+  }
+  public override toLogicalType(): DuckDBLogicalType {
+    const logicalType = DuckDBLogicalType.createUnion(
+      this.memberTags,
+      this.memberTypes.map((t) => t.toLogicalType())
+    );
+    if (this.alias) {
+      logicalType.alias = this.alias;
+    }
+    return logicalType;
+  }
+  public override toJson(): Json {
+    return {
+      typeId: this.typeId,
+      memberTags: [...this.memberTags],
+      memberTypes: this.memberTypes.map(t => t.toJson()),
+      ...(this.alias ? { alias: this.alias } : {}),
+    };
+  }
+}
+export function UNION(
+  members: Record<string, DuckDBType>,
+  alias?: string
+): DuckDBUnionType {
+  const memberTags = Object.keys(members);
+  const memberTypes = Object.values(members);
+  return new DuckDBUnionType(memberTags, memberTypes, alias);
+}