@leonardovida-md/drizzle-neo-duckdb 1.0.0

package/dist/duckdb-introspect.mjs

@@ -0,0 +1,1364 @@
+#!/usr/bin/env node
+
+// src/bin/duckdb-introspect.ts
+import { DuckDBInstance } from "@duckdb/node-api";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+// src/driver.ts
+import { entityKind as entityKind3 } from "drizzle-orm/entity";
+import { DefaultLogger } from "drizzle-orm/logger";
+import { PgDatabase } from "drizzle-orm/pg-core/db";
+import {
+  createTableRelationsHelpers,
+  extractTablesRelationalConfig
+} from "drizzle-orm/relations";
+
+// src/session.ts
+import { entityKind } from "drizzle-orm/entity";
+import { NoopLogger } from "drizzle-orm/logger";
+import { PgTransaction } from "drizzle-orm/pg-core";
+import { PgPreparedQuery, PgSession } from "drizzle-orm/pg-core/session";
+import { fillPlaceholders, sql } from "drizzle-orm/sql/sql";
+
+// src/sql/query-rewriters.ts
+var tableIdPropSelectionRegex = new RegExp([
+  `("(.+)"\\."(.+)")`,
+  `(\\s+as\\s+'?(.+?)'?\\.'?(.+?)'?)?`
+].join(""), "i");
+function adaptArrayOperators(query) {
+  const operators = [
+    { token: "@>", fn: "array_has_all" },
+    { token: "<@", fn: "array_has_all", swap: true },
+    { token: "&&", fn: "array_has_any" }
+  ];
+  const isWhitespace = (char) => char !== undefined && /\s/.test(char);
+  const walkLeft = (source, start) => {
+    let idx = start;
+    while (idx >= 0 && isWhitespace(source[idx])) {
+      idx--;
+    }
+    let depth = 0;
+    let inString = false;
+    for (;idx >= 0; idx--) {
+      const ch = source[idx];
+      if (ch === "'" && source[idx - 1] !== "\\") {
+        inString = !inString;
+      }
+      if (inString)
+        continue;
+      if (ch === ")" || ch === "]") {
+        depth++;
+      } else if (ch === "(" || ch === "[") {
+        depth--;
+        if (depth < 0) {
+          return [idx + 1, source.slice(idx + 1, start + 1)];
+        }
+      } else if (depth === 0 && isWhitespace(ch)) {
+        return [idx + 1, source.slice(idx + 1, start + 1)];
+      }
+    }
+    return [0, source.slice(0, start + 1)];
+  };
+  const walkRight = (source, start) => {
+    let idx = start;
+    while (idx < source.length && isWhitespace(source[idx])) {
+      idx++;
+    }
+    let depth = 0;
+    let inString = false;
+    for (;idx < source.length; idx++) {
+      const ch = source[idx];
+      if (ch === "'" && source[idx - 1] !== "\\") {
+        inString = !inString;
+      }
+      if (inString)
+        continue;
+      if (ch === "(" || ch === "[") {
+        depth++;
+      } else if (ch === ")" || ch === "]") {
+        depth--;
+        if (depth < 0) {
+          return [idx, source.slice(start, idx)];
+        }
+      } else if (depth === 0 && isWhitespace(ch)) {
+        return [idx, source.slice(start, idx)];
+      }
+    }
+    return [source.length, source.slice(start)];
+  };
+  let rewritten = query;
+  for (const { token, fn, swap } of operators) {
+    let idx = rewritten.indexOf(token);
+    while (idx !== -1) {
+      const [leftStart, leftExpr] = walkLeft(rewritten, idx - 1);
+      const [rightEnd, rightExpr] = walkRight(rewritten, idx + token.length);
+      const left = leftExpr.trim();
+      const right = rightExpr.trim();
+      const replacement = `${fn}(${swap ? right : left}, ${swap ? left : right})`;
+      rewritten = rewritten.slice(0, leftStart) + replacement + rewritten.slice(rightEnd);
+      idx = rewritten.indexOf(token, leftStart + replacement.length);
+    }
+  }
+  return rewritten;
+}
+
+// src/sql/result-mapper.ts
+import {
+  Column,
+  SQL,
+  getTableName,
+  is
+} from "drizzle-orm";
+import {
+  PgCustomColumn,
+  PgDate,
+  PgDateString,
+  PgInterval,
+  PgTime,
+  PgTimestamp,
+  PgTimestampString
+} from "drizzle-orm/pg-core";
+function toDecoderInput(decoder, value) {
+  return value;
+}
+function normalizeInet(value) {
+  if (value && typeof value === "object" && "address" in value && typeof value.address !== "undefined") {
+    const { address, mask } = value;
+    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.toString?.();
+    if (fallback && fallback !== "[object Object]") {
+      return fallback;
+    }
+  }
+  return value;
+}
+function normalizeTimestampString(value, withTimezone) {
+  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;
+}
+function normalizeTimestamp(value, withTimezone) {
+  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;
+}
+function normalizeDateString(value) {
+  if (value instanceof Date) {
+    return value.toISOString().slice(0, 10);
+  }
+  if (typeof value === "string") {
+    return value.slice(0, 10);
+  }
+  return value;
+}
+function normalizeDateValue(value) {
+  if (value instanceof Date) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return new Date(`${value.slice(0, 10)}T00:00:00Z`);
+  }
+  return value;
+}
+function normalizeTime(value) {
+  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;
+}
+function normalizeInterval(value) {
+  if (value && typeof value === "object" && "days" in value && "months" in value) {
+    const { months, days, micros } = value;
+    if (months === 0 && days !== undefined) {
+      if (micros && Number(micros) !== 0) {
+        const seconds = Number(micros) / 1e6;
+        return `${days} day${days === 1 ? "" : "s"} ${seconds} seconds`.trim();
+      }
+      return `${days} day${days === 1 ? "" : "s"}`;
+    }
+  }
+  return value;
+}
+function mapDriverValue(decoder, rawValue) {
+  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));
+}
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce((acc, { path, field }, columnIndex) => {
+    let decoder;
+    if (is(field, Column)) {
+      decoder = field;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+    } else {
+      const col = field.sql.queryChunks.find((chunk) => is(chunk, Column));
+      if (is(col, PgCustomColumn)) {
+        decoder = col;
+      } else {
+        decoder = field.sql.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;
+}
+
+// src/session.ts
+import { TransactionRollbackError } from "drizzle-orm/errors";
+
+// src/client.ts
+import {
+  listValue
+} from "@duckdb/node-api";
+function isPgArrayLiteral(value) {
+  return value.startsWith("{") && value.endsWith("}");
+}
+function parsePgArrayLiteral(value) {
+  const json = value.replace(/{/g, "[").replace(/}/g, "]");
+  try {
+    return JSON.parse(json);
+  } catch {
+    return value;
+  }
+}
+var warnedArrayLiteral = false;
+function prepareParams(params, options = {}) {
+  return params.map((param) => {
+    if (typeof param === "string" && isPgArrayLiteral(param)) {
+      if (options.rejectStringArrayLiterals) {
+        throw new Error("Stringified array literals are not supported. Use duckDbList()/duckDbArray() or pass native arrays.");
+      }
+      if (!warnedArrayLiteral && options.warnOnStringArrayLiteral) {
+        warnedArrayLiteral = true;
+        options.warnOnStringArrayLiteral();
+      }
+      return parsePgArrayLiteral(param);
+    }
+    return param;
+  });
+}
+function toNodeApiValue(value) {
+  if (Array.isArray(value)) {
+    return listValue(value.map((inner) => toNodeApiValue(inner)));
+  }
+  return value;
+}
+async function executeOnClient(client, query, params) {
+  const values = params.length > 0 ? params.map((param) => toNodeApiValue(param)) : undefined;
+  const result = await client.run(query, values);
+  const rows = await result.getRowsJS();
+  const columns = result.columnNames();
+  const seen = {};
+  const uniqueColumns = columns.map((col) => {
+    const count = seen[col] ?? 0;
+    seen[col] = count + 1;
+    return count === 0 ? col : `${col}_${count}`;
+  });
+  return (rows ?? []).map((vals) => {
+    const obj = {};
+    uniqueColumns.forEach((col, idx) => {
+      obj[col] = vals[idx];
+    });
+    return obj;
+  });
+}
+
+// src/session.ts
+class DuckDBPreparedQuery extends PgPreparedQuery {
+  client;
+  dialect;
+  queryString;
+  params;
+  logger;
+  fields;
+  _isResponseInArrayMode;
+  customResultMapper;
+  rewriteArrays;
+  rejectStringArrayLiterals;
+  warnOnStringArrayLiteral;
+  static [entityKind] = "DuckDBPreparedQuery";
+  constructor(client, dialect, queryString, params, logger, fields, _isResponseInArrayMode, customResultMapper, rewriteArrays, rejectStringArrayLiterals, warnOnStringArrayLiteral) {
+    super({ sql: queryString, params });
+    this.client = client;
+    this.dialect = dialect;
+    this.queryString = queryString;
+    this.params = params;
+    this.logger = logger;
+    this.fields = fields;
+    this._isResponseInArrayMode = _isResponseInArrayMode;
+    this.customResultMapper = customResultMapper;
+    this.rewriteArrays = rewriteArrays;
+    this.rejectStringArrayLiterals = rejectStringArrayLiterals;
+    this.warnOnStringArrayLiteral = warnOnStringArrayLiteral;
+  }
+  async execute(placeholderValues = {}) {
+    this.dialect.assertNoPgJsonColumns();
+    const params = prepareParams(fillPlaceholders(this.params, placeholderValues), {
+      rejectStringArrayLiterals: this.rejectStringArrayLiterals,
+      warnOnStringArrayLiteral: this.warnOnStringArrayLiteral ? () => this.warnOnStringArrayLiteral?.(this.queryString) : undefined
+    });
+    const rewrittenQuery = this.rewriteArrays ? adaptArrayOperators(this.queryString) : this.queryString;
+    if (this.rewriteArrays && rewrittenQuery !== this.queryString) {
+      this.logger.logQuery(`[duckdb] original query before array rewrite: ${this.queryString}`, params);
+    }
+    this.logger.logQuery(rewrittenQuery, params);
+    const {
+      fields,
+      joinsNotNullableMap,
+      customResultMapper
+    } = this;
+    const rows = await executeOnClient(this.client, rewrittenQuery, params);
+    if (rows.length === 0 || !fields) {
+      return rows;
+    }
+    const rowValues = rows.map((row) => Object.values(row));
+    return customResultMapper ? customResultMapper(rowValues) : rowValues.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
+  }
+  all(placeholderValues = {}) {
+    return this.execute(placeholderValues);
+  }
+  isResponseInArrayMode() {
+    return this._isResponseInArrayMode;
+  }
+}
+
+class DuckDBSession extends PgSession {
+  client;
+  schema;
+  options;
+  static [entityKind] = "DuckDBSession";
+  dialect;
+  logger;
+  rewriteArrays;
+  rejectStringArrayLiterals;
+  hasWarnedArrayLiteral = false;
+  constructor(client, dialect, schema, options = {}) {
+    super(dialect);
+    this.client = client;
+    this.schema = schema;
+    this.options = options;
+    this.dialect = dialect;
+    this.logger = options.logger ?? new NoopLogger;
+    this.rewriteArrays = options.rewriteArrays ?? true;
+    this.rejectStringArrayLiterals = options.rejectStringArrayLiterals ?? false;
+  }
+  prepareQuery(query, fields, name, isResponseInArrayMode, customResultMapper) {
+    return new DuckDBPreparedQuery(this.client, this.dialect, query.sql, query.params, this.logger, fields, isResponseInArrayMode, customResultMapper, this.rewriteArrays, this.rejectStringArrayLiterals, this.rejectStringArrayLiterals ? undefined : this.warnOnStringArrayLiteral);
+  }
+  async transaction(transaction) {
+    const session = new DuckDBSession(this.client, this.dialect, this.schema, this.options);
+    const tx = new DuckDBTransaction(this.dialect, session, this.schema);
+    await tx.execute(sql`BEGIN TRANSACTION;`);
+    try {
+      const result = await transaction(tx);
+      await tx.execute(sql`commit`);
+      return result;
+    } catch (error) {
+      await tx.execute(sql`rollback`);
+      throw error;
+    }
+  }
+  warnOnStringArrayLiteral = (query) => {
+    if (this.hasWarnedArrayLiteral) {
+      return;
+    }
+    this.hasWarnedArrayLiteral = true;
+    this.logger.logQuery(`[duckdb] ${arrayLiteralWarning}
+query: ${query}`, []);
+  };
+}
+
+class DuckDBTransaction extends PgTransaction {
+  static [entityKind] = "DuckDBTransaction";
+  rollback() {
+    throw new TransactionRollbackError;
+  }
+  getTransactionConfigSQL(config) {
+    const chunks = [];
+    if (config.isolationLevel) {
+      chunks.push(`isolation level ${config.isolationLevel}`);
+    }
+    if (config.accessMode) {
+      chunks.push(config.accessMode);
+    }
+    if (typeof config.deferrable === "boolean") {
+      chunks.push(config.deferrable ? "deferrable" : "not deferrable");
+    }
+    return sql.raw(chunks.join(" "));
+  }
+  setTransaction(config) {
+    return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
+  }
+  async transaction(transaction) {
+    const nestedTx = new DuckDBTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
+    return transaction(nestedTx);
+  }
+}
+var arrayLiteralWarning = "Received a stringified Postgres-style array literal. Use duckDbList()/duckDbArray() or pass native arrays instead. You can also set rejectStringArrayLiterals=true to throw.";
+
+// src/dialect.ts
+import { entityKind as entityKind2, is as is2 } from "drizzle-orm/entity";
+import {
+  PgDate as PgDate2,
+  PgDateString as PgDateString2,
+  PgDialect,
+  PgJson,
+  PgJsonb,
+  PgNumeric,
+  PgTime as PgTime2,
+  PgTimestamp as PgTimestamp2,
+  PgTimestampString as PgTimestampString2,
+  PgUUID
+} from "drizzle-orm/pg-core";
+import {
+  sql as sql2
+} from "drizzle-orm";
+
+class DuckDBDialect extends PgDialect {
+  static [entityKind2] = "DuckDBPgDialect";
+  hasPgJsonColumn = false;
+  assertNoPgJsonColumns() {
+    if (this.hasPgJsonColumn) {
+      throw new Error("Pg JSON/JSONB columns are not supported in DuckDB. Replace them with duckDbJson() to use DuckDB’s native JSON type.");
+    }
+  }
+  async migrate(migrations, session, config) {
+    const migrationConfig = typeof config === "string" ? { migrationsFolder: config } : config;
+    const migrationsSchema = migrationConfig.migrationsSchema ?? "drizzle";
+    const migrationsTable = migrationConfig.migrationsTable ?? "__drizzle_migrations";
+    const migrationsSequence = `${migrationsTable}_id_seq`;
+    const legacySequence = "migrations_pk_seq";
+    const escapeIdentifier = (value) => value.replace(/"/g, '""');
+    const sequenceLiteral = `"${escapeIdentifier(migrationsSchema)}"."${escapeIdentifier(migrationsSequence)}"`;
+    const migrationTableCreate = sql2`
+      CREATE TABLE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} (
+        id integer PRIMARY KEY default nextval('${sql2.raw(sequenceLiteral)}'),
+        hash text NOT NULL,
+        created_at bigint
+      )
+    `;
+    await session.execute(sql2`CREATE SCHEMA IF NOT EXISTS ${sql2.identifier(migrationsSchema)}`);
+    await session.execute(sql2`CREATE SEQUENCE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsSequence)}`);
+    if (legacySequence !== migrationsSequence) {
+      await session.execute(sql2`CREATE SEQUENCE IF NOT EXISTS ${sql2.identifier(migrationsSchema)}.${sql2.identifier(legacySequence)}`);
+    }
+    await session.execute(migrationTableCreate);
+    const dbMigrations = await session.all(sql2`select id, hash, created_at from ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} order by created_at desc limit 1`);
+    const lastDbMigration = dbMigrations[0];
+    await session.transaction(async (tx) => {
+      for await (const migration of migrations) {
+        if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
+          for (const stmt of migration.sql) {
+            await tx.execute(sql2.raw(stmt));
+          }
+          await tx.execute(sql2`insert into ${sql2.identifier(migrationsSchema)}.${sql2.identifier(migrationsTable)} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`);
+        }
+      }
+    });
+  }
+  prepareTyping(encoder) {
+    if (is2(encoder, PgJsonb) || is2(encoder, PgJson)) {
+      this.hasPgJsonColumn = true;
+      return "none";
+    } else if (is2(encoder, PgNumeric)) {
+      return "decimal";
+    } else if (is2(encoder, PgTime2)) {
+      return "time";
+    } else if (is2(encoder, PgTimestamp2) || is2(encoder, PgTimestampString2)) {
+      return "timestamp";
+    } else if (is2(encoder, PgDate2) || is2(encoder, PgDateString2)) {
+      return "date";
+    } else if (is2(encoder, PgUUID)) {
+      return "uuid";
+    } else {
+      return "none";
+    }
+  }
+}
+
+// src/select-builder.ts
+import { is as is4 } from "drizzle-orm/entity";
+import {
+  PgSelectBase,
+  PgSelectBuilder
+} from "drizzle-orm/pg-core/query-builders";
+import { Subquery, ViewBaseConfig } from "drizzle-orm";
+import { PgViewBase } from "drizzle-orm/pg-core/view-base";
+import { SQL as SQL4 } from "drizzle-orm/sql/sql";
+
+// src/sql/selection.ts
+import {
+  Column as Column2,
+  SQL as SQL3,
+  getTableName as getTableName2,
+  is as is3,
+  sql as sql3
+} from "drizzle-orm";
+function mapEntries(obj, prefix, fullJoin = false) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => key !== "enableRLS").map(([key, value]) => {
+    const qualified = prefix ? `${prefix}.${key}` : key;
+    if (fullJoin && is3(value, Column2)) {
+      return [
+        key,
+        sql3`${value}`.mapWith(value).as(`${getTableName2(value.table)}.${value.name}`)
+      ];
+    }
+    if (fullJoin && is3(value, SQL3)) {
+      const col = value.getSQL().queryChunks.find((chunk) => is3(chunk, Column2));
+      const tableName = col?.table && getTableName2(col?.table);
+      return [key, value.as(tableName ? `${tableName}.${key}` : key)];
+    }
+    if (is3(value, SQL3) || is3(value, Column2)) {
+      const aliased = is3(value, SQL3) ? value : sql3`${value}`.mapWith(value);
+      return [key, aliased.as(qualified)];
+    }
+    if (is3(value, SQL3.Aliased)) {
+      return [key, value];
+    }
+    if (typeof value === "object" && value !== null) {
+      return [
+        key,
+        mapEntries(value, qualified, fullJoin)
+      ];
+    }
+    return [key, value];
+  }));
+}
+function aliasFields(fields, fullJoin = false) {
+  return mapEntries(fields, undefined, fullJoin);
+}
+
+// src/select-builder.ts
+import { getTableColumns } from "drizzle-orm/utils";
+
+class DuckDBSelectBuilder extends PgSelectBuilder {
+  _fields;
+  _session;
+  _dialect;
+  _withList = [];
+  _distinct;
+  constructor(config) {
+    super(config);
+    this._fields = config.fields;
+    this._session = config.session;
+    this._dialect = config.dialect;
+    if (config.withList) {
+      this._withList = config.withList;
+    }
+    this._distinct = config.distinct;
+  }
+  from(source) {
+    const isPartialSelect = !!this._fields;
+    const src = source;
+    let fields;
+    if (this._fields) {
+      fields = this._fields;
+    } else if (is4(src, Subquery)) {
+      fields = Object.fromEntries(Object.keys(src._.selectedFields).map((key) => [
+        key,
+        src[key]
+      ]));
+    } else if (is4(src, PgViewBase)) {
+      fields = src[ViewBaseConfig]?.selectedFields;
+    } else if (is4(src, SQL4)) {
+      fields = {};
+    } else {
+      fields = aliasFields(getTableColumns(src), !isPartialSelect);
+    }
+    return new PgSelectBase({
+      table: src,
+      fields,
+      isPartialSelect,
+      session: this._session,
+      dialect: this._dialect,
+      withList: this._withList,
+      distinct: this._distinct
+    });
+  }
+}
+
+// src/driver.ts
+class DuckDBDriver {
+  client;
+  dialect;
+  options;
+  static [entityKind3] = "DuckDBDriver";
+  constructor(client, dialect, options = {}) {
+    this.client = client;
+    this.dialect = dialect;
+    this.options = options;
+  }
+  createSession(schema) {
+    return new DuckDBSession(this.client, this.dialect, schema, {
+      logger: this.options.logger,
+      rewriteArrays: this.options.rewriteArrays,
+      rejectStringArrayLiterals: this.options.rejectStringArrayLiterals
+    });
+  }
+}
+function drizzle(client, config = {}) {
+  const dialect = new DuckDBDialect;
+  const logger = config.logger === true ? new DefaultLogger : config.logger || undefined;
+  let schema;
+  if (config.schema) {
+    const tablesConfig = extractTablesRelationalConfig(config.schema, createTableRelationsHelpers);
+    schema = {
+      fullSchema: config.schema,
+      schema: tablesConfig.tables,
+      tableNamesMap: tablesConfig.tableNamesMap
+    };
+  }
+  const driver = new DuckDBDriver(client, dialect, {
+    logger,
+    rewriteArrays: config.rewriteArrays,
+    rejectStringArrayLiterals: config.rejectStringArrayLiterals
+  });
+  const session = driver.createSession(schema);
+  return new DuckDBDatabase(dialect, session, schema);
+}
+
+class DuckDBDatabase extends PgDatabase {
+  dialect;
+  session;
+  static [entityKind3] = "DuckDBDatabase";
+  constructor(dialect, session, schema) {
+    super(dialect, session, schema);
+    this.dialect = dialect;
+    this.session = session;
+  }
+  select(fields) {
+    const selectedFields = fields ? aliasFields(fields) : undefined;
+    return new DuckDBSelectBuilder({
+      fields: selectedFields ?? undefined,
+      session: this.session,
+      dialect: this.dialect
+    });
+  }
+  async transaction(transaction) {
+    return await this.session.transaction(transaction);
+  }
+}
+
+// src/introspect.ts
+import { sql as sql4 } from "drizzle-orm";
+var SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog"]);
+var DEFAULT_IMPORT_BASE = "@leonardovida-md/drizzle-neo-duckdb";
+async function introspect(db, opts = {}) {
+  const schemas = await resolveSchemas(db, opts.schemas);
+  const includeViews = opts.includeViews ?? false;
+  const tables = await loadTables(db, schemas, includeViews);
+  const columns = await loadColumns(db, schemas);
+  const constraints = await loadConstraints(db, schemas);
+  const indexes = await loadIndexes(db, schemas);
+  const grouped = buildTables(tables, columns, constraints, indexes);
+  const schemaTs = emitSchema(grouped, {
+    useCustomTimeTypes: opts.useCustomTimeTypes ?? true,
+    mapJsonAsDuckDbJson: opts.mapJsonAsDuckDbJson ?? true,
+    importBasePath: opts.importBasePath ?? DEFAULT_IMPORT_BASE
+  });
+  return {
+    files: {
+      schemaTs,
+      metaJson: grouped
+    }
+  };
+}
+async function resolveSchemas(db, targetSchemas) {
+  if (targetSchemas?.length) {
+    return targetSchemas;
+  }
+  const rows = await db.execute(sql4`select schema_name from information_schema.schemata`);
+  return rows.map((row) => row.schema_name).filter((name) => !SYSTEM_SCHEMAS.has(name));
+}
+async function loadTables(db, schemas, includeViews) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  return await db.execute(sql4`
+      select table_schema as schema_name, table_name, table_type
+      from information_schema.tables
+      where table_schema in (${sql4.join(schemaFragments, sql4.raw(", "))})
+      and ${includeViews ? sql4`1 = 1` : sql4`table_type = 'BASE TABLE'`}
+      order by table_schema, table_name
+    `);
+}
+async function loadColumns(db, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  return await db.execute(sql4`
+      select
+        schema_name,
+        table_name,
+        column_name,
+        column_index,
+        column_default,
+        is_nullable,
+        data_type,
+        character_maximum_length,
+        numeric_precision,
+        numeric_scale,
+        internal
+      from duckdb_columns()
+      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
+      order by schema_name, table_name, column_index
+    `);
+}
+async function loadConstraints(db, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  return await db.execute(sql4`
+      select
+        schema_name,
+        table_name,
+        constraint_name,
+        constraint_type,
+        constraint_text,
+        constraint_column_names,
+        referenced_table,
+        referenced_column_names
+      from duckdb_constraints()
+      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
+      order by schema_name, table_name, constraint_index
+    `);
+}
+async function loadIndexes(db, schemas) {
+  const schemaFragments = schemas.map((schema) => sql4`${schema}`);
+  return await db.execute(sql4`
+      select
+        schema_name,
+        table_name,
+        index_name,
+        is_unique,
+        expressions
+      from duckdb_indexes()
+      where schema_name in (${sql4.join(schemaFragments, sql4.raw(", "))})
+      order by schema_name, table_name, index_name
+    `);
+}
+function buildTables(tables, columns, constraints, indexes) {
+  const byTable = {};
+  for (const table of tables) {
+    const key = tableKey(table.schema_name, table.table_name);
+    byTable[key] = {
+      schema: table.schema_name,
+      name: table.table_name,
+      kind: table.table_type === "VIEW" ? "view" : "table",
+      columns: [],
+      constraints: [],
+      indexes: []
+    };
+  }
+  for (const column of columns) {
+    if (column.internal) {
+      continue;
+    }
+    const key = tableKey(column.schema_name, column.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    table.columns.push({
+      name: column.column_name,
+      dataType: column.data_type,
+      columnDefault: column.column_default,
+      nullable: column.is_nullable,
+      characterLength: column.character_maximum_length,
+      numericPrecision: column.numeric_precision,
+      numericScale: column.numeric_scale
+    });
+  }
+  for (const constraint of constraints) {
+    const key = tableKey(constraint.schema_name, constraint.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    if (!constraint.constraint_column_names?.length) {
+      continue;
+    }
+    table.constraints.push({
+      name: constraint.constraint_name,
+      type: constraint.constraint_type,
+      columns: constraint.constraint_column_names ?? [],
+      referencedTable: constraint.referenced_table && constraint.referenced_column_names ? {
+        schema: constraint.schema_name,
+        name: constraint.referenced_table,
+        columns: constraint.referenced_column_names
+      } : undefined,
+      rawExpression: constraint.constraint_text
+    });
+  }
+  for (const index of indexes) {
+    const key = tableKey(index.schema_name, index.table_name);
+    const table = byTable[key];
+    if (!table) {
+      continue;
+    }
+    table.indexes.push(index);
+  }
+  return Object.values(byTable);
+}
+function emitSchema(catalog, options) {
+  const imports = {
+    drizzle: new Set,
+    pgCore: new Set,
+    local: new Set
+  };
+  imports.pgCore.add("pgSchema");
+  const sorted = [...catalog].sort((a, b) => a.schema === b.schema ? a.name.localeCompare(b.name) : a.schema.localeCompare(b.schema));
+  const lines = [];
+  for (const schema of uniqueSchemas(sorted)) {
+    imports.pgCore.add("pgSchema");
+    const schemaVar = toSchemaIdentifier(schema);
+    lines.push(`export const ${schemaVar} = pgSchema(${JSON.stringify(schema)});`, "");
+    const tables = sorted.filter((table) => table.schema === schema);
+    for (const table of tables) {
+      lines.push(...emitTable(schemaVar, table, imports, options));
+      lines.push("");
+    }
+  }
+  const importsBlock = renderImports(imports, options.importBasePath);
+  return [importsBlock, ...lines].join(`
+`).trim() + `
+`;
+}
+function emitTable(schemaVar, table, imports, options) {
+  const tableVar = toIdentifier(table.name);
+  const columnLines = [];
+  for (const column of table.columns) {
+    columnLines.push(`  ${columnProperty(column.name)}: ${emitColumn(column, imports, options)},`);
+  }
+  const constraintBlock = emitConstraints(table, imports);
+  const tableLines = [];
+  tableLines.push(`export const ${tableVar} = ${schemaVar}.table(${JSON.stringify(table.name)}, {`);
+  tableLines.push(...columnLines);
+  tableLines.push(`}${constraintBlock ? "," : ""}${constraintBlock ? ` ${constraintBlock}` : ""});`);
+  return tableLines;
+}
+function emitConstraints(table, imports) {
+  const constraints = table.constraints.filter((constraint) => ["PRIMARY KEY", "FOREIGN KEY", "UNIQUE"].includes(constraint.type));
+  if (!constraints.length) {
+    return "";
+  }
+  const entries = [];
+  for (const constraint of constraints) {
+    const key = toIdentifier(constraint.name || `${table.name}_constraint`);
+    if (constraint.type === "PRIMARY KEY") {
+      imports.pgCore.add("primaryKey");
+      entries.push(`${key}: primaryKey({ columns: [${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")}], name: ${JSON.stringify(constraint.name)} })`);
+    } else if (constraint.type === "UNIQUE" && constraint.columns.length > 1) {
+      imports.pgCore.add("unique");
+      entries.push(`${key}: unique(${JSON.stringify(constraint.name)}).on(${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")})`);
+    } else if (constraint.type === "FOREIGN KEY" && constraint.referencedTable) {
+      imports.pgCore.add("foreignKey");
+      const targetTable = toIdentifier(constraint.referencedTable.name);
+      entries.push(`${key}: foreignKey({ columns: [${constraint.columns.map((col) => `t.${toIdentifier(col)}`).join(", ")}], foreignColumns: [${constraint.referencedTable.columns.map((col) => `${targetTable}.${toIdentifier(col)}`).join(", ")}], name: ${JSON.stringify(constraint.name)} })`);
+    } else if (constraint.type === "UNIQUE" && constraint.columns.length === 1) {
+      const columnName = constraint.columns[0];
+      entries.push(`${key}: t.${toIdentifier(columnName)}.unique(${JSON.stringify(constraint.name)})`);
+    }
+  }
+  if (!entries.length) {
+    return "";
+  }
+  const lines = ["(t) => ({"];
+  for (const entry of entries) {
+    lines.push(`  ${entry},`);
+  }
+  lines.push("})");
+  return lines.join(`
+`);
+}
+function emitColumn(column, imports, options) {
+  const mapping = mapDuckDbType(column, imports, options);
+  let builder = mapping.builder;
+  if (!column.nullable) {
+    builder += ".notNull()";
+  }
+  const defaultFragment = buildDefault(column.columnDefault);
+  if (defaultFragment) {
+    imports.drizzle.add("sql");
+    builder += defaultFragment;
+  }
+  return builder;
+}
+function buildDefault(defaultValue) {
+  if (!defaultValue) {
+    return "";
+  }
+  const trimmed = defaultValue.trim();
+  if (!trimmed || trimmed.toUpperCase() === "NULL") {
+    return "";
+  }
+  if (/^nextval\(/i.test(trimmed)) {
+    return `.default(sql\`${trimmed}\`)`;
+  }
+  if (/^current_timestamp(?:\(\))?$/i.test(trimmed) || /^now\(\)$/i.test(trimmed)) {
+    return `.defaultNow()`;
+  }
+  if (trimmed === "true" || trimmed === "false") {
+    return `.default(${trimmed})`;
+  }
+  const numberValue = Number(trimmed);
+  if (!Number.isNaN(numberValue)) {
+    return `.default(${trimmed})`;
+  }
+  const stringLiteralMatch = /^'(.*)'$/.exec(trimmed);
+  if (stringLiteralMatch) {
+    const value = stringLiteralMatch[1]?.replace(/''/g, "'");
+    return `.default(${JSON.stringify(value)})`;
+  }
+  return "";
+}
+function mapDuckDbType(column, imports, options) {
+  const raw = column.dataType.trim();
+  const upper = raw.toUpperCase();
+  if (upper === "BOOLEAN" || upper === "BOOL") {
+    imports.pgCore.add("boolean");
+    return { builder: `boolean(${columnName(column.name)})` };
+  }
+  if (upper === "SMALLINT" || upper === "INT2" || upper === "INT16" || upper === "TINYINT") {
+    imports.pgCore.add("integer");
+    return { builder: `integer(${columnName(column.name)})` };
+  }
+  if (upper === "INTEGER" || upper === "INT" || upper === "INT4" || upper === "SIGNED") {
+    imports.pgCore.add("integer");
+    return { builder: `integer(${columnName(column.name)})` };
+  }
+  if (upper === "BIGINT" || upper === "INT8" || upper === "UBIGINT") {
+    imports.pgCore.add("bigint");
+    return { builder: `bigint(${columnName(column.name)})` };
+  }
+  const decimalMatch = /^DECIMAL\((\d+),(\d+)\)/i.exec(upper);
+  const numericMatch = /^NUMERIC\((\d+),(\d+)\)/i.exec(upper);
+  if (decimalMatch || numericMatch) {
+    imports.pgCore.add("numeric");
+    const [, precision, scale] = decimalMatch ?? numericMatch;
+    return {
+      builder: `numeric(${columnName(column.name)}, { precision: ${precision}, scale: ${scale} })`
+    };
+  }
+  if (upper.startsWith("DECIMAL") || upper.startsWith("NUMERIC")) {
+    imports.pgCore.add("numeric");
+    const precision = column.numericPrecision;
+    const scale = column.numericScale;
+    const options2 = [];
+    if (precision !== null && precision !== undefined) {
+      options2.push(`precision: ${precision}`);
+    }
+    if (scale !== null && scale !== undefined) {
+      options2.push(`scale: ${scale}`);
+    }
+    const suffix = options2.length ? `, { ${options2.join(", ")} }` : "";
+    return { builder: `numeric(${columnName(column.name)}${suffix})` };
+  }
+  if (upper === "REAL" || upper === "FLOAT4") {
+    imports.pgCore.add("real");
+    return { builder: `real(${columnName(column.name)})` };
+  }
+  if (upper === "DOUBLE" || upper === "DOUBLE PRECISION" || upper === "FLOAT") {
+    imports.pgCore.add("doublePrecision");
+    return { builder: `doublePrecision(${columnName(column.name)})` };
+  }
+  if (upper.startsWith("CHAR(") || upper === "CHAR") {
+    imports.pgCore.add("char");
+    const length = column.characterLength;
+    const lengthPart = typeof length === "number" ? `, { length: ${length} }` : "";
+    return { builder: `char(${columnName(column.name)}${lengthPart})` };
+  }
+  if (upper.startsWith("VARCHAR")) {
+    imports.pgCore.add("varchar");
+    const length = column.characterLength;
+    const lengthPart = typeof length === "number" ? `, { length: ${length} }` : "";
+    return { builder: `varchar(${columnName(column.name)}${lengthPart})` };
+  }
+  if (upper === "TEXT" || upper === "STRING") {
+    imports.pgCore.add("text");
+    return { builder: `text(${columnName(column.name)})` };
+  }
+  if (upper === "UUID") {
+    imports.pgCore.add("uuid");
+    return { builder: `uuid(${columnName(column.name)})` };
+  }
+  if (upper === "JSON") {
+    if (options.mapJsonAsDuckDbJson) {
+      imports.local.add("duckDbJson");
+      return { builder: `duckDbJson(${columnName(column.name)})` };
+    }
+    imports.pgCore.add("text");
+    return { builder: `text(${columnName(column.name)}) /* JSON */` };
+  }
+  if (upper === "INET") {
+    imports.local.add("duckDbInet");
+    return { builder: `duckDbInet(${columnName(column.name)})` };
+  }
+  if (upper === "INTERVAL") {
+    imports.local.add("duckDbInterval");
+    return { builder: `duckDbInterval(${columnName(column.name)})` };
+  }
+  if (upper === "BLOB" || upper === "BYTEA" || upper === "VARBINARY") {
+    imports.local.add("duckDbBlob");
+    return { builder: `duckDbBlob(${columnName(column.name)})` };
+  }
+  const arrayMatch = /^(.*)\[(\d+)\]$/.exec(upper);
+  if (arrayMatch) {
+    imports.local.add("duckDbArray");
+    const [, base, length] = arrayMatch;
+    return {
+      builder: `duckDbArray(${columnName(column.name)}, ${JSON.stringify(base)}, ${Number(length)})`
+    };
+  }
+  const listMatch = /^(.*)\[\]$/.exec(upper);
+  if (listMatch) {
+    imports.local.add("duckDbList");
+    const [, base] = listMatch;
+    return {
+      builder: `duckDbList(${columnName(column.name)}, ${JSON.stringify(base)})`
+    };
+  }
+  if (upper.startsWith("STRUCT")) {
+    imports.local.add("duckDbStruct");
+    const inner = upper.replace(/^STRUCT\s*\(/i, "").replace(/\)$/, "");
+    const fields = parseStructFields(inner);
+    const entries = fields.map(({ name, type }) => `${JSON.stringify(name)}: ${JSON.stringify(type)}`);
+    return {
+      builder: `duckDbStruct(${columnName(column.name)}, { ${entries.join(", ")} })`
+    };
+  }
+  if (upper.startsWith("MAP(")) {
+    imports.local.add("duckDbMap");
+    const valueType = parseMapValue(upper);
+    return {
+      builder: `duckDbMap(${columnName(column.name)}, ${JSON.stringify(valueType)})`
+    };
+  }
+  if (upper.startsWith("TIMESTAMP WITH TIME ZONE")) {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTimestamp");
+    } else {
+      imports.pgCore.add("timestamp");
+    }
+    const factory = options.useCustomTimeTypes ? `duckDbTimestamp(${columnName(column.name)}, { withTimezone: true })` : `timestamp(${columnName(column.name)}, { withTimezone: true })`;
+    return { builder: factory };
+  }
+  if (upper.startsWith("TIMESTAMP")) {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTimestamp");
+      return {
+        builder: `duckDbTimestamp(${columnName(column.name)})`
+      };
+    }
+    imports.pgCore.add("timestamp");
+    return { builder: `timestamp(${columnName(column.name)})` };
+  }
+  if (upper === "TIME") {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbTime");
+      return { builder: `duckDbTime(${columnName(column.name)})` };
+    }
+    imports.pgCore.add("time");
+    return { builder: `time(${columnName(column.name)})` };
+  }
+  if (upper === "DATE") {
+    if (options.useCustomTimeTypes) {
+      imports.local.add("duckDbDate");
+      return { builder: `duckDbDate(${columnName(column.name)})` };
+    }
+    imports.pgCore.add("date");
+    return { builder: `date(${columnName(column.name)})` };
+  }
+  imports.pgCore.add("text");
+  return {
+    builder: `text(${columnName(column.name)}) /* TODO: verify type ${upper} */`
+  };
+}
+function parseStructFields(inner) {
+  const result = [];
+  for (const part of splitTopLevel(inner, ",")) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    const match = /^"?([^"]+)"?\s+(.*)$/i.exec(trimmed);
+    if (!match) {
+      continue;
+    }
+    const [, name, type] = match;
+    result.push({ name, type: type.trim() });
+  }
+  return result;
+}
+function parseMapValue(raw) {
+  const inner = raw.replace(/^MAP\(/i, "").replace(/\)$/, "");
+  const parts = splitTopLevel(inner, ",");
+  if (parts.length < 2) {
+    return "TEXT";
+  }
+  return parts[1]?.trim() ?? "TEXT";
+}
+function splitTopLevel(input, delimiter) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0;i < input.length; i += 1) {
+    const char = input[i];
+    if (char === "(")
+      depth += 1;
+    if (char === ")")
+      depth = Math.max(0, depth - 1);
+    if (char === delimiter && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current) {
+    parts.push(current);
+  }
+  return parts;
+}
+function tableKey(schema, table) {
+  return `${schema}.${table}`;
+}
+function toIdentifier(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_]/g, "_");
+  const parts = cleaned.split("_").filter(Boolean);
+  const base = parts.map((part, index) => index === 0 ? part.toLowerCase() : capitalize(part.toLowerCase())).join("");
+  const candidate = base || "item";
+  return /^[A-Za-z_]/.test(candidate) ? candidate : `t${candidate}`;
+}
+function toSchemaIdentifier(schema) {
+  const base = toIdentifier(schema);
+  return base.endsWith("Schema") ? base : `${base}Schema`;
+}
+function columnProperty(column) {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(column)) {
+    return toIdentifier(column);
+  }
+  return JSON.stringify(column);
+}
+function columnName(name) {
+  return JSON.stringify(name);
+}
+function capitalize(value) {
+  if (!value)
+    return value;
+  return value[0].toUpperCase() + value.slice(1);
+}
+function uniqueSchemas(tables) {
+  const seen = new Set;
+  const result = [];
+  for (const table of tables) {
+    if (!seen.has(table.schema)) {
+      seen.add(table.schema);
+      result.push(table.schema);
+    }
+  }
+  return result;
+}
+function renderImports(imports, importBasePath) {
+  const lines = [];
+  const drizzle2 = [...imports.drizzle];
+  if (drizzle2.length) {
+    lines.push(`import { ${drizzle2.sort().join(", ")} } from 'drizzle-orm';`);
+  }
+  const pgCore = [...imports.pgCore];
+  if (pgCore.length) {
+    lines.push(`import { ${pgCore.sort().join(", ")} } from 'drizzle-orm/pg-core';`);
+  }
+  const local = [...imports.local];
+  if (local.length) {
+    lines.push(`import { ${local.sort().join(", ")} } from '${importBasePath}';`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/bin/duckdb-introspect.ts
+function parseArgs(argv) {
+  const options = {
+    outFile: path.resolve(process.cwd(), "drizzle/schema.ts"),
+    includeViews: false,
+    useCustomTimeTypes: true
+  };
+  for (let i = 0;i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--url":
+        options.url = argv[++i];
+        break;
+      case "--schema":
+      case "--schemas":
+        options.schemas = argv[++i]?.split(",").map((s) => s.trim()).filter(Boolean);
+        break;
+      case "--out":
+      case "--outFile":
+        options.outFile = path.resolve(process.cwd(), argv[++i] ?? "drizzle/schema.ts");
+        break;
+      case "--include-views":
+      case "--includeViews":
+        options.includeViews = true;
+        break;
+      case "--use-pg-time":
+        options.useCustomTimeTypes = false;
+        break;
+      case "--import-base":
+        options.importBasePath = argv[++i];
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+      default:
+        if (arg.startsWith("-")) {
+          console.warn(`Unknown option ${arg}`);
+        }
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`duckdb-introspect
+
+Usage:
+  bun x duckdb-introspect --url <duckdb path|md:> [--schema my_schema] [--out ./drizzle/schema.ts]
+
+Options:
+  --url            DuckDB database path (e.g. :memory:, ./local.duckdb, md:)
+  --schema         Comma separated schema list (defaults to all non-system schemas)
+  --out            Output file (default: ./drizzle/schema.ts)
+  --include-views  Include views in the generated schema
+  --use-pg-time    Use pg-core timestamp/date/time instead of DuckDB custom helpers
+  --import-base    Override import path for duckdb helpers (default: package name)
+`);
+}
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (!options.url) {
+    printHelp();
+    throw new Error("Missing required --url");
+  }
+  const instanceOptions = options.url.startsWith("md:") && process.env.MOTHERDUCK_TOKEN ? { motherduck_token: process.env.MOTHERDUCK_TOKEN } : undefined;
+  const instance = await DuckDBInstance.create(options.url, instanceOptions);
+  const connection = await instance.connect();
+  const db = drizzle(connection);
+  try {
+    const result = await introspect(db, {
+      schemas: options.schemas,
+      includeViews: options.includeViews,
+      useCustomTimeTypes: options.useCustomTimeTypes,
+      importBasePath: options.importBasePath
+    });
+    await mkdir(path.dirname(options.outFile), { recursive: true });
+    await writeFile(options.outFile, result.files.schemaTs, "utf8");
+    console.log(`Wrote schema to ${options.outFile}`);
+  } finally {
+    if ("closeSync" in connection && typeof connection.closeSync === "function") {
+      connection.closeSync();
+    }
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});