metal-orm 1.0.46 → 1.0.47

package/dist/index.cjs

@@ -2,8 +2,8 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn4, res) => function __init() {
-  return fn4 && (res = (0, fn4[__getOwnPropNames(fn4)[0]])(fn4 = 0)), res;
+var __esm = (fn5, res) => function __init() {
+  return fn5 && (res = (0, fn5[__getOwnPropNames(fn5)[0]])(fn5 = 0)), res;
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -86,6 +86,7 @@ __export(index_exports, {
   between: () => between,
   bootstrapEntities: () => bootstrapEntities,
   caseWhen: () => caseWhen,
+  cast: () => cast,
   ceil: () => ceil,
   ceiling: () => ceiling,
   char: () => char,
@@ -153,6 +154,7 @@ __export(index_exports, {
   instr: () => instr,
   introspectSchema: () => introspectSchema,
   isCaseExpressionNode: () => isCaseExpressionNode,
+  isCastExpressionNode: () => isCastExpressionNode,
   isExpressionSelectionNode: () => isExpressionSelectionNode,
   isFunctionNode: () => isFunctionNode,
   isNotNull: () => isNotNull,
@@ -575,7 +577,9 @@ var operandTypes = /* @__PURE__ */ new Set([
   "JsonPath",
   "ScalarSubquery",
   "CaseExpression",
-  "WindowFunction"
+  "Cast",
+  "WindowFunction",
+  "ArithmeticExpression"
 ]);
 var hasTypeProperty = (value) => typeof value === "object" && value !== null && "type" in value;
 var isOperandNode = (node) => {
@@ -584,8 +588,9 @@ var isOperandNode = (node) => {
 };
 var isFunctionNode = (node) => isOperandNode(node) && node.type === "Function";
 var isCaseExpressionNode = (node) => isOperandNode(node) && node.type === "CaseExpression";
+var isCastExpressionNode = (node) => isOperandNode(node) && node.type === "Cast";
 var isWindowFunctionNode = (node) => isOperandNode(node) && node.type === "WindowFunction";
-var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
+var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isCastExpressionNode(node) || isWindowFunctionNode(node);
 
 // src/core/ast/expression-builders.ts
 var isLiteralValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
@@ -721,6 +726,11 @@ var caseWhen = (conditions, elseValue) => ({
   })),
   else: elseValue !== void 0 ? toOperand(elseValue) : void 0
 });
+var cast = (expression, castType) => ({
+  type: "Cast",
+  expression: toOperand(expression),
+  castType
+});
 var exists = (subquery) => ({
   type: "ExistsExpression",
   operator: "EXISTS",
@@ -978,6 +988,9 @@ var visitOperand = (node, visitor) => {
     case "AliasRef":
       if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
       break;
+    case "Cast":
+      if (visitor.visitCast) return visitor.visitCast(node);
+      break;
     default:
       break;
   }
@@ -1504,6 +1517,10 @@ var Dialect = class _Dialect {
       parts.push("END");
       return parts.join(" ");
     });
+    this.registerOperandCompiler("Cast", (node, ctx) => {
+      const value = this.compileOperand(node.expression, ctx);
+      return `CAST(${value} AS ${node.castType})`;
+    });
     this.registerOperandCompiler("WindowFunction", (node, ctx) => {
       let result = `${node.name}(`;
       if (node.args.length > 0) {
@@ -1530,6 +1547,11 @@ var Dialect = class _Dialect {
       result += ")";
       return result;
     });
+    this.registerOperandCompiler("ArithmeticExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      return `(${left2} ${node.operator} ${right2})`;
+    });
   }
   // Default fallback, should be overridden by dialects if supported
   compileJsonPath(_node) {
@@ -1562,13 +1584,13 @@ var FunctionTableFormatter = class {
    * @param dialect - The dialect instance for compiling operands.
    * @returns SQL function table expression (e.g., "LATERAL schema.func(args) WITH ORDINALITY AS alias(col1, col2)").
    */
-  static format(fn4, ctx, dialect) {
-    const schemaPart = this.formatSchema(fn4, dialect);
-    const args = this.formatArgs(fn4, ctx, dialect);
-    const base = this.formatBase(fn4, schemaPart, args, dialect);
-    const lateral = this.formatLateral(fn4);
-    const alias = this.formatAlias(fn4, dialect);
-    const colAliases = this.formatColumnAliases(fn4, dialect);
+  static format(fn5, ctx, dialect) {
+    const schemaPart = this.formatSchema(fn5, dialect);
+    const args = this.formatArgs(fn5, ctx, dialect);
+    const base = this.formatBase(fn5, schemaPart, args, dialect);
+    const lateral = this.formatLateral(fn5);
+    const alias = this.formatAlias(fn5, dialect);
+    const colAliases = this.formatColumnAliases(fn5, dialect);
     return `${lateral}${base}${alias}${colAliases}`;
   }
   /**
@@ -1578,9 +1600,9 @@ var FunctionTableFormatter = class {
    * @returns Schema prefix (e.g., "schema.") or empty string.
    * @internal
    */
-  static formatSchema(fn4, dialect) {
-    if (!fn4.schema) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn4.schema) : fn4.schema;
+  static formatSchema(fn5, dialect) {
+    if (!fn5.schema) return "";
+    const quoted = dialect ? dialect.quoteIdentifier(fn5.schema) : fn5.schema;
     return `${quoted}.`;
   }
   /**
@@ -1591,8 +1613,8 @@ var FunctionTableFormatter = class {
    * @returns Comma-separated function arguments.
    * @internal
    */
-  static formatArgs(fn4, ctx, dialect) {
-    return (fn4.args || []).map((a) => {
+  static formatArgs(fn5, ctx, dialect) {
+    return (fn5.args || []).map((a) => {
       if (ctx && dialect) {
         return dialect.compileOperand(a, ctx);
       }
@@ -1608,9 +1630,9 @@ var FunctionTableFormatter = class {
    * @returns Base function call expression (e.g., "schema.func(args) WITH ORDINALITY").
    * @internal
    */
-  static formatBase(fn4, schemaPart, args, dialect) {
-    const ordinality = fn4.withOrdinality ? " WITH ORDINALITY" : "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn4.name) : fn4.name;
+  static formatBase(fn5, schemaPart, args, dialect) {
+    const ordinality = fn5.withOrdinality ? " WITH ORDINALITY" : "";
+    const quoted = dialect ? dialect.quoteIdentifier(fn5.name) : fn5.name;
     return `${schemaPart}${quoted}(${args})${ordinality}`;
   }
   /**
@@ -1619,8 +1641,8 @@ var FunctionTableFormatter = class {
    * @returns "LATERAL " or empty string.
    * @internal
    */
-  static formatLateral(fn4) {
-    return fn4.lateral ? "LATERAL " : "";
+  static formatLateral(fn5) {
+    return fn5.lateral ? "LATERAL " : "";
   }
   /**
    * Formats the table alias for the function table.
@@ -1629,9 +1651,9 @@ var FunctionTableFormatter = class {
    * @returns " AS alias" or empty string.
    * @internal
    */
-  static formatAlias(fn4, dialect) {
-    if (!fn4.alias) return "";
-    const quoted = dialect ? dialect.quoteIdentifier(fn4.alias) : fn4.alias;
+  static formatAlias(fn5, dialect) {
+    if (!fn5.alias) return "";
+    const quoted = dialect ? dialect.quoteIdentifier(fn5.alias) : fn5.alias;
     return ` AS ${quoted}`;
   }
   /**
@@ -1641,9 +1663,9 @@ var FunctionTableFormatter = class {
    * @returns "(col1, col2, ...)" or empty string.
    * @internal
    */
-  static formatColumnAliases(fn4, dialect) {
-    if (!fn4.columnAliases || !fn4.columnAliases.length) return "";
-    const aliases = fn4.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
+  static formatColumnAliases(fn5, dialect) {
+    if (!fn5.columnAliases || !fn5.columnAliases.length) return "";
+    const aliases = fn5.columnAliases.map((col2) => dialect ? dialect.quoteIdentifier(col2) : col2).join(", ");
     return `(${aliases})`;
   }
 };
@@ -1911,8 +1933,8 @@ var SqlDialectBase = class extends Dialect {
     }
     return this.compileTableSource(tableSource);
   }
-  compileFunctionTable(fn4, ctx) {
-    return FunctionTableFormatter.format(fn4, ctx, this);
+  compileFunctionTable(fn5, ctx) {
+    return FunctionTableFormatter.format(fn5, ctx, this);
   }
   compileDerivedTable(table, ctx) {
     if (!table.alias) {
@@ -2536,16 +2558,7 @@ var SqlServerDialect = class extends SqlDialectBase {
   }
   compileSelectCoreForMssql(ast, ctx) {
     const columns = ast.columns.map((c) => {
-      let expr = "";
-      if (c.type === "Function") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "Column") {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === "ScalarSubquery") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "WindowFunction") {
-        expr = this.compileOperand(c, ctx);
-      }
+      const expr = c.type === "Column" ? `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}` : this.compileOperand(c, ctx);
       if (c.alias) {
         if (c.alias.includes("(")) return c.alias;
         return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
@@ -6819,15 +6832,11 @@ var PgReferentialConstraints = defineTable(
 async function runSelect(qb, ctx) {
   const ast = qb.getAST();
   const compiled = ctx.dialect.compileSelect(ast);
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  const [first] = results;
-  return toRows(first);
+  return await queryRows(ctx.executor, compiled.sql, compiled.params);
 }
 async function runSelectNode(ast, ctx) {
   const compiled = ctx.dialect.compileSelect(ast);
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  const [first] = results;
-  return toRows(first);
+  return await queryRows(ctx.executor, compiled.sql, compiled.params);
 }
 
 // src/core/ddl/introspect/postgres.ts
@@ -6852,6 +6861,32 @@ var postgresIntrospector = {
       ordinal_position: PgInformationSchemaColumns.columns.ordinal_position
     }).where(eq(PgInformationSchemaColumns.columns.table_schema, schema)).orderBy(PgInformationSchemaColumns.columns.table_name).orderBy(PgInformationSchemaColumns.columns.ordinal_position);
     const columnRows = await runSelect(qbColumns, ctx);
+    const columnCommentRows = await queryRows(
+      ctx.executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        cls.relname AS table_name,
+        att.attname AS column_name,
+        pg_catalog.col_description(cls.oid, att.attnum) AS description
+      FROM pg_catalog.pg_attribute att
+      JOIN pg_catalog.pg_class cls ON cls.oid = att.attrelid
+      JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+      WHERE ns.nspname = $1
+        AND att.attnum > 0
+        AND NOT att.attisdropped
+      `,
+      [schema]
+    );
+    const columnComments = /* @__PURE__ */ new Map();
+    columnCommentRows.forEach((r) => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!r.description) return;
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const trimmed = r.description.trim();
+      if (!trimmed) return;
+      columnComments.set(key, trimmed);
+    });
     const qbPk = new SelectQueryBuilder(PgKeyColumnUsage).select({
       table_schema: PgKeyColumnUsage.columns.table_schema,
       table_name: PgKeyColumnUsage.columns.table_name,
@@ -6879,7 +6914,9 @@ var postgresIntrospector = {
       constraint_name: PgKeyColumnUsage.columns.constraint_name,
       foreign_table_schema: PgConstraintColumnUsage.columns.table_schema,
       foreign_table_name: PgConstraintColumnUsage.columns.table_name,
-      foreign_column_name: PgConstraintColumnUsage.columns.column_name
+      foreign_column_name: PgConstraintColumnUsage.columns.column_name,
+      delete_rule: PgReferentialConstraints.columns.delete_rule,
+      update_rule: PgReferentialConstraints.columns.update_rule
     }).innerJoin(PgTableConstraints, eq(PgTableConstraints.columns.constraint_name, PgKeyColumnUsage.columns.constraint_name)).innerJoin(PgConstraintColumnUsage, eq(PgConstraintColumnUsage.columns.constraint_name, PgTableConstraints.columns.constraint_name)).innerJoin(PgReferentialConstraints, eq(PgReferentialConstraints.columns.constraint_name, PgTableConstraints.columns.constraint_name)).where(eq(PgTableConstraints.columns.constraint_type, "FOREIGN KEY")).where(eq(PgKeyColumnUsage.columns.table_schema, schema));
     const fkRows = await runSelect(qbFk, ctx);
     const fkMap = /* @__PURE__ */ new Map();
@@ -6889,8 +6926,8 @@ var postgresIntrospector = {
       existing.push({
         table: `${r.foreign_table_schema}.${r.foreign_table_name}`,
         column: r.foreign_column_name,
-        onDelete: void 0,
-        onUpdate: void 0
+        onDelete: r.delete_rule,
+        onUpdate: r.update_rule
       });
       fkMap.set(key, existing);
     }
@@ -6994,12 +7031,15 @@ var postgresIntrospector = {
         });
       }
       const cols = tablesByKey.get(key);
+      const commentKey = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const columnComment = columnComments.get(commentKey);
       const fk = fkMap.get(`${r.table_schema}.${r.table_name}.${r.column_name}`)?.[0];
       const column = {
         name: r.column_name,
         type: r.data_type,
         notNull: r.is_nullable === "NO",
         default: r.column_default ?? void 0,
+        comment: columnComment ?? void 0,
         references: fk ? {
           table: fk.table,
           column: fk.column,
@@ -7027,32 +7067,252 @@ var postgresIntrospector = {
   }
 };
 
+// src/core/ddl/introspect/catalogs/mysql.ts
+var INFORMATION_SCHEMA = "information_schema";
+var InformationSchemaTables = defineTable(
+  "tables",
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    table_comment: col.varchar(1024)
+  },
+  {},
+  void 0,
+  { schema: INFORMATION_SCHEMA }
+);
+var InformationSchemaColumns = defineTable(
+  "columns",
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    column_type: col.varchar(255),
+    data_type: col.varchar(255),
+    is_nullable: col.varchar(3),
+    column_default: col.varchar(1024),
+    extra: col.varchar(255),
+    column_comment: col.varchar(1024),
+    ordinal_position: col.int()
+  },
+  {},
+  void 0,
+  { schema: INFORMATION_SCHEMA }
+);
+var InformationSchemaKeyColumnUsage = defineTable(
+  "key_column_usage",
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    ordinal_position: col.int(),
+    referenced_table_schema: col.varchar(255),
+    referenced_table_name: col.varchar(255),
+    referenced_column_name: col.varchar(255)
+  },
+  {},
+  void 0,
+  { schema: INFORMATION_SCHEMA }
+);
+var InformationSchemaReferentialConstraints = defineTable(
+  "referential_constraints",
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    delete_rule: col.varchar(255),
+    update_rule: col.varchar(255)
+  },
+  {},
+  void 0,
+  { schema: INFORMATION_SCHEMA }
+);
+var InformationSchemaStatistics = defineTable(
+  "statistics",
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    index_name: col.varchar(255),
+    non_unique: col.int(),
+    column_name: col.varchar(255),
+    seq_in_index: col.int()
+  },
+  {},
+  void 0,
+  { schema: INFORMATION_SCHEMA }
+);
+
 // src/core/ddl/introspect/mysql.ts
+var tableNode = (table, alias) => ({
+  type: "Table",
+  name: table.name,
+  schema: table.schema,
+  alias
+});
+var columnNode = (table, name, alias) => ({
+  type: "Column",
+  table,
+  name,
+  alias
+});
+var combineConditions = (...expressions) => {
+  const filtered = expressions.filter(Boolean);
+  if (!filtered.length) return void 0;
+  if (filtered.length === 1) return filtered[0];
+  return and(...filtered);
+};
+var databaseFunction = {
+  type: "Function",
+  name: "DATABASE",
+  fn: "DATABASE",
+  args: []
+};
 var mysqlIntrospector = {
   async introspect(ctx, options) {
     const schema = options.schema;
-    const filterClause = schema ? "table_schema = ?" : "table_schema = database()";
-    const params = schema ? [schema] : [];
-    const columnRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default, extra
-      FROM information_schema.columns
-      WHERE ${filterClause}
-      ORDER BY table_name, ordinal_position
-      `,
-      params
-    );
-    const pkRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT table_schema, table_name, column_name
-      FROM information_schema.key_column_usage
-      WHERE constraint_name = 'PRIMARY' AND ${filterClause}
-      ORDER BY ordinal_position
-      `,
-      params
-    );
+    const buildSchemaCondition = (alias) => schema ? eq(columnNode(alias, "table_schema"), schema) : eq(columnNode(alias, "table_schema"), databaseFunction);
+    const tablesQuery = {
+      type: "SelectQuery",
+      from: tableNode(InformationSchemaTables, "t"),
+      columns: [
+        columnNode("t", "table_schema"),
+        columnNode("t", "table_name"),
+        columnNode("t", "table_comment")
+      ],
+      joins: [],
+      where: buildSchemaCondition("t")
+    };
+    const columnsQuery = {
+      type: "SelectQuery",
+      from: tableNode(InformationSchemaColumns, "c"),
+      columns: [
+        columnNode("c", "table_schema"),
+        columnNode("c", "table_name"),
+        columnNode("c", "column_name"),
+        columnNode("c", "column_type"),
+        columnNode("c", "data_type"),
+        columnNode("c", "is_nullable"),
+        columnNode("c", "column_default"),
+        columnNode("c", "extra"),
+        columnNode("c", "column_comment")
+      ],
+      joins: [],
+      where: buildSchemaCondition("c"),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode("c", "table_name"),
+          direction: "ASC"
+        },
+        {
+          type: "OrderBy",
+          term: columnNode("c", "ordinal_position"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const pkQuery = {
+      type: "SelectQuery",
+      from: tableNode(InformationSchemaKeyColumnUsage, "kcu"),
+      columns: [
+        columnNode("kcu", "table_schema"),
+        columnNode("kcu", "table_name"),
+        columnNode("kcu", "column_name")
+      ],
+      joins: [],
+      where: combineConditions(
+        eq(columnNode("kcu", "constraint_name"), "PRIMARY"),
+        buildSchemaCondition("kcu")
+      ),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode("kcu", "ordinal_position"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const fkQuery = {
+      type: "SelectQuery",
+      from: tableNode(InformationSchemaKeyColumnUsage, "kcu"),
+      columns: [
+        columnNode("kcu", "table_schema"),
+        columnNode("kcu", "table_name"),
+        columnNode("kcu", "column_name"),
+        columnNode("kcu", "constraint_name"),
+        columnNode("kcu", "referenced_table_schema"),
+        columnNode("kcu", "referenced_table_name"),
+        columnNode("kcu", "referenced_column_name"),
+        columnNode("rc", "delete_rule"),
+        columnNode("rc", "update_rule")
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode(InformationSchemaReferentialConstraints, "rc"),
+          condition: and(
+            eq({ table: "rc", name: "constraint_schema" }, { table: "kcu", name: "constraint_schema" }),
+            eq({ table: "rc", name: "constraint_name" }, { table: "kcu", name: "constraint_name" })
+          )
+        }
+      ],
+      where: combineConditions(
+        isNotNull(columnNode("kcu", "referenced_table_name")),
+        buildSchemaCondition("kcu")
+      ),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode("kcu", "table_name"),
+          direction: "ASC"
+        },
+        {
+          type: "OrderBy",
+          term: columnNode("kcu", "ordinal_position"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const indexQuery = {
+      type: "SelectQuery",
+      from: tableNode(InformationSchemaStatistics, "stats"),
+      columns: [
+        columnNode("stats", "table_schema"),
+        columnNode("stats", "table_name"),
+        columnNode("stats", "index_name"),
+        columnNode("stats", "non_unique"),
+        {
+          ...groupConcat(columnNode("stats", "column_name"), {
+            orderBy: [{ column: columnNode("stats", "seq_in_index") }]
+          }),
+          alias: "cols"
+        }
+      ],
+      joins: [],
+      where: combineConditions(
+        neq(columnNode("stats", "index_name"), "PRIMARY"),
+        buildSchemaCondition("stats")
+      ),
+      groupBy: [
+        columnNode("stats", "table_schema"),
+        columnNode("stats", "table_name"),
+        columnNode("stats", "index_name"),
+        columnNode("stats", "non_unique")
+      ]
+    };
+    const tableRows = await runSelectNode(tablesQuery, ctx);
+    const columnRows = await runSelectNode(columnsQuery, ctx);
+    const pkRows = await runSelectNode(pkQuery, ctx);
+    const fkRows = await runSelectNode(fkQuery, ctx);
+    const indexRows = await runSelectNode(indexQuery, ctx);
+    const tableComments = /* @__PURE__ */ new Map();
+    tableRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (r.table_comment) {
+        tableComments.set(key, r.table_comment);
+      }
+    });
     const pkMap = /* @__PURE__ */ new Map();
     pkRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}`;
@@ -7060,21 +7320,19 @@ var mysqlIntrospector = {
       list.push(r.column_name);
       pkMap.set(key, list);
     });
-    const indexRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        table_schema,
-        table_name,
-        index_name,
-        non_unique,
-        GROUP_CONCAT(column_name ORDER BY seq_in_index) AS cols
-      FROM information_schema.statistics
-      WHERE ${filterClause} AND index_name <> 'PRIMARY'
-      GROUP BY table_schema, table_name, index_name, non_unique
-      `,
-      params
-    );
+    const fkMap = /* @__PURE__ */ new Map();
+    fkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const list = fkMap.get(key) || [];
+      list.push({
+        table: `${r.referenced_table_schema}.${r.referenced_table_name}`,
+        column: r.referenced_column_name,
+        onDelete: r.delete_rule,
+        onUpdate: r.update_rule,
+        name: r.constraint_name
+      });
+      fkMap.set(key, list);
+    });
     const tablesByKey = /* @__PURE__ */ new Map();
     columnRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}`;
@@ -7085,18 +7343,32 @@ var mysqlIntrospector = {
           schema: r.table_schema,
           columns: [],
           primaryKey: pkMap.get(key) || [],
-          indexes: []
+          indexes: [],
+          comment: tableComments.get(key) || void 0
         });
       }
-      const cols = tablesByKey.get(key);
+      const table = tablesByKey.get(key);
+      const columnType = r.column_type || r.data_type;
+      const comment = r.column_comment?.trim() ? r.column_comment : void 0;
       const column = {
         name: r.column_name,
-        type: r.data_type,
+        type: columnType,
         notNull: r.is_nullable === "NO",
         default: r.column_default ?? void 0,
-        autoIncrement: typeof r.extra === "string" && r.extra.includes("auto_increment")
+        autoIncrement: typeof r.extra === "string" && r.extra.includes("auto_increment"),
+        comment
       };
-      cols.columns.push(column);
+      const fk = fkMap.get(`${key}.${r.column_name}`)?.[0];
+      if (fk) {
+        column.references = {
+          table: fk.table,
+          column: fk.column,
+          onDelete: fk.onDelete,
+          onUpdate: fk.onUpdate,
+          name: fk.name
+        };
+      }
+      table.columns.push(column);
     });
     indexRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}`;
@@ -7124,43 +7396,79 @@ var toReferentialAction = (value) => {
   }
   return void 0;
 };
-var escapeSingleQuotes = (name) => name.replace(/'/g, "''");
+var columnNode2 = (table, name, alias) => ({
+  type: "Column",
+  table,
+  name,
+  alias
+});
+var buildPragmaQuery = (name, table, alias, columnAliases) => ({
+  type: "SelectQuery",
+  from: fnTable(name, [valueToOperand(table)], alias, { columnAliases }),
+  columns: columnAliases.map((column) => columnNode2(alias, column)),
+  joins: []
+});
+var runPragma = async (name, table, alias, columnAliases, ctx) => {
+  const query = buildPragmaQuery(name, table, alias, columnAliases);
+  return await runSelectNode(query, ctx);
+};
 var sqliteIntrospector = {
-  /**
-   * Introspects the SQLite database schema by querying sqlite_master and various PRAGMAs.
-   * @param ctx - The database execution context containing the DbExecutor.
-   * @param options - Options controlling which tables and schemas to include.
-   * @returns A promise that resolves to the introspected DatabaseSchema.
-   */
   async introspect(ctx, options) {
+    const alias = "sqlite_master";
+    const tablesQuery = {
+      type: "SelectQuery",
+      from: { type: "Table", name: "sqlite_master" },
+      columns: [columnNode2(alias, "name")],
+      joins: [],
+      where: and(
+        eq(columnNode2(alias, "type"), "table"),
+        notLike(columnNode2(alias, "name"), "sqlite_%")
+      )
+    };
+    const tableRows = await runSelectNode(tablesQuery, ctx);
     const tables = [];
-    const tableRows = await queryRows(
-      ctx.executor,
-      `SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';`
-    );
     for (const row of tableRows) {
-      const name = row.name;
-      if (!shouldIncludeTable(name, options)) continue;
-      const table = { name, columns: [], primaryKey: [], indexes: [] };
-      const cols = await queryRows(ctx.executor, `PRAGMA table_info('${escapeSingleQuotes(name)}');`);
-      cols.forEach((c) => {
-        table.columns.push({
-          name: c.name,
-          type: c.type,
-          notNull: c.notnull === 1,
-          default: c.dflt_value ?? void 0,
+      const tableName = row.name;
+      if (!shouldIncludeTable(tableName, options)) continue;
+      const tableInfo = await runPragma(
+        "pragma_table_info",
+        tableName,
+        "ti",
+        ["cid", "name", "type", "notnull", "dflt_value", "pk"],
+        ctx
+      );
+      const foreignKeys = await runPragma(
+        "pragma_foreign_key_list",
+        tableName,
+        "fk",
+        ["id", "seq", "table", "from", "to", "on_update", "on_delete", "match"],
+        ctx
+      );
+      const indexList = await runPragma(
+        "pragma_index_list",
+        tableName,
+        "idx",
+        ["seq", "name", "unique"],
+        ctx
+      );
+      const tableEntry = { name: tableName, columns: [], primaryKey: [], indexes: [] };
+      tableInfo.forEach((info) => {
+        tableEntry.columns.push({
+          name: info.name,
+          type: info.type,
+          notNull: info.notnull === 1,
+          default: info.dflt_value ?? void 0,
           autoIncrement: false
         });
-        if (c.pk && c.pk > 0) {
-          table.primaryKey = table.primaryKey || [];
-          table.primaryKey.push(c.name);
+        if (info.pk && info.pk > 0) {
+          tableEntry.primaryKey = tableEntry.primaryKey || [];
+          tableEntry.primaryKey.push(info.name);
         }
       });
-      const fkRows = await queryRows(ctx.executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`);
-      fkRows.forEach((fk) => {
-        const col2 = table.columns.find((c) => c.name === fk.from);
-        if (col2) {
-          col2.references = {
+      foreignKeys.forEach((fk) => {
+        const column = tableEntry.columns.find((col2) => col2.name === fk.from);
+        if (column) {
+          column.references = {
             table: fk.table,
             column: fk.to,
             onDelete: toReferentialAction(fk.on_delete),
@@ -7168,88 +7476,529 @@ var sqliteIntrospector = {
           };
         }
       });
-      const idxList = await queryRows(ctx.executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`);
-      for (const idx of idxList) {
-        const idxName = idx.name;
-        const columnsInfo = await queryRows(ctx.executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`);
+      for (const idx of indexList) {
+        if (!idx.name) continue;
+        const indexColumns = await runPragma(
+          "pragma_index_info",
+          idx.name,
+          "info",
+          ["seqno", "cid", "name"],
+          ctx
+        );
         const idxEntry = {
-          name: idxName,
-          columns: columnsInfo.map((ci) => ({ column: ci.name })),
+          name: idx.name,
+          columns: indexColumns.map((col2) => ({ column: col2.name })),
           unique: idx.unique === 1
         };
-        table.indexes.push(idxEntry);
+        tableEntry.indexes.push(idxEntry);
       }
-      tables.push(table);
+      tables.push(tableEntry);
     }
     return { tables };
   }
 };
 
+// src/core/ddl/introspect/catalogs/mssql.ts
+var SysColumns = defineTable(
+  "columns",
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    column_id: col.int(),
+    max_length: col.int(),
+    precision: col.int(),
+    scale: col.int(),
+    is_nullable: col.boolean(),
+    is_identity: col.boolean(),
+    default_object_id: col.int(),
+    user_type_id: col.int()
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysTables = defineTable(
+  "tables",
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    schema_id: col.int(),
+    is_ms_shipped: col.boolean()
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysSchemas = defineTable(
+  "schemas",
+  {
+    schema_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysTypes = defineTable(
+  "types",
+  {
+    user_type_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysIndexes = defineTable(
+  "indexes",
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    name: col.varchar(255),
+    is_primary_key: col.boolean(),
+    is_unique: col.boolean(),
+    has_filter: col.boolean(),
+    filter_definition: col.varchar(1024),
+    is_hypothetical: col.boolean()
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysIndexColumns = defineTable(
+  "index_columns",
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    column_id: col.int(),
+    key_ordinal: col.int()
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysForeignKeys = defineTable(
+  "foreign_keys",
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    delete_referential_action_desc: col.varchar(64),
+    update_referential_action_desc: col.varchar(64)
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+var SysForeignKeyColumns = defineTable(
+  "foreign_key_columns",
+  {
+    constraint_object_id: col.int(),
+    parent_object_id: col.int(),
+    parent_column_id: col.int(),
+    referenced_object_id: col.int(),
+    referenced_column_id: col.int(),
+    constraint_column_id: col.int()
+  },
+  {},
+  void 0,
+  { schema: "sys" }
+);
+
+// src/core/functions/text.ts
+var isColumnDef = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
+var toOperand2 = (input) => {
+  if (isOperandNode(input)) return input;
+  if (isColumnDef(input)) return columnOperand(input);
+  return valueToOperand(input);
+};
+var fn = (key, args) => ({
+  type: "Function",
+  name: key,
+  fn: key,
+  args: args.map(toOperand2)
+});
+var lower = (value) => fn("LOWER", [value]);
+var upper = (value) => fn("UPPER", [value]);
+var ascii = (value) => fn("ASCII", [value]);
+var char = (...codes) => {
+  if (codes.length === 0) throw new Error("char() expects at least 1 argument");
+  return fn("CHAR", codes);
+};
+var charLength = (value) => fn("CHAR_LENGTH", [value]);
+var length = (value) => fn("LENGTH", [value]);
+var trim = (value, chars) => chars === void 0 ? fn("TRIM", [value]) : fn("TRIM", [value, chars]);
+var ltrim = (value) => fn("LTRIM", [value]);
+var rtrim = (value) => fn("RTRIM", [value]);
+var concat = (...args) => {
+  if (args.length < 2) throw new Error("concat() expects at least 2 arguments");
+  return fn("CONCAT", args);
+};
+var concatWs = (separator, ...args) => {
+  if (args.length < 1) throw new Error("concatWs() expects at least 2 arguments including the separator");
+  return fn("CONCAT_WS", [separator, ...args]);
+};
+var substr = (value, start, length2) => length2 === void 0 ? fn("SUBSTR", [value, start]) : fn("SUBSTR", [value, start, length2]);
+var left = (value, len) => fn("LEFT", [value, len]);
+var right = (value, len) => fn("RIGHT", [value, len]);
+var position = (substring, value) => fn("POSITION", [substring, value]);
+var instr = (value, substring) => fn("INSTR", [value, substring]);
+var locate = (substring, value, start) => start === void 0 ? fn("LOCATE", [substring, value]) : fn("LOCATE", [substring, value, start]);
+var replace = (value, search, replacement) => fn("REPLACE", [value, search, replacement]);
+var repeat = (value, count2) => fn("REPEAT", [value, count2]);
+var lpad = (value, len, pad) => fn("LPAD", [value, len, pad]);
+var rpad = (value, len, pad) => fn("RPAD", [value, len, pad]);
+var space = (count2) => fn("SPACE", [count2]);
+
+// src/core/ddl/introspect/functions/mssql.ts
+var isColumnReference = (value) => typeof value === "object" && value !== null && !("type" in value) && "name" in value && typeof value.name === "string";
+var toOperandNode2 = (value) => {
+  if (isOperandNode(value)) return value;
+  if (isColumnReference(value)) return columnOperand(value);
+  return valueToOperand(value);
+};
+var fn2 = (name, args) => ({
+  type: "Function",
+  name,
+  fn: name,
+  args: args.map((arg) => toOperandNode2(arg))
+});
+var CHAR_TYPES = ["varchar", "char", "varbinary", "binary", "nvarchar", "nchar"];
+var DECIMAL_TYPES = ["decimal", "numeric"];
+var objectDefinition = (objectId) => fn2("OBJECT_DEFINITION", [objectId]);
+var buildMssqlDataType = (typeName, maxLength, precision, scale) => {
+  const typeOperand = toOperandNode2(typeName);
+  const maxLenOperand = toOperandNode2(maxLength);
+  const precisionOperand = toOperandNode2(precision);
+  const scaleOperand = toOperandNode2(scale);
+  const typeLower = lower(typeOperand);
+  const lengthCase = caseWhen(
+    [
+      {
+        when: eq(maxLenOperand, -1),
+        then: "max"
+      },
+      {
+        when: inList(typeLower, ["nvarchar", "nchar"]),
+        then: cast(div(maxLenOperand, 2), "varchar(10)")
+      }
+    ],
+    cast(maxLenOperand, "varchar(10)")
+  );
+  const charSuffix = concat("(", lengthCase, ")");
+  const decimalSuffix = concat(
+    "(",
+    cast(precisionOperand, "varchar(10)"),
+    ",",
+    cast(scaleOperand, "varchar(10)"),
+    ")"
+  );
+  const suffix = caseWhen(
+    [
+      { when: inList(typeLower, CHAR_TYPES), then: charSuffix },
+      { when: inList(typeLower, DECIMAL_TYPES), then: decimalSuffix }
+    ],
+    ""
+  );
+  return concat(typeLower, suffix);
+};
+
 // src/core/ddl/introspect/mssql.ts
+var normalizeReferentialAction = (value) => {
+  if (!value) return void 0;
+  const normalized = value.replace(/_/g, " ").toUpperCase();
+  const allowed = ["NO ACTION", "RESTRICT", "CASCADE", "SET NULL", "SET DEFAULT"];
+  return allowed.includes(normalized) ? normalized : void 0;
+};
+var tableNode2 = (table, alias) => ({
+  type: "Table",
+  name: table.name,
+  schema: table.schema,
+  alias
+});
+var columnNode3 = (table, name, alias) => ({
+  type: "Column",
+  table,
+  name,
+  alias
+});
+var combineConditions2 = (...expressions) => {
+  const filtered = expressions.filter(Boolean);
+  if (!filtered.length) return void 0;
+  if (filtered.length === 1) return filtered[0];
+  return and(...filtered);
+};
 var mssqlIntrospector = {
-  /**
-   * Introspects the MSSQL database schema.
-   * @param ctx - The introspection context containing the database executor.
-   * @param options - Options for introspection, such as schema filter.
-   * @returns A promise that resolves to the introspected database schema.
-   */
   async introspect(ctx, options) {
     const schema = options.schema;
-    const filterSchema = schema ? "sch.name = @p1" : "1=1";
-    const params = schema ? [schema] : [];
-    const columnRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        c.name AS column_name,
-        LOWER(ty.name)
-          + CASE
-            WHEN LOWER(ty.name) IN ('varchar', 'char', 'varbinary', 'binary', 'nvarchar', 'nchar') THEN
-              '('
-              + (
-                CASE
-                  WHEN c.max_length = -1 THEN 'max'
-                  WHEN LOWER(ty.name) IN ('nvarchar', 'nchar') THEN CAST(c.max_length / 2 AS varchar(10))
-                  ELSE CAST(c.max_length AS varchar(10))
-                END
-              )
-              + ')'
-            WHEN LOWER(ty.name) IN ('decimal', 'numeric') THEN
-              '(' + CAST(c.precision AS varchar(10)) + ',' + CAST(c.scale AS varchar(10)) + ')'
-            ELSE
-              ''
-          END AS data_type,
-        c.is_nullable,
-        c.is_identity,
-        object_definition(c.default_object_id) AS column_default
-      FROM sys.columns c
-      JOIN sys.tables t ON t.object_id = c.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      JOIN sys.types ty ON ty.user_type_id = c.user_type_id
-      WHERE t.is_ms_shipped = 0 AND ${filterSchema}
-      `,
-      params
-    );
-    const pkRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        c.name AS column_name,
-        ic.key_ordinal
-      FROM sys.indexes i
-      JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
-      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 1 AND ${filterSchema}
-      ORDER BY ic.key_ordinal
-      `,
-      params
+    const schemaCondition = schema ? eq(columnNode3("sch", "name"), schema) : void 0;
+    const dataTypeExpression = buildMssqlDataType(
+      { table: "ty", name: "name" },
+      { table: "c", name: "max_length" },
+      { table: "c", name: "precision" },
+      { table: "c", name: "scale" }
     );
+    const defaultExpression = objectDefinition({ table: "c", name: "default_object_id" });
+    const columnsQuery = {
+      type: "SelectQuery",
+      from: tableNode2(SysColumns, "c"),
+      columns: [
+        columnNode3("sch", "name", "table_schema"),
+        columnNode3("t", "name", "table_name"),
+        columnNode3("c", "name", "column_name"),
+        { ...dataTypeExpression, alias: "data_type" },
+        columnNode3("c", "is_nullable"),
+        columnNode3("c", "is_identity"),
+        { ...defaultExpression, alias: "column_default" }
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "t"),
+          condition: eq({ table: "t", name: "object_id" }, { table: "c", name: "object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "sch"),
+          condition: eq({ table: "sch", name: "schema_id" }, { table: "t", name: "schema_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTypes, "ty"),
+          condition: eq({ table: "ty", name: "user_type_id" }, { table: "c", name: "user_type_id" })
+        }
+      ],
+      where: combineConditions2(
+        eq({ table: "t", name: "is_ms_shipped" }, 0),
+        schemaCondition
+      )
+    };
+    const pkQuery = {
+      type: "SelectQuery",
+      from: tableNode2(SysIndexes, "i"),
+      columns: [
+        columnNode3("sch", "name", "table_schema"),
+        columnNode3("t", "name", "table_name"),
+        columnNode3("c", "name", "column_name"),
+        columnNode3("ic", "key_ordinal", "key_ordinal")
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysIndexColumns, "ic"),
+          condition: and(
+            eq({ table: "ic", name: "object_id" }, { table: "i", name: "object_id" }),
+            eq({ table: "ic", name: "index_id" }, { table: "i", name: "index_id" })
+          )
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysColumns, "c"),
+          condition: and(
+            eq({ table: "c", name: "object_id" }, { table: "ic", name: "object_id" }),
+            eq({ table: "c", name: "column_id" }, { table: "ic", name: "column_id" })
+          )
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "t"),
+          condition: eq({ table: "t", name: "object_id" }, { table: "i", name: "object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "sch"),
+          condition: eq({ table: "sch", name: "schema_id" }, { table: "t", name: "schema_id" })
+        }
+      ],
+      where: combineConditions2(
+        eq({ table: "i", name: "is_primary_key" }, 1),
+        schemaCondition
+      ),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode3("ic", "key_ordinal"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const fkQuery = {
+      type: "SelectQuery",
+      from: tableNode2(SysForeignKeyColumns, "fkc"),
+      columns: [
+        columnNode3("sch", "name", "table_schema"),
+        columnNode3("t", "name", "table_name"),
+        columnNode3("c", "name", "column_name"),
+        columnNode3("fk", "name", "constraint_name"),
+        columnNode3("rsch", "name", "referenced_schema"),
+        columnNode3("rt", "name", "referenced_table"),
+        columnNode3("rc", "name", "referenced_column"),
+        columnNode3("fk", "delete_referential_action_desc", "delete_rule"),
+        columnNode3("fk", "update_referential_action_desc", "update_rule")
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysForeignKeys, "fk"),
+          condition: eq({ table: "fk", name: "object_id" }, { table: "fkc", name: "constraint_object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "t"),
+          condition: eq({ table: "t", name: "object_id" }, { table: "fkc", name: "parent_object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "sch"),
+          condition: eq({ table: "sch", name: "schema_id" }, { table: "t", name: "schema_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysColumns, "c"),
+          condition: and(
+            eq({ table: "c", name: "object_id" }, { table: "fkc", name: "parent_object_id" }),
+            eq({ table: "c", name: "column_id" }, { table: "fkc", name: "parent_column_id" })
+          )
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "rt"),
+          condition: eq({ table: "rt", name: "object_id" }, { table: "fkc", name: "referenced_object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "rsch"),
+          condition: eq({ table: "rsch", name: "schema_id" }, { table: "rt", name: "schema_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysColumns, "rc"),
+          condition: and(
+            eq({ table: "rc", name: "object_id" }, { table: "fkc", name: "referenced_object_id" }),
+            eq({ table: "rc", name: "column_id" }, { table: "fkc", name: "referenced_column_id" })
+          )
+        }
+      ],
+      where: combineConditions2(
+        eq({ table: "t", name: "is_ms_shipped" }, 0),
+        schemaCondition
+      ),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode3("fk", "name"),
+          direction: "ASC"
+        },
+        {
+          type: "OrderBy",
+          term: columnNode3("fkc", "constraint_column_id"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const indexQuery = {
+      type: "SelectQuery",
+      from: tableNode2(SysIndexes, "i"),
+      columns: [
+        columnNode3("sch", "name", "table_schema"),
+        columnNode3("t", "name", "table_name"),
+        columnNode3("i", "name", "index_name"),
+        columnNode3("i", "is_unique"),
+        columnNode3("i", "has_filter"),
+        columnNode3("i", "filter_definition")
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "t"),
+          condition: eq({ table: "t", name: "object_id" }, { table: "i", name: "object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "sch"),
+          condition: eq({ table: "sch", name: "schema_id" }, { table: "t", name: "schema_id" })
+        }
+      ],
+      where: combineConditions2(
+        eq({ table: "i", name: "is_primary_key" }, 0),
+        eq({ table: "i", name: "is_hypothetical" }, 0),
+        schemaCondition
+      )
+    };
+    const indexColumnsQuery = {
+      type: "SelectQuery",
+      from: tableNode2(SysIndexColumns, "ic"),
+      columns: [
+        columnNode3("sch", "name", "table_schema"),
+        columnNode3("t", "name", "table_name"),
+        columnNode3("i", "name", "index_name"),
+        columnNode3("c", "name", "column_name"),
+        columnNode3("ic", "key_ordinal", "key_ordinal")
+      ],
+      joins: [
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysIndexes, "i"),
+          condition: and(
+            eq({ table: "ic", name: "object_id" }, { table: "i", name: "object_id" }),
+            eq({ table: "ic", name: "index_id" }, { table: "i", name: "index_id" })
+          )
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysColumns, "c"),
+          condition: and(
+            eq({ table: "c", name: "object_id" }, { table: "ic", name: "object_id" }),
+            eq({ table: "c", name: "column_id" }, { table: "ic", name: "column_id" })
+          )
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysTables, "t"),
+          condition: eq({ table: "t", name: "object_id" }, { table: "i", name: "object_id" })
+        },
+        {
+          type: "Join",
+          kind: "INNER",
+          table: tableNode2(SysSchemas, "sch"),
+          condition: eq({ table: "sch", name: "schema_id" }, { table: "t", name: "schema_id" })
+        }
+      ],
+      where: combineConditions2(
+        eq({ table: "i", name: "is_primary_key" }, 0),
+        schemaCondition
+      ),
+      orderBy: [
+        {
+          type: "OrderBy",
+          term: columnNode3("ic", "key_ordinal"),
+          direction: "ASC"
+        }
+      ]
+    };
+    const columnRows = await runSelectNode(columnsQuery, ctx);
+    const pkRows = await runSelectNode(pkQuery, ctx);
+    const fkRows = await runSelectNode(fkQuery, ctx);
+    const indexRows = await runSelectNode(indexQuery, ctx);
+    const indexColsRows = await runSelectNode(indexColumnsQuery, ctx);
     const pkMap = /* @__PURE__ */ new Map();
     pkRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}`;
@@ -7257,42 +8006,19 @@ var mssqlIntrospector = {
       list.push(r.column_name);
       pkMap.set(key, list);
     });
-    const indexRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        i.name AS index_name,
-        i.is_unique,
-        i.has_filter,
-        i.filter_definition
-      FROM sys.indexes i
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 0 AND i.is_hypothetical = 0 AND ${filterSchema}
-      `,
-      params
-    );
-    const indexColsRows = await queryRows(
-      ctx.executor,
-      `
-      SELECT
-        sch.name AS table_schema,
-        t.name AS table_name,
-        i.name AS index_name,
-        c.name AS column_name,
-        ic.key_ordinal
-      FROM sys.index_columns ic
-      JOIN sys.indexes i ON i.object_id = ic.object_id AND i.index_id = ic.index_id
-      JOIN sys.columns c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
-      JOIN sys.tables t ON t.object_id = i.object_id
-      JOIN sys.schemas sch ON sch.schema_id = t.schema_id
-      WHERE i.is_primary_key = 0 AND ${filterSchema}
-      ORDER BY ic.key_ordinal
-      `,
-      params
-    );
+    const fkMap = /* @__PURE__ */ new Map();
+    fkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      const list = fkMap.get(key) || [];
+      list.push({
+        table: `${r.referenced_schema}.${r.referenced_table}`,
+        column: r.referenced_column,
+        onDelete: normalizeReferentialAction(r.delete_rule),
+        onUpdate: normalizeReferentialAction(r.update_rule),
+        name: r.constraint_name
+      });
+      fkMap.set(key, list);
+    });
     const indexColumnsMap = /* @__PURE__ */ new Map();
     indexColsRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
@@ -7313,7 +8039,7 @@ var mssqlIntrospector = {
           indexes: []
         });
       }
-      const t = tablesByKey.get(key);
+      const table = tablesByKey.get(key);
       const column = {
         name: r.column_name,
         type: r.data_type,
@@ -7321,7 +8047,17 @@ var mssqlIntrospector = {
         default: r.column_default ?? void 0,
         autoIncrement: !!r.is_identity
       };
-      t.columns.push(column);
+      const fk = fkMap.get(`${key}.${r.column_name}`)?.[0];
+      if (fk) {
+        column.references = {
+          table: fk.table,
+          column: fk.column,
+          onDelete: fk.onDelete,
+          onUpdate: fk.onUpdate,
+          name: fk.name
+        };
+      }
+      table.columns.push(column);
     });
     indexRows.forEach((r) => {
       const key = `${r.table_schema}.${r.table_name}`;
@@ -7332,7 +8068,7 @@ var mssqlIntrospector = {
         name: r.index_name,
         columns: cols,
         unique: !!r.is_unique,
-        where: r.has_filter ? r.filter_definition : void 0
+        where: r.has_filter ? r.filter_definition ?? void 0 : void 0
       };
       table.indexes = table.indexes || [];
       table.indexes.push(idx);
@@ -7368,51 +8104,6 @@ var introspectSchema = async (executor, dialect, options = {}) => {
   return handler.introspect(ctx, options);
 };
 
-// src/core/functions/text.ts
-var isColumnDef = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
-var toOperand2 = (input) => {
-  if (isOperandNode(input)) return input;
-  if (isColumnDef(input)) return columnOperand(input);
-  return valueToOperand(input);
-};
-var fn = (key, args) => ({
-  type: "Function",
-  name: key,
-  fn: key,
-  args: args.map(toOperand2)
-});
-var lower = (value) => fn("LOWER", [value]);
-var upper = (value) => fn("UPPER", [value]);
-var ascii = (value) => fn("ASCII", [value]);
-var char = (...codes) => {
-  if (codes.length === 0) throw new Error("char() expects at least 1 argument");
-  return fn("CHAR", codes);
-};
-var charLength = (value) => fn("CHAR_LENGTH", [value]);
-var length = (value) => fn("LENGTH", [value]);
-var trim = (value, chars) => chars === void 0 ? fn("TRIM", [value]) : fn("TRIM", [value, chars]);
-var ltrim = (value) => fn("LTRIM", [value]);
-var rtrim = (value) => fn("RTRIM", [value]);
-var concat = (...args) => {
-  if (args.length < 2) throw new Error("concat() expects at least 2 arguments");
-  return fn("CONCAT", args);
-};
-var concatWs = (separator, ...args) => {
-  if (args.length < 1) throw new Error("concatWs() expects at least 2 arguments including the separator");
-  return fn("CONCAT_WS", [separator, ...args]);
-};
-var substr = (value, start, length2) => length2 === void 0 ? fn("SUBSTR", [value, start]) : fn("SUBSTR", [value, start, length2]);
-var left = (value, len) => fn("LEFT", [value, len]);
-var right = (value, len) => fn("RIGHT", [value, len]);
-var position = (substring, value) => fn("POSITION", [substring, value]);
-var instr = (value, substring) => fn("INSTR", [value, substring]);
-var locate = (substring, value, start) => start === void 0 ? fn("LOCATE", [substring, value]) : fn("LOCATE", [substring, value, start]);
-var replace = (value, search, replacement) => fn("REPLACE", [value, search, replacement]);
-var repeat = (value, count2) => fn("REPEAT", [value, count2]);
-var lpad = (value, len, pad) => fn("LPAD", [value, len, pad]);
-var rpad = (value, len, pad) => fn("RPAD", [value, len, pad]);
-var space = (count2) => fn("SPACE", [count2]);
-
 // src/core/functions/numeric.ts
 var isColumnDef2 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
 var toOperand3 = (input) => {
@@ -7420,42 +8111,42 @@ var toOperand3 = (input) => {
   if (isColumnDef2(input)) return columnOperand(input);
   return valueToOperand(input);
 };
-var fn2 = (key, args) => ({
+var fn3 = (key, args) => ({
   type: "Function",
   name: key,
   fn: key,
   args: args.map(toOperand3)
 });
-var abs = (value) => fn2("ABS", [value]);
-var acos = (value) => fn2("ACOS", [value]);
-var asin = (value) => fn2("ASIN", [value]);
-var atan = (value) => fn2("ATAN", [value]);
-var atan2 = (y, x) => fn2("ATAN2", [y, x]);
-var ceil = (value) => fn2("CEIL", [value]);
-var ceiling = (value) => fn2("CEILING", [value]);
-var cos = (value) => fn2("COS", [value]);
-var cot = (value) => fn2("COT", [value]);
-var degrees = (value) => fn2("DEGREES", [value]);
-var exp = (value) => fn2("EXP", [value]);
-var floor = (value) => fn2("FLOOR", [value]);
-var ln = (value) => fn2("LN", [value]);
-var log = (value) => fn2("LOG", [value]);
-var log10 = (value) => fn2("LOG10", [value]);
-var logBase = (base, value) => fn2("LOG_BASE", [base, value]);
-var mod = (x, y) => fn2("MOD", [x, y]);
-var pi = () => fn2("PI", []);
-var power = (x, y) => fn2("POWER", [x, y]);
-var pow = (x, y) => fn2("POW", [x, y]);
-var radians = (value) => fn2("RADIANS", [value]);
-var random = () => fn2("RANDOM", []);
-var rand = () => fn2("RAND", []);
-var round = (value, decimals) => decimals === void 0 ? fn2("ROUND", [value]) : fn2("ROUND", [value, decimals]);
-var sign = (value) => fn2("SIGN", [value]);
-var sin = (value) => fn2("SIN", [value]);
-var sqrt = (value) => fn2("SQRT", [value]);
-var tan = (value) => fn2("TAN", [value]);
-var trunc = (value, decimals) => decimals === void 0 ? fn2("TRUNC", [value]) : fn2("TRUNC", [value, decimals]);
-var truncate = (value, decimals) => fn2("TRUNCATE", [value, decimals]);
+var abs = (value) => fn3("ABS", [value]);
+var acos = (value) => fn3("ACOS", [value]);
+var asin = (value) => fn3("ASIN", [value]);
+var atan = (value) => fn3("ATAN", [value]);
+var atan2 = (y, x) => fn3("ATAN2", [y, x]);
+var ceil = (value) => fn3("CEIL", [value]);
+var ceiling = (value) => fn3("CEILING", [value]);
+var cos = (value) => fn3("COS", [value]);
+var cot = (value) => fn3("COT", [value]);
+var degrees = (value) => fn3("DEGREES", [value]);
+var exp = (value) => fn3("EXP", [value]);
+var floor = (value) => fn3("FLOOR", [value]);
+var ln = (value) => fn3("LN", [value]);
+var log = (value) => fn3("LOG", [value]);
+var log10 = (value) => fn3("LOG10", [value]);
+var logBase = (base, value) => fn3("LOG_BASE", [base, value]);
+var mod = (x, y) => fn3("MOD", [x, y]);
+var pi = () => fn3("PI", []);
+var power = (x, y) => fn3("POWER", [x, y]);
+var pow = (x, y) => fn3("POW", [x, y]);
+var radians = (value) => fn3("RADIANS", [value]);
+var random = () => fn3("RANDOM", []);
+var rand = () => fn3("RAND", []);
+var round = (value, decimals) => decimals === void 0 ? fn3("ROUND", [value]) : fn3("ROUND", [value, decimals]);
+var sign = (value) => fn3("SIGN", [value]);
+var sin = (value) => fn3("SIN", [value]);
+var sqrt = (value) => fn3("SQRT", [value]);
+var tan = (value) => fn3("TAN", [value]);
+var trunc = (value, decimals) => decimals === void 0 ? fn3("TRUNC", [value]) : fn3("TRUNC", [value, decimals]);
+var truncate = (value, decimals) => fn3("TRUNCATE", [value, decimals]);
 
 // src/core/functions/datetime.ts
 var isColumnDef3 = (val) => !!val && typeof val === "object" && "type" in val && "name" in val;
@@ -7464,29 +8155,29 @@ var toOperand4 = (input) => {
   if (isColumnDef3(input)) return columnOperand(input);
   return valueToOperand(input);
 };
-var fn3 = (key, args) => ({
+var fn4 = (key, args) => ({
   type: "Function",
   name: key,
   args: args.map(toOperand4)
 });
-var now = () => fn3("NOW", []);
-var currentDate = () => fn3("CURRENT_DATE", []);
-var currentTime = () => fn3("CURRENT_TIME", []);
-var utcNow = () => fn3("UTC_NOW", []);
-var extract = (part, date) => fn3("EXTRACT", [part, date]);
-var year = (date) => fn3("YEAR", [date]);
-var month = (date) => fn3("MONTH", [date]);
-var day = (date) => fn3("DAY", [date]);
-var dateAdd = (date, interval, unit) => fn3("DATE_ADD", [date, interval, unit]);
-var dateSub = (date, interval, unit) => fn3("DATE_SUB", [date, interval, unit]);
-var dateDiff = (date1, date2) => fn3("DATE_DIFF", [date1, date2]);
-var dateFormat = (date, format) => fn3("DATE_FORMAT", [date, format]);
-var unixTimestamp = () => fn3("UNIX_TIMESTAMP", []);
-var fromUnixTime = (timestamp) => fn3("FROM_UNIXTIME", [timestamp]);
-var endOfMonth = (date) => fn3("END_OF_MONTH", [date]);
-var dayOfWeek = (date) => fn3("DAY_OF_WEEK", [date]);
-var weekOfYear = (date) => fn3("WEEK_OF_YEAR", [date]);
-var dateTrunc = (part, date) => fn3("DATE_TRUNC", [part, date]);
+var now = () => fn4("NOW", []);
+var currentDate = () => fn4("CURRENT_DATE", []);
+var currentTime = () => fn4("CURRENT_TIME", []);
+var utcNow = () => fn4("UTC_NOW", []);
+var extract = (part, date) => fn4("EXTRACT", [part, date]);
+var year = (date) => fn4("YEAR", [date]);
+var month = (date) => fn4("MONTH", [date]);
+var day = (date) => fn4("DAY", [date]);
+var dateAdd = (date, interval, unit) => fn4("DATE_ADD", [date, interval, unit]);
+var dateSub = (date, interval, unit) => fn4("DATE_SUB", [date, interval, unit]);
+var dateDiff = (date1, date2) => fn4("DATE_DIFF", [date1, date2]);
+var dateFormat = (date, format) => fn4("DATE_FORMAT", [date, format]);
+var unixTimestamp = () => fn4("UNIX_TIMESTAMP", []);
+var fromUnixTime = (timestamp) => fn4("FROM_UNIXTIME", [timestamp]);
+var endOfMonth = (date) => fn4("END_OF_MONTH", [date]);
+var dayOfWeek = (date) => fn4("DAY_OF_WEEK", [date]);
+var weekOfYear = (date) => fn4("WEEK_OF_YEAR", [date]);
+var dateTrunc = (part, date) => fn4("DATE_TRUNC", [part, date]);
 
 // src/orm/als.ts
 var AsyncLocalStorage = class {
@@ -7721,6 +8412,7 @@ var TypeScriptGenerator = class {
       case "ScalarSubquery":
       case "CaseExpression":
       case "WindowFunction":
+      case "Cast":
         return this.printOperand(term);
       default:
         return this.printExpression(term);
@@ -7780,6 +8472,9 @@ var TypeScriptGenerator = class {
   visitWindowFunction(node) {
     return this.printWindowFunctionOperand(node);
   }
+  visitCast(node) {
+    return this.printCastOperand(node);
+  }
   visitAliasRef(node) {
     return `aliasRef('${node.name}')`;
   }
@@ -7791,12 +8486,12 @@ var TypeScriptGenerator = class {
   printBinaryExpression(binary) {
     const left2 = this.printOperand(binary.left);
     const right2 = this.printOperand(binary.right);
-    const fn4 = this.mapOp(binary.operator);
+    const fn5 = this.mapOp(binary.operator);
     const args = [left2, right2];
     if (binary.escape) {
       args.push(this.printOperand(binary.escape));
     }
-    return `${fn4}(${args.join(", ")})`;
+    return `${fn5}(${args.join(", ")})`;
   }
   /**
    * Prints a logical expression to TypeScript code
@@ -7825,13 +8520,13 @@ var TypeScriptGenerator = class {
    */
   printInExpression(inExpr) {
     const left2 = this.printOperand(inExpr.left);
-    const fn4 = this.mapOp(inExpr.operator);
+    const fn5 = this.mapOp(inExpr.operator);
     if (Array.isArray(inExpr.right)) {
       const values = inExpr.right.map((v) => this.printOperand(v)).join(", ");
-      return `${fn4}(${left2}, [${values}])`;
+      return `${fn5}(${left2}, [${values}])`;
     }
     const subquery = this.inlineChain(this.buildSelectLines(inExpr.right.query));
-    return `${fn4}(${left2}, (${subquery}))`;
+    return `${fn5}(${left2}, (${subquery}))`;
   }
   /**
    * Prints a null expression to TypeScript code
@@ -7840,8 +8535,8 @@ var TypeScriptGenerator = class {
    */
   printNullExpression(nullExpr) {
     const left2 = this.printOperand(nullExpr.left);
-    const fn4 = this.mapOp(nullExpr.operator);
-    return `${fn4}(${left2})`;
+    const fn5 = this.mapOp(nullExpr.operator);
+    return `${fn5}(${left2})`;
   }
   /**
    * Prints a BETWEEN expression to TypeScript code
@@ -7885,9 +8580,9 @@ var TypeScriptGenerator = class {
    * @param fn - Function node
    * @returns TypeScript code representation
    */
-  printFunctionOperand(fn4) {
-    const args = fn4.args.map((a) => this.printOperand(a)).join(", ");
-    return `${fn4.name.toLowerCase()}(${args})`;
+  printFunctionOperand(fn5) {
+    const args = fn5.args.map((a) => this.printOperand(a)).join(", ");
+    return `${fn5.name.toLowerCase()}(${args})`;
   }
   /**
    * Prints a JSON path operand to TypeScript code
@@ -7947,6 +8642,10 @@ var TypeScriptGenerator = class {
     result += ")";
     return result;
   }
+  printCastOperand(node) {
+    const typeLiteral = node.castType.replace(/'/g, "\\'");
+    return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
+  }
   /**
    * Converts method chain lines to inline format
    * @param lines - Method chain lines
@@ -9111,15 +9810,15 @@ var OrmSession = class {
    * @returns The result of the function
    * @throws If the transaction fails
    */
-  async transaction(fn4) {
+  async transaction(fn5) {
     if (!this.executor.capabilities.transactions) {
-      const result = await fn4(this);
+      const result = await fn5(this);
       await this.commit();
       return result;
     }
     await this.executor.beginTransaction();
     try {
-      const result = await fn4(this);
+      const result = await fn5(this);
       await this.flushWithHooks();
       await this.executor.commitTransaction();
       await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
@@ -9222,11 +9921,11 @@ var Orm = class {
    * @returns The result of the function
    * @throws If the transaction fails
    */
-  async transaction(fn4) {
+  async transaction(fn5) {
     const executor = this.executorFactory.createTransactionalExecutor();
     const session = new OrmSession({ orm: this, executor });
     try {
-      return await session.transaction(() => fn4(session));
+      return await session.transaction(() => fn5(session));
     } finally {
       await session.dispose();
     }
@@ -10046,6 +10745,7 @@ function createPooledExecutorFactory(opts) {
   between,
   bootstrapEntities,
   caseWhen,
+  cast,
   ceil,
   ceiling,
   char,
@@ -10113,6 +10813,7 @@ function createPooledExecutorFactory(opts) {
   instr,
   introspectSchema,
   isCaseExpressionNode,
+  isCastExpressionNode,
   isExpressionSelectionNode,
   isFunctionNode,
   isNotNull,