@avidian/duckdb-bun 0.0.0-stage → 1.0.1

package/vendor/node-api/src/conversion/stringFromBlob.ts

@@ -0,0 +1,48 @@
+/** Matches BLOB-to-VARCHAR conversion behavior of DuckDB. */
+export function stringFromBlob(bytes: Uint8Array): string {
+  // String concatenation appears to be faster for this function at smaller sizes.
+  // Threshold of (2^16) experimentally determined on a MacBook Pro (M2 Max).
+  // See stringFromBlob.bench.ts.
+  if (bytes.length <= 65536) {
+    return stringFromBlobStringConcat(bytes);
+  }
+  return stringFromBlobArrayJoin(bytes);
+}
+
+export function stringFromBlobStringConcat(bytes: Uint8Array): string {
+  let byteString: string = '';
+
+  for (const byte of bytes) {
+    if (
+      byte <= 0x1f ||
+      byte === 0x22 /* double quote */ ||
+      byte === 0x27 /* single quote */ ||
+      byte >= 0x7f
+    ) {
+      byteString += `\\x${byte.toString(16).toUpperCase().padStart(2, '0')}`;
+    } else {
+      byteString += String.fromCharCode(byte);
+    }
+  }
+  return byteString;
+}
+
+export function stringFromBlobArrayJoin(bytes: Uint8Array): string {
+  const byteStrings: string[] = [];
+
+  for (const byte of bytes) {
+    if (
+      byte <= 0x1f ||
+      byte === 0x22 /* double quote */ ||
+      byte === 0x27 /* single quote */ ||
+      byte >= 0x7f
+    ) {
+      byteStrings.push(
+        `\\x${byte.toString(16).toUpperCase().padStart(2, '0')}`
+      );
+    } else {
+      byteStrings.push(String.fromCharCode(byte));
+    }
+  }
+  return byteStrings.join('');
+}

package/vendor/node-api/src/conversion/stringFromDecimal.ts

@@ -0,0 +1,129 @@
+/**
+ * Decimal string formatting.
+ *
+ * Supports a subset of the functionality of `BigInt.prototype.toLocaleString` for locale-specific formatting.
+ */
+
+/*
+ * Locale formatting options for DuckDBDecimal.
+ *
+ * This is a subset of the options available for `BigInt.prototype.toLocaleString`
+ */
+export interface DuckDBDecimalFormatOptions {
+  useGrouping?: boolean;
+  minimumFractionDigits?: number;
+  maximumFractionDigits?: number;
+}
+
+export interface LocaleOptions {
+  locales?: string | string[];
+  options?: DuckDBDecimalFormatOptions;
+}
+
+/*
+ * Get the decimal separator for a given locale.
+ * Somewhat expensive, so use getCachedDecimalSeparator if you need to call this multiple times.
+ */
+
+function getDecimalSeparator(locales?: string | string[]): string {
+  const decimalSeparator =
+    new Intl.NumberFormat(locales, { useGrouping: false })
+      .formatToParts(0.1)
+      .find((part) => part.type === 'decimal')?.value ?? '.';
+  return decimalSeparator;
+}
+
+/*
+ * Get the decimal separator for a given locale, and cache the result.
+ */
+const cachedDecimalSeparators: { [localeKey: string]: string } = {};
+
+function getCachedDecimalSeparator(locales?: string | string[]): string {
+  const cacheKey = JSON.stringify(locales);
+  if (cacheKey in cachedDecimalSeparators) {
+    return cachedDecimalSeparators[cacheKey];
+  }
+  const decimalSeparator = getDecimalSeparator(locales);
+  cachedDecimalSeparators[cacheKey] = decimalSeparator;
+  return decimalSeparator;
+}
+
+// Helper function to format whole part of a decimal value.
+// Note that we explicitly omit 'minimumFractionDigits' and 'maximumFractionDigits' from the options
+// passed to toLocaleString, because they are only relevant for the fractional part of the number, and
+// would result in formatting the whole part as a real number, which we don't want.
+function formatWholePart(
+  localeOptions: LocaleOptions | undefined,
+  val: bigint,
+): string {
+  if (localeOptions) {
+    const {
+      minimumFractionDigits: _minFD,
+      maximumFractionDigits: _maxFD,
+      ...restOptions
+    } = localeOptions.options ?? {};
+    return val.toLocaleString(localeOptions?.locales, restOptions);
+  }
+  return String(val);
+}
+
+// Format the fractional part of a decimal value
+// Note that we must handle minimumFractionDigits and maximumFractionDigits ourselves, and that
+// we don't apply `useGrouping` because that only applies to the whole part of the number.
+function formatFractionalPart(
+  localeOptions: LocaleOptions | undefined,
+  val: bigint,
+  scale: number,
+): string {
+  const fractionalPartStr = String(val).padStart(scale, '0');
+  if (!localeOptions) {
+    return fractionalPartStr;
+  }
+  const minFracDigits = localeOptions?.options?.minimumFractionDigits ?? 0;
+  const maxFracDigits = localeOptions?.options?.maximumFractionDigits ?? 20;
+
+  return fractionalPartStr.padEnd(minFracDigits, '0').slice(0, maxFracDigits);
+}
+
+/**
+ * Convert a scaled decimal value to a string, possibly using locale-specific formatting.
+ */
+export function stringFromDecimal(
+  scaledValue: bigint,
+  scale: number,
+  localeOptions?: LocaleOptions,
+): string {
+  // Decimal values are represented as integers that have been scaled up by a power of ten. The `scale` property of
+  // the type is the exponent of the scale factor. For a scale greater than zero, we need to separate out the
+  // fractional part by reversing this scaling.
+  if (scale > 0) {
+    const scaleFactor = BigInt(10) ** BigInt(scale);
+    const absScaledValue = scaledValue < 0 ? -scaledValue : scaledValue;
+
+    const prefix = scaledValue < 0 ? '-' : '';
+
+    const wholePartNum = absScaledValue / scaleFactor;
+    const wholePartStr = formatWholePart(localeOptions, wholePartNum);
+
+    const fractionalPartNum = absScaledValue % scaleFactor;
+    const fractionalPartStr = formatFractionalPart(
+      localeOptions,
+      fractionalPartNum,
+      scale,
+    );
+
+    const decimalSeparatorStr = localeOptions
+      ? getCachedDecimalSeparator(localeOptions.locales)
+      : '.';
+
+    return `${prefix}${wholePartStr}${decimalSeparatorStr}${fractionalPartStr}`;
+  }
+  // For a scale of zero, there is no fractional part, so a direct string conversion works.
+  if (localeOptions) {
+    return scaledValue.toLocaleString(
+      localeOptions?.locales,
+      localeOptions?.options as BigIntToLocaleStringOptions | undefined,
+    );
+  }
+  return String(scaledValue);
+}

package/vendor/node-api/src/conversion/varintDecode.ts

@@ -0,0 +1,42 @@
+/**
+ * Decodes an unsigned LEB128 (little-endian base-128) varint at
+ * `view[offset]`. Each byte contributes 7 bits of payload; the high bit is
+ * a continuation flag.
+ *
+ * Returns the decoded `value` and the byte position `nextOffset` immediately
+ * after the varint. Throws if the varint:
+ *   - reads past the end of `view` (truncated),
+ *   - exceeds 2**32-1 (overflow).
+ *
+ * Uses arithmetic (not bitwise) accumulation so values up to 2**32-1
+ * round-trip correctly — JS bitwise operators coerce to signed int32 and
+ * would turn 0xffffffff into -1.
+ */
+export function varintDecode(
+  view: DataView,
+  offset: number
+): { value: number; nextOffset: number } {
+  let value = 0;
+  let multiplier = 1;
+  let cur = offset;
+  while (true) {
+    if (cur >= view.byteLength) {
+      throw new Error('varint truncated');
+    }
+    const byte = view.getUint8(cur++);
+    value += (byte & 0x7f) * multiplier;
+    if ((byte & 0x80) === 0) {
+      break;
+    }
+    multiplier *= 128;
+    if (multiplier > 0x80000000) {
+      // multiplier == 128**5 means we're about to process a 6th byte —
+      // even a single payload bit beyond would push past 2**32-1.
+      throw new Error('varint overflow');
+    }
+  }
+  if (value > 0xffffffff) {
+    throw new Error('varint overflow');
+  }
+  return { value, nextOffset: cur };
+}

package/vendor/node-api/src/convertColumnsFromChunks.ts

@@ -0,0 +1,28 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+
+export function convertColumnsFromChunks<T>(
+  chunks: readonly DuckDBDataChunk[],
+  columnCount: number,
+  converter: DuckDBValueConverter<T>
+): (T | null)[][] {
+  if (chunks.length === 0) {
+    return Array.from({ length: columnCount }, () => []);
+  }
+  const convertedColumns = chunks[0].convertColumns(converter);
+  for (let chunkIndex = 1; chunkIndex < chunks.length; chunkIndex++) {
+    for (
+      let columnIndex = 0;
+      columnIndex < convertedColumns.length;
+      columnIndex++
+    ) {
+      const chunk = chunks[chunkIndex];
+      chunk.visitColumnValues(
+        columnIndex,
+        (value, _rowIndex, _columnIndex, type) =>
+          convertedColumns[columnIndex].push(converter(value, type, converter))
+      );
+    }
+  }
+  return convertedColumns;
+}

package/vendor/node-api/src/convertColumnsObjectFromChunks.ts

@@ -0,0 +1,29 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+
+export function convertColumnsObjectFromChunks<T>(
+  chunks: readonly DuckDBDataChunk[],
+  columnNames: readonly string[],
+  converter: DuckDBValueConverter<T>
+): Record<string, (T | null)[]> {
+  const convertedColumnsObject: Record<string, (T | null)[]> = {};
+  for (const columnName of columnNames) {
+    convertedColumnsObject[columnName] = [];
+  }
+  if (chunks.length === 0) {
+    return convertedColumnsObject;
+  }
+  const columnCount = chunks[0].columnCount;
+  for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+    for (let columnIndex = 0; columnIndex < columnCount; columnIndex++) {
+      chunks[chunkIndex].visitColumnValues(
+        columnIndex,
+        (value, _rowIndex, _columnIndex, type) =>
+          convertedColumnsObject[columnNames[columnIndex]].push(
+            converter(value, type, converter)
+          )
+      );
+    }
+  }
+  return convertedColumnsObject;
+}

package/vendor/node-api/src/convertRowObjectsFromChunks.ts

@@ -0,0 +1,21 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+
+export function convertRowObjectsFromChunks<T>(
+  chunks: readonly DuckDBDataChunk[],
+  columnNames: readonly string[],
+  converter: DuckDBValueConverter<T>
+): Record<string, T | null>[] {
+  const rowObjects: Record<string, T | null>[] = [];
+  for (const chunk of chunks) {
+    const rowCount = chunk.rowCount;
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+      const rowObject: Record<string, T | null> = {};
+      chunk.visitRowValues(rowIndex, (value, _rowIndex, columnIndex, type) => {
+        rowObject[columnNames[columnIndex]] = converter(value, type, converter);
+      });
+      rowObjects.push(rowObject);
+    }
+  }
+  return rowObjects;
+}

package/vendor/node-api/src/convertRowsFromChunks.ts

@@ -0,0 +1,16 @@
+import { DuckDBDataChunk } from './DuckDBDataChunk';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+
+export function convertRowsFromChunks<T>(
+  chunks: readonly DuckDBDataChunk[],
+  converter: DuckDBValueConverter<T>
+): (T | null)[][] {
+  const rows: (T | null)[][] = [];
+  for (const chunk of chunks) {
+    const rowCount = chunk.rowCount;
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+      rows.push(chunk.convertRowValues(rowIndex, converter));
+    }
+  }
+  return rows;
+}

package/vendor/node-api/src/createConfig.ts

@@ -0,0 +1,14 @@
+import duckdb from "../../../src/bindings/index.ts";
+
+export function createConfig(options?: Record<string, string>): duckdb.Config {
+  const config = duckdb.create_config();
+  // Set the default duckdb_api value for the api. Can be overridden.
+  duckdb.set_config(config, 'duckdb_api', 'node-neo-api');
+  if (options) {
+    for (const optionName in options) {
+      const optionValue = String(options[optionName]);
+      duckdb.set_config(config, optionName, optionValue);
+    }
+  }
+  return config;
+}

package/vendor/node-api/src/createDuckDBValueConverter.ts

@@ -0,0 +1,17 @@
+import { DuckDBTypeId } from './DuckDBTypeId';
+import { DuckDBValueConverter } from './DuckDBValueConverter';
+
+export function createDuckDBValueConverter<T>(
+  convertersByTypeId: Record<DuckDBTypeId, DuckDBValueConverter<T> | undefined>
+): DuckDBValueConverter<T> {
+  return (value, type, converter) => {
+    if (value == null) {
+      return null;
+    }
+    const converterForTypeId = convertersByTypeId[type.typeId];
+    if (!converterForTypeId) {
+      throw new Error(`No converter for typeId: ${type.typeId}`);
+    }
+    return converterForTypeId(value, type, converter);
+  };
+}

package/vendor/node-api/src/createResult.ts

@@ -0,0 +1,15 @@
+import duckdb from "../../../src/bindings/index.ts";
+import { DuckDBMaterializedResult } from './DuckDBMaterializedResult';
+import { DuckDBResult } from './DuckDBResult';
+import { StatementType } from './enums';
+
+export function createResult(
+  result: duckdb.Result,
+  preparedStatementType?: StatementType
+) {
+  if (duckdb.result_is_streaming(result)) {
+    return new DuckDBResult(result, preparedStatementType);
+  } else {
+    return new DuckDBMaterializedResult(result, preparedStatementType);
+  }
+}