@drzl/analyzer 1.18.0 → 1.21.0

package/dist/index.cjs

@@ -36,10 +36,18 @@ __export(index_exports, {
   isDrizzleView: () => isDrizzleView,
   isReadOnlyRelation: () => isReadOnlyRelation,
   isRelationsV2: () => isRelationsV2,
+  qualifiedForeignTable: () => qualifiedForeignTable,
+  qualifiedTableName: () => qualifiedTableName,
   readRelationsV2: () => readRelationsV2
 });
 module.exports = __toCommonJS(index_exports);
 var import_meta = {};
+function qualifiedTableName(table) {
+  return table.schema ? `${table.schema}.${table.name}` : table.name;
+}
+function qualifiedForeignTable(fk) {
+  return fk.foreignSchema ? `${fk.foreignSchema}.${fk.foreignTable}` : fk.foreignTable;
+}
 function renderSqlLiteral(v) {
   if (v === null || v === void 0) return "NULL";
   if (typeof v === "number" || typeof v === "bigint") return String(v);
@@ -71,15 +79,23 @@ var GEOMETRIC_CLASS_SHAPES = {
   // The object modes. `line({ mode: 'abc' })` is a `PgLineABC` and not a `PgLineObject`, and any
   // mode but `'tuple'` builds the object class: `point({ mode: 'abc' })` is a `PgPointObject` too.
   PgPointObject: { kind: "numberObject", fields: ["x", "y"] },
-  PgLineABC: { kind: "numberObject", fields: ["a", "b", "c"] }
+  PgLineABC: { kind: "numberObject", fields: ["a", "b", "c"] },
+  // `geometry()` and `geometry({ mode: 'xy' })` are two classes, not one class with a flag, and
+  // the fuzzer found both unnamed on this path. Their driver mappers disagree the same way the
+  // point ones do: the default hands back `[1, 2]` and the xy mode hands back `{ x: 1, y: 2 }`.
+  PgGeometry: { kind: "tuple", length: 2 },
+  PgGeometryObject: { kind: "numberObject", fields: ["x", "y"] }
 };
 var V1_ONLY_ENTITY_KINDS = /^(?:MsSql|Cockroach)/;
+var NUMBER_VECTOR_CLASSES = /* @__PURE__ */ new Set(["PgVector", "PgHalfVector", "SingleStoreVector"]);
+var BIT_STRING_CLASSES = /* @__PURE__ */ new Set(["PgBinaryVector"]);
 var BYTE_STRING_CLASSES = /* @__PURE__ */ new Set([
   "MySqlBinary",
   "MySqlVarBinary",
   "SingleStoreBinary",
   "SingleStoreVarBinary"
 ]);
+var BUFFER_CLASSES = /* @__PURE__ */ new Set(["SQLiteBlobBuffer"]);
 function describeV1Column(column) {
   const codec = column?.codec;
   const dataType = column?.dataType;
@@ -98,27 +114,63 @@ function describeV1Column(column) {
   const out = {};
   switch (semantic) {
     case "int8":
+    case "uint8":
     case "int16":
+    case "uint16":
     case "int24":
+    case "uint24":
     case "int32":
+    case "uint32":
     case "int53":
     case "uint53":
-    case "int64": {
+    case "int64":
+    case "uint64": {
+      if (DECIMAL_BIGINT_MODE.test(entityKind)) {
+        out.tsType = "bigint";
+        out.dbType = "NUMERIC";
+        out.integer = true;
+        const range2 = decimalModeRange(column, entityKind, "bigint");
+        if (range2) [out.min, out.max] = range2;
+        break;
+      }
+      if ((semantic === "int64" || semantic === "uint64") && js === "string") {
+        out.tsType = "string";
+        out.dbType = "BIGINT";
+        if (entityKind.startsWith("Pg")) out.format = "pgBigint";
+        else if (entityKind.startsWith("MySql") || entityKind.startsWith("SingleStore"))
+          out.format = "mysqlBigint";
+        break;
+      }
       const range = {
         int8: ["-128", "127"],
+        uint8: ["0", "255"],
         int16: ["-32768", "32767"],
+        uint16: ["0", "65535"],
         int24: ["-8388608", "8388607"],
+        uint24: ["0", "16777215"],
         int32: ["-2147483648", "2147483647"],
+        uint32: ["0", "4294967295"],
         int53: ["-9007199254740991", "9007199254740991"],
         // MySQL `serial` is `bigint unsigned auto_increment`, so it starts at 0 rather than
-        // spanning the signed range.
+        // spanning the signed range. An explicit `bigint({ mode: 'number', unsigned: true })`
+        // states the same semantic and takes the same answer.
         uint53: ["0", "9007199254740991"],
-        int64: ["-9223372036854775808", "9223372036854775807"]
+        int64: ["-9223372036854775808", "9223372036854775807"],
+        uint64: ["0", "18446744073709551615"]
       }[semantic];
       [out.min, out.max] = range;
       out.integer = true;
       out.tsType = js === "bigint" ? "bigint" : "number";
-      out.dbType = semantic === "int8" ? "TINYINT" : semantic === "int16" ? "SMALLINT" : semantic === "int24" ? "MEDIUMINT" : semantic === "int32" ? "INTEGER" : "BIGINT";
+      out.dbType = {
+        int8: "TINYINT",
+        uint8: "TINYINT",
+        int16: "SMALLINT",
+        uint16: "SMALLINT",
+        int24: "MEDIUMINT",
+        uint24: "MEDIUMINT",
+        int32: "INTEGER",
+        uint32: "INTEGER"
+      }[semantic] ?? "BIGINT";
       break;
     }
     case "year":
@@ -134,6 +186,14 @@ function describeV1Column(column) {
       out.integer = false;
       out.tsType = "number";
       out.dbType = semantic === "float" ? "REAL" : "DOUBLE";
+      if (codec === "float4" || codec === "float8") {
+        out.allowsNaN = true;
+        out.allowsInfinity = true;
+      }
+      if (codec === "float" || codec === "double" || codec === "real" || entityKind.startsWith("SingleStore")) {
+        out.allowsNaN = false;
+        out.allowsInfinity = false;
+      }
       break;
     }
     case "uuid":
@@ -163,6 +223,16 @@ function describeV1Column(column) {
       out.dbType = codec?.startsWith("timestamp") ? "TIMESTAMP" : "DATE";
       break;
     case "timestamp":
+    // `datetime` is the same fact under MySQL's name for it, and it had no arm, so every column
+    // stating it fell to the bare-string arm and was labelled TEXT. The columns that reach this
+    // are the string modes of `datetime` on mssql, mysql and singlestore, plus mssql's
+    // `datetime2` and `datetimeoffset`, swept over every builder the six v1 cores export; the
+    // `{ mode: 'date' }` half of the same builders states `object date` and takes the arm above.
+    // A label only, since `dbType` is read outside this file in exactly one place,
+    // `isIntegerColumn`, which the generators consult for a `tsType` of `number`. It matters
+    // because the class-name path already answers TIMESTAMP for the same 0.4x column, and the
+    // two majors disagreeing about a column is what the cross-major diff exists to catch.
+    case "datetime":
       out.tsType = js === "string" ? "string" : "Date";
       out.dbType = "TIMESTAMP";
       break;
@@ -184,13 +254,25 @@ function describeV1Column(column) {
       const entity = String(column?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
       const bytes = entity.startsWith("MySql") || entity.startsWith("SingleStore");
       out.tsType = "string";
-      out.dbType = codec === "bit" ? "BIT" : "BINARY";
+      out.dbType = bytes ? "BINARY" : "BIT";
       out.shape = bytes ? { kind: "byteString", length: declaredLength(column) } : {
         kind: "bitstring",
         length: declaredLength(column),
         // A Postgres `bit(3)` holds exactly three digits; a Cockroach `varbit(16)` holds at
         // most that many, which is why `''` is valid there and not here.
-        exact: codec === "bit"
+        //
+        // `codec === 'bit'` alone was Postgres's answer applied to everything, and Cockroach
+        // states no codec, so both of its builders came back `exact: false` and a `bit(3)`
+        // was indistinguishable from a `varbit(3)`. Measured on CockroachDB v24.3.5: a
+        // `bit(3)` refuses '', '1', '10' and '1011' with "bit string length n does not match
+        // type BIT(3)" and takes '101'; a `varbit(8)` takes '', '1' and '10101010' and
+        // refuses nine digits with "too large for type VARBIT(8)". `drizzle-orm/zod` at
+        // 1.0.0-rc.4 answers the same for both columns.
+        //
+        // The class rather than a prefix, because `CockroachVarbit` starts with neither
+        // `CockroachBit` nor anything else this could key on without catching the varying
+        // half too.
+        exact: codec === "bit" || entity === "CockroachBit"
       };
       break;
     }
@@ -216,7 +298,16 @@ function describeV1Column(column) {
       out.dbType = "LINE";
       out.shape = js === "object" ? { kind: "numberObject", fields: ["a", "b", "c"] } : { kind: "tuple", length: 3 };
       break;
+    // `halfvec` beside `vector`, because they differ in storage width and in nothing a validator
+    // can see: `mapFromDriverValue` on both hands back `[1, 2, 3]`. It had no arm and came back
+    // `unknown` on this path too, which the fuzzer found.
+    //
+    // `sparsevec` is deliberately not here. Its name says vector and its value is the string
+    // `{1:1.5,3:2}/3`, so typing it `number[]` for symmetry would reject every row the database
+    // returns. Its codec already answers `string` on its own, which is the same conclusion reached
+    // without this arm.
     case "vector":
+    case "halfvec":
       out.tsType = "number[]";
       out.dbType = "VECTOR";
       out.shape = { kind: "numberVector", length: declaredLength(column) };
@@ -233,7 +324,12 @@ function describeV1Column(column) {
         out.tsType = "number";
         out.dbType = "NUMERIC";
         out.integer = false;
-        [out.min, out.max] = JS_SAFE_INTEGER_BOUNDS;
+        const range = decimalModeRange(column, entityKind, "number");
+        if (range) [out.min, out.max] = range;
+        if (codec === "numeric:number") {
+          out.allowsNaN = true;
+          out.allowsInfinity = !declaredDecimalRange(column);
+        }
       } else if (js === "string") {
         out.tsType = "string";
         out.dbType = codec === "varchar" ? "VARCHAR" : codec === "char" ? "CHAR" : "TEXT";
@@ -261,6 +357,28 @@ function declaredLength(column) {
   const n = column?.length ?? column?.config?.length ?? column?.config?.dimensions;
   return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : void 0;
 }
+function declaredDecimalRange(column) {
+  const cfg = column?.config ?? {};
+  const precision = column?.precision ?? cfg.precision;
+  const scale = column?.scale ?? cfg.scale ?? 0;
+  if (typeof precision !== "number" || !Number.isInteger(precision) || precision < 1)
+    return void 0;
+  if (typeof scale !== "number" || !Number.isInteger(scale) || scale < 0) return void 0;
+  const nines = "9".repeat(precision);
+  const max = scale === 0 ? nines : scale < precision ? `${nines.slice(0, precision - scale)}.${nines.slice(precision - scale)}` : `0.${"0".repeat(scale - precision)}${nines}`;
+  return [`-${max}`, max];
+}
+var DECIMAL_NUMBER_MODE = /(?:Numeric|Decimal)Number$/;
+var DECIMAL_BIGINT_MODE = /(?:Numeric|Decimal)BigInt$/;
+var MYSQL_IMPLICIT_DECIMAL_RANGE = ["-9999999999", "9999999999"];
+function decimalModeRange(column, kind, mode) {
+  const declared = declaredDecimalRange(column);
+  if (declared) return declared;
+  if (kind.startsWith("MySql") || kind.startsWith("SingleStore"))
+    return MYSQL_IMPLICIT_DECIMAL_RANGE;
+  if (kind.startsWith("SQLite")) return void 0;
+  return mode === "number" ? JS_SAFE_INTEGER_BOUNDS : void 0;
+}
 var VIEW_CONFIG_FIELDS = {
   "drizzle:Columns": "selectedFields",
   "drizzle:Name": "name",
@@ -305,28 +423,51 @@ function isRelationsV2(val) {
     )
   );
 }
+function qualifiedNameOfDrizzleTable(tbl) {
+  const name = getSymbolOf(tbl, "drizzle:Name");
+  if (typeof name !== "string" || !name) return void 0;
+  const schema = getSymbolOf(tbl, "drizzle:Schema");
+  return typeof schema === "string" && schema ? `${schema}.${name}` : name;
+}
 function readRelationsV2(val, issues = []) {
   const out = [];
   for (const [tableKey, entry] of Object.entries(val)) {
-    const from = getSymbolOf(entry.table, "drizzle:Name") ?? entry.name ?? tableKey;
+    const from = qualifiedNameOfDrizzleTable(entry.table) ?? entry.name ?? tableKey;
     for (const [fieldName, r] of Object.entries(entry.relations ?? {})) {
-      const to = r?.targetTableName;
+      const to = qualifiedNameOfDrizzleTable(r?.targetTable) ?? r?.targetTableName;
       if (typeof to !== "string" || !to) {
         issues.push({
           code: "DRZL_ANL_REL_V2",
           level: "warn",
-          message: `Relation "${fieldName}" on "${from}" names no target table and was skipped.`
+          message: `Relation "${fieldName}" on "${from}" names no target table and was skipped.`,
+          path: from
         });
         continue;
       }
-      const via = getSymbolOf(r.throughTable, "drizzle:Name") ?? getSymbolOf(r.through?.sourceTable, "drizzle:Name") ?? void 0;
+      const via = qualifiedNameOfDrizzleTable(r.throughTable) ?? qualifiedNameOfDrizzleTable(r.through?.sourceTable) ?? void 0;
       if (via) out.push({ kind: "manyToMany", from, to, via });
       else out.push({ kind: r.relationType === "many" ? "many" : "one", from, to });
     }
   }
   return out;
 }
+function unknownColumnHint(reason) {
+  if (reason === "custom") {
+    return "A customType has no runtime shape to read. Declare it with .$type<T>() and turn on typedColumns to give the validator the type.";
+  }
+  if (reason === "gel-temporal") {
+    return "A Gel temporal column holds an instance of a class from the `gel` package, which DRZL cannot import, so it is left untyped on purpose rather than guessed at. Turn on typedColumns to recover the declared type, and validate the value yourself.";
+  }
+  return "Open an issue naming the column type so it can be modelled, or declare it with .$type<T>() and turn on typedColumns.";
+}
 var _SchemaAnalyzer = class _SchemaAnalyzer {
+  /**
+   * One path or several. The plural exists for drizzle-kit interop: kit's `schema` key names
+   * files in the plural (arrays, globs), and the commonest multi-file layout is a directory of
+   * one file per table with no barrel, so there is no single module to point at. Entries are
+   * concrete files, never globs; expansion is the caller's job, so this class's contract stays
+   * "load exactly these modules and read their exports as one schema".
+   */
   constructor(schemaPath) {
     this.schemaPath = schemaPath;
   }
@@ -376,6 +517,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         code: "DRZL_ANL_EXTRACONFIG",
         level: "warn",
         message: `Could not evaluate the extra-config callback for table "${tableName}": ${e.message}`,
+        path: tableName,
         hint: "Indexes, composite keys, checks and table-level foreign keys will be missing for this table."
       });
       return [];
@@ -429,9 +571,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     };
     const foreignColumnsObj = this.getSymbol(ref.foreignTable, "drizzle:Columns") ?? {};
     const toForeignTs = this.dbToTsNames(foreignColumnsObj);
+    const foreignSchema = this.getSymbol(ref.foreignTable, "drizzle:Schema");
     return {
       columns: (ref.columns ?? []).map((c) => toTs(c?.name)),
       foreignTable: this.getSymbol(ref.foreignTable, "drizzle:Name") ?? "unknown",
+      ...foreignSchema ? { foreignSchema } : {},
       foreignColumns: (ref.foreignColumns ?? []).map((c) => toForeignTs(c?.name)),
       onDelete: action(fk?.onDelete, fk?._onDelete),
       onUpdate: action(fk?.onUpdate, fk?._onUpdate),
@@ -480,7 +624,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
    * on each returned value, so the stand-in results must carry that method or the call throws.
    */
   readRelationsObject(val, exportName, issues) {
-    const from = this.getSymbol(val.table, "drizzle:Name") ?? exportName;
+    const from = qualifiedNameOfDrizzleTable(val.table) ?? exportName;
     const make = (kind) => (table, cfg) => ({
       kind,
       referencedTable: table,
@@ -494,7 +638,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       const built = val.config({ one: make("one"), many: make("many") });
       const out = [];
       for (const rel of Object.values(built ?? {})) {
-        const to = this.getSymbol(rel?.referencedTable, "drizzle:Name");
+        const to = qualifiedNameOfDrizzleTable(rel?.referencedTable);
         if (to) out.push({ kind: rel.kind, from, to });
       }
       return out;
@@ -503,6 +647,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         code: "DRZL_ANL_RELATIONS",
         level: "warn",
         message: `Could not read the relations declared in "${exportName}": ${e.message}`,
+        path: from,
         hint: "Relations for this table will be missing from the analysis."
       });
       return [];
@@ -523,10 +668,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (fks.length < 2) continue;
       const fkCols = new Set(fks.flatMap((f) => f.columns));
       if (!t.columns.every((c) => fkCols.has(c.name))) continue;
-      const targets = [...new Set(fks.map((f) => f.foreignTable))];
+      const targets = [...new Set(fks.map(qualifiedForeignTable))];
       if (targets.length !== 2) continue;
-      out.push({ kind: "manyToMany", from: targets[0], to: targets[1], via: t.name });
-      out.push({ kind: "manyToMany", from: targets[1], to: targets[0], via: t.name });
+      const via = qualifiedTableName(t);
+      out.push({ kind: "manyToMany", from: targets[0], to: targets[1], via });
+      out.push({ kind: "manyToMany", from: targets[1], to: targets[0], via });
     }
     return out;
   }
@@ -543,7 +689,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     if (typeof length === "number" && Number.isFinite(length) && length > 0) {
       out.maxLength = length;
     }
-    const range = _SchemaAnalyzer.INT_RANGES[ctor];
+    const unsignedRange = column?.config?.unsigned === true ? _SchemaAnalyzer.UNSIGNED_INT_RANGES[ctor] : void 0;
+    const range = unsignedRange ?? _SchemaAnalyzer.INT_RANGES[ctor];
     if (range) {
       [out.min, out.max] = range;
       out.integer = true;
@@ -553,6 +700,24 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (inexact) [out.min, out.max] = inexact;
       out.integer = false;
     }
+    const nonFinite = _SchemaAnalyzer.NON_FINITE_BY_CLASS[ctor];
+    if (nonFinite) {
+      out.allowsNaN = nonFinite.nan;
+      out.allowsInfinity = nonFinite.infinity;
+    }
+    if (DECIMAL_NUMBER_MODE.test(ctor)) {
+      const range2 = decimalModeRange(column, ctor, "number");
+      if (range2) [out.min, out.max] = range2;
+      out.integer = false;
+      if (ctor === "PgNumericNumber") {
+        out.allowsNaN = true;
+        out.allowsInfinity = !declaredDecimalRange(column);
+      }
+    } else if (DECIMAL_BIGINT_MODE.test(ctor)) {
+      const range2 = decimalModeRange(column, ctor, "bigint");
+      if (range2) [out.min, out.max] = range2;
+      out.integer = true;
+    }
     if (/^(Pg)?UUID$/i.test(ctor) || /Uuid$/i.test(ctor)) out.format = "uuid";
     return out;
   }
@@ -564,12 +729,36 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           tsType: column?.config?.mode === "timestamp" ? "Date" : "number",
           dbType: "INTEGER"
         };
+      // Both timestamp modes of `integer()`, which are one class and one type. `timestamp` and
+      // `timestamp_ms` differ in the scale of the number on the wire, seconds against
+      // milliseconds, and `mapFromDriverValue` consumes that difference and hands back a `Date`
+      // either way; nothing downstream of the analyzer ever sees the integer. So an arm keyed on
+      // the class covers both, where the mode check that used to answer this fell through the
+      // switch to a default arm testing `config.mode === 'timestamp'` and named only the first.
+      // The second came back `unknown`, and every generator emitted a schema accepting anything.
+      //
+      // `DATE` rather than the `INTEGER` that mode check returned, so the two majors describe the
+      // column identically. `dbType` is read in exactly one place outside this file,
+      // `isIntegerColumn`, which the generators consult only for a `tsType` of `number`, so the
+      // relabel reaches no output. Measured rather than argued: emitting a `Date` column under
+      // both labels, nullable and not, through all five generators gives ten byte-identical pairs.
+      case "SQLiteTimestamp":
+        return { tsType: "Date", dbType: "DATE" };
       case "SQLiteText":
         return { tsType: "string", dbType: "TEXT" };
       case "SQLiteReal":
         return { tsType: "number", dbType: "REAL" };
+      // No 0.4x column is a `SQLiteBlob`: `sqlite-core` builds a `SQLiteBlobBuffer`, a
+      // `SQLiteBlobJson` or a `SQLiteBigInt`, one per mode, and exports no class of this name at
+      // all. The arm answers the hand-built column in sqlite-types.spec.ts and nothing drizzle
+      // produces, which is why a real `blob()` reached neither it nor anything else.
       case "SQLiteBlob":
         return { tsType: "Uint8Array", dbType: "BLOB" };
+      // The class a real `blob()` and `blob({ mode: 'buffer' })` both build. See `BUFFER_CLASSES`
+      // for the measurement; the answers here are v1's own for the same column, so this is the
+      // two majors agreeing rather than a new opinion.
+      case "SQLiteBlobBuffer":
+        return { tsType: "Buffer", dbType: "BYTEA" };
       // SQLite spells a mode as a distinct class rather than as config, so `text({mode:'json'})`
       // is a `SQLiteTextJson` and matched no arm at all: the column came back UNKNOWN, which is
       // wider than the `any` a json column at least used to get.
@@ -608,6 +797,34 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       case "MySqlEnumColumn":
       case "SingleStoreEnumColumn":
         return { tsType: "string", dbType: "TEXT" };
+      // The pgvector family, found by the analyzer fuzzer: all three came back `unknown` on this
+      // path, so their validators accepted anything. The answers are drizzle's own mappers rather
+      // than the type names, and the three do not agree with each other:
+      //
+      //   vector(3)     SELECT gives [1,2,3]          INSERT sends "[1,2,3]"
+      //   halfvec(3)    SELECT gives [1,2,3]          INSERT sends "[1,2,3]"
+      //   sparsevec(3)  SELECT gives "{1:1.5,3:2}/3"  INSERT sends "{1:1.5,3:2}/3"
+      //
+      // So the two dense ones are number arrays and the sparse one is a string. Typing `sparsevec`
+      // as a vector for symmetry would reject every row the database returns, which is the defect
+      // this family was filed under to begin with. The `shape` carries the dimension count where
+      // one is declared, as the codec path already did for `vector`.
+      case "PgVector":
+      case "PgHalfVector":
+      case "SingleStoreVector":
+        return { tsType: "number[]", dbType: "VECTOR" };
+      // `BIT` rather than `TEXT`, which a first version of this arm returned. v1's codec says `BIT`
+      // for the same column, and the cross-major diff said so: naming the class made ten of its
+      // twelve entries go stale and left `c_bit.dbType` and its nullable twin standing, which is
+      // that check distinguishing a fix from a half fix.
+      case "PgBinaryVector":
+        return { tsType: "string", dbType: "BIT" };
+      case "PgGeometry":
+        return { tsType: "[number, number]", dbType: "GEOMETRY" };
+      case "PgGeometryObject":
+        return { tsType: "{ x: number; y: number }", dbType: "GEOMETRY" };
+      case "PgSparseVector":
+        return { tsType: "string", dbType: "TEXT" };
       case "PgInteger":
       case "PgSmallInt":
         return { tsType: "number", dbType: "INTEGER" };
@@ -728,7 +945,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           }
           if (/Numeric|Float|Double|Real/i.test(ctor))
             return { tsType: "number", dbType: "NUMERIC" };
-          if (/Int|Serial|TinyInt|SmallInt|MediumInt/i.test(ctor))
+          if (/Serial/i.test(ctor)) return { tsType: "number", dbType: "BIGINT" };
+          if (/Int|TinyInt|SmallInt|MediumInt/i.test(ctor))
             return { tsType: "number", dbType: "INTEGER" };
           if (/Bool|Boolean/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampString|DateTimeString|DateString/i.test(ctor))
@@ -752,7 +970,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           }
           if (/Numeric|Float|Double|Real/i.test(ctor))
             return { tsType: "number", dbType: "NUMERIC" };
-          if (/Int|Serial|TinyInt|SmallInt|MediumInt/i.test(ctor))
+          if (/Serial/i.test(ctor)) return { tsType: "number", dbType: "BIGINT" };
+          if (/Int|TinyInt|SmallInt|MediumInt/i.test(ctor))
             return { tsType: "number", dbType: "INTEGER" };
           if (/Bool|Boolean/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampString|DateTimeString|DateString/i.test(ctor))
@@ -768,7 +987,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         if (/^Gel/i.test(ctor)) {
           if (/BigInt64/i.test(ctor)) return { tsType: "bigint", dbType: "BIGINT" };
           if (/Int53|Integer|SmallInt/i.test(ctor)) return { tsType: "number", dbType: "INTEGER" };
-          if (/Real|DoublePrecision/i.test(ctor)) return { tsType: "number", dbType: "NUMERIC" };
+          if (/DoublePrecision/i.test(ctor)) return { tsType: "number", dbType: "DOUBLE" };
+          if (/Real/i.test(ctor)) return { tsType: "number", dbType: "REAL" };
           if (/Decimal/i.test(ctor)) return { tsType: "string", dbType: "NUMERIC" };
           if (/UUID/i.test(ctor)) return { tsType: "string", dbType: "UUID" };
           if (/Json/i.test(ctor)) return { tsType: "any", dbType: "JSON" };
@@ -777,7 +997,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (/Bool/i.test(ctor)) return { tsType: "boolean", dbType: "BOOLEAN" };
           if (/TimestampTz/i.test(ctor)) return { tsType: "Date", dbType: "TIMESTAMPTZ" };
           if (/Timestamp|LocalDateString|LocalTime|DateDuration|RelDuration|Duration/i.test(ctor))
-            return { tsType: "unknown", dbType: "UNKNOWN" };
+            return { tsType: "unknown", dbType: "UNKNOWN", unnameable: "gel-temporal" };
         }
         return { tsType: "unknown", dbType: "UNKNOWN" };
     }
@@ -793,7 +1013,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     const uniqueGroups = /* @__PURE__ */ new Map();
     for (const [colName, outerCol] of Object.entries(columnsObj)) {
       const { element: col, dimensions: arrayDims } = unwrapArrayColumn(outerCol);
-      let { tsType, dbType } = this.mapColumnType(col);
+      const mapped = this.mapColumnType(col);
+      let { tsType, dbType } = mapped;
       if (tsType === "unknown" && /At$/.test(colName)) {
         tsType = "Date";
         dbType = "INTEGER";
@@ -819,11 +1040,13 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       const v1 = describeV1Column(col);
       const constraints = this.columnConstraints(col);
       if (v1?.shape) delete constraints.maxLength;
-      const sqlKind = String(outerCol?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? "");
+      const sqlKind = String(
+        outerCol?.constructor?.[/* @__PURE__ */ Symbol.for("drizzle:entityKind")] ?? ""
+      );
       const sqlType = sqlKind.startsWith("MySql") && typeof col?.getSQLType === "function" ? String(col.getSQLType()).toLowerCase() : void 0;
       const byteCap = sqlType ? MYSQL_TEXT_CAPS[sqlType] : void 0;
       const ctorName = String(col?.constructor?.name ?? "");
-      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : BYTE_STRING_CLASSES.has(ctorName) ? { kind: "byteString", length: declaredLength(col) } : GEOMETRIC_CLASS_SHAPES[ctorName];
+      const fallbackShape = dbType === "JSON" || dbType === "JSONB" || col?.config?.mode === "json" ? { kind: "json" } : BYTE_STRING_CLASSES.has(ctorName) ? { kind: "byteString", length: declaredLength(col) } : BUFFER_CLASSES.has(ctorName) ? { kind: "buffer" } : NUMBER_VECTOR_CLASSES.has(ctorName) ? { kind: "numberVector", length: declaredLength(col) } : BIT_STRING_CLASSES.has(ctorName) ? { kind: "bitstring", length: declaredLength(col), exact: true } : GEOMETRIC_CLASS_SHAPES[ctorName];
       if (fallbackShape?.kind === "byteString") delete constraints.maxLength;
       const shape = (v1?.shape ?? fallbackShape)?.kind;
       const finalTs = v1?.tsType ?? tsType;
@@ -834,13 +1057,26 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           code: "DRZL_ANL_UNKNOWN_COLUMN",
           level: "warn",
           message: `Column "${colName}" on table "${tsName}" has no known type${sqlType2 ? ` (SQL type ${sqlType2})` : ""}, so its validator will accept any value.`,
-          hint: shape === "custom" ? "A customType has no runtime shape to read. Declare it with .$type<T>() and turn on typedColumns to give the validator the type." : "Open an issue naming the column type so it can be modelled, or declare it with .$type<T>() and turn on typedColumns."
+          path: `${tsName}.${colName}`,
+          hint: unknownColumnHint(shape === "custom" ? "custom" : mapped.unnameable)
         });
       }
+      const dims = arrayDims || v1?.arrayDimensions || 0;
+      const declaredSqlType = (() => {
+        let raw;
+        try {
+          raw = typeof outerCol?.getSQLType === "function" ? outerCol.getSQLType() : void 0;
+        } catch {
+          return void 0;
+        }
+        if (typeof raw !== "string" || !raw) return void 0;
+        return raw.endsWith("]") ? raw : raw + "[]".repeat(dims);
+      })();
       columns.push({
         name: colName,
         tsType,
         dbType,
+        ...declaredSqlType ? { sqlType: declaredSqlType } : {},
         nullable,
         hasDefault,
         isGenerated,
@@ -917,6 +1153,7 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       if (!col) continue;
       col.references = {
         table: fk.foreignTable,
+        ...fk.foreignSchema ? { schema: fk.foreignSchema } : {},
         column: fk.foreignColumns[0],
         onDelete: fk.onDelete,
         onUpdate: fk.onUpdate
@@ -945,31 +1182,85 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
     const fs = await import("fs/promises");
     const path = await import("path");
     const issues = [];
-    const full = path.resolve(process.cwd(), this.schemaPath);
-    try {
-      await fs.access(full);
-    } catch (_e) {
-      issues.push({
-        code: "DRZL_ANL_NOFILE",
-        level: "error",
-        message: `Schema file not found: ${this.schemaPath}`
-      });
-      return { dialect: "unknown", tables: [], enums: [], relations: [], issues };
+    const listed = Array.isArray(this.schemaPath);
+    const inputs = listed ? this.schemaPath : [this.schemaPath];
+    const fulls = inputs.map((p) => path.resolve(process.cwd(), p));
+    let missing = false;
+    for (let i = 0; i < fulls.length; i++) {
+      try {
+        await fs.access(fulls[i]);
+      } catch (_e) {
+        missing = true;
+        issues.push({
+          code: "DRZL_ANL_NOFILE",
+          level: "error",
+          message: `Schema file not found: ${inputs[i]}`
+        });
+      }
     }
-    let mod;
-    try {
-      const { default: jiti } = await import("jiti");
-      const jit = jiti(import_meta.url, { moduleCache: false });
-      mod = jit(full);
-    } catch (e) {
-      issues.push({
-        code: "DRZL_ANL_IMPORT",
-        level: "error",
-        message: `Failed to import schema: ${String(e)}`
-      });
+    if (missing) {
       return { dialect: "unknown", tables: [], enums: [], relations: [], issues };
     }
-    const exportsObj = mod?.default && typeof mod.default === "object" ? mod.default : mod;
+    const { default: jiti } = await import("jiti");
+    const jit = jiti(import_meta.url, { moduleCache: false });
+    const exportsObj = {};
+    const exportOrigin = /* @__PURE__ */ new Map();
+    const duplicateDisagreement = (a, b) => {
+      if (Object.is(a, b)) return null;
+      const aCols = this.getSymbol(a, "drizzle:Columns");
+      const bCols = this.getSymbol(b, "drizzle:Columns");
+      if (aCols && bCols) {
+        const aName = this.getSymbol(a, "drizzle:Name");
+        const bName = this.getSymbol(b, "drizzle:Name");
+        const aSchema = this.getSymbol(a, "drizzle:Schema");
+        const bSchema = this.getSymbol(b, "drizzle:Schema");
+        if (aName !== bName || aSchema !== bSchema) {
+          return `two different tables ("${String(aName)}" and "${String(bName)}")`;
+        }
+        if (Object.keys(aCols).join(",") !== Object.keys(bCols).join(",")) {
+          return `two declarations of table "${String(aName)}" with different columns`;
+        }
+        return null;
+      }
+      if (!!aCols !== !!bCols) return "a table and a non-table";
+      const aEnum = a?.enumValues;
+      const bEnum = b?.enumValues;
+      if (Array.isArray(aEnum) && Array.isArray(bEnum)) {
+        return JSON.stringify(aEnum) === JSON.stringify(bEnum) ? null : "two enums with different values";
+      }
+      return null;
+    };
+    for (let i = 0; i < fulls.length; i++) {
+      let mod;
+      try {
+        mod = jit(fulls[i]);
+      } catch (e) {
+        issues.push({
+          code: "DRZL_ANL_IMPORT",
+          level: "error",
+          // The single-path message keeps its historical bytes; a list names the file, since
+          // "the schema" no longer identifies one.
+          message: listed ? `Failed to import schema ${inputs[i]}: ${String(e)}` : `Failed to import schema: ${String(e)}`
+        });
+        return { dialect: "unknown", tables: [], enums: [], relations: [], issues };
+      }
+      const one = mod?.default && typeof mod.default === "object" ? mod.default : mod;
+      for (const [name, val] of Object.entries(one)) {
+        if (!(name in exportsObj)) {
+          exportsObj[name] = val;
+          exportOrigin.set(name, inputs[i]);
+          continue;
+        }
+        const disagreement = duplicateDisagreement(exportsObj[name], val);
+        if (!disagreement) continue;
+        issues.push({
+          code: "DRZL_ANL_DUP_EXPORT",
+          level: "warn",
+          message: `Export "${name}" is ${disagreement}: defined by both ${exportOrigin.get(name)} and ${inputs[i]}; keeping the one in ${exportOrigin.get(name)}.`,
+          path: name
+        });
+      }
+    }
     const tables = [];
     const relations = [];
     const enums = [];
@@ -989,9 +1280,11 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
             }
           }
           if (opts.includeRelations) {
+            const self = qualifiedTableName(table);
             for (const fk of table.foreignKeys ?? []) {
-              relations.push({ kind: "one", from: table.name, to: fk.foreignTable });
-              relations.push({ kind: "many", from: fk.foreignTable, to: table.name });
+              const target = qualifiedForeignTable(fk);
+              relations.push({ kind: "one", from: self, to: target });
+              relations.push({ kind: "many", from: target, to: self });
             }
           }
         } else if (this.isRelationsObject(val)) {
@@ -1019,7 +1312,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
         issues.push({
           code: "DRZL_ANL_TABLE",
           level: "warn",
-          message: `Failed to analyze export ${name}: ${String(e)}`
+          message: `Failed to analyze export ${name}: ${String(e)}`,
+          path: name
         });
       }
     }
@@ -1064,11 +1358,21 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
       relations.push(...this.inferManyToMany(tables));
     }
     if (opts.includeRelations && opts.includeHeuristicRelations) {
-      const tableNames = new Set(tables.map((t) => t.name));
-      const findTarget = (base) => {
-        if (tableNames.has(base)) return base;
-        if (tableNames.has(base + "s")) return base + "s";
-        if (tableNames.has(base + "es")) return base + "es";
+      const byBareName = /* @__PURE__ */ new Map();
+      for (const t of tables) {
+        const list = byBareName.get(t.name);
+        if (list) list.push(t);
+        else byBareName.set(t.name, [t]);
+      }
+      const findTarget = (base, from) => {
+        for (const candidate of [base, base + "s", base + "es"]) {
+          const hits = byBareName.get(candidate);
+          if (!hits?.length) continue;
+          const sameSchema = hits.filter((t) => t.schema === from.schema);
+          if (sameSchema.length === 1) return qualifiedTableName(sameSchema[0]);
+          if (hits.length === 1) return qualifiedTableName(hits[0]);
+          return void 0;
+        }
         return void 0;
       };
       for (const t of tables) {
@@ -1076,8 +1380,8 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
           if (c.references) continue;
           if (c.name.endsWith("Id")) {
             const base = c.name.slice(0, -2);
-            const target = findTarget(base);
-            if (target) relations.push({ kind: "one", from: t.name, to: target });
+            const target = findTarget(base, t);
+            if (target) relations.push({ kind: "one", from: qualifiedTableName(t), to: target });
           }
         }
       }
@@ -1109,6 +1413,12 @@ var _SchemaAnalyzer = class _SchemaAnalyzer {
 _SchemaAnalyzer.INT_RANGES = {
   // 8 bit
   MySqlTinyInt: ["-128", "127"],
+  // Absent until the unsigned fix swept the family: v1 states `number int8` for the same
+  // column, so the majors disagreed about every SingleStore tinyint. That is the shape the
+  // cross-major diff in `scripts/verify-packed.sh` exists to catch, and its fixture carries no
+  // SingleStore table, so unsigned-int-ranges.spec.ts holds these two classes across both
+  // majors instead. The width is the type's, the one `MySqlTinyInt` beside it already carries.
+  SingleStoreTinyInt: ["-128", "127"],
   SQLiteInteger: ["-9223372036854775808", "9223372036854775807"],
   // 16 bit
   PgSmallInt: ["-32768", "32767"],
@@ -1121,6 +1431,8 @@ _SchemaAnalyzer.INT_RANGES = {
   SingleStoreSmallInt: ["-32768", "32767"],
   // 24 bit
   MySqlMediumInt: ["-8388608", "8388607"],
+  // As SingleStoreTinyInt above: v1 states `number int24` and this table said nothing.
+  SingleStoreMediumInt: ["-8388608", "8388607"],
   // 32 bit
   PgInteger: ["-2147483648", "2147483647"],
   PgSerial: ["-2147483648", "2147483647"],
@@ -1135,7 +1447,61 @@ _SchemaAnalyzer.INT_RANGES = {
   PgBigInt64: ["-9223372036854775808", "9223372036854775807"],
   PgBigSerial64: ["-9223372036854775808", "9223372036854775807"],
   MySqlBigInt64: ["-9223372036854775808", "9223372036854775807"],
-  SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"]
+  SingleStoreBigInt64: ["-9223372036854775808", "9223372036854775807"],
+  // MySQL and SingleStore `serial`, which is `bigint unsigned auto_increment`: unsigned by the
+  // builder's own definition, with no `config.unsigned` stating it, so the flag-keyed table
+  // below cannot answer and the range lives here. The mode is number, so the safe-integer
+  // ceiling rather than the column's, exactly as the 53 bit block above. The Postgres serials
+  // stay signed on purpose: a Postgres serial is a plain integer defaulting from a sequence,
+  // and the negative backfill note above applies to them and not to these. Before this entry
+  // the class was in no table at all, so an auto-increment column accepted -1 and the majors
+  // disagreed: v1 states `number uint53` for the same column and was already bounded.
+  MySqlSerial: ["0", "9007199254740991"],
+  SingleStoreSerial: ["0", "9007199254740991"]
+};
+/**
+ * The same widths with `{ unsigned: true }` set, which is the half the table above cannot see.
+ *
+ * On 0.4x the flag moves no class name: `int('x', { unsigned: true })` still builds a
+ * `MySqlInt`, and only `config.unsigned` and the ` unsigned` suffix on `getSQLType()` record
+ * the difference, measured off real 0.45.2 columns. So the table above answered every unsigned
+ * width with its signed range, and the emitted select schema refused every stored value in the
+ * upper half of the column: an `int unsigned` holding 4294967295 failed validation on a row the
+ * database returned, and the same one width up meant `bigint unsigned` refused
+ * 18446744073709551615n.
+ *
+ * The ceilings are the type's, verified against a live MySQL 8.4.11: 255, 65535, 16777215 and
+ * 4294967295 store and return, -1 and each ceiling plus one are refused with
+ * ER_WARN_DATA_OUT_OF_RANGE. The bigint pair keeps the two modes apart for the reason the
+ * signed pair above does: number mode tops out at the safe-integer bound the wire imposes,
+ * bigint mode at the column's own 2^64-1, which a bigint can spell. SingleStore is MySQL wire
+ * compatible, ships the same builders with the same `config.unsigned`, and v1 states the same
+ * `uintN` semantics for it, measured off real rc.4 columns; the entries keep the majors in
+ * agreement, which is what the cross-major diff in `scripts/verify-packed.sh` holds together.
+ *
+ * Keyed by class exactly like `INT_RANGES`, and consulted only when `config.unsigned` is
+ * `true`, so no Postgres or SQLite column can ever reach it: neither dialect has an unsigned
+ * spelling, neither builder accepts the flag, and no class of theirs is named here.
+ */
+_SchemaAnalyzer.UNSIGNED_INT_RANGES = {
+  // 8 bit
+  MySqlTinyInt: ["0", "255"],
+  SingleStoreTinyInt: ["0", "255"],
+  // 16 bit
+  MySqlSmallInt: ["0", "65535"],
+  SingleStoreSmallInt: ["0", "65535"],
+  // 24 bit
+  MySqlMediumInt: ["0", "16777215"],
+  SingleStoreMediumInt: ["0", "16777215"],
+  // 32 bit
+  MySqlInt: ["0", "4294967295"],
+  SingleStoreInt: ["0", "4294967295"],
+  // 53 bit, the JS safe-integer ceiling rather than the column's
+  MySqlBigInt53: ["0", "9007199254740991"],
+  SingleStoreBigInt53: ["0", "9007199254740991"],
+  // 64 bit, representable because the value is a bigint
+  MySqlBigInt64: ["0", "18446744073709551615"],
+  SingleStoreBigInt64: ["0", "18446744073709551615"]
 };
 /**
  * The numeric column classes that are not exact, and the magnitude each one can really hold.
@@ -1186,10 +1552,85 @@ _SchemaAnalyzer.INEXACT_RANGES = {
   SQLiteReal: null,
   SingleStoreDouble: null,
   SingleStoreReal: null,
-  // `numeric({ mode: 'number' })`, which v1 reaches through the bare-number arm of
-  // `describeV1Column`. This one is about what a JS number can carry rather than about the
-  // column, which Postgres caps far lower: it refuses 2147483648 into a `numeric(10,2)`.
-  PgNumericNumber: JS_SAFE_INTEGER_BOUNDS
+  // Gel, whose `real` is a `std::float32` and whose `doublePrecision` is a `std::float64`. Both
+  // used to be answered by a `/Real|DoublePrecision/i` arm that said NUMERIC and stated nothing
+  // else at all, so a `real` column accepted 1e300 and the server refused it.
+  //
+  // Measured on a live Gel 7.1 (`geldata/gel:7`, sys::get_version_as_str() -> 7.1+08db576)
+  // through the `gel` client, casting each literal so the server parses it, and again through a
+  // stored property on a real object type. The float32 edge is Postgres's exactly, to the double:
+  //
+  //   3.4028234663852886e38   accepted, returned unchanged
+  //   3.4028235677973366e38   accepted, and stored as 3.4028234663852886e38
+  //   3.402823567797337e38    refused, "is out of range for type std::float32"
+  //   1e300                   refused, the same way
+  //
+  // The same value accepted, the same next double up refused, and the same rounding down of the
+  // midpoint, so it takes the constant already here rather than a second name for one number.
+  // float64 took 1e300 and Number.MAX_VALUE faithfully, for the reason no 8 byte float has a
+  // truthful finite bound.
+  GelReal: PG_FLOAT4_RANGE,
+  GelDoublePrecision: null
+};
+// `numeric`/`decimal` in either of its two numeric modes is deliberately not in the table above.
+// Its bound is not a fixed magnitude per class but the precision each column declares for itself,
+// which no table keyed on a class name can hold; see `declaredDecimalRange`.
+/**
+ * The number columns whose server has an answer about a non-finite double, and what it is.
+ *
+ * Three states rather than two, and the third is the reason this table has a `false` half at all.
+ * A column present here with `true` stores the value and hands it back, so a schema refusing it
+ * refuses rows the column returns. A column present with `false` is one the server was asked
+ * about and refused, so a schema accepting it promises what the server will not take. A column
+ * *absent* is one nobody has measured, and the generators leave whatever their library does alone
+ * rather than guessing; `nonFiniteAccepted` and `nonFiniteRefused` in `@drzl/validation-core` are
+ * the two readings of that.
+ *
+ * The class-name half of what `describeV1Column` reads off the codec, and the two must agree: a
+ * fact stated on one path and not the other is a schema that changes when the user upgrades
+ * drizzle, which the cross-major diff in `verify-packed.sh` fails on. Every class name here is the
+ * same on both majors, read off real columns on 0.45.2 and on 1.0.0-rc.4, so this table also
+ * answers for a v1 column and the two answers are identical rather than merely compatible.
+ * non-finite-numbers.spec.ts asserts that agreement through the real analyzer.
+ *
+ * Postgres and Gel store all three. Gel joined on a measurement of its own rather than on being
+ * Postgres-backed: a live Gel 7.1 stored `nan`, `inf` and `-inf` in both `std::float32` and
+ * `std::float64` and handed all three back, through a cast and again through a stored property.
+ * Without them every row of such a column failed validation.
+ *
+ * MySQL and SingleStore refuse all three, and that used to be left unstated on the reasoning that
+ * a column stating nothing costs nothing. It cost two libraries: `v.number()` and ArkType's
+ * `number` take both infinities where `z.number()` and `Type.Number()` refuse them, so an
+ * unbounded `double` or `real` accepted a value the server answers `ER_WARN_DATA_OUT_OF_RANGE`
+ * for. Measured on MySQL 8.4.11 in `STRICT_TRANS_TABLES`, on the binary prepared path, which is
+ * the one that puts the real IEEE double on the wire: `float`, `double` and `real` refuse
+ * `Infinity`, `-Infinity` and `NaN` alike, while `double` and `real` store 1e300 and
+ * 3.4028235e38 unchanged. SingleStore is MySQL wire-compatible and unmeasured, and takes MySQL's
+ * answer here exactly as it already takes MySQL's float32 bound in `INEXACT_RANGES`.
+ *
+ * No SQLite class belongs here in either direction. A real SQLite 3.53.4 stores both infinities in
+ * a `real` and hands them back, and silently turns `NaN` into NULL, so it is neither the Postgres
+ * answer nor the MySQL one; it is filed on its own and a column needs both halves of it or none.
+ *
+ * The decimal families are absent too. `PgNumeric` is a string whose pattern already accepts `NaN`
+ * and `Infinity`. `PgNumericNumber` is a per-column question this table cannot ask: it takes `NaN`
+ * at any width and an infinity only where no precision is declared, and `columnConstraints`
+ * answers it beside the bound that decides it. MySQL's `decimal` is absent because the two client
+ * paths disagree: on the binary prepared path MySQL 8.4.11 silently stored `0.00` for all three,
+ * where the text path answers `Incorrect decimal value`, and "refuses" is only half true of a
+ * column that accepted the row.
+ */
+_SchemaAnalyzer.NON_FINITE_BY_CLASS = {
+  PgReal: { nan: true, infinity: true },
+  PgDoublePrecision: { nan: true, infinity: true },
+  GelReal: { nan: true, infinity: true },
+  GelDoublePrecision: { nan: true, infinity: true },
+  MySqlFloat: { nan: false, infinity: false },
+  MySqlDouble: { nan: false, infinity: false },
+  MySqlReal: { nan: false, infinity: false },
+  SingleStoreFloat: { nan: false, infinity: false },
+  SingleStoreDouble: { nan: false, infinity: false },
+  SingleStoreReal: { nan: false, infinity: false }
 };
 var SchemaAnalyzer = _SchemaAnalyzer;
 var index_default = SchemaAnalyzer;
@@ -1200,5 +1641,7 @@ var index_default = SchemaAnalyzer;
   isDrizzleView,
   isReadOnlyRelation,
   isRelationsV2,
+  qualifiedForeignTable,
+  qualifiedTableName,
   readRelationsV2
 });