@avidian/duckdb-bun 0.0.0-stage → 1.0.1

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

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

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

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

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

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

package/vendor/node-api/src/values/DuckDBArrayValue.ts

@@ -0,0 +1,18 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+import { DuckDBValue } from './DuckDBValue';
+
+export class DuckDBArrayValue {
+  public readonly items: readonly DuckDBValue[];
+
+  public constructor(items: readonly DuckDBValue[]) {
+    this.items = items;
+  }
+
+  public toString(): string {
+    return `[${this.items.map(displayStringForDuckDBValue).join(', ')}]`;
+  }
+}
+
+export function arrayValue(items: readonly DuckDBValue[]): DuckDBArrayValue {
+  return new DuckDBArrayValue(items);
+}

package/vendor/node-api/src/values/DuckDBBitValue.ts

@@ -0,0 +1,117 @@
+export class DuckDBBitValue {
+  public readonly data: Uint8Array;
+
+  public constructor(data: Uint8Array) {
+    this.data = data;
+  }
+
+  public padding(): number {
+    return this.data[0];
+  }
+
+  public get length(): number {
+    return (this.data.length - 1) * 8 - this.padding();
+  }
+
+  public getBool(index: number): boolean {
+    const offset = index + this.padding();
+    const dataIndex = Math.floor(offset / 8) + 1;
+    const byte = this.data[dataIndex] >> (7 - (offset % 8));
+    return (byte & 1) !== 0;
+  }
+
+  public toBools(): boolean[] {
+    const bools: boolean[] = [];
+    const length = this.length;
+    for (let i = 0; i < length; i++) {
+      bools.push(this.getBool(i));
+    }
+    return bools;
+  }
+
+  public getBit(index: number): 0 | 1 {
+    return this.getBool(index) ? 1 : 0;
+  }
+
+  public toBits(): number[] {
+    const bits: number[] = [];
+    const length = this.length;
+    for (let i = 0; i < length; i++) {
+      bits.push(this.getBit(i));
+    }
+    return bits;
+  }
+
+  public toString(): string {
+    const length = this.length;
+    const chars = Array.from<string>({ length });
+    for (let i = 0; i < length; i++) {
+      chars[i] = this.getBool(i) ? '1' : '0';
+    }
+    return chars.join('');
+  }
+
+  public static fromString(str: string, on: string = '1'): DuckDBBitValue {
+    return DuckDBBitValue.fromLengthAndPredicate(str.length, i => str[i] === on);
+  }
+
+  public static fromBits(bits: readonly number[], on: number = 1): DuckDBBitValue {
+    return DuckDBBitValue.fromLengthAndPredicate(bits.length, i => bits[i] === on);
+  }
+
+  public static fromBools(bools: readonly boolean[]): DuckDBBitValue {
+    return DuckDBBitValue.fromLengthAndPredicate(bools.length, i => bools[i]);
+  }
+
+  public static fromLengthAndPredicate(length: number, predicate: (index: number) => boolean): DuckDBBitValue {
+    const byteCount = Math.ceil(length / 8) + 1;
+    const paddingBitCount = (8 - (length % 8)) % 8;
+
+    const data = new Uint8Array(byteCount);
+    let byteIndex = 0;
+
+    // first byte contains count of padding bits
+    data[byteIndex++] = paddingBitCount;
+
+    let byte = 0;
+    let byteBit = 0;
+
+    // padding consists of 1s in MSB of second byte
+    while (byteBit < paddingBitCount) {
+      byte <<= 1;
+      byte |= 1;
+      byteBit++;
+    }
+
+    let bitIndex = 0;
+
+    while (byteIndex < byteCount) {
+      while (byteBit < 8) {
+        byte <<= 1;
+        if (predicate(bitIndex++)) {
+          byte |= 1;
+        }
+        byteBit++;
+      }
+      data[byteIndex++] = byte;
+      byte = 0;
+      byteBit = 0;
+    }
+
+    return new DuckDBBitValue(data);
+  }
+}
+
+export function bitValue(input: string | readonly boolean[] | readonly number[]): DuckDBBitValue {
+  if (typeof input === 'string') {
+    return DuckDBBitValue.fromString(input);
+  }
+  if (input.length > 0) {
+    if (typeof input[0] === 'boolean') {
+      return DuckDBBitValue.fromBools(input as readonly boolean[]);
+    } else if (typeof input[0] === 'number') {
+      return DuckDBBitValue.fromBits(input as readonly number[]);
+    }
+  }
+  return DuckDBBitValue.fromLengthAndPredicate(0, _ => false);
+}

package/vendor/node-api/src/values/DuckDBBlobValue.ts

@@ -0,0 +1,26 @@
+import { bytesFromString } from '../conversion/bytesFromString';
+import { stringFromBlob } from '../conversion/stringFromBlob';
+
+export class DuckDBBlobValue {
+  public readonly bytes: Uint8Array;
+
+  public constructor(bytes: Uint8Array) {
+    this.bytes = bytes;
+  }
+
+  /** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
+  public toString(): string {
+    return stringFromBlob(this.bytes);
+  }
+
+  public static fromString(str: string): DuckDBBlobValue {
+    return new DuckDBBlobValue(Buffer.from(bytesFromString(str)));
+  }
+}
+
+export function blobValue(input: Uint8Array | string): DuckDBBlobValue {
+  if (typeof input === 'string') {
+    return DuckDBBlobValue.fromString(input);
+  }
+  return new DuckDBBlobValue(input);
+}

package/vendor/node-api/src/values/DuckDBDateValue.ts

@@ -0,0 +1,43 @@
+import duckdb, { Date_, DateParts } from "../../../../src/bindings/index.ts";
+import { getDuckDBDateStringFromDays } from '../conversion/dateTimeStringConversion';
+
+export type { DateParts };
+
+export class DuckDBDateValue implements Date_ {
+  public readonly days: number;
+
+  public constructor(days: number) {
+    this.days = days;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_date(this);
+  }
+
+  public toString(): string {
+    return getDuckDBDateStringFromDays(this.days);
+  }
+
+  public toParts(): DateParts {
+    return duckdb.from_date(this);
+  }
+
+  public static fromParts(parts: DateParts): DuckDBDateValue {
+    return new DuckDBDateValue(duckdb.to_date(parts).days);
+  }
+
+  public static readonly Epoch = new DuckDBDateValue(0);
+
+  public static readonly Max = new DuckDBDateValue(2 ** 31 - 2);
+  public static readonly Min = new DuckDBDateValue(-(2 ** 31 - 2));
+
+  public static readonly PosInf = new DuckDBDateValue(2 ** 31 - 1);
+  public static readonly NegInf = new DuckDBDateValue(-(2 ** 31 - 1));
+}
+
+export function dateValue(daysOrParts: number | DateParts): DuckDBDateValue {
+  if (typeof daysOrParts === 'number') {
+    return new DuckDBDateValue(daysOrParts);
+  }
+  return DuckDBDateValue.fromParts(daysOrParts);
+}

package/vendor/node-api/src/values/DuckDBDecimalValue.ts

@@ -0,0 +1,44 @@
+import duckdb, { Decimal } from "../../../../src/bindings/index.ts";
+import { stringFromDecimal } from '../conversion/stringFromDecimal';
+
+export class DuckDBDecimalValue implements Decimal {
+  /** Total number of decimal digits (including fractional digits) in represented number. */
+  public readonly width: number;
+
+  /** Number of fractional digits in represented number. */
+  public readonly scale: number;
+
+  /** Scaled-up value. Represented number is value/(10^scale). */
+  public readonly value: bigint;
+
+  /**
+   * @param value Scaled-up value. Represented number is value/(10^scale).
+   * @param width Total number of decimal digits (including fractional digits) in represented number.
+   * @param scale Number of fractional digits in represented number.
+   */
+  public constructor(value: bigint, width: number, scale: number) {
+    this.width = width;
+    this.scale = scale;
+    this.value = value;
+  }
+
+  public toString(): string {
+    return stringFromDecimal(this.value, this.scale);
+  }
+
+  public toDouble(): number {
+    return duckdb.decimal_to_double(this);
+  }
+
+  public static fromDouble(double: number, width: number, scale: number): DuckDBDecimalValue {
+    const decimal = duckdb.double_to_decimal(double, width, scale);
+    return new DuckDBDecimalValue(decimal.value, decimal.width, decimal.scale);
+  }
+}
+
+export function decimalValue(value: bigint | number, width: number, scale: number): DuckDBDecimalValue {
+  if (typeof value === 'number') {
+    return DuckDBDecimalValue.fromDouble(value, width, scale);
+  }
+  return new DuckDBDecimalValue(value, width, scale);
+}

package/vendor/node-api/src/values/DuckDBGeometryValue.ts

@@ -0,0 +1,30 @@
+import { bytesFromString } from '../conversion/bytesFromString';
+import { stringFromBlob } from '../conversion/stringFromBlob';
+
+export class DuckDBGeometryValue {
+  /** In WKB. */
+  public readonly bytes: Uint8Array;
+
+  /** Takes raw WKB. */
+  public constructor(bytes: Uint8Array) {
+    this.bytes = bytes;
+  }
+
+  /** Returns WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+  public toString(): string {
+    return stringFromBlob(this.bytes);
+  }
+
+  /** Takes WKB in string form matching DuckDB's BLOB-to-VARCHAR. */
+  public static fromString(str: string): DuckDBGeometryValue {
+    return new DuckDBGeometryValue(Buffer.from(bytesFromString(str)));
+  }
+}
+
+/** Takes WKB, either raw or in string form matching DuckDB's BLOB-to-VARCHAR. */
+export function geometryValue(input: Uint8Array | string): DuckDBGeometryValue {
+  if (typeof input === 'string') {
+    return DuckDBGeometryValue.fromString(input);
+  }
+  return new DuckDBGeometryValue(input);
+}

package/vendor/node-api/src/values/DuckDBIntervalValue.ts

@@ -0,0 +1,22 @@
+import { Interval } from "../../../../src/bindings/index.ts";
+import { getDuckDBIntervalString } from '../conversion/dateTimeStringConversion';
+
+export class DuckDBIntervalValue implements Interval {
+  public readonly months: number;
+  public readonly days: number;
+  public readonly micros: bigint;
+
+  public constructor(months: number, days: number, micros: bigint) {
+    this.months = months;
+    this.days = days;
+    this.micros = micros;
+  }
+
+  public toString(): string {
+    return getDuckDBIntervalString(this.months, this.days, this.micros);
+  }
+}
+
+export function intervalValue(months: number, days: number, micros: bigint): DuckDBIntervalValue {
+  return new DuckDBIntervalValue(months, days, micros);
+}

package/vendor/node-api/src/values/DuckDBListValue.ts

@@ -0,0 +1,18 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+import { DuckDBValue } from './DuckDBValue';
+
+export class DuckDBListValue {
+  public readonly items: readonly DuckDBValue[];
+
+  public constructor(items: readonly DuckDBValue[]) {
+    this.items = items;
+  }
+
+  public toString(): string {
+    return `[${this.items.map(displayStringForDuckDBValue).join(', ')}]`;
+  }
+}
+
+export function listValue(items: readonly DuckDBValue[]): DuckDBListValue {
+  return new DuckDBListValue(items);
+}

package/vendor/node-api/src/values/DuckDBMapValue.ts

@@ -0,0 +1,25 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+import { DuckDBValue } from './DuckDBValue';
+
+export interface DuckDBMapEntry {
+  key: DuckDBValue;
+  value: DuckDBValue;
+}
+
+export class DuckDBMapValue {
+  public readonly entries: DuckDBMapEntry[];
+
+  public constructor(entries: DuckDBMapEntry[]) {
+    this.entries = entries;
+  }
+
+  public toString(): string {
+    return `{${this.entries.map(({ key, value }) =>
+      `${displayStringForDuckDBValue(key)}: ${displayStringForDuckDBValue(value)}`
+    ).join(', ')}}`;
+  }
+}
+
+export function mapValue(entries: DuckDBMapEntry[]): DuckDBMapValue {
+  return new DuckDBMapValue(entries);
+}

package/vendor/node-api/src/values/DuckDBStructValue.ts

@@ -0,0 +1,22 @@
+import { displayStringForDuckDBValue } from '../conversion/displayStringForDuckDBValue';
+import { DuckDBValue } from './DuckDBValue';
+
+export class DuckDBStructValue {
+  public readonly entries: Readonly<Record<string, DuckDBValue>>;
+
+  public constructor(entries: Readonly<Record<string, DuckDBValue>>) {
+    this.entries = entries;
+  }
+
+  public toString(): string {
+    const parts: string[] = [];
+    for (const name in this.entries) {
+      parts.push(`${displayStringForDuckDBValue(name)}: ${displayStringForDuckDBValue(this.entries[name])}`);
+    }
+    return `{${parts.join(', ')}}`;
+  }
+}
+
+export function structValue(entries: Readonly<Record<string, DuckDBValue>>): DuckDBStructValue {
+  return new DuckDBStructValue(entries);
+}

package/vendor/node-api/src/values/DuckDBTimeNSValue.ts

@@ -0,0 +1,23 @@
+import { TimeNS } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimeStringFromNanosecondsInDay } from '../conversion/dateTimeStringConversion';
+
+export class DuckDBTimeNSValue implements TimeNS {
+  public readonly nanos: bigint;
+
+  public constructor(nanos: bigint) {
+    this.nanos = nanos;
+  }
+
+  public toString(): string {
+    return getDuckDBTimeStringFromNanosecondsInDay(this.nanos);
+  }
+
+  public static readonly Max = new DuckDBTimeNSValue(
+    24n * 60n * 60n * 1000n * 1000n * 1000n
+  );
+  public static readonly Min = new DuckDBTimeNSValue(0n);
+}
+
+export function timeNSValue(nanos: bigint): DuckDBTimeNSValue {
+  return new DuckDBTimeNSValue(nanos);
+}

package/vendor/node-api/src/values/DuckDBTimeTZValue.ts

@@ -0,0 +1,96 @@
+import duckdb, { TimeTZ, TimeTZParts } from "../../../../src/bindings/index.ts";
+import {
+  getDuckDBTimeStringFromMicrosecondsInDay,
+  getOffsetStringFromSeconds
+} from '../conversion/dateTimeStringConversion';
+
+export type { TimeTZParts };
+
+export class DuckDBTimeTZValue implements TimeTZ {
+  /**
+   * 40 bits for micros, then 24 bits for encoded offset in seconds.
+   *
+   * Max absolute unencoded offset = 15:59:59 = 60 * (60 * 15 + 59) + 59 = 57599.
+   *
+   * Encoded offset is unencoded offset inverted then shifted (by +57599) to unsigned.
+   *
+   * Max unencoded offset = 57599 -> -57599 -> 0 encoded.
+   *
+   * Min unencoded offset = -57599 -> 57599 -> 115198 encoded.
+   */
+  public readonly bits: bigint;
+
+  /** Ranges from 0 to 86400000000 (= 24 * 60 * 60 * 1000 * 1000) */
+  public readonly micros: bigint;
+
+  /** In seconds, ranges from -57599 to 57599 (= 16 * 60 * 60 - 1) */
+  public readonly offset: number;
+
+  public constructor(bits: bigint, micros: bigint, offset: number) {
+    this.bits = bits;
+    this.micros = micros;
+    this.offset = offset;
+  }
+
+  public toString(): string {
+    return `${getDuckDBTimeStringFromMicrosecondsInDay(
+      this.micros
+    )}${getOffsetStringFromSeconds(this.offset)}`;
+  }
+
+  public toParts(): TimeTZParts {
+    return duckdb.from_time_tz(this);
+  }
+
+  public static TimeBits = 40;
+  public static OffsetBits = 24;
+  public static MaxOffset = 16 * 60 * 60 - 1; // ±15:59:59 = 57599 seconds
+  public static MinOffset = -DuckDBTimeTZValue.MaxOffset;
+  public static MaxMicros = 24n * 60n * 60n * 1000n * 1000n; // 86400000000
+  public static MinMicros = 0n;
+
+  public static fromBits(bits: bigint): DuckDBTimeTZValue {
+    const micros = BigInt.asUintN(
+      DuckDBTimeTZValue.TimeBits,
+      bits >> BigInt(DuckDBTimeTZValue.OffsetBits)
+    );
+    const offset =
+      DuckDBTimeTZValue.MaxOffset -
+      Number(BigInt.asUintN(DuckDBTimeTZValue.OffsetBits, bits));
+    return new DuckDBTimeTZValue(bits, micros, offset);
+  }
+
+  public static fromMicrosAndOffset(
+    micros: bigint,
+    offset: number
+  ): DuckDBTimeTZValue {
+    const bits =
+      (BigInt.asUintN(DuckDBTimeTZValue.TimeBits, micros) <<
+        BigInt(DuckDBTimeTZValue.OffsetBits)) |
+      BigInt.asUintN(
+        DuckDBTimeTZValue.OffsetBits,
+        BigInt(DuckDBTimeTZValue.MaxOffset - offset)
+      );
+    return new DuckDBTimeTZValue(bits, micros, offset);
+  }
+
+  public static fromParts(parts: TimeTZParts): DuckDBTimeTZValue {
+    return DuckDBTimeTZValue.fromMicrosAndOffset(
+      duckdb.to_time(parts.time).micros,
+      parts.offset
+    );
+  }
+
+  public static readonly Max = DuckDBTimeTZValue.fromMicrosAndOffset(
+    DuckDBTimeTZValue.MaxMicros,
+    DuckDBTimeTZValue.MinOffset
+  );
+  public static readonly Min = DuckDBTimeTZValue.fromMicrosAndOffset(
+    DuckDBTimeTZValue.MinMicros,
+    DuckDBTimeTZValue.MaxOffset
+  );
+}
+
+export function timeTZValue(micros: bigint, offset: number): DuckDBTimeTZValue {
+  return DuckDBTimeTZValue.fromMicrosAndOffset(micros, offset);
+}

package/vendor/node-api/src/values/DuckDBTimeValue.ts

@@ -0,0 +1,34 @@
+import duckdb, { Time, TimeParts } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimeStringFromMicrosecondsInDay } from '../conversion/dateTimeStringConversion';
+
+export type { TimeParts };
+
+export class DuckDBTimeValue implements Time {
+  public readonly micros: bigint;
+
+  public constructor(micros: bigint) {
+    this.micros = micros;
+  }
+
+  public toString(): string {
+    return getDuckDBTimeStringFromMicrosecondsInDay(this.micros);
+  }
+
+  public toParts(): TimeParts {
+    return duckdb.from_time(this);
+  }
+
+  public static fromParts(parts: TimeParts): DuckDBTimeValue {
+    return new DuckDBTimeValue(duckdb.to_time(parts).micros);
+  }
+
+  public static readonly Max = new DuckDBTimeValue(24n * 60n * 60n * 1000n * 1000n);
+  public static readonly Min = new DuckDBTimeValue(0n);
+}
+
+export function timeValue(microsOrParts: bigint | TimeParts): DuckDBTimeValue {
+  if (typeof microsOrParts === 'bigint') {
+    return new DuckDBTimeValue(microsOrParts);
+  }
+  return DuckDBTimeValue.fromParts(microsOrParts);
+}

package/vendor/node-api/src/values/DuckDBTimestampMillisecondsValue.ts

@@ -0,0 +1,29 @@
+import duckdb, { TimestampMilliseconds } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromMilliseconds } from '../conversion/dateTimeStringConversion';
+import { DuckDBTimestampSecondsValue } from './DuckDBTimestampSecondsValue';
+
+export class DuckDBTimestampMillisecondsValue implements TimestampMilliseconds {
+  public readonly millis: bigint;
+
+  public constructor(millis: bigint) {
+    this.millis = millis;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp_ms(this);
+  }
+
+  public toString(): string {
+    return getDuckDBTimestampStringFromMilliseconds(this.millis);
+  }
+
+  public static readonly Epoch = new DuckDBTimestampMillisecondsValue(0n);
+  public static readonly Max = new DuckDBTimestampMillisecondsValue((2n ** 63n - 2n) / 1000n);
+  public static readonly Min = new DuckDBTimestampMillisecondsValue(DuckDBTimestampSecondsValue.Min.seconds * 1000n);
+  public static readonly PosInf = new DuckDBTimestampMillisecondsValue(2n ** 63n - 1n);
+  public static readonly NegInf = new DuckDBTimestampMillisecondsValue(-(2n ** 63n - 1n));
+}
+
+export function timestampMillisValue(millis: bigint): DuckDBTimestampMillisecondsValue {
+  return new DuckDBTimestampMillisecondsValue(millis);
+}

package/vendor/node-api/src/values/DuckDBTimestampNanosecondsValue.ts

@@ -0,0 +1,28 @@
+import duckdb, { TimestampNanoseconds } from "../../../../src/bindings/index.ts";
+import { getDuckDBTimestampStringFromNanoseconds } from '../conversion/dateTimeStringConversion';
+
+export class DuckDBTimestampNanosecondsValue implements TimestampNanoseconds {
+  public readonly nanos: bigint;
+
+  public constructor(nanos: bigint) {
+    this.nanos = nanos;
+  }
+
+  public get isFinite(): boolean {
+    return duckdb.is_finite_timestamp_ns(this);
+  }
+
+  public toString(): string {
+    return getDuckDBTimestampStringFromNanoseconds(this.nanos);
+  }
+
+  public static readonly Epoch = new DuckDBTimestampNanosecondsValue(0n);
+  public static readonly Max = new DuckDBTimestampNanosecondsValue(2n ** 63n - 2n);
+  public static readonly Min = new DuckDBTimestampNanosecondsValue(-9223286400000000000n);
+  public static readonly PosInf = new DuckDBTimestampNanosecondsValue(2n ** 63n - 1n);
+  public static readonly NegInf = new DuckDBTimestampNanosecondsValue(-(2n ** 63n - 1n));
+}
+
+export function timestampNanosValue(nanos: bigint): DuckDBTimestampNanosecondsValue {
+  return new DuckDBTimestampNanosecondsValue(nanos);
+}