@dbsp/adapter-pgsql 1.11.1 → 1.11.2

package/dist/index.js

@@ -94,6 +94,332 @@ var init_naming_plugin = __esm({
   }
 });
 
+// src/db-type.ts
+function splitDbType(input) {
+  const trimmed = input.trim();
+  let rest = trimmed;
+  let isArray = false;
+  if (rest.endsWith("[]")) {
+    isArray = true;
+    rest = rest.slice(0, -2).trimEnd();
+  }
+  const lowerRest = rest.toLowerCase();
+  for (const suffix of TEMPORAL_TZ_SUFFIXES) {
+    if (!lowerRest.endsWith(suffix)) continue;
+    const beforeSuffix = rest.slice(0, -suffix.length).trimEnd();
+    const temporal = splitTrailingModifier(beforeSuffix);
+    const temporalBase = normalizeBase(temporal.base).toLowerCase();
+    if (temporalBase === "timestamp" || temporalBase === "time") {
+      const base2 = normalizeBase(`${temporal.base}${suffix}`);
+      return {
+        base: base2,
+        modifier: temporal.modifier,
+        isArray,
+        schemaQualified: isSchemaQualified(base2)
+      };
+    }
+  }
+  const split = splitTrailingModifier(rest);
+  const base = normalizeBase(split.base);
+  return {
+    base,
+    modifier: split.modifier,
+    isArray,
+    schemaQualified: isSchemaQualified(base)
+  };
+}
+function splitTrailingModifier(input) {
+  const match = input.match(/^(.*)\(([^()]*)\)$/);
+  if (!match) return { base: input.trim(), modifier: void 0 };
+  return {
+    base: (match[1] ?? "").trimEnd(),
+    modifier: (match[2] ?? "").trim()
+  };
+}
+function normalizeBase(base) {
+  const trimmed = base.trim();
+  return trimmed.includes('"') ? trimmed : trimmed.replace(/\s+/g, " ");
+}
+function isSchemaQualified(base) {
+  return QUALIFIED_IDENTIFIER_RE.test(base);
+}
+function canonicalizeDbType(type) {
+  const split = splitDbType(type);
+  const base = normalizeBase(split.base);
+  const canonicalBase = base.includes('"') ? base : TYPE_ALIASES.get(base.toLowerCase()) ?? base.toLowerCase();
+  const modifier = split.modifier === void 0 ? "" : `(${split.modifier.replace(/\s*,\s*/g, ",").trim()})`;
+  const arraySuffix = split.isArray ? "[]" : "";
+  return `${canonicalBase}${modifier}${arraySuffix}`;
+}
+function dbTypeCastTarget(originalDbType) {
+  const split = splitDbType(originalDbType);
+  const base = normalizeBase(split.base).toLowerCase();
+  const hasModifier = split.modifier !== void 0;
+  const arraySuffix = split.isArray ? "[]" : "";
+  if (base === "varchar" || base === "character varying") {
+    return hasModifier ? `varchar${arraySuffix}` : originalDbType;
+  }
+  if (base === "char" || base === "character" || base === "bpchar") {
+    return `text${arraySuffix}`;
+  }
+  if (base === "bit" || base === "bit varying" || base === "varbit") {
+    return hasModifier ? `bit varying${arraySuffix}` : originalDbType;
+  }
+  if (base === "numeric" || base === "decimal") {
+    return hasModifier ? `numeric${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp with time zone" || base === "timestamptz") {
+    return hasModifier ? `timestamp with time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp without time zone") {
+    return hasModifier ? `timestamp without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "timestamp") {
+    return hasModifier ? `timestamp without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time with time zone" || base === "timetz") {
+    return hasModifier ? `time with time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time without time zone") {
+    return hasModifier ? `time without time zone${arraySuffix}` : originalDbType;
+  }
+  if (base === "time") {
+    return hasModifier ? `time${arraySuffix}` : originalDbType;
+  }
+  if (INTERVAL_BASE_RE.test(base)) {
+    return hasModifier ? `${base}${arraySuffix}` : originalDbType;
+  }
+  return originalDbType;
+}
+function dbTypesEqual(a, b) {
+  return canonicalizeDbType(a) === canonicalizeDbType(b);
+}
+function isPgBuiltInTypeName(type) {
+  const split = splitDbType(type);
+  const base = normalizeBase(split.base);
+  if (base.includes('"') || split.schemaQualified) return false;
+  const baseLower = base.toLowerCase();
+  return MULTIWORD_BASE_TYPES.has(baseLower) || INTERVAL_BASE_RE.test(base) || BUILTIN_BASE_TYPES.has(baseLower);
+}
+function quoteTypeIdentifier(rawIdentifier) {
+  if (SAFE_LOWERCASE_IDENTIFIER_RE.test(rawIdentifier)) return rawIdentifier;
+  return `"${rawIdentifier.replace(/"/g, '""')}"`;
+}
+function unquoteIdentifier(id) {
+  const t = id.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) {
+    return t.slice(1, -1).replace(/""/g, '"');
+  }
+  return t;
+}
+function enumReferenceKind(originalDbType, typname) {
+  const split = splitDbType(originalDbType);
+  if (split.schemaQualified) return null;
+  if (unquoteIdentifier(normalizeBase(split.base)) !== typname) return null;
+  return split.isArray ? "array" : "scalar";
+}
+function validateDbType(type) {
+  if (typeof type !== "string") {
+    throw new Error(
+      `Unsafe database type name: expected a string, received ${typeof type}`
+    );
+  }
+  if (!isStructurallyValidDbType(type)) {
+    throw new Error(
+      `Unsafe database type name: "${type}". Must be a structurally valid PostgreSQL type name.`
+    );
+  }
+  return type;
+}
+function isStructurallyValidDbType(type) {
+  const trimmed = type.trim();
+  if (trimmed.length === 0 || trimmed !== type) return false;
+  if (/[;]|--|\/\*|\*\//.test(trimmed)) return false;
+  if (trimmed.endsWith("[][]")) return false;
+  if (hasForbiddenTypeKeyword(trimmed)) return false;
+  const split = splitDbType(trimmed);
+  const base = split.base;
+  const baseLower = base.toLowerCase();
+  if (split.modifier !== void 0 && !isSafeModifier(split.modifier, baseLower)) {
+    return false;
+  }
+  if (MULTIWORD_BASE_TYPES.has(baseLower)) {
+    return true;
+  }
+  if (INTERVAL_BASE_RE.test(base)) {
+    return true;
+  }
+  return IDENTIFIER_RE.test(base) || split.schemaQualified;
+}
+function isSafeModifier(modifier, baseLower) {
+  const structurallySafe = modifier.length > 0 && !/[();]|--|\/\*|\*\//.test(modifier) && !MODIFIER_OPERATOR_RE.test(modifier) && MODIFIER_CONTENT_RE.test(modifier) && !hasForbiddenTypeKeyword(modifier);
+  if (!structurallySafe) return false;
+  if (PRECISION_SCALE_BUILTINS.has(baseLower)) {
+    return /^\d+(\s*,\s*-?\d+)?$/.test(modifier);
+  }
+  if (SINGLE_INT_MODIFIER_BUILTINS.has(baseLower) || INTERVAL_BASE_RE.test(baseLower)) {
+    return /^\d+$/.test(modifier.trim());
+  }
+  if (BUILTIN_BASE_TYPES.has(baseLower) || MULTIWORD_BASE_TYPES.has(baseLower)) {
+    return false;
+  }
+  return true;
+}
+function hasForbiddenTypeKeyword(type) {
+  const withoutQuotedIdentifiers = type.replace(QUOTED_IDENTIFIER_RE, '""');
+  return /\bnot\s+null\b|\b(default|references|check|primary|unique|constraint|select|insert|update|delete|drop|alter|create|truncate|grant|revoke|copy)\b/i.test(
+    withoutQuotedIdentifiers
+  );
+}
+var TEMPORAL_TZ_SUFFIXES, SAFE_LOWERCASE_IDENTIFIER_RE, MULTIWORD_BASE_TYPES, TYPE_ALIASES, BUILTIN_BASE_TYPES, UNQUOTED_IDENTIFIER, QUOTED_IDENTIFIER, IDENTIFIER_RE, QUALIFIED_IDENTIFIER_RE, QUOTED_IDENTIFIER_RE, INTERVAL_FIELD, INTERVAL_BASE_RE, MODIFIER_CONTENT_RE, MODIFIER_OPERATOR_RE, SINGLE_INT_MODIFIER_BUILTINS, PRECISION_SCALE_BUILTINS;
+var init_db_type = __esm({
+  "src/db-type.ts"() {
+    "use strict";
+    TEMPORAL_TZ_SUFFIXES = [" without time zone", " with time zone"];
+    SAFE_LOWERCASE_IDENTIFIER_RE = /^[a-z_][a-z0-9_]*$/;
+    MULTIWORD_BASE_TYPES = /* @__PURE__ */ new Set([
+      "timestamp with time zone",
+      "timestamp without time zone",
+      "time with time zone",
+      "time without time zone",
+      "double precision",
+      "character varying",
+      "bit varying"
+    ]);
+    TYPE_ALIASES = /* @__PURE__ */ new Map([
+      ["character varying", "varchar"],
+      ["character", "char"],
+      ["bpchar", "char"],
+      ["bit varying", "varbit"],
+      ["timestamp with time zone", "timestamptz"],
+      ["timestamp without time zone", "timestamp"],
+      ["time with time zone", "timetz"],
+      ["time without time zone", "time"],
+      ["int", "integer"],
+      ["int4", "integer"],
+      ["int8", "bigint"],
+      ["int2", "smallint"],
+      ["float", "double precision"],
+      ["float8", "double precision"],
+      ["float4", "real"],
+      ["bool", "boolean"],
+      ["decimal", "numeric"],
+      ["serial", "integer"],
+      ["serial4", "integer"],
+      ["bigserial", "bigint"],
+      ["serial8", "bigint"],
+      ["smallserial", "smallint"],
+      ["serial2", "smallint"]
+    ]);
+    BUILTIN_BASE_TYPES = /* @__PURE__ */ new Set([
+      ...TYPE_ALIASES.keys(),
+      ...TYPE_ALIASES.values(),
+      "bigint",
+      "bit",
+      "boolean",
+      "box",
+      "bytea",
+      "char",
+      "cidr",
+      "circle",
+      "date",
+      "float",
+      "inet",
+      "integer",
+      "interval",
+      "json",
+      "jsonb",
+      "line",
+      "lseg",
+      "macaddr",
+      "macaddr8",
+      "money",
+      "numeric",
+      "path",
+      "pg_lsn",
+      "point",
+      "polygon",
+      "real",
+      "text",
+      "time",
+      "timestamp",
+      "timetz",
+      "timestamptz",
+      "tsquery",
+      "tsvector",
+      "txid_snapshot",
+      "uuid",
+      "varbit",
+      "varchar",
+      "xml",
+      "jsonpath",
+      "name",
+      "oid",
+      "regclass",
+      "regtype",
+      "regrole",
+      "regnamespace",
+      "regproc",
+      "regprocedure",
+      "xid",
+      "xid8",
+      "cid",
+      "tid",
+      "daterange",
+      "int4range",
+      "int8range",
+      "numrange",
+      "tsrange",
+      "tstzrange",
+      "datemultirange",
+      "int4multirange",
+      "int8multirange",
+      "nummultirange",
+      "tsmultirange",
+      "tstzmultirange"
+    ]);
+    UNQUOTED_IDENTIFIER = "[A-Za-z_][A-Za-z0-9_]*";
+    QUOTED_IDENTIFIER = '"(?:[^"]|"")+"';
+    IDENTIFIER_RE = new RegExp(
+      `^(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})$`
+    );
+    QUALIFIED_IDENTIFIER_RE = new RegExp(
+      `^(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})\\.(?:${UNQUOTED_IDENTIFIER}|${QUOTED_IDENTIFIER})$`
+    );
+    QUOTED_IDENTIFIER_RE = new RegExp(QUOTED_IDENTIFIER, "g");
+    INTERVAL_FIELD = "(?:year|month|day|hour|minute|second)";
+    INTERVAL_BASE_RE = new RegExp(
+      `^interval(?: ${INTERVAL_FIELD}(?: to ${INTERVAL_FIELD})?)?$`,
+      "i"
+    );
+    MODIFIER_CONTENT_RE = /^[A-Za-z0-9_,.\- ]+$/;
+    MODIFIER_OPERATOR_RE = /[=<>+*/%|&!@#^~]/;
+    SINGLE_INT_MODIFIER_BUILTINS = /* @__PURE__ */ new Set([
+      "varchar",
+      "character varying",
+      "char",
+      "character",
+      "bpchar",
+      // float(p): PostgreSQL treats float(1..24) as real, float(25..53) as double
+      // precision — a single-integer mantissa precision.
+      "float",
+      "bit",
+      "bit varying",
+      "varbit",
+      "timestamp",
+      "timestamptz",
+      "timestamp with time zone",
+      "timestamp without time zone",
+      "time",
+      "timetz",
+      "time with time zone",
+      "time without time zone",
+      "interval"
+    ]);
+    PRECISION_SCALE_BUILTINS = /* @__PURE__ */ new Set(["numeric", "decimal"]);
+  }
+});
+
 // src/validate.ts
 function assertString(value, context) {
   if (typeof value !== "string") {
@@ -494,17 +820,13 @@ function isDollarQuoteTagContinuation(ch) {
 }
 function validateDbTypeName(type) {
   assertString(type, "Unsafe database type name");
-  if (!SAFE_TYPE_PATTERN.test(type)) {
-    throw new Error(
-      `Unsafe database type name: "${type}". Must match PostgreSQL type name rules.`
-    );
-  }
-  return type;
+  return validateDbType(type);
 }
-var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_DECIMAL_LITERAL, SAFE_STORAGE_BOOLEAN_LITERAL, SAFE_SIMPLE_IDENTIFIER_VALUE, SAFE_TYPE_PATTERN;
+var SQL_RESERVED_KEYWORDS, InvalidIdentifierError, SAFE_DECIMAL_LITERAL, SAFE_STORAGE_BOOLEAN_LITERAL, SAFE_SIMPLE_IDENTIFIER_VALUE;
 var init_validate = __esm({
   "src/validate.ts"() {
     "use strict";
+    init_db_type();
     SQL_RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
       "all",
       "analyse",
@@ -623,7 +945,6 @@ var init_validate = __esm({
     SAFE_DECIMAL_LITERAL = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/;
     SAFE_STORAGE_BOOLEAN_LITERAL = /^(?:true|false|on|off)$/i;
     SAFE_SIMPLE_IDENTIFIER_VALUE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-    SAFE_TYPE_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])?$/;
   }
 });
 
@@ -2909,7 +3230,7 @@ var init_raw_expression_parser = __esm({
 });
 
 // src/compiler-utils.ts
-import { InvalidOperationError, validateTypeName as validateTypeName2 } from "@dbsp/core";
+import { InvalidOperationError } from "@dbsp/core";
 function inferPgArrayType(columnName, columnTypes, sampleValue) {
   if (columnTypes?.[columnName]) {
     const pgBase = mapToPgBaseType(columnTypes[columnName]);
@@ -2927,7 +3248,16 @@ function inferPgArrayType(columnName, columnTypes, sampleValue) {
   return "text[]";
 }
 function mapToPgBaseType(pgType) {
-  const normalized = pgType.toUpperCase().replace(/\(.*\)/, "").trim();
+  const trimmedPgType = pgType.trim();
+  try {
+    validateDbType(trimmedPgType);
+  } catch {
+    throw new Error(
+      `batchValues: invalid type name '${pgType}'. Must be a structurally valid PostgreSQL type name.`
+    );
+  }
+  const elementType = stripArraySuffix(trimmedPgType);
+  const normalized = elementType.toUpperCase().replace(/\(.*\)/, "").trim();
   switch (normalized) {
     // ColumnType aliases (lowercase ColumnType values from ModelIR)
     case "STRING":
@@ -2957,9 +3287,10 @@ function mapToPgBaseType(pgType) {
     case "DOUBLE PRECISION":
     case "FLOAT8":
     case "FLOAT":
+      return "float8";
     case "NUMERIC":
     case "DECIMAL":
-      return "float8";
+      return "numeric";
     case "TEXT":
     case "VARCHAR":
     case "CHAR":
@@ -2979,11 +3310,8 @@ function mapToPgBaseType(pgType) {
       return "timestamptz";
     case "DATE":
       return "date";
-    default: {
-      const customType = pgType.toLowerCase();
-      validateTypeName2(customType);
-      return customType;
-    }
+    default:
+      return elementType;
   }
 }
 function stripArraySuffix(pgArrayType) {
@@ -3032,6 +3360,7 @@ function parseRawExpression(sqlFragment) {
 var init_compiler_utils = __esm({
   "src/compiler-utils.ts"() {
     "use strict";
+    init_db_type();
     init_raw_expression_parser();
   }
 });
@@ -3048,7 +3377,6 @@ var init_param_intent = __esm({
 });
 
 // src/handlers/where/utils.ts
-import { validateTypeName as validateTypeName3 } from "@dbsp/core";
 import { isFieldRef, isParamIntent as isParamIntent3 } from "@dbsp/types";
 function buildColumnRef(column, ctx) {
   if (column.includes(".")) {
@@ -3112,8 +3440,8 @@ function resolveColumnPgType(columnName, ctx) {
   if (!column) return void 0;
   if (column.originalDbType) {
     const typeName = column.originalDbType.trim();
-    validateTypeName3(typeName);
-    return typeName;
+    validateDbType(typeName);
+    return dbTypeCastTarget(typeName);
   }
   return void 0;
 }
@@ -3121,6 +3449,7 @@ var init_utils = __esm({
   "src/handlers/where/utils.ts"() {
     "use strict";
     init_ast_helpers();
+    init_db_type();
     init_param_intent();
     init_param_ref();
     init_types();
@@ -11753,16 +12082,37 @@ function generateRlsPhase(ctx) {
 init_validate();
 
 // src/ddl/type-mapping.ts
+init_db_type();
 init_validate();
 function mapColumnType(col) {
   if (col.originalDbType) {
-    return validateDbTypeName(col.originalDbType.toUpperCase()).toUpperCase();
+    const originalDbType = validateDbTypeName(col.originalDbType);
+    return isPgBuiltInTypeName(originalDbType) ? uppercaseOutsideQuotedIdentifiers(originalDbType) : originalDbType;
   }
   if (col.autoIncrement) {
     return col.type === "bigint" ? "BIGSERIAL" : "SERIAL";
   }
   return mapBaseType(col.type);
 }
+function uppercaseOutsideQuotedIdentifiers(type) {
+  let result = "";
+  let inQuotedIdentifier = false;
+  for (let i = 0; i < type.length; i++) {
+    const char = type[i];
+    if (char === '"') {
+      result += char;
+      if (inQuotedIdentifier && type[i + 1] === '"') {
+        result += type[i + 1];
+        i++;
+        continue;
+      }
+      inQuotedIdentifier = !inQuotedIdentifier;
+      continue;
+    }
+    result += inQuotedIdentifier ? char : char.toUpperCase();
+  }
+  return result;
+}
 function mapBaseType(type) {
   switch (type) {
     case "string":
@@ -12265,9 +12615,12 @@ function upDropEnum(change, schemaName) {
   if (!enumDef) return void 0;
   const enumName = schemaName ? `${quoteIdent2(schemaName, "alias")}.${quoteIdent2(enumDef.name, "alias")}` : quoteIdent2(enumDef.name, "alias");
   const refs = change.meta?.referencingColumns;
-  const alterStatements = refs && refs.length > 0 ? refs.map(
-    (ref) => `ALTER TABLE ${qualifyTable(ref.table, schemaName)} ALTER COLUMN ${quoteIdent2(ref.column, "alias")} TYPE text;`
-  ) : [];
+  const alterStatements = refs && refs.length > 0 ? refs.map((ref) => {
+    const column = quoteIdent2(ref.column, "alias");
+    const targetType = ref.isArray ? "text[]" : "text";
+    const using = ref.isArray ? ` USING ${column}::text[]` : "";
+    return `ALTER TABLE ${qualifyTable(ref.table, schemaName)} ALTER COLUMN ${column} TYPE ${targetType}${using};`;
+  }) : [];
   return [...alterStatements, `DROP TYPE IF EXISTS ${enumName} CASCADE;`].join(
     "\n"
   );
@@ -13351,6 +13704,7 @@ async function removeMigrationRecord(pool, name) {
 }
 
 // src/ddl/schema-diff.ts
+init_db_type();
 init_naming_plugin();
 function compareSchemata(schema, db, options) {
   const changes = [];
@@ -13538,9 +13892,7 @@ function compareColumns(schema, db, changes) {
   }
 }
 function compareColumnDetails(tableName, schema, db, changes) {
-  const schemaDbType = schema.originalDbType?.toLowerCase();
-  const dbDbType = db.originalDbType?.toLowerCase();
-  if (schemaDbType && dbDbType && schemaDbType !== dbDbType) {
+  if (schema.originalDbType && db.originalDbType && !dbTypesEqual(schema.originalDbType, db.originalDbType)) {
     changes.push({
       kind: "alter_column_type",
       table: tableName,
@@ -14011,8 +14363,13 @@ function compareEnums(schema, db, changes) {
       const referencingColumns = [];
       for (const [tableName, tableIR] of db.tables) {
         for (const col of tableIR.columns) {
-          if (col.originalDbType === name) {
-            referencingColumns.push({ table: tableName, column: col.name });
+          const kind = col.originalDbType !== void 0 ? enumReferenceKind(col.originalDbType, name) : null;
+          if (kind !== null) {
+            referencingColumns.push({
+              table: tableName,
+              column: col.name,
+              ...kind === "array" ? { isArray: true } : {}
+            });
           }
         }
       }
@@ -14402,6 +14759,7 @@ function vectorDims(column) {
 
 // src/introspection.ts
 init_assert_field();
+init_db_type();
 import { ModelIRImpl } from "@dbsp/core";
 import { buildRelationKeyFields } from "@dbsp/types";
 function parseExpressionsList(raw) {
@@ -14438,7 +14796,8 @@ async function queryAllCatalogs(pool, schema) {
     extensionsResult,
     sequencesResult,
     rlsResult,
-    policiesResult
+    policiesResult,
+    formattedColumnTypesResult
   ] = await Promise.all([
     // 1. Columns (including identity and collation)
     pool.query(
@@ -14672,6 +15031,29 @@ async function queryAllCatalogs(pool, schema) {
 			 JOIN pg_namespace n ON n.oid = c.relnamespace
 			 WHERE n.nspname = $1`,
       [schema]
+    ),
+    // 14. Faithful SQL-facing column types via format_type, for two cases:
+    // (a) typmod-bearing columns (atttypmod <> -1) — varchar(120), numeric(10,2),
+    //     timestamptz(3), bit(8), vector(768) — to preserve modifier fidelity (#261);
+    // (b) array columns (typcategory 'A') — so integer[] is stored as `integer[]`
+    //     rather than the internal `_int4` udt_name.
+    // Other columns (plain base types, enums/composites/domains) fall back to
+    // quoteTypeIdentifier(udt_name) in buildTableIR, which keeps a bare typname for
+    // lowercase types and quotes a case-sensitive custom type (`"Money"`).
+    pool.query(
+      `SELECT c.relname AS table_name,
+			        a.attname AS column_name,
+			        format_type(a.atttypid, a.atttypmod) AS db_type
+			 FROM pg_catalog.pg_attribute a
+			 JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+			 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+			 JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+			 WHERE n.nspname = $1
+			   AND c.relkind IN ('r','p','v','m','f')
+			   AND a.attnum > 0
+			   AND NOT a.attisdropped
+			   AND (a.atttypmod <> -1 OR t.typcategory = 'A')`,
+      [schema]
     )
   ]);
   return {
@@ -14687,7 +15069,8 @@ async function queryAllCatalogs(pool, schema) {
     extensions: extensionsResult.rows,
     sequences: sequencesResult.rows,
     rls: rlsResult.rows,
-    policies: policiesResult.rows
+    policies: policiesResult.rows,
+    formattedColumnTypes: formattedColumnTypesResult.rows
   };
 }
 function buildPartitionMap(rows) {
@@ -14879,6 +15262,16 @@ function buildRLSMaps(rlsRows, policiesRows) {
   }
   return { tableRlsEnabled, tablePolicies };
 }
+function columnTypeMapKey(tableName, columnName) {
+  return `${tableName}\0${columnName}`;
+}
+function buildFormattedColumnTypeMap(rows) {
+  const result = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    result.set(columnTypeMapKey(row.table_name, row.column_name), row.db_type);
+  }
+  return result;
+}
 function buildTableIR(tableName, ctx) {
   const rawCols = ctx.tableColumns.get(tableName) ?? [];
   const pkCols = ctx.tablePKs.get(tableName);
@@ -14896,7 +15289,13 @@ function buildTableIR(tableName, ctx) {
       // it verbatim (e.g. CURRENT_TIMESTAMP, nextval('seq'::regclass)) instead
       // of quoting it as a string literal.
       ...col.column_default != null ? { default: { sql: col.column_default } } : {},
-      originalDbType: col.udt_name,
+      // format_type output (typmod-bearing + array columns) is already
+      // SQL-facing; the udt_name fallback is a bare catalog typname, so
+      // quote it when case-sensitive (`"Money"`) — a lowercase typname
+      // stays bare, preserving the common enum/UDT identity.
+      originalDbType: ctx.formattedColumnTypes.get(
+        columnTypeMapKey(tableName, col.column_name)
+      ) ?? quoteTypeIdentifier(col.udt_name),
       ...uniqueConstraintName !== void 0 ? { unique: true, uniqueConstraintName } : {},
       ...collation ? { collation } : {},
       ...identity ? { identity } : {},
@@ -14966,6 +15365,9 @@ async function introspect(pool, options) {
   const tableIndexes = buildIndexMap(raw.indexes);
   const uniqueColumns = buildUniqueColumnMap(raw.uniqueColumns);
   const tableColumns = buildColumnMap(raw.columns);
+  const formattedColumnTypes = buildFormattedColumnTypeMap(
+    raw.formattedColumnTypes
+  );
   const tablePKs = buildPKMap(raw.pks);
   const fksByConstraint = buildFKMap(raw.fks);
   const enumMap = buildEnumMap(raw.enums);
@@ -14980,6 +15382,7 @@ async function introspect(pool, options) {
   for (const tableName of tableNames) {
     const table = buildTableIR(tableName, {
       tableColumns,
+      formattedColumnTypes,
       tablePKs,
       fksByConstraint,
       tableIndexes,
@@ -16027,11 +16430,7 @@ init_naming_plugin();
 init_param_ref();
 
 // src/pgsql-adapter.ts
-import {
-  POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2,
-  plan as planFn2,
-  validateTypeName as validateTypeName4
-} from "@dbsp/core";
+import { POSTGRESQL_CAPABILITIES as POSTGRESQL_CAPABILITIES2, plan as planFn2 } from "@dbsp/core";
 import { getNqlBindingRefName as getNqlBindingRefName2, isNqlBindingRef as isNqlBindingRef2 } from "@dbsp/types/internal";
 
 // src/adapter-compiler-includes.ts
@@ -16251,6 +16650,7 @@ init_compile_where();
 import { countDistinctRelationPathsByName } from "@dbsp/core";
 import { toColumnList as toColumnList10 } from "@dbsp/types";
 init_compiler_utils();
+init_db_type();
 init_types();
 init_intent_to_decisions();
 init_param_ref();
@@ -17153,16 +17553,6 @@ function buildIncludeTree(allDecisions) {
 }
 
 // src/adapter-compiler-select.ts
-var ADAPTER_MULTIWORD_BASE_TYPES = [
-  "timestamp with time zone",
-  "timestamp without time zone",
-  "time with time zone",
-  "time without time zone",
-  "double precision",
-  "character varying",
-  "bit varying"
-];
-var ADAPTER_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function assertSafeTypeName(typeName, colIndex) {
   const raw = typeName.trim();
   if (raw.length === 0) {
@@ -17170,42 +17560,14 @@ function assertSafeTypeName(typeName, colIndex) {
       `BatchValues compile error: type name at column index ${colIndex} must not be empty.`
     );
   }
-  let rest = raw;
-  if (rest.endsWith("[]")) {
-    rest = rest.slice(0, -2);
-    if (rest.endsWith("[]")) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. At most one array suffix "[]" is allowed as a raw type-name input.`
-      );
-    }
-  }
-  const modifierMatch = rest.match(/\(([^)]*)\)$/);
-  if (modifierMatch) {
-    const inner = modifierMatch[1] ?? "";
-    if (!/^\d+(?:,\d+)?$/.test(inner)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Type modifier must be "(N)" or "(N,M)" with digits only; got "(${inner})".`
-      );
-    }
-    rest = rest.slice(0, rest.length - modifierMatch[0].length).trimEnd();
-  }
-  const baseLower = rest.toLowerCase();
-  if (ADAPTER_MULTIWORD_BASE_TYPES.includes(baseLower)) {
-    return;
-  }
-  const parts = rest.split(".");
-  if (parts.length > 2) {
+  try {
+    validateDbType(raw);
+  } catch (error) {
+    const reason = error instanceof Error ? ` ${error.message}` : "";
     throw new Error(
-      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Schema-qualified types allow at most one dot (schema.type).`
+      `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}.${reason}`
     );
   }
-  for (const part of parts) {
-    if (!ADAPTER_IDENT_RE.test(part)) {
-      throw new Error(
-        `BatchValues compile error: unsafe type name '${typeName}' at column index ${colIndex}. Base type "${part}" is not a valid SQL identifier and is not in the multi-word type allowlist.`
-      );
-    }
-  }
 }
 function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
   const params = [];
@@ -17668,6 +18030,7 @@ function compileWithIncludes(plan, options, deps) {
 init_binding_registry();
 init_compile_where();
 init_compiler_utils();
+init_db_type();
 init_handlers();
 init_cte_compiler();
 function whereIntentAsDecision(where) {
@@ -17780,7 +18143,14 @@ function getColumnTypes(tableName, columns, deps) {
     const columnIR = table.columns.find((c) => c.name === col);
     if (columnIR) {
       result ??= {};
-      result[col] = columnIR.originalDbType ?? columnIR.type;
+      const authored = columnIR.originalDbType?.trim();
+      const castTarget = authored !== void 0 && authored !== "" ? dbTypeCastTarget(validateDbType(authored)) : columnIR.type;
+      if (castTarget.trim().endsWith("[]")) {
+        throw new Error(
+          `Batch mutation of array-typed column '${col}' (${castTarget}) is not supported: unnest flattens multi-dimensional arrays. Use single-row mutations for array columns.`
+        );
+      }
+      result[col] = castTarget;
     }
   }
   return result;
@@ -18567,6 +18937,7 @@ function buildRecursiveAnchorWhere(where, tableAlias, deps, state) {
 init_assert_field();
 init_ast_helpers();
 init_binding_registry();
+init_db_type();
 
 // src/ddl/index-operations.ts
 init_validate();
@@ -19020,7 +19391,8 @@ function resolveRuntimeBindingColumnType(bindingName, sourceTable, columnName) {
       `NQL runtime binding '${bindingName}' cannot resolve projected column '${columnName}' on source table '${sourceTable.name}'.`
     );
   }
-  const dbType = column.originalDbType?.trim() || mapRuntimeBindingColumnType(column.type);
+  const originalDbType = column.originalDbType?.trim();
+  const dbType = originalDbType || mapRuntimeBindingColumnType(column.type);
   if (dbType === void 0 || dbType.trim() === "") {
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${columnName}' on source table '${sourceTable.name}'.`
@@ -19028,14 +19400,14 @@ function resolveRuntimeBindingColumnType(bindingName, sourceTable, columnName) {
   }
   const typeName = dbType.trim();
   try {
-    validateTypeName4(typeName);
+    validateDbType(typeName);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${columnName}': ${reason}`
     );
   }
-  return typeName;
+  return originalDbType !== void 0 ? dbTypeCastTarget(typeName) : typeName;
 }
 function resolveRuntimeBindingColumnTypes(name, binding, model, sourceTableName) {
   if (model === void 0) {
@@ -19069,7 +19441,8 @@ function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}': unsupported aggregate kind '${String(info.fn)}'.`
     );
   }
-  const rawType = info.kind === "aggregate" ? "bigint" : info.originalDbType?.trim() || mapRuntimeBindingColumnType(info.type);
+  const originalDbType = info.kind === "aggregate" ? void 0 : info.originalDbType?.trim();
+  const rawType = info.kind === "aggregate" ? "bigint" : originalDbType || mapRuntimeBindingColumnType(info.type);
   if (rawType === void 0 || rawType.trim() === "") {
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}'.`
@@ -19077,14 +19450,14 @@ function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
   }
   const typeName = rawType.trim();
   try {
-    validateTypeName4(typeName);
+    validateDbType(typeName);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(
       `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${column}': ${reason}`
     );
   }
-  return typeName;
+  return originalDbType !== void 0 ? dbTypeCastTarget(typeName) : typeName;
 }
 function resolveRuntimeBindingCteColumnTypes(name, binding) {
   const columnTypes = binding.columnTypes;