metal-orm 1.0.11 → 1.0.13

package/dist/index.js

@@ -1,10 +1,23 @@
 // src/schema/table.ts
-var defineTable = (name, columns, relations = {}, hooks) => {
+var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
     acc[key] = { ...def, name: key, table: name };
     return acc;
   }, {});
-  return { name, columns: colsWithNames, relations, hooks };
+  return {
+    name,
+    schema: options.schema,
+    columns: colsWithNames,
+    relations,
+    hooks,
+    primaryKey: options.primaryKey,
+    indexes: options.indexes,
+    checks: options.checks,
+    comment: options.comment,
+    engine: options.engine,
+    charset: options.charset,
+    collation: options.collation
+  };
 };
 
 // src/schema/column.ts
@@ -14,12 +27,52 @@ var col = {
    * @returns ColumnDef with INT type
    */
   int: () => ({ name: "", type: "INT" }),
+  /**
+   * Creates a big integer column definition
+   */
+  bigint: () => ({ name: "", type: "BIGINT" }),
   /**
    * Creates a variable character column definition
    * @param length - Maximum length of the string
    * @returns ColumnDef with VARCHAR type
    */
   varchar: (length) => ({ name: "", type: "VARCHAR", args: [length] }),
+  /**
+   * Creates a fixed precision decimal column definition
+   */
+  decimal: (precision, scale = 0) => ({
+    name: "",
+    type: "DECIMAL",
+    args: [precision, scale]
+  }),
+  /**
+   * Creates a floating point column definition
+   */
+  float: (precision) => ({
+    name: "",
+    type: "FLOAT",
+    args: precision !== void 0 ? [precision] : void 0
+  }),
+  /**
+   * Creates a UUID column definition
+   */
+  uuid: () => ({ name: "", type: "UUID" }),
+  /**
+   * Creates a timestamp column definition
+   */
+  timestamp: () => ({ name: "", type: "TIMESTAMP" }),
+  /**
+   * Creates a timestamptz column definition
+   */
+  timestamptz: () => ({ name: "", type: "TIMESTAMPTZ" }),
+  /**
+   * Creates a date column definition
+   */
+  date: () => ({ name: "", type: "DATE" }),
+  /**
+   * Creates a datetime column definition
+   */
+  datetime: () => ({ name: "", type: "DATETIME" }),
   /**
    * Creates a JSON column definition
    * @returns ColumnDef with JSON type
@@ -30,12 +83,64 @@ var col = {
    * @returns ColumnDef with BOOLEAN type
    */
   boolean: () => ({ name: "", type: "BOOLEAN" }),
+  /**
+   * Creates an enum column definition
+   * @param values - Enum values
+   */
+  enum: (values) => ({ name: "", type: "ENUM", args: values }),
   /**
    * Marks a column definition as a primary key
    * @param def - Column definition to modify
    * @returns Modified ColumnDef with primary: true
    */
-  primaryKey: (def) => ({ ...def, primary: true })
+  primaryKey: (def) => ({ ...def, primary: true }),
+  /**
+   * Marks a column as NOT NULL
+   */
+  notNull: (def) => ({ ...def, notNull: true }),
+  /**
+   * Marks a column as UNIQUE
+   */
+  unique: (def, name) => ({
+    ...def,
+    unique: name ?? true
+  }),
+  /**
+   * Sets a default value for the column
+   */
+  default: (def, value) => ({
+    ...def,
+    default: value
+  }),
+  /**
+   * Sets a raw SQL default value for the column
+   */
+  defaultRaw: (def, expression) => ({
+    ...def,
+    default: { raw: expression }
+  }),
+  /**
+   * Marks a column as auto-increment / identity
+   */
+  autoIncrement: (def, strategy = "byDefault") => ({
+    ...def,
+    autoIncrement: true,
+    generated: strategy
+  }),
+  /**
+   * Adds a foreign key reference
+   */
+  references: (def, ref) => ({
+    ...def,
+    references: ref
+  }),
+  /**
+   * Adds a check constraint to the column
+   */
+  check: (def, expression) => ({
+    ...def,
+    check: expression
+  })
 };
 
 // src/schema/relation.ts
@@ -445,6 +550,82 @@ var SelectQueryState = class _SelectQueryState {
       ctes: [...this.ast.ctes ?? [], cte]
     });
   }
+  /**
+   * Adds a set operation (UNION/INTERSECT/EXCEPT) to the query
+   * @param op - Set operation node to add
+   * @returns New SelectQueryState with set operation
+   */
+  withSetOperation(op) {
+    return this.clone({
+      ...this.ast,
+      setOps: [...this.ast.setOps ?? [], op]
+    });
+  }
+};
+
+// src/core/ast/join-node.ts
+var createJoinNode = (kind, tableName, condition, relationName) => ({
+  type: "Join",
+  kind,
+  table: { type: "Table", name: tableName },
+  condition,
+  relationName
+});
+
+// src/core/sql/sql.ts
+var SQL_OPERATORS = {
+  /** Equality operator */
+  EQUALS: "=",
+  /** Not equals operator */
+  NOT_EQUALS: "!=",
+  /** Greater than operator */
+  GREATER_THAN: ">",
+  /** Greater than or equal operator */
+  GREATER_OR_EQUAL: ">=",
+  /** Less than operator */
+  LESS_THAN: "<",
+  /** Less than or equal operator */
+  LESS_OR_EQUAL: "<=",
+  /** LIKE pattern matching operator */
+  LIKE: "LIKE",
+  /** NOT LIKE pattern matching operator */
+  NOT_LIKE: "NOT LIKE",
+  /** IN membership operator */
+  IN: "IN",
+  /** NOT IN membership operator */
+  NOT_IN: "NOT IN",
+  /** BETWEEN range operator */
+  BETWEEN: "BETWEEN",
+  /** NOT BETWEEN range operator */
+  NOT_BETWEEN: "NOT BETWEEN",
+  /** IS NULL null check operator */
+  IS_NULL: "IS NULL",
+  /** IS NOT NULL null check operator */
+  IS_NOT_NULL: "IS NOT NULL",
+  /** Logical AND operator */
+  AND: "AND",
+  /** Logical OR operator */
+  OR: "OR",
+  /** EXISTS operator */
+  EXISTS: "EXISTS",
+  /** NOT EXISTS operator */
+  NOT_EXISTS: "NOT EXISTS"
+};
+var JOIN_KINDS = {
+  /** INNER JOIN type */
+  INNER: "INNER",
+  /** LEFT JOIN type */
+  LEFT: "LEFT",
+  /** RIGHT JOIN type */
+  RIGHT: "RIGHT",
+  /** CROSS JOIN type */
+  CROSS: "CROSS"
+};
+var ORDER_DIRECTIONS = {
+  /** Ascending order */
+  ASC: "ASC",
+  /** Descending order */
+  DESC: "DESC"
 };
 
 // src/query-builder/hydration-manager.ts
@@ -496,8 +677,26 @@ var HydrationManager = class _HydrationManager {
    * @returns AST with hydration metadata
    */
   applyToAst(ast) {
+    if (ast.setOps && ast.setOps.length > 0) {
+      return ast;
+    }
     const plan = this.planner.getPlan();
     if (!plan) return ast;
+    const needsPaginationGuard = this.requiresParentPagination(ast, plan);
+    const rewritten = needsPaginationGuard ? this.wrapForParentPagination(ast, plan) : ast;
+    return this.attachHydrationMeta(rewritten, plan);
+  }
+  /**
+   * Gets the current hydration plan
+   * @returns Hydration plan or undefined if none exists
+   */
+  getPlan() {
+    return this.planner.getPlan();
+  }
+  /**
+   * Attaches hydration metadata to a query AST node.
+   */
+  attachHydrationMeta(ast, plan) {
     return {
       ...ast,
       meta: {
@@ -507,11 +706,154 @@ var HydrationManager = class _HydrationManager {
     };
   }
   /**
-   * Gets the current hydration plan
-   * @returns Hydration plan or undefined if none exists
+   * Determines whether the query needs pagination rewriting to keep LIMIT/OFFSET
+   * applied to parent rows when eager-loading multiplicative relations.
    */
-  getPlan() {
-    return this.planner.getPlan();
+  requiresParentPagination(ast, plan) {
+    const hasPagination = ast.limit !== void 0 || ast.offset !== void 0;
+    return hasPagination && this.hasMultiplyingRelations(plan);
+  }
+  hasMultiplyingRelations(plan) {
+    return plan.relations.some(
+      (rel) => rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany
+    );
+  }
+  /**
+   * Rewrites the query using CTEs so LIMIT/OFFSET target distinct parent rows
+   * instead of the joined result set.
+   *
+   * The strategy:
+   * - Hoist the original query (minus limit/offset) into a base CTE.
+   * - Select distinct parent ids from that base CTE with the original ordering and pagination.
+   * - Join the base CTE against the paged ids to retrieve the joined rows for just that page.
+   */
+  wrapForParentPagination(ast, plan) {
+    const projectionNames = this.getProjectionNames(ast.columns);
+    if (!projectionNames) {
+      return ast;
+    }
+    const projectionAliases = this.buildProjectionAliasMap(ast.columns);
+    const projectionSet = new Set(projectionNames);
+    const rootPkAlias = projectionAliases.get(`${plan.rootTable}.${plan.rootPrimaryKey}`) ?? plan.rootPrimaryKey;
+    const baseCteName = this.nextCteName(ast.ctes, "__metal_pagination_base");
+    const baseQuery = {
+      ...ast,
+      ctes: void 0,
+      limit: void 0,
+      offset: void 0,
+      orderBy: void 0,
+      meta: void 0
+    };
+    const baseCte = {
+      type: "CommonTableExpression",
+      name: baseCteName,
+      query: baseQuery,
+      recursive: false
+    };
+    const orderBy = this.mapOrderBy(ast.orderBy, plan, projectionAliases, baseCteName, projectionSet);
+    if (orderBy === null) {
+      return ast;
+    }
+    const pageCteName = this.nextCteName([...ast.ctes ?? [], baseCte], "__metal_pagination_page");
+    const pagingColumns = this.buildPagingColumns(rootPkAlias, orderBy, baseCteName);
+    const pageCte = {
+      type: "CommonTableExpression",
+      name: pageCteName,
+      query: {
+        type: "SelectQuery",
+        from: { type: "Table", name: baseCteName },
+        columns: pagingColumns,
+        joins: [],
+        distinct: [{ type: "Column", table: baseCteName, name: rootPkAlias }],
+        orderBy,
+        limit: ast.limit,
+        offset: ast.offset
+      },
+      recursive: false
+    };
+    const joinCondition = eq(
+      { type: "Column", table: baseCteName, name: rootPkAlias },
+      { type: "Column", table: pageCteName, name: rootPkAlias }
+    );
+    const outerColumns = projectionNames.map((name) => ({
+      type: "Column",
+      table: baseCteName,
+      name,
+      alias: name
+    }));
+    return {
+      type: "SelectQuery",
+      from: { type: "Table", name: baseCteName },
+      columns: outerColumns,
+      joins: [createJoinNode(JOIN_KINDS.INNER, pageCteName, joinCondition)],
+      orderBy,
+      ctes: [...ast.ctes ?? [], baseCte, pageCte]
+    };
+  }
+  nextCteName(existing, baseName) {
+    const names = new Set((existing ?? []).map((cte) => cte.name));
+    let candidate = baseName;
+    let suffix = 1;
+    while (names.has(candidate)) {
+      suffix += 1;
+      candidate = `${baseName}_${suffix}`;
+    }
+    return candidate;
+  }
+  getProjectionNames(columns) {
+    const names = [];
+    for (const col2 of columns) {
+      const alias = col2.alias ?? col2.name;
+      if (!alias) return void 0;
+      names.push(alias);
+    }
+    return names;
+  }
+  buildProjectionAliasMap(columns) {
+    const map = /* @__PURE__ */ new Map();
+    for (const col2 of columns) {
+      if (col2.type !== "Column") continue;
+      const node = col2;
+      const key = `${node.table}.${node.name}`;
+      map.set(key, node.alias ?? node.name);
+    }
+    return map;
+  }
+  mapOrderBy(orderBy, plan, projectionAliases, baseAlias, availableColumns) {
+    if (!orderBy || orderBy.length === 0) {
+      return void 0;
+    }
+    const mapped = [];
+    for (const ob of orderBy) {
+      if (ob.column.table !== plan.rootTable) {
+        return null;
+      }
+      const alias = projectionAliases.get(`${ob.column.table}.${ob.column.name}`) ?? ob.column.name;
+      if (!availableColumns.has(alias)) {
+        return null;
+      }
+      mapped.push({
+        type: "OrderBy",
+        column: { type: "Column", table: baseAlias, name: alias },
+        direction: ob.direction
+      });
+    }
+    return mapped;
+  }
+  buildPagingColumns(primaryKey, orderBy, tableAlias) {
+    const columns = [{ type: "Column", table: tableAlias, name: primaryKey, alias: primaryKey }];
+    if (!orderBy) return columns;
+    for (const ob of orderBy) {
+      if (!columns.some((col2) => col2.name === ob.column.name)) {
+        columns.push({
+          type: "Column",
+          table: tableAlias,
+          name: ob.column.name,
+          alias: ob.column.name
+        });
+      }
+    }
+    return columns;
   }
 };
 
@@ -774,6 +1116,20 @@ var QueryAstService = class {
     };
     return this.state.withCte(cte);
   }
+  /**
+   * Adds a set operation (UNION/UNION ALL/INTERSECT/EXCEPT) to the query
+   * @param operator - Set operator
+   * @param query - Right-hand side query
+   * @returns Updated query state with set operation
+   */
+  withSetOperation(operator, query) {
+    const op = {
+      type: "SetOperation",
+      operator,
+      query
+    };
+    return this.state.withSetOperation(op);
+  }
   /**
    * Selects a subquery as a column
    * @param alias - Alias for the subquery
@@ -926,15 +1282,6 @@ var RelationProjectionHelper = class {
   }
 };
 
-// src/core/ast/join-node.ts
-var createJoinNode = (kind, tableName, condition, relationName) => ({
-  type: "Join",
-  kind,
-  table: { type: "Table", name: tableName },
-  condition,
-  relationName
-});
-
 // src/query-builder/relation-conditions.ts
 var assertNever = (value) => {
   throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
@@ -990,62 +1337,6 @@ var buildRelationCorrelation = (root, relation) => {
   return baseRelationCondition(root, relation);
 };
 
-// src/core/sql/sql.ts
-var SQL_OPERATORS = {
-  /** Equality operator */
-  EQUALS: "=",
-  /** Not equals operator */
-  NOT_EQUALS: "!=",
-  /** Greater than operator */
-  GREATER_THAN: ">",
-  /** Greater than or equal operator */
-  GREATER_OR_EQUAL: ">=",
-  /** Less than operator */
-  LESS_THAN: "<",
-  /** Less than or equal operator */
-  LESS_OR_EQUAL: "<=",
-  /** LIKE pattern matching operator */
-  LIKE: "LIKE",
-  /** NOT LIKE pattern matching operator */
-  NOT_LIKE: "NOT LIKE",
-  /** IN membership operator */
-  IN: "IN",
-  /** NOT IN membership operator */
-  NOT_IN: "NOT IN",
-  /** BETWEEN range operator */
-  BETWEEN: "BETWEEN",
-  /** NOT BETWEEN range operator */
-  NOT_BETWEEN: "NOT BETWEEN",
-  /** IS NULL null check operator */
-  IS_NULL: "IS NULL",
-  /** IS NOT NULL null check operator */
-  IS_NOT_NULL: "IS NOT NULL",
-  /** Logical AND operator */
-  AND: "AND",
-  /** Logical OR operator */
-  OR: "OR",
-  /** EXISTS operator */
-  EXISTS: "EXISTS",
-  /** NOT EXISTS operator */
-  NOT_EXISTS: "NOT EXISTS"
-};
-var JOIN_KINDS = {
-  /** INNER JOIN type */
-  INNER: "INNER",
-  /** LEFT JOIN type */
-  LEFT: "LEFT",
-  /** RIGHT JOIN type */
-  RIGHT: "RIGHT",
-  /** CROSS JOIN type */
-  CROSS: "CROSS"
-};
-var ORDER_DIRECTIONS = {
-  /** Ascending order */
-  ASC: "ASC",
-  /** Descending order */
-  DESC: "DESC"
-};
-
 // src/query-builder/relation-service.ts
 var RelationService = class {
   /**
@@ -1491,6 +1782,16 @@ var hasEntityMeta = (entity) => {
 
 // src/orm/relations/has-many.ts
 var toKey2 = (value) => value === null || value === void 0 ? "" : String(value);
+var hideInternal = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
 var DefaultHasManyCollection = class {
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
     this.ctx = ctx;
@@ -1506,6 +1807,7 @@ var DefaultHasManyCollection = class {
     this.items = [];
     this.added = /* @__PURE__ */ new Set();
     this.removed = /* @__PURE__ */ new Set();
+    hideInternal(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
     this.hydrateFromCache();
   }
   async load() {
@@ -1581,10 +1883,23 @@ var DefaultHasManyCollection = class {
     this.items = rows.map((row) => this.createEntity(row));
     this.loaded = true;
   }
+  toJSON() {
+    return this.items;
+  }
 };
 
 // src/orm/relations/belongs-to.ts
 var toKey3 = (value) => value === null || value === void 0 ? "" : String(value);
+var hideInternal2 = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
 var DefaultBelongsToReference = class {
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, targetKey) {
     this.ctx = ctx;
@@ -1598,6 +1913,7 @@ var DefaultBelongsToReference = class {
     this.targetKey = targetKey;
     this.loaded = false;
     this.current = null;
+    hideInternal2(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "targetKey"]);
     this.populateFromHydrationCache();
   }
   async load() {
@@ -1658,10 +1974,23 @@ var DefaultBelongsToReference = class {
     this.current = this.createEntity(row);
     this.loaded = true;
   }
+  toJSON() {
+    return this.current;
+  }
 };
 
 // src/orm/relations/many-to-many.ts
 var toKey4 = (value) => value === null || value === void 0 ? "" : String(value);
+var hideInternal3 = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
 var DefaultManyToManyCollection = class {
   constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
     this.ctx = ctx;
@@ -1675,6 +2004,7 @@ var DefaultManyToManyCollection = class {
     this.localKey = localKey;
     this.loaded = false;
     this.items = [];
+    hideInternal3(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
     this.hydrateFromCache();
   }
   async load() {
@@ -1780,6 +2110,9 @@ var DefaultManyToManyCollection = class {
     });
     this.loaded = true;
   }
+  toJSON() {
+    return this.items;
+  }
 };
 
 // src/orm/lazy-batch.ts
@@ -2140,9 +2473,15 @@ var flattenResults = (results) => {
   return rows;
 };
 async function executeHydrated(ctx, qb) {
-  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const ast = qb.getAST();
+  const compiled = ctx.dialect.compileSelect(ast);
   const executed = await ctx.executor.executeSql(compiled.sql, compiled.params);
   const rows = flattenResults(executed);
+  if (ast.setOps && ast.setOps.length > 0) {
+    return rows.map(
+      (row) => createEntityProxy(ctx, qb.getTable(), row, qb.getLazyRelations())
+    );
+  }
   const hydrated = hydrateRows(rows, qb.getHydrationPlan());
   return hydrated.map(
     (row) => createEntityFromRow(ctx, qb.getTable(), row, qb.getLazyRelations())
@@ -2189,6 +2528,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     const joinNode = createJoinNode(kind, table.name, condition);
     return this.applyAst(context, (service) => service.withJoin(joinNode));
   }
+  applySetOperation(operator, query) {
+    const subAst = this.resolveQueryNode(query);
+    return this.applyAst(this.context, (service) => service.withSetOperation(operator, subAst));
+  }
   /**
    * Selects specific columns for the query
    * @param columns - Record of column definitions, function nodes, case expressions, or window functions
@@ -2377,6 +2720,38 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     const nextContext = this.applyAst(this.context, (service) => service.withOffset(n));
     return this.clone(nextContext);
   }
+  /**
+   * Combines this query with another using UNION
+   * @param query - Query to union with
+   * @returns New query builder instance with the set operation
+   */
+  union(query) {
+    return this.clone(this.applySetOperation("UNION", query));
+  }
+  /**
+   * Combines this query with another using UNION ALL
+   * @param query - Query to union with
+   * @returns New query builder instance with the set operation
+   */
+  unionAll(query) {
+    return this.clone(this.applySetOperation("UNION ALL", query));
+  }
+  /**
+   * Combines this query with another using INTERSECT
+   * @param query - Query to intersect with
+   * @returns New query builder instance with the set operation
+   */
+  intersect(query) {
+    return this.clone(this.applySetOperation("INTERSECT", query));
+  }
+  /**
+   * Combines this query with another using EXCEPT
+   * @param query - Query to subtract
+   * @returns New query builder instance with the set operation
+   */
+  except(query) {
+    return this.clone(this.applySetOperation("EXCEPT", query));
+  }
   /**
    * Adds a WHERE EXISTS condition to the query
    * @param subquery - Subquery to check for existence
@@ -2666,7 +3041,8 @@ var Dialect = class {
    */
   compileSelect(ast) {
     const ctx = this.createCompilerContext();
-    const rawSql = this.compileSelectAst(ast, ctx).trim();
+    const normalized = this.normalizeSelectAst(ast);
+    const rawSql = this.compileSelectAst(normalized, ctx).trim();
     const sql = rawSql.endsWith(";") ? rawSql : `${rawSql};`;
     return {
       sql,
@@ -2700,6 +3076,9 @@ var Dialect = class {
       params: [...ctx.params]
     };
   }
+  supportsReturning() {
+    return false;
+  }
   /**
    * Compiles a WHERE clause
    * @param where - WHERE expression
@@ -2724,7 +3103,11 @@ var Dialect = class {
    * @returns SQL for EXISTS subquery
    */
   compileSelectForExists(ast, ctx) {
-    const full = this.compileSelectAst(ast, ctx).trim().replace(/;$/, "");
+    const normalized = this.normalizeSelectAst(ast);
+    const full = this.compileSelectAst(normalized, ctx).trim().replace(/;$/, "");
+    if (normalized.setOps && normalized.setOps.length > 0) {
+      return `SELECT 1 FROM (${full}) AS _exists`;
+    }
     const upper = full.toUpperCase();
     const fromIndex = upper.indexOf(" FROM ");
     if (fromIndex === -1) {
@@ -2757,6 +3140,65 @@ var Dialect = class {
   formatPlaceholder(index) {
     return "?";
   }
+  /**
+   * Whether the current dialect supports a given set operation.
+   * Override in concrete dialects to restrict support.
+   */
+  supportsSetOperation(kind) {
+    return true;
+  }
+  /**
+   * Validates set-operation semantics:
+   * - Ensures the dialect supports requested operators.
+   * - Enforces that only the outermost compound query may have ORDER/LIMIT/OFFSET.
+   * @param ast - Query to validate
+   * @param isOutermost - Whether this node is the outermost compound query
+   */
+  validateSetOperations(ast, isOutermost = true) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    if (!isOutermost && (ast.orderBy || ast.limit !== void 0 || ast.offset !== void 0)) {
+      throw new Error("ORDER BY / LIMIT / OFFSET are only allowed on the outermost compound query.");
+    }
+    if (hasSetOps) {
+      for (const op of ast.setOps) {
+        if (!this.supportsSetOperation(op.operator)) {
+          throw new Error(`Set operation ${op.operator} is not supported by this dialect.`);
+        }
+        this.validateSetOperations(op.query, false);
+      }
+    }
+  }
+  /**
+   * Hoists CTEs from set-operation operands to the outermost query so WITH appears once.
+   * @param ast - Query AST
+   * @returns Normalized AST without inner CTEs and a list of hoisted CTEs
+   */
+  hoistCtes(ast) {
+    let hoisted = [];
+    const normalizedSetOps = ast.setOps?.map((op) => {
+      const { normalized: child, hoistedCtes: childHoisted } = this.hoistCtes(op.query);
+      const childCtes = child.ctes ?? [];
+      if (childCtes.length) {
+        hoisted = hoisted.concat(childCtes);
+      }
+      hoisted = hoisted.concat(childHoisted);
+      const queryWithoutCtes = childCtes.length ? { ...child, ctes: void 0 } : child;
+      return { ...op, query: queryWithoutCtes };
+    });
+    const normalized = normalizedSetOps ? { ...ast, setOps: normalizedSetOps } : ast;
+    return { normalized, hoistedCtes: hoisted };
+  }
+  /**
+   * Normalizes a SELECT AST before compilation (validation + CTE hoisting).
+   * @param ast - Query AST
+   * @returns Normalized query AST
+   */
+  normalizeSelectAst(ast) {
+    this.validateSetOperations(ast, true);
+    const { normalized, hoistedCtes } = this.hoistCtes(ast);
+    const combinedCtes = [...normalized.ctes ?? [], ...hoistedCtes];
+    return combinedCtes.length ? { ...normalized, ctes: combinedCtes } : normalized;
+  }
   constructor() {
     this.expressionCompilers = /* @__PURE__ */ new Map();
     this.operandCompilers = /* @__PURE__ */ new Map();
@@ -2899,102 +3341,181 @@ var Dialect = class {
   }
 };
 
-// src/core/dialect/mysql/index.ts
-var MySqlDialect = class extends Dialect {
+// src/core/dialect/base/sql-dialect.ts
+var SqlDialectBase = class extends Dialect {
   /**
-   * Creates a new MySqlDialect instance
+   * Compiles SELECT query AST to SQL using common rules.
    */
-  constructor() {
-    super();
+  compileSelectAst(ast, ctx) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
+    const baseSelect = this.compileSelectCore(baseAst, ctx);
+    if (!hasSetOps) {
+      return `${ctes}${baseSelect}`;
+    }
+    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
+    return `${ctes}${combined}${orderBy}${pagination}`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.compileTableName(ast.into);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
   }
   /**
-   * Quotes an identifier using MySQL backtick syntax
-   * @param id - Identifier to quote
-   * @returns Quoted identifier
+   * Compiles a single SELECT (no set operations, no CTE prefix).
    */
-  quoteIdentifier(id) {
-    return `\`${id}\``;
+  compileSelectCore(ast, ctx) {
+    const columns = this.compileSelectColumns(ast, ctx);
+    const from = this.compileFrom(ast.from);
+    const joins = this.compileJoins(ast, ctx);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = this.compileGroupBy(ast);
+    const having = this.compileHaving(ast, ctx);
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    return `SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.compileTableName(ast.table);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.compileTableName(ast.from);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning}`;
   }
   /**
-   * Compiles JSON path expression using MySQL syntax
-   * @param node - JSON path node
-   * @returns MySQL JSON path expression
+   * Default RETURNING compilation: no support.
    */
-  compileJsonPath(node) {
-    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    return `${col2}->'${node.path}'`;
+  compileReturning(returning, _ctx) {
+    if (!returning || returning.length === 0) return "";
+    throw new Error("RETURNING is not supported by this dialect.");
+  }
+  formatReturningColumns(returning) {
+    return returning.map((column) => {
+      const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : "";
+      const aliasPart = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : "";
+      return `${tablePart}${this.quoteIdentifier(column.name)}${aliasPart}`;
+    }).join(", ");
   }
   /**
-   * Compiles SELECT query AST to MySQL SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns MySQL SQL string
+   * DISTINCT clause. Override for DISTINCT ON support.
    */
-  compileSelectAst(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);
-      }
+  compileDistinct(ast) {
+    return ast.distinct ? "DISTINCT " : "";
+  }
+  compileSelectColumns(ast, ctx) {
+    return ast.columns.map((c) => {
+      const expr = this.compileOperand(c, ctx);
       if (c.alias) {
         if (c.alias.includes("(")) return c.alias;
         return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
       }
       return expr;
     }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-    const joins = ast.joins.map((j) => {
-      const table = this.quoteIdentifier(j.table.name);
+  }
+  compileFrom(ast) {
+    const base = this.compileTableName(ast);
+    return ast.alias ? `${base} AS ${this.quoteIdentifier(ast.alias)}` : base;
+  }
+  compileTableName(table) {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+  compileJoins(ast, ctx) {
+    if (!ast.joins || ast.joins.length === 0) return "";
+    const parts = ast.joins.map((j) => {
+      const table = this.compileFrom(j.table);
       const cond = this.compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
-    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
-      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
-      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
-      const cteDefs = ast.ctes.map((cte) => {
-        const name = this.quoteIdentifier(cte.name);
-        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
-        return `${name}${cols} AS (${query})`;
-      }).join(", ");
-      return prefix + cteDefs + " ";
-    })() : "";
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
+    });
+    return ` ${parts.join(" ")}`;
   }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  compileGroupBy(ast) {
+    if (!ast.groupBy || ast.groupBy.length === 0) return "";
+    const cols = ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ");
+    return ` GROUP BY ${cols}`;
   }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
+  compileHaving(ast, ctx) {
+    if (!ast.having) return "";
+    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+  }
+  compileOrderBy(ast) {
+    if (!ast.orderBy || ast.orderBy.length === 0) return "";
+    const parts = ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
+    return ` ORDER BY ${parts}`;
+  }
+  /**
+   * Default LIMIT/OFFSET pagination clause.
+   */
+  compilePagination(ast, _orderByClause) {
+    const parts = [];
+    if (ast.limit !== void 0) parts.push(`LIMIT ${ast.limit}`);
+    if (ast.offset !== void 0) parts.push(`OFFSET ${ast.offset}`);
+    return parts.length ? ` ${parts.join(" ")}` : "";
+  }
+  compileCtes(ast, ctx) {
+    if (!ast.ctes || ast.ctes.length === 0) return "";
+    const hasRecursive = ast.ctes.some((cte) => cte.recursive);
+    const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
+    const cteDefs = ast.ctes.map((cte) => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns && cte.columns.length ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+      const query = this.stripTrailingSemicolon(this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx));
+      return `${name}${cols} AS (${query})`;
     }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+    return `${prefix}${cteDefs} `;
   }
-  compileDeleteAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
+  stripTrailingSemicolon(sql) {
+    return sql.trim().replace(/;$/, "");
+  }
+  wrapSetOperand(sql) {
+    const trimmed = this.stripTrailingSemicolon(sql);
+    return `(${trimmed})`;
+  }
+};
+
+// src/core/dialect/mysql/index.ts
+var MySqlDialect = class extends SqlDialectBase {
+  /**
+   * Creates a new MySqlDialect instance
+   */
+  constructor() {
+    super();
+  }
+  /**
+   * Quotes an identifier using MySQL backtick syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `\`${id}\``;
+  }
+  /**
+   * Compiles JSON path expression using MySQL syntax
+   * @param node - JSON path node
+   * @returns MySQL JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${col2}->'${node.path}'`;
   }
 };
 
@@ -3038,6 +3559,43 @@ var SqlServerDialect = class extends Dialect {
    * @returns SQL Server SQL string
    */
   compileSelectAst(ast, ctx) {
+    const hasSetOps = !!(ast.setOps && ast.setOps.length);
+    const ctes = this.compileCtes(ast, ctx);
+    const baseAst = hasSetOps ? { ...ast, setOps: void 0, orderBy: void 0, limit: void 0, offset: void 0 } : ast;
+    const baseSelect = this.compileSelectCore(baseAst, ctx);
+    if (!hasSetOps) {
+      return `${ctes}${baseSelect}`;
+    }
+    const compound = ast.setOps.map((op) => `${op.operator} ${this.wrapSetOperand(this.compileSelectAst(op.query, ctx))}`).join(" ");
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    const combined = `${this.wrapSetOperand(baseSelect)} ${compound}`;
+    const tail = pagination || orderBy;
+    return `${ctes}${combined}${tail}`;
+  }
+  compileInsertAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.into.name);
+    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
+  }
+  compileUpdateAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.table.name);
+    const assignments = ast.set.map((assignment) => {
+      const col2 = assignment.column;
+      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(", ");
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+  }
+  compileDeleteAst(ast, ctx) {
+    const table = this.quoteIdentifier(ast.from.name);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    return `DELETE FROM ${table}${whereClause};`;
+  }
+  compileSelectCore(ast, ctx) {
     const columns = ast.columns.map((c) => {
       let expr = "";
       if (c.type === "Function") {
@@ -3065,51 +3623,47 @@ var SqlServerDialect = class extends Dialect {
     const whereClause = this.compileWhere(ast.where, ctx);
     const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
     const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
-    let pagination = "";
-    if (ast.limit || ast.offset) {
-      const off = ast.offset || 0;
-      const orderClause = orderBy || " ORDER BY (SELECT NULL)";
-      pagination = `${orderClause} OFFSET ${off} ROWS`;
-      if (ast.limit) {
-        pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
-      }
-      return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination};`;
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+    if (pagination) {
+      return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${pagination}`;
+    }
+    return `SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}`;
+  }
+  compileOrderBy(ast) {
+    if (!ast.orderBy || ast.orderBy.length === 0) return "";
+    return " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ");
+  }
+  compilePagination(ast, orderBy) {
+    const hasLimit = ast.limit !== void 0;
+    const hasOffset = ast.offset !== void 0;
+    if (!hasLimit && !hasOffset) return "";
+    const off = ast.offset ?? 0;
+    const orderClause = orderBy || " ORDER BY (SELECT NULL)";
+    let pagination = `${orderClause} OFFSET ${off} ROWS`;
+    if (hasLimit) {
+      pagination += ` FETCH NEXT ${ast.limit} ROWS ONLY`;
     }
-    const ctes = ast.ctes && ast.ctes.length > 0 ? "WITH " + ast.ctes.map((cte) => {
+    return pagination;
+  }
+  compileCtes(ast, ctx) {
+    if (!ast.ctes || ast.ctes.length === 0) return "";
+    const defs = ast.ctes.map((cte) => {
       const name = this.quoteIdentifier(cte.name);
       const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-      const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
+      const query = this.compileSelectAst(this.normalizeSelectAst(cte.query), ctx).trim().replace(/;$/, "");
       return `${name}${cols} AS (${query})`;
-    }).join(", ") + " " : "";
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy};`;
-  }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
     }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
+    return `WITH ${defs} `;
   }
-  compileDeleteAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
+  wrapSetOperand(sql) {
+    const trimmed = sql.trim().replace(/;$/, "");
+    return `(${trimmed})`;
   }
 };
 
 // src/core/dialect/sqlite/index.ts
-var SqliteDialect = class extends Dialect {
+var SqliteDialect = class extends SqlDialectBase {
   /**
    * Creates a new SqliteDialect instance
    */
@@ -3133,91 +3687,1143 @@ var SqliteDialect = class extends Dialect {
     const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
     return `json_extract(${col2}, '${node.path}')`;
   }
+  compileReturning(returning, ctx) {
+    if (!returning || returning.length === 0) return "";
+    const columns = this.formatReturningColumns(returning);
+    return ` RETURNING ${columns}`;
+  }
+  supportsReturning() {
+    return true;
+  }
+};
+
+// src/core/dialect/postgres/index.ts
+var PostgresDialect = class extends SqlDialectBase {
   /**
-   * Compiles SELECT query AST to SQLite SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQLite SQL string
+   * Creates a new PostgresDialect instance
    */
-  compileSelectAst(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 === "CaseExpression") {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === "WindowFunction") {
-        expr = this.compileOperand(c, ctx);
-      }
-      if (c.alias) {
-        if (c.alias.includes("(")) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(", ");
-    const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-    const joins = ast.joins.map((j) => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(" ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const groupBy = ast.groupBy && ast.groupBy.length > 0 ? " GROUP BY " + ast.groupBy.map((c) => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(", ") : "";
-    const having = ast.having ? ` HAVING ${this.compileExpression(ast.having, ctx)}` : "";
-    const orderBy = ast.orderBy && ast.orderBy.length > 0 ? " ORDER BY " + ast.orderBy.map((o) => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(", ") : "";
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : "";
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : "";
-    const ctes = ast.ctes && ast.ctes.length > 0 ? (() => {
-      const hasRecursive = ast.ctes.some((cte) => cte.recursive);
-      const prefix = hasRecursive ? "WITH RECURSIVE " : "WITH ";
-      const cteDefs = ast.ctes.map((cte) => {
-        const name = this.quoteIdentifier(cte.name);
-        const cols = cte.columns ? `(${cte.columns.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
-        const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, "");
-        return `${name}${cols} AS (${query})`;
-      }).join(", ");
-      return prefix + cteDefs + " ";
-    })() : "";
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? " " + joins : ""}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-  compileInsertAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
-    const values = ast.values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
+  constructor() {
+    super();
   }
-  compileUpdateAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map((assignment) => {
-      const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(", ");
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
+  /**
+   * Quotes an identifier using PostgreSQL double-quote syntax
+   * @param id - Identifier to quote
+   * @returns Quoted identifier
+   */
+  quoteIdentifier(id) {
+    return `"${id}"`;
   }
-  compileDeleteAst(ast, ctx) {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning};`;
+  /**
+   * Compiles JSON path expression using PostgreSQL syntax
+   * @param node - JSON path node
+   * @returns PostgreSQL JSON path expression
+   */
+  compileJsonPath(node) {
+    const col2 = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    return `${col2}->>'${node.path}'`;
   }
   compileReturning(returning, ctx) {
     if (!returning || returning.length === 0) return "";
-    const columns = returning.map((column) => {
-      const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : "";
-      return `${tablePart}${this.quoteIdentifier(column.name)}`;
-    }).join(", ");
+    const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;
   }
+  supportsReturning() {
+    return true;
+  }
+};
+
+// src/core/ddl/dialects/base-schema-dialect.ts
+var BaseSchemaDialect = class {
+  supportsPartialIndexes() {
+    return false;
+  }
+  formatTableName(table) {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+  renderDefault(value, _column) {
+    return formatLiteral(value, this.name);
+  }
+  renderReference(ref, _table) {
+    const parts = ["REFERENCES", quoteQualified(this, ref.table), `(${this.quoteIdentifier(ref.column)})`];
+    if (ref.onDelete) parts.push("ON DELETE", ref.onDelete);
+    if (ref.onUpdate) parts.push("ON UPDATE", ref.onUpdate);
+    if (ref.deferrable && this.name === "postgres") parts.push("DEFERRABLE INITIALLY DEFERRED");
+    return parts.join(" ");
+  }
+  renderTableOptions(_table) {
+    return void 0;
+  }
+  dropTableSql(table) {
+    return [`DROP TABLE IF EXISTS ${this.formatTableName(table)};`];
+  }
+  warnDropColumn(_table, _column) {
+    return void 0;
+  }
+};
+
+// src/core/ddl/dialects/postgres-schema-dialect.ts
+var PostgresSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "postgres";
+  }
+  quoteIdentifier(id) {
+    return `"${id}"`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "integer";
+      case "BIGINT":
+      case "bigint":
+        return "bigint";
+      case "UUID":
+      case "uuid":
+        return "uuid";
+      case "BOOLEAN":
+      case "boolean":
+        return "boolean";
+      case "JSON":
+      case "json":
+        return "jsonb";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : "numeric";
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "double precision";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "timestamptz";
+      case "TIMESTAMP":
+      case "timestamp":
+        return "timestamp";
+      case "DATE":
+      case "date":
+        return "date";
+      case "DATETIME":
+      case "datetime":
+        return "timestamp";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `varchar(${column.args[0]})` : "varchar";
+      case "TEXT":
+      case "text":
+        return "text";
+      case "ENUM":
+      case "enum":
+        return "text";
+      default:
+        return String(column.type).toLowerCase();
+    }
+  }
+  renderAutoIncrement(column) {
+    if (!column.autoIncrement) return void 0;
+    const strategy = column.generated === "always" ? "GENERATED ALWAYS" : "GENERATED BY DEFAULT";
+    return `${strategy} AS IDENTITY`;
+  }
+  renderIndex(table, index) {
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
+  }
+  supportsPartialIndexes() {
+    return true;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    const qualified = table.schema ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(index)}` : this.quoteIdentifier(index);
+    return [`DROP INDEX IF EXISTS ${qualified};`];
+  }
+};
+
+// src/core/ddl/dialects/mysql-schema-dialect.ts
+var MySqlSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "mysql";
+  }
+  quoteIdentifier(id) {
+    return `\`${id}\``;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "INT";
+      case "BIGINT":
+      case "bigint":
+        return "BIGINT";
+      case "UUID":
+      case "uuid":
+        return "CHAR(36)";
+      case "BOOLEAN":
+      case "boolean":
+        return "TINYINT(1)";
+      case "JSON":
+      case "json":
+        return "JSON";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL";
+      case "FLOAT":
+      case "float":
+        return column.args?.length ? `FLOAT(${column.args[0]})` : "FLOAT";
+      case "DOUBLE":
+      case "double":
+        return "DOUBLE";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "TIMESTAMP";
+      case "TIMESTAMP":
+      case "timestamp":
+        return "TIMESTAMP";
+      case "DATETIME":
+      case "datetime":
+        return "DATETIME";
+      case "DATE":
+      case "date":
+        return "DATE";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `VARCHAR(${column.args[0]})` : "VARCHAR(255)";
+      case "TEXT":
+      case "text":
+        return "TEXT";
+      case "ENUM":
+      case "enum":
+        return column.args && Array.isArray(column.args) && column.args.length ? `ENUM(${column.args.map((v) => `'${escapeLiteral(v)}'`).join(",")})` : "ENUM";
+      default:
+        return String(column.type).toUpperCase();
+    }
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderAutoIncrement(column) {
+    return column.autoIncrement ? "AUTO_INCREMENT" : void 0;
+  }
+  renderIndex(table, index) {
+    if (index.where) {
+      throw new Error("MySQL does not support partial/filtered indexes");
+    }
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
+  }
+  renderTableOptions(table) {
+    const parts = [];
+    if (table.engine) parts.push(`ENGINE=${table.engine}`);
+    if (table.charset) parts.push(`DEFAULT CHARSET=${table.charset}`);
+    if (table.collation) parts.push(`COLLATE=${table.collation}`);
+    return parts.length ? parts.join(" ") : void 0;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  }
+};
+
+// src/core/ddl/dialects/sqlite-schema-dialect.ts
+var SQLiteSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "sqlite";
+  }
+  quoteIdentifier(id) {
+    return `"${id}"`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+      case "BIGINT":
+      case "bigint":
+        return "INTEGER";
+      case "BOOLEAN":
+      case "boolean":
+        return "INTEGER";
+      case "DECIMAL":
+      case "decimal":
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "REAL";
+      case "DATE":
+      case "date":
+      case "DATETIME":
+      case "datetime":
+      case "TIMESTAMP":
+      case "timestamp":
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+        return "TEXT";
+      case "VARCHAR":
+      case "varchar":
+      case "TEXT":
+      case "text":
+      case "JSON":
+      case "json":
+      case "UUID":
+      case "uuid":
+        return "TEXT";
+      case "ENUM":
+      case "enum":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  renderAutoIncrement(column, table) {
+    const pk = resolvePrimaryKey(table);
+    if (column.autoIncrement && pk.length === 1 && pk[0] === column.name) {
+      return "PRIMARY KEY AUTOINCREMENT";
+    }
+    return void 0;
+  }
+  preferInlinePkAutoincrement(column, table, pk) {
+    return !!(column.autoIncrement && pk.length === 1 && pk[0] === column.name);
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderIndex(table, index) {
+    if (index.where) {
+      throw new Error("SQLite does not support partial/filtered indexes");
+    }
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols});`;
+  }
+  dropColumnSql(_table, _column) {
+    return [];
+  }
+  dropIndexSql(_table, index) {
+    return [`DROP INDEX IF EXISTS ${this.quoteIdentifier(index)};`];
+  }
+  warnDropColumn(table, column) {
+    const key = table.schema ? `${table.schema}.${table.name}` : table.name;
+    return `Dropping columns on SQLite requires table rebuild (column ${column} on ${key}).`;
+  }
+};
+
+// src/core/ddl/dialects/mssql-schema-dialect.ts
+var MSSqlSchemaDialect = class extends BaseSchemaDialect {
+  constructor() {
+    super(...arguments);
+    this.name = "mssql";
+  }
+  quoteIdentifier(id) {
+    return `[${id.replace(/]/g, "]]")}]`;
+  }
+  renderColumnType(column) {
+    switch (column.type) {
+      case "INT":
+      case "INTEGER":
+      case "int":
+      case "integer":
+        return "INT";
+      case "BIGINT":
+      case "bigint":
+        return "BIGINT";
+      case "UUID":
+      case "uuid":
+        return "UNIQUEIDENTIFIER";
+      case "BOOLEAN":
+      case "boolean":
+        return "BIT";
+      case "JSON":
+      case "json":
+        return "NVARCHAR(MAX)";
+      case "DECIMAL":
+      case "decimal":
+        return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : "DECIMAL(18,0)";
+      case "FLOAT":
+      case "float":
+      case "DOUBLE":
+      case "double":
+        return "FLOAT";
+      case "TIMESTAMPTZ":
+      case "timestamptz":
+      case "TIMESTAMP":
+      case "timestamp":
+      case "DATETIME":
+      case "datetime":
+        return "DATETIME2";
+      case "DATE":
+      case "date":
+        return "DATE";
+      case "VARCHAR":
+      case "varchar":
+        return column.args?.length ? `NVARCHAR(${column.args[0]})` : "NVARCHAR(255)";
+      case "TEXT":
+      case "text":
+        return "NVARCHAR(MAX)";
+      case "ENUM":
+      case "enum":
+        return "NVARCHAR(255)";
+      default:
+        return String(column.type).toUpperCase();
+    }
+  }
+  renderDefault(value) {
+    return formatLiteral(value, this.name);
+  }
+  renderAutoIncrement(column) {
+    return column.autoIncrement ? "IDENTITY(1,1)" : void 0;
+  }
+  renderIndex(table, index) {
+    const name = index.name || deriveIndexName(table, index);
+    const cols = renderIndexColumns(this, index.columns);
+    const unique = index.unique ? "UNIQUE " : "";
+    const where = index.where ? ` WHERE ${index.where}` : "";
+    return `CREATE ${unique}INDEX ${this.quoteIdentifier(name)} ON ${this.formatTableName(table)} (${cols})${where};`;
+  }
+  supportsPartialIndexes() {
+    return true;
+  }
+  dropColumnSql(table, column) {
+    return [`ALTER TABLE ${this.formatTableName(table)} DROP COLUMN ${this.quoteIdentifier(column)};`];
+  }
+  dropIndexSql(table, index) {
+    return [`DROP INDEX ${this.quoteIdentifier(index)} ON ${this.formatTableName(table)};`];
+  }
+};
+
+// src/core/ddl/schema-generator.ts
+var escapeLiteral = (value) => value.replace(/'/g, "''");
+var isRawDefault = (value) => {
+  return !!value && typeof value === "object" && "raw" in value && typeof value.raw === "string";
+};
+var formatLiteral = (value, dialect) => {
+  if (isRawDefault(value)) return value.raw;
+  if (value === null) return "NULL";
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") {
+    if (dialect === "mysql" || dialect === "sqlite" || dialect === "mssql") {
+      return value ? "1" : "0";
+    }
+    return value ? "TRUE" : "FALSE";
+  }
+  if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
+  if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+  return `'${escapeLiteral(JSON.stringify(value))}'`;
+};
+var resolvePrimaryKey = (table) => {
+  if (table.primaryKey && table.primaryKey.length > 0) {
+    return table.primaryKey;
+  }
+  const cols = Object.values(table.columns);
+  return cols.filter((c) => c.primary).map((c) => c.name);
+};
+var quoteQualified = (dialect, identifier) => {
+  if (identifier.includes(".")) {
+    return identifier.split(".").map((part) => dialect.quoteIdentifier(part)).join(".");
+  }
+  return dialect.quoteIdentifier(identifier);
+};
+var renderIndexColumns = (dialect, columns) => {
+  return columns.map((col2) => {
+    if (typeof col2 === "string") return dialect.quoteIdentifier(col2);
+    const parts = [dialect.quoteIdentifier(col2.column)];
+    if (col2.order) parts.push(col2.order);
+    if (col2.nulls) parts.push(`NULLS ${col2.nulls}`);
+    return parts.join(" ");
+  }).join(", ");
+};
+var deriveIndexName = (table, index) => {
+  const base = (index.columns || []).map((col2) => typeof col2 === "string" ? col2 : col2.column).join("_");
+  const suffix = index.unique ? "uniq" : "idx";
+  return `${table.name}_${base}_${suffix}`;
+};
+var renderColumnDefinition = (table, col2, dialect, options = {}) => {
+  const parts = [];
+  parts.push(dialect.quoteIdentifier(col2.name));
+  parts.push(dialect.renderColumnType(col2));
+  const autoInc = dialect.renderAutoIncrement(col2, table);
+  if (autoInc) parts.push(autoInc);
+  if (col2.notNull) parts.push("NOT NULL");
+  if (col2.unique) parts.push("UNIQUE");
+  if (col2.default !== void 0) {
+    parts.push(`DEFAULT ${dialect.renderDefault(col2.default, col2)}`);
+  }
+  if (options.includePrimary && col2.primary) {
+    parts.push("PRIMARY KEY");
+  }
+  if (col2.check) {
+    parts.push(`CHECK (${col2.check})`);
+  }
+  if (col2.references) {
+    parts.push(dialect.renderReference(col2.references, table));
+  }
+  return { sql: parts.join(" "), inlinePrimary: !!(options.includePrimary && col2.primary) };
+};
+var generateCreateTableSql = (table, dialect) => {
+  const pk = resolvePrimaryKey(table);
+  const inlinePkColumns = /* @__PURE__ */ new Set();
+  const columnLines = Object.values(table.columns).map((col2) => {
+    const includePk = dialect.preferInlinePkAutoincrement?.(col2, table, pk) && pk.includes(col2.name);
+    if (includePk) {
+      inlinePkColumns.add(col2.name);
+    }
+    return renderColumnDefinition(table, col2, dialect, { includePrimary: includePk }).sql;
+  });
+  const constraintLines = [];
+  if (pk.length > 0 && !(pk.length === 1 && inlinePkColumns.has(pk[0]))) {
+    const cols = pk.map((c) => dialect.quoteIdentifier(c)).join(", ");
+    constraintLines.push(`PRIMARY KEY (${cols})`);
+  }
+  if (table.checks) {
+    table.checks.forEach((check) => {
+      const name = check.name ? `${dialect.quoteIdentifier(check.name)} ` : "";
+      constraintLines.push(`CONSTRAINT ${name}CHECK (${check.expression})`);
+    });
+  }
+  const allLines = [...columnLines, ...constraintLines];
+  const body = allLines.map((line) => `  ${line}`).join(",\n");
+  const tableOptions = dialect.renderTableOptions(table);
+  const tableSql = `CREATE TABLE ${dialect.formatTableName(table)} (
+${body}
+)${tableOptions ? " " + tableOptions : ""};`;
+  const indexSql = [];
+  if (table.indexes && table.indexes.length > 0) {
+    for (const idx of table.indexes) {
+      if (idx.where && !dialect.supportsPartialIndexes()) {
+        throw new Error(`Dialect ${dialect.name} does not support partial/filtered indexes (${idx.name || idx.columns.join("_")}).`);
+      }
+      indexSql.push(dialect.renderIndex(table, idx));
+    }
+  }
+  return { tableSql, indexSql };
+};
+var generateSchemaSql = (tables, dialect) => {
+  const ordered = orderTablesByDependencies(tables);
+  const statements = [];
+  ordered.forEach((table) => {
+    const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+    statements.push(tableSql, ...indexSql);
+  });
+  return statements;
+};
+var orderTablesByDependencies = (tables) => {
+  const map = /* @__PURE__ */ new Map();
+  tables.forEach((t) => map.set(t.name, t));
+  const deps = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const refTables = /* @__PURE__ */ new Set();
+    Object.values(table.columns).forEach((col2) => {
+      if (col2.references?.table) {
+        refTables.add(col2.references.table);
+      }
+    });
+    deps.set(table.name, refTables);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (name, stack) => {
+    if (visited.has(name)) return;
+    const table = map.get(name);
+    if (!table) return;
+    if (stack.has(name)) {
+      ordered.push(table);
+      visited.add(name);
+      return;
+    }
+    stack.add(name);
+    for (const dep of deps.get(name) || []) {
+      visit(dep, stack);
+    }
+    stack.delete(name);
+    visited.add(name);
+    ordered.push(table);
+  };
+  tables.forEach((t) => visit(t.name, /* @__PURE__ */ new Set()));
+  return ordered;
+};
+
+// src/core/ddl/schema-diff.ts
+var tableKey = (name, schema) => schema ? `${schema}.${name}` : name;
+var mapTables = (schema) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    map.set(tableKey(table.name, table.schema), table);
+  }
+  return map;
+};
+var buildAddColumnSql = (table, colName, dialect) => {
+  const column = table.columns[colName];
+  const rendered = renderColumnDefinition(table, column, dialect);
+  return `ALTER TABLE ${dialect.formatTableName(table)} ADD ${rendered.sql};`;
+};
+var diffSchema = (expectedTables, actualSchema, dialect, options = {}) => {
+  const allowDestructive = options.allowDestructive ?? false;
+  const plan = { changes: [], warnings: [] };
+  const actualMap = mapTables(actualSchema);
+  for (const table of expectedTables) {
+    const key = tableKey(table.name, table.schema);
+    const actual = actualMap.get(key);
+    if (!actual) {
+      const { tableSql, indexSql } = generateCreateTableSql(table, dialect);
+      plan.changes.push({
+        kind: "createTable",
+        table: key,
+        description: `Create table ${key}`,
+        statements: [tableSql, ...indexSql],
+        safe: true
+      });
+      continue;
+    }
+    const actualCols = new Map(actual.columns.map((c) => [c.name, c]));
+    for (const colName of Object.keys(table.columns)) {
+      if (!actualCols.has(colName)) {
+        plan.changes.push({
+          kind: "addColumn",
+          table: key,
+          description: `Add column ${colName} to ${key}`,
+          statements: [buildAddColumnSql(table, colName, dialect)],
+          safe: true
+        });
+      }
+    }
+    for (const colName of actualCols.keys()) {
+      if (!table.columns[colName]) {
+        plan.changes.push({
+          kind: "dropColumn",
+          table: key,
+          description: `Drop column ${colName} from ${key}`,
+          statements: allowDestructive ? dialect.dropColumnSql(actual, colName) : [],
+          safe: false
+        });
+        const warning = dialect.warnDropColumn?.(actual, colName);
+        if (warning) plan.warnings.push(warning);
+      }
+    }
+    const expectedIndexes = table.indexes ?? [];
+    const actualIndexes = actual.indexes ?? [];
+    const actualIndexMap = new Map(actualIndexes.map((idx) => [idx.name, idx]));
+    for (const idx of expectedIndexes) {
+      const name = idx.name || deriveIndexName(table, idx);
+      if (!actualIndexMap.has(name)) {
+        plan.changes.push({
+          kind: "addIndex",
+          table: key,
+          description: `Create index ${name} on ${key}`,
+          statements: [dialect.renderIndex(table, { ...idx, name })],
+          safe: true
+        });
+      }
+    }
+    for (const idx of actualIndexes) {
+      if (idx.name && !expectedIndexes.find((expected) => (expected.name || deriveIndexName(table, expected)) === idx.name)) {
+        plan.changes.push({
+          kind: "dropIndex",
+          table: key,
+          description: `Drop index ${idx.name} on ${key}`,
+          statements: allowDestructive ? dialect.dropIndexSql(actual, idx.name) : [],
+          safe: false
+        });
+      }
+    }
+  }
+  for (const actual of actualSchema.tables) {
+    const key = tableKey(actual.name, actual.schema);
+    if (!expectedTables.find((t) => tableKey(t.name, t.schema) === key)) {
+      plan.changes.push({
+        kind: "dropTable",
+        table: key,
+        description: `Drop table ${key}`,
+        statements: allowDestructive ? dialect.dropTableSql(actual) : [],
+        safe: false
+      });
+    }
+  }
+  return plan;
+};
+var synchronizeSchema = async (expectedTables, actualSchema, dialect, executor, options = {}) => {
+  const plan = diffSchema(expectedTables, actualSchema, dialect, options);
+  if (options.dryRun) return plan;
+  for (const change of plan.changes) {
+    if (!change.statements.length) continue;
+    if (!change.safe && !options.allowDestructive) continue;
+    for (const stmt of change.statements) {
+      if (!stmt.trim()) continue;
+      await executor.executeSql(stmt);
+    }
+  }
+  return plan;
+};
+
+// src/core/ddl/introspect/utils.ts
+var toRows = (result) => {
+  if (!result) return [];
+  return result.values.map(
+    (row) => result.columns.reduce((acc, col2, idx) => {
+      acc[col2] = row[idx];
+      return acc;
+    }, {})
+  );
+};
+var queryRows = async (executor, sql, params = []) => {
+  const [first] = await executor.executeSql(sql, params);
+  return toRows(first);
+};
+var shouldIncludeTable = (name, options) => {
+  if (options.includeTables && !options.includeTables.includes(name)) return false;
+  if (options.excludeTables && options.excludeTables.includes(name)) return false;
+  return true;
+};
+
+// src/core/ddl/introspect/postgres.ts
+var postgresIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema || "public";
+    const tables = [];
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT table_schema, table_name, column_name, data_type, is_nullable, column_default
+      FROM information_schema.columns
+      WHERE table_schema = $1
+      ORDER BY table_name, ordinal_position
+      `,
+      [schema]
+    );
+    const pkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        array_agg(att.attname ORDER BY arr.idx) AS pk_columns
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE i.indisprimary AND ns.nspname = $1
+      GROUP BY ns.nspname, tbl.relname
+      `,
+      [schema]
+    );
+    const pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      pkMap.set(`${r.table_schema}.${r.table_name}`, r.pk_columns || []);
+    });
+    const fkRows = await queryRows(
+      executor,
+      `
+      SELECT
+        tc.table_schema,
+        tc.table_name,
+        kcu.column_name,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        ccu.column_name AS foreign_column_name,
+        rc.update_rule AS on_update,
+        rc.delete_rule AS on_delete
+      FROM information_schema.table_constraints AS tc
+      JOIN information_schema.key_column_usage AS kcu
+        ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage AS ccu
+        ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+      JOIN information_schema.referential_constraints rc
+        ON rc.constraint_name = tc.constraint_name AND rc.constraint_schema = tc.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
+      `,
+      [schema]
+    );
+    const fkMap = /* @__PURE__ */ new Map();
+    fkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.column_name}`;
+      fkMap.set(key, [{
+        table: `${r.foreign_table_schema}.${r.foreign_table_name}`,
+        column: r.foreign_column_name,
+        onDelete: r.on_delete?.toUpperCase(),
+        onUpdate: r.on_update?.toUpperCase()
+      }]);
+    });
+    const indexRows = await queryRows(
+      executor,
+      `
+      SELECT
+        ns.nspname AS table_schema,
+        tbl.relname AS table_name,
+        idx.relname AS index_name,
+        i.indisunique AS is_unique,
+        pg_get_expr(i.indpred, i.indrelid) AS predicate,
+        array_agg(att.attname ORDER BY arr.idx) AS column_names
+      FROM pg_index i
+      JOIN pg_class tbl ON tbl.oid = i.indrelid
+      JOIN pg_namespace ns ON ns.oid = tbl.relnamespace
+      JOIN pg_class idx ON idx.oid = i.indexrelid
+      JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS arr(attnum, idx) ON TRUE
+      LEFT JOIN pg_attribute att ON att.attrelid = tbl.oid AND att.attnum = arr.attnum
+      WHERE ns.nspname = $1 AND NOT i.indisprimary
+      GROUP BY ns.nspname, tbl.relname, idx.relname, i.indisunique, i.indpred
+      `,
+      [schema]
+    );
+    const tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) {
+        return;
+      }
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key);
+      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,
+        references: fk ? {
+          table: fk.table,
+          column: fk.column,
+          onDelete: fk.onDelete,
+          onUpdate: fk.onUpdate
+        } : void 0
+      };
+      cols.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const idx = {
+        name: r.index_name,
+        columns: (r.column_names || []).map((c) => ({ column: c })),
+        unique: !!r.is_unique,
+        where: r.predicate || void 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    tables.push(...tablesByKey.values());
+    return { tables };
+  }
+};
+
+// src/core/ddl/introspect/mysql.ts
+var mysqlIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema;
+    const filterClause = schema ? "table_schema = ?" : "table_schema = database()";
+    const params = schema ? [schema] : [];
+    const columnRows = await queryRows(
+      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(
+      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 pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+    const indexRows = await queryRows(
+      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 tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const cols = tablesByKey.get(key);
+      const column = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === "NO",
+        default: r.column_default ?? void 0,
+        autoIncrement: typeof r.extra === "string" && r.extra.includes("auto_increment")
+      };
+      cols.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (typeof r.cols === "string" ? r.cols.split(",") : []).map((c) => ({ column: c.trim() }));
+      const idx = {
+        name: r.index_name,
+        columns: cols,
+        unique: r.non_unique === 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};
+
+// src/core/ddl/introspect/sqlite.ts
+var escapeSingleQuotes = (name) => name.replace(/'/g, "''");
+var sqliteIntrospector = {
+  async introspect(executor, options) {
+    const tables = [];
+    const tableRows = await queryRows(
+      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(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,
+          autoIncrement: false
+        });
+        if (c.pk && c.pk > 0) {
+          table.primaryKey = table.primaryKey || [];
+          table.primaryKey.push(c.name);
+        }
+      });
+      const fkRows = await queryRows(executor, `PRAGMA foreign_key_list('${escapeSingleQuotes(name)}');`);
+      fkRows.forEach((fk) => {
+        const col2 = table.columns.find((c) => c.name === fk.from);
+        if (col2) {
+          col2.references = {
+            table: fk.table,
+            column: fk.to,
+            onDelete: fk.on_delete?.toUpperCase(),
+            onUpdate: fk.on_update?.toUpperCase()
+          };
+        }
+      });
+      const idxList = await queryRows(executor, `PRAGMA index_list('${escapeSingleQuotes(name)}');`);
+      for (const idx of idxList) {
+        const idxName = idx.name;
+        const columnsInfo = await queryRows(executor, `PRAGMA index_info('${escapeSingleQuotes(idxName)}');`);
+        const idxEntry = {
+          name: idxName,
+          columns: columnsInfo.map((ci) => ({ column: ci.name })),
+          unique: idx.unique === 1
+        };
+        table.indexes.push(idxEntry);
+      }
+      tables.push(table);
+    }
+    return { tables };
+  }
+};
+
+// src/core/ddl/introspect/mssql.ts
+var mssqlIntrospector = {
+  async introspect(executor, options) {
+    const schema = options.schema;
+    const filterSchema = schema ? "sch.name = @p1" : "1=1";
+    const params = schema ? [schema] : [];
+    const columnRows = await queryRows(
+      executor,
+      `
+      SELECT
+        sch.name AS table_schema,
+        t.name AS table_name,
+        c.name AS column_name,
+        ty.name 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(
+      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 pkMap = /* @__PURE__ */ new Map();
+    pkRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const list = pkMap.get(key) || [];
+      list.push(r.column_name);
+      pkMap.set(key, list);
+    });
+    const indexRows = await queryRows(
+      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(
+      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 indexColumnsMap = /* @__PURE__ */ new Map();
+    indexColsRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}.${r.index_name}`;
+      const list = indexColumnsMap.get(key) || [];
+      list.push({ column: r.column_name, order: r.key_ordinal });
+      indexColumnsMap.set(key, list);
+    });
+    const tablesByKey = /* @__PURE__ */ new Map();
+    columnRows.forEach((r) => {
+      if (!shouldIncludeTable(r.table_name, options)) return;
+      const key = `${r.table_schema}.${r.table_name}`;
+      if (!tablesByKey.has(key)) {
+        tablesByKey.set(key, {
+          name: r.table_name,
+          schema: r.table_schema,
+          columns: [],
+          primaryKey: pkMap.get(key) || [],
+          indexes: []
+        });
+      }
+      const t = tablesByKey.get(key);
+      const column = {
+        name: r.column_name,
+        type: r.data_type,
+        notNull: r.is_nullable === false || r.is_nullable === 0,
+        default: r.column_default ?? void 0,
+        autoIncrement: !!r.is_identity
+      };
+      t.columns.push(column);
+    });
+    indexRows.forEach((r) => {
+      const key = `${r.table_schema}.${r.table_name}`;
+      const table = tablesByKey.get(key);
+      if (!table) return;
+      const cols = (indexColumnsMap.get(`${r.table_schema}.${r.table_name}.${r.index_name}`) || []).sort((a, b) => a.order - b.order).map((c) => ({ column: c.column }));
+      const idx = {
+        name: r.index_name,
+        columns: cols,
+        unique: !!r.is_unique,
+        where: r.has_filter ? r.filter_definition : void 0
+      };
+      table.indexes = table.indexes || [];
+      table.indexes.push(idx);
+    });
+    return { tables: Array.from(tablesByKey.values()) };
+  }
+};
+
+// src/core/ddl/schema-introspect.ts
+var INTROSPECTORS = {
+  postgres: postgresIntrospector,
+  mysql: mysqlIntrospector,
+  sqlite: sqliteIntrospector,
+  mssql: mssqlIntrospector
+};
+var introspectSchema = async (executor, dialect, options = {}) => {
+  const handler = INTROSPECTORS[dialect];
+  if (!handler) {
+    throw new Error(`Unsupported dialect for introspection: ${dialect}`);
+  }
+  return handler.introspect(executor, options);
 };
 
 // src/orm/als.ts
@@ -3887,9 +5493,13 @@ var UnitOfWork = class {
   async flushInsert(tracked) {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
     const payload = this.extractColumns(tracked.table, tracked.entity);
-    const builder = new InsertQueryBuilder(tracked.table).values(payload);
+    let builder = new InsertQueryBuilder(tracked.table).values(payload);
+    if (this.dialect.supportsReturning()) {
+      builder = builder.returning(...this.getReturningColumns(tracked.table));
+    }
     const compiled = builder.compile(this.dialect);
-    await this.executeCompiled(compiled);
+    const results = await this.executeCompiled(compiled);
+    this.applyReturningResults(tracked, results);
     tracked.status = "managed" /* Managed */;
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
     tracked.pk = this.getPrimaryKeyValue(tracked);
@@ -3906,9 +5516,13 @@ var UnitOfWork = class {
     await this.runHook(tracked.table.hooks?.beforeUpdate, tracked);
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
-    const builder = new UpdateQueryBuilder(tracked.table).set(changes).where(eq(pkColumn, tracked.pk));
+    let builder = new UpdateQueryBuilder(tracked.table).set(changes).where(eq(pkColumn, tracked.pk));
+    if (this.dialect.supportsReturning()) {
+      builder = builder.returning(...this.getReturningColumns(tracked.table));
+    }
     const compiled = builder.compile(this.dialect);
-    await this.executeCompiled(compiled);
+    const results = await this.executeCompiled(compiled);
+    this.applyReturningResults(tracked, results);
     tracked.status = "managed" /* Managed */;
     tracked.original = this.createSnapshot(tracked.table, tracked.entity);
     this.registerIdentity(tracked);
@@ -3950,7 +5564,31 @@ var UnitOfWork = class {
     return payload;
   }
   async executeCompiled(compiled) {
-    await this.executor.executeSql(compiled.sql, compiled.params);
+    return this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  getReturningColumns(table) {
+    return Object.values(table.columns).map((column) => ({
+      type: "Column",
+      table: table.name,
+      name: column.name,
+      alias: column.name
+    }));
+  }
+  applyReturningResults(tracked, results) {
+    if (!this.dialect.supportsReturning()) return;
+    const first = results[0];
+    if (!first || first.values.length === 0) return;
+    const row = first.values[0];
+    for (let i = 0; i < first.columns.length; i++) {
+      const columnName = this.normalizeColumnName(first.columns[i]);
+      if (!(columnName in tracked.table.columns)) continue;
+      tracked.entity[columnName] = row[i];
+    }
+  }
+  normalizeColumnName(column) {
+    const parts = column.split(".");
+    const candidate = parts[parts.length - 1];
+    return candidate.replace(/^["`[\]]+|["`[\]]+$/g, "");
   }
   registerIdentity(tracked) {
     if (tracked.pk == null) return;
@@ -3971,22 +5609,46 @@ var UnitOfWork = class {
   }
 };
 
+// src/orm/query-logger.ts
+var createQueryLoggingExecutor = (executor, logger) => {
+  if (!logger) {
+    return executor;
+  }
+  const wrapped = {
+    async executeSql(sql, params) {
+      logger({ sql, params });
+      return executor.executeSql(sql, params);
+    }
+  };
+  if (executor.beginTransaction) {
+    wrapped.beginTransaction = executor.beginTransaction.bind(executor);
+  }
+  if (executor.commitTransaction) {
+    wrapped.commitTransaction = executor.commitTransaction.bind(executor);
+  }
+  if (executor.rollbackTransaction) {
+    wrapped.rollbackTransaction = executor.rollbackTransaction.bind(executor);
+  }
+  return wrapped;
+};
+
 // src/orm/orm-context.ts
 var OrmContext = class {
   constructor(options) {
     this.options = options;
     this.identityMap = new IdentityMap();
     this.interceptors = [...options.interceptors ?? []];
+    this.executorWithLogging = createQueryLoggingExecutor(options.executor, options.queryLogger);
     this.unitOfWork = new UnitOfWork(
       options.dialect,
-      options.executor,
+      this.executorWithLogging,
       this.identityMap,
       () => this
     );
     this.relationChanges = new RelationChangeProcessor(
       this.unitOfWork,
       options.dialect,
-      options.executor
+      this.executorWithLogging
     );
     this.domainEvents = new DomainEventBus(options.domainEventHandlers);
   }
@@ -3994,7 +5656,7 @@ var OrmContext = class {
     return this.options.dialect;
   }
   get executor() {
-    return this.options.executor;
+    return this.executorWithLogging;
   }
   get identityBuckets() {
     return this.unitOfWork.identityBuckets;
@@ -4057,15 +5719,21 @@ var OrmContext = class {
 };
 export {
   AsyncLocalStorage,
+  BaseSchemaDialect,
   DefaultBelongsToReference,
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
   EntityStatus,
   InsertQueryBuilder,
+  MSSqlSchemaDialect,
   MySqlDialect,
+  MySqlSchemaDialect,
   OrmContext,
+  PostgresDialect,
+  PostgresSchemaDialect,
   RelationKinds,
+  SQLiteSchemaDialect,
   SelectQueryBuilder,
   SqlServerDialect,
   SqliteDialect,
@@ -4087,15 +5755,22 @@ export {
   createLiteral,
   defineTable,
   denseRank,
+  deriveIndexName,
+  diffSchema,
   eq,
+  escapeLiteral,
   executeHydrated,
   exists,
   firstValue,
+  formatLiteral,
+  generateCreateTableSql,
+  generateSchemaSql,
   gt,
   gte,
   hasMany,
   hydrateRows,
   inList,
+  introspectSchema,
   isCaseExpressionNode,
   isExpressionSelectionNode,
   isFunctionNode,
@@ -4120,9 +5795,14 @@ export {
   notLike,
   ntile,
   or,
+  quoteQualified,
   rank,
+  renderColumnDefinition,
+  renderIndexColumns,
+  resolvePrimaryKey,
   rowNumber,
   sum,
+  synchronizeSchema,
   valueToOperand,
   visitExpression,
   visitOperand,