@duckdbfan/drizzle-duckdb 0.0.6 → 1.3.1

package/src/sql/result-mapper.ts

@@ -0,0 +1,303 @@
+import {
+  Column,
+  SQL,
+  getTableName,
+  is,
+  type AnyColumn,
+  type DriverValueDecoder,
+  type SelectedFieldsOrdered,
+} from 'drizzle-orm';
+import {
+  PgCustomColumn,
+  PgDate,
+  PgDateString,
+  PgInterval,
+  PgTime,
+  PgTimestamp,
+  PgTimestampString,
+} from 'drizzle-orm/pg-core';
+
+type SQLInternal<T = unknown> = SQL<T> & {
+  decoder: DriverValueDecoder<T, any>;
+};
+
+type DecoderInput<TDecoder extends DriverValueDecoder<unknown, unknown>> =
+  Parameters<TDecoder['mapFromDriverValue']>[0];
+
+function toDecoderInput<TDecoder extends DriverValueDecoder<unknown, unknown>>(
+  decoder: TDecoder,
+  value: unknown
+): DecoderInput<TDecoder> {
+  void decoder;
+  return value as DecoderInput<TDecoder>;
+}
+
+export function normalizeInet(value: unknown): unknown {
+  if (
+    value &&
+    typeof value === 'object' &&
+    'address' in value &&
+    typeof (value as { address: unknown }).address !== 'undefined'
+  ) {
+    const { address, mask } = value as {
+      address: bigint | number;
+      mask?: number;
+    };
+
+    if (typeof address === 'bigint' || typeof address === 'number') {
+      const inet = typeof address === 'number' ? BigInt(address) : address;
+      const maxIpv4 = (1n << 32n) - 1n;
+      if (inet >= 0 && inet <= maxIpv4) {
+        const num = Number(inet);
+        const octets = [
+          (num >>> 24) & 255,
+          (num >>> 16) & 255,
+          (num >>> 8) & 255,
+          num & 255,
+        ];
+        const suffix =
+          typeof mask === 'number' && mask !== 32 ? `/${mask}` : '';
+        return `${octets.join('.')}${suffix}`;
+      }
+    }
+
+    const fallback = (value as { toString?: () => string }).toString?.();
+    if (fallback && fallback !== '[object Object]') {
+      return fallback;
+    }
+  }
+
+  return value;
+}
+
+export function normalizeTimestampString(
+  value: unknown,
+  withTimezone: boolean
+): string | unknown {
+  if (value instanceof Date) {
+    const iso = value.toISOString().replace('T', ' ');
+    return withTimezone ? iso.replace('Z', '+00') : iso.replace('Z', '');
+  }
+  if (typeof value === 'string') {
+    const normalized = value.replace('T', ' ');
+    if (withTimezone) {
+      return normalized.includes('+') ? normalized : `${normalized}+00`;
+    }
+    return normalized.replace(/\+00$/, '');
+  }
+  return value;
+}
+
+export function normalizeTimestamp(
+  value: unknown,
+  withTimezone: boolean
+): Date | unknown {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const hasOffset =
+      value.endsWith('Z') || /[+-]\d{2}:?\d{2}$/.test(value.trim());
+    const spaced = value.replace(' ', 'T');
+    const normalized = withTimezone || hasOffset ? spaced : `${spaced}+00`;
+    return new Date(normalized);
+  }
+  return value;
+}
+
+export function normalizeDateString(value: unknown): string | unknown {
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === 'string') {
+    return value.slice(0, 10);
+  }
+  return value;
+}
+
+export function normalizeDateValue(value: unknown): Date | unknown {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    return new Date(`${value.slice(0, 10)}T00:00:00Z`);
+  }
+  return value;
+}
+
+export function normalizeTime(value: unknown): string | unknown {
+  if (typeof value === 'bigint') {
+    const totalMillis = Number(value) / 1000;
+    const date = new Date(totalMillis);
+    return date.toISOString().split('T')[1]!.replace('Z', '');
+  }
+  if (value instanceof Date) {
+    return value.toISOString().split('T')[1]!.replace('Z', '');
+  }
+  return value;
+}
+
+export function normalizeInterval(value: unknown): string | unknown {
+  if (
+    value &&
+    typeof value === 'object' &&
+    'days' in value &&
+    'months' in value
+  ) {
+    const { months, days, micros } = value as {
+      months: number;
+      days: number;
+      micros?: number | string;
+    };
+
+    if (months === 0 && days !== undefined) {
+      if (micros && Number(micros) !== 0) {
+        const seconds = Number(micros) / 1_000_000;
+        return `${days} day${days === 1 ? '' : 's'} ${seconds} seconds`.trim();
+      }
+      return `${days} day${days === 1 ? '' : 's'}`;
+    }
+  }
+  return value;
+}
+
+function mapDriverValue(
+  decoder: DriverValueDecoder<unknown, unknown>,
+  rawValue: unknown
+): unknown {
+  if (is(decoder, PgTimestampString)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(
+        decoder,
+        normalizeTimestampString(rawValue, decoder.withTimezone)
+      )
+    );
+  }
+
+  if (is(decoder, PgTimestamp)) {
+    const normalized = normalizeTimestamp(rawValue, decoder.withTimezone);
+    if (normalized instanceof Date) {
+      return normalized;
+    }
+    return decoder.mapFromDriverValue(toDecoderInput(decoder, normalized));
+  }
+
+  if (is(decoder, PgDateString)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeDateString(rawValue))
+    );
+  }
+
+  if (is(decoder, PgDate)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeDateValue(rawValue))
+    );
+  }
+
+  if (is(decoder, PgTime)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeTime(rawValue))
+    );
+  }
+
+  if (is(decoder, PgInterval)) {
+    return decoder.mapFromDriverValue(
+      toDecoderInput(decoder, normalizeInterval(rawValue))
+    );
+  }
+
+  return decoder.mapFromDriverValue(toDecoderInput(decoder, rawValue));
+}
+
+export function mapResultRow<TResult>(
+  columns: SelectedFieldsOrdered<AnyColumn>,
+  row: unknown[],
+  joinsNotNullableMap: Record<string, boolean> | undefined
+): TResult {
+  const nullifyMap: Record<string, string | false> = {};
+
+  const result = columns.reduce<Record<string, any>>(
+    (acc, { path, field }, columnIndex) => {
+      let decoder: DriverValueDecoder<unknown, unknown>;
+      if (is(field, Column)) {
+        decoder = field;
+      } else if (is(field, SQL)) {
+        decoder = (field as SQLInternal).decoder;
+      } else {
+        const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+
+        if (is(col, PgCustomColumn)) {
+          decoder = col;
+        } else {
+          decoder = (field.sql as SQLInternal).decoder;
+        }
+      }
+      let node = acc;
+      for (const [pathChunkIndex, pathChunk] of path.entries()) {
+        if (pathChunkIndex < path.length - 1) {
+          if (!(pathChunk in node)) {
+            node[pathChunk] = {};
+          }
+          node = node[pathChunk];
+          continue;
+        }
+
+        const rawValue = normalizeInet(row[columnIndex]!);
+
+        const value = (node[pathChunk] =
+          rawValue === null ? null : mapDriverValue(decoder, rawValue));
+
+        if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+          const objectName = path[0]!;
+          if (!(objectName in nullifyMap)) {
+            nullifyMap[objectName] =
+              value === null ? getTableName(field.table) : false;
+          } else if (
+            typeof nullifyMap[objectName] === 'string' &&
+            nullifyMap[objectName] !== getTableName(field.table)
+          ) {
+            nullifyMap[objectName] = false;
+          }
+          continue;
+        }
+
+        if (
+          joinsNotNullableMap &&
+          is(field, SQL.Aliased) &&
+          path.length === 2
+        ) {
+          const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+          const tableName = col?.table && getTableName(col?.table);
+
+          if (!tableName) {
+            continue;
+          }
+
+          const objectName = path[0]!;
+
+          if (!(objectName in nullifyMap)) {
+            nullifyMap[objectName] = value === null ? tableName : false;
+            continue;
+          }
+
+          if (nullifyMap[objectName] && nullifyMap[objectName] !== tableName) {
+            nullifyMap[objectName] = false;
+          }
+          continue;
+        }
+      }
+      return acc;
+    },
+    {}
+  );
+
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+
+  return result as TResult;
+}

package/src/sql/selection.ts

@@ -0,0 +1,60 @@
+import { Column, SQL, getTableName, is, sql } from 'drizzle-orm';
+import type { SelectedFields } from 'drizzle-orm/pg-core';
+
+function mapEntries(
+  obj: Record<string, unknown>,
+  prefix?: string,
+  fullJoin = false
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(obj)
+      .filter(([key]) => key !== 'enableRLS')
+      .map(([key, value]) => {
+        const qualified = prefix ? `${prefix}.${key}` : key;
+
+        if (fullJoin && is(value, Column)) {
+          return [
+            key,
+            sql`${value}`
+              .mapWith(value)
+              .as(`${getTableName(value.table)}.${value.name}`),
+          ];
+        }
+
+        if (fullJoin && is(value, SQL)) {
+          const col = value
+            .getSQL()
+            .queryChunks.find((chunk) => is(chunk, Column));
+
+          const tableName = col?.table && getTableName(col?.table);
+
+          return [key, value.as(tableName ? `${tableName}.${key}` : key)];
+        }
+
+        if (is(value, SQL) || is(value, Column)) {
+          const aliased = is(value, SQL) ? value : sql`${value}`.mapWith(value);
+          return [key, aliased.as(qualified)];
+        }
+
+        if (is(value, SQL.Aliased)) {
+          return [key, value];
+        }
+
+        if (typeof value === 'object' && value !== null) {
+          return [
+            key,
+            mapEntries(value as Record<string, unknown>, qualified, fullJoin),
+          ];
+        }
+
+        return [key, value];
+      })
+  );
+}
+
+export function aliasFields(
+  fields: SelectedFields,
+  fullJoin = false
+): SelectedFields {
+  return mapEntries(fields, undefined, fullJoin) as SelectedFields;
+}

package/src/sql/visitors/array-operators.ts

@@ -0,0 +1,214 @@
+/**
+ * AST visitor to transform Postgres array operators to DuckDB functions.
+ */
+
+import type {
+  AST,
+  Binary,
+  ExpressionValue,
+  Select,
+  From,
+  Join,
+} from 'node-sql-parser';
+
+const OPERATOR_MAP: Record<string, { fn: string; swap?: boolean }> = {
+  '@>': { fn: 'array_has_all' },
+  '<@': { fn: 'array_has_all', swap: true },
+  '&&': { fn: 'array_has_any' },
+};
+
+function walkExpression(
+  expr: ExpressionValue | null | undefined,
+  parent?: object,
+  key?: string
+): boolean {
+  if (!expr || typeof expr !== 'object') return false;
+
+  let transformed = false;
+  const exprObj = expr as Record<string, unknown>;
+
+  if ('type' in expr && exprObj.type === 'binary_expr') {
+    const binary = expr as Binary;
+    const mapping = OPERATOR_MAP[binary.operator];
+
+    if (mapping) {
+      const fnExpr = {
+        type: 'function' as const,
+        name: { name: [{ type: 'default', value: mapping.fn }] },
+        args: {
+          type: 'expr_list' as const,
+          value: mapping.swap
+            ? [binary.right, binary.left]
+            : [binary.left, binary.right],
+        },
+      };
+
+      if (parent && key) {
+        (parent as Record<string, unknown>)[key] = fnExpr;
+      }
+      transformed = true;
+    } else {
+      transformed =
+        walkExpression(binary.left as ExpressionValue, binary, 'left') ||
+        transformed;
+      transformed =
+        walkExpression(binary.right as ExpressionValue, binary, 'right') ||
+        transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'unary_expr') {
+    if ('expr' in exprObj) {
+      transformed =
+        walkExpression(exprObj.expr as ExpressionValue, exprObj, 'expr') ||
+        transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'case') {
+    if ('expr' in exprObj && exprObj.expr) {
+      transformed =
+        walkExpression(exprObj.expr as ExpressionValue, exprObj, 'expr') ||
+        transformed;
+    }
+    if ('args' in exprObj && Array.isArray(exprObj.args)) {
+      for (let i = 0; i < exprObj.args.length; i++) {
+        const whenClause = exprObj.args[i] as Record<string, unknown>;
+        if (whenClause.cond) {
+          transformed =
+            walkExpression(
+              whenClause.cond as ExpressionValue,
+              whenClause,
+              'cond'
+            ) || transformed;
+        }
+        if (whenClause.result) {
+          transformed =
+            walkExpression(
+              whenClause.result as ExpressionValue,
+              whenClause,
+              'result'
+            ) || transformed;
+        }
+      }
+    }
+  }
+
+  if ('args' in expr && exprObj.args) {
+    const args = exprObj.args as Record<string, unknown>;
+    if ('value' in args && Array.isArray(args.value)) {
+      for (let i = 0; i < args.value.length; i++) {
+        transformed =
+          walkExpression(
+            args.value[i] as ExpressionValue,
+            args.value,
+            String(i)
+          ) || transformed;
+      }
+    } else if ('expr' in args) {
+      transformed =
+        walkExpression(args.expr as ExpressionValue, args, 'expr') ||
+        transformed;
+    }
+  }
+
+  if ('ast' in exprObj && exprObj.ast) {
+    const subAst = exprObj.ast as Select;
+    if (subAst.type === 'select') {
+      transformed = walkSelectImpl(subAst) || transformed;
+    }
+  }
+
+  if ('type' in expr && exprObj.type === 'expr_list') {
+    if ('value' in exprObj && Array.isArray(exprObj.value)) {
+      for (let i = 0; i < exprObj.value.length; i++) {
+        transformed =
+          walkExpression(
+            exprObj.value[i] as ExpressionValue,
+            exprObj.value,
+            String(i)
+          ) || transformed;
+      }
+    }
+  }
+
+  return transformed;
+}
+
+function walkFrom(from: From[] | null | undefined): boolean {
+  if (!from || !Array.isArray(from)) return false;
+
+  let transformed = false;
+
+  for (const f of from) {
+    if ('join' in f) {
+      const join = f as Join;
+      transformed = walkExpression(join.on, join, 'on') || transformed;
+    }
+    if ('expr' in f && f.expr && 'ast' in f.expr) {
+      transformed = walkSelectImpl(f.expr.ast) || transformed;
+    }
+  }
+
+  return transformed;
+}
+
+function walkSelectImpl(select: Select): boolean {
+  let transformed = false;
+
+  if (select.with) {
+    for (const cte of select.with) {
+      const cteSelect = cte.stmt?.ast ?? cte.stmt;
+      if (cteSelect && cteSelect.type === 'select') {
+        transformed = walkSelectImpl(cteSelect as Select) || transformed;
+      }
+    }
+  }
+
+  if (Array.isArray(select.from)) {
+    transformed = walkFrom(select.from) || transformed;
+  }
+
+  transformed = walkExpression(select.where, select, 'where') || transformed;
+
+  if (select.having) {
+    if (Array.isArray(select.having)) {
+      for (let i = 0; i < select.having.length; i++) {
+        transformed =
+          walkExpression(select.having[i], select.having, String(i)) ||
+          transformed;
+      }
+    } else {
+      transformed =
+        walkExpression(select.having as ExpressionValue, select, 'having') ||
+        transformed;
+    }
+  }
+
+  if (Array.isArray(select.columns)) {
+    for (const col of select.columns) {
+      if ('expr' in col) {
+        transformed = walkExpression(col.expr, col, 'expr') || transformed;
+      }
+    }
+  }
+
+  if (select._next) {
+    transformed = walkSelectImpl(select._next) || transformed;
+  }
+
+  return transformed;
+}
+
+export function transformArrayOperators(ast: AST | AST[]): boolean {
+  const statements = Array.isArray(ast) ? ast : [ast];
+  let transformed = false;
+
+  for (const stmt of statements) {
+    if (stmt.type === 'select') {
+      transformed = walkSelectImpl(stmt as Select) || transformed;
+    }
+  }
+
+  return transformed;
+}