@simplysm/orm-common 13.0.99 → 14.0.1

package/dist/query-builder/mssql/mssql-query-builder.js

@@ -1,446 +1,486 @@
 import { QueryBuilderBase } from "../base/query-builder-base.js";
 import { MssqlExprRenderer } from "./mssql-expr-renderer.js";
-class MssqlQueryBuilder extends QueryBuilderBase {
-  expr = new MssqlExprRenderer((def) => this.select(def).sql);
-  //#region ========== Utilities ==========
-  /** Render table name */
-  tableName(obj) {
-    const parts = [];
-    if (obj.database != null) {
-      parts.push(this.expr.wrap(obj.database));
-    }
-    if (obj.schema != null) {
-      parts.push(this.expr.wrap(obj.schema));
-    } else if (obj.database != null) {
-      parts.push("[dbo]");
-    }
-    parts.push(this.expr.wrap(obj.name));
-    return parts.join(".");
-  }
-  /** Render OFFSET...FETCH clause */
-  renderLimit(limit) {
-    if (limit == null) return "";
-    const [offset, count] = limit;
-    return ` OFFSET ${offset} ROWS FETCH NEXT ${count} ROWS ONLY`;
-  }
-  renderJoin(join) {
-    const alias = this.expr.wrap(join.as);
-    if (this.needsLateral(join)) {
-      const from2 = Array.isArray(join.from) ? this.renderFrom(join.from) : this.renderFrom(join);
-      return ` OUTER APPLY ${from2} AS ${alias}`;
-    }
-    const from = this.renderFrom(join.from);
-    const where = join.where != null && join.where.length > 0 ? ` ON ${this.expr.renderWhere(join.where)}` : " ON 1=1";
-    return ` LEFT OUTER JOIN ${from} AS ${alias}${where}`;
-  }
-  //#endregion
-  //#region ========== DML - SELECT ==========
-  select(def) {
-    let sql = "";
-    if (def.with != null) {
-      const { name, base, recursive } = def.with;
-      sql += `WITH ${this.expr.wrap(name)} AS (${this.select(base).sql} UNION ALL ${this.select(recursive).sql}) `;
-    }
-    sql += "SELECT";
-    if (def.distinct) {
-      sql += " DISTINCT";
-    }
-    if (def.top != null) {
-      sql += ` TOP ${def.top}`;
-    }
-    if (def.select != null) {
-      const cols = Object.entries(def.select).map(
-        ([alias, expr]) => `${this.expr.render(expr)} AS ${this.expr.wrap(alias)}`
-      );
-      sql += ` ${cols.join(", ")}`;
-    } else {
-      sql += " *";
-    }
-    if (def.from != null) {
-      const from = this.renderFrom(def.from);
-      sql += ` FROM ${from} AS ${this.expr.wrap(def.as)}`;
-      if (def.lock) {
-        sql += " WITH (UPDLOCK, ROWLOCK)";
-      }
-    }
-    sql += this.renderJoins(def.joins);
-    sql += this.renderWhere(def.where);
-    sql += this.renderGroupBy(def.groupBy);
-    sql += this.renderHaving(def.having);
-    sql += this.renderOrderBy(def.orderBy);
-    sql += this.renderLimit(def.limit);
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - INSERT ==========
-  insert(def) {
-    const table = this.tableName(def.table);
-    if (def.records.length === 0) {
-      throw new Error("INSERT requires at least one record.");
-    }
-    const columns = Object.keys(def.records[0]);
-    const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
-    let sql = "";
-    if (def.overrideIdentity) {
-      sql += `SET IDENTITY_INSERT ${table} ON;
-`;
-    }
-    sql += `INSERT INTO ${table} (${colList})`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
-      sql += ` OUTPUT ${outputCols}`;
-    }
-    sql += ` VALUES`;
-    const valuesList = def.records.map((record) => {
-      const values = columns.map((c) => this.expr.escapeValue(record[c]));
-      return `(${values.join(", ")})`;
-    });
-    sql += ` ${valuesList.join(", ")}`;
-    if (def.overrideIdentity) {
-      sql += `;
-SET IDENTITY_INSERT ${table} OFF;`;
-    }
-    return { sql, resultSetIndex: def.overrideIdentity ? 1 : void 0 };
-  }
-  insertIfNotExists(def) {
-    const table = this.tableName(def.table);
-    const columns = Object.keys(def.record);
-    const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
-    const values = columns.map((c) => this.expr.escapeValue(def.record[c])).join(", ");
-    const existsQuerySql = this.select({
-      ...def.existsSelectQuery,
-      select: { _: { type: "value", value: 1 } }
-    }).sql;
-    let sql = `INSERT INTO ${table} (${colList})`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
-      sql += ` OUTPUT ${outputCols}`;
-    }
-    sql += ` SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
-    return { sql };
-  }
-  insertInto(def) {
-    const table = this.tableName(def.table);
-    const selectSql = this.select(def.recordsSelectQuery).sql;
-    const selectDef = def.recordsSelectQuery;
-    const colList = selectDef.select != null ? Object.keys(selectDef.select).map((c) => this.expr.wrap(c)).join(", ") : "*";
-    let sql = `INSERT INTO ${table} (${colList})`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
-      sql += ` OUTPUT ${outputCols}`;
-    }
-    sql += ` ${selectSql}`;
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - UPDATE ==========
-  update(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.as);
-    const setParts = Object.entries(def.record).map(
-      ([col, e]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(e)}`
-    );
-    let sql = "UPDATE";
-    if (def.top != null) {
-      sql += ` TOP ${def.top}`;
-    }
-    sql += ` ${alias} SET ${setParts.join(", ")}`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
-      sql += ` OUTPUT ${outputCols}`;
-    }
-    sql += ` FROM ${table} AS ${alias}`;
-    sql += this.renderJoins(def.joins);
-    sql += this.renderWhere(def.where);
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - DELETE ==========
-  delete(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.as);
-    let sql = "DELETE";
-    if (def.top != null) {
-      sql += ` TOP ${def.top}`;
-    }
-    sql += ` ${alias}`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `DELETED.${this.expr.wrap(c)}`).join(", ");
-      sql += ` OUTPUT ${outputCols}`;
-    }
-    sql += ` FROM ${table} AS ${alias}`;
-    sql += this.renderJoins(def.joins);
-    sql += this.renderWhere(def.where);
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - UPSERT ==========
-  upsert(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.existsSelectQuery.as);
-    const existsWhere = def.existsSelectQuery.where;
-    const updateSetParts = Object.entries(def.updateRecord).map(
-      ([col, e]) => `${this.expr.wrap(col)} = ${this.expr.render(e)}`
-    );
-    const insertColumns = Object.keys(def.insertRecord);
-    const insertColList = insertColumns.map((c) => this.expr.wrap(c)).join(", ");
-    const insertValues = insertColumns.map((c) => this.expr.render(def.insertRecord[c])).join(", ");
-    let sql = `MERGE ${table} AS ${alias}
-`;
-    sql += `USING (SELECT 1 AS [_]) AS [_src] ON `;
-    sql += existsWhere != null && existsWhere.length > 0 ? this.expr.renderWhere(existsWhere) : "1=0";
-    if (updateSetParts.length > 0) {
-      sql += `
-WHEN MATCHED THEN UPDATE SET ${updateSetParts.join(", ")}`;
-    }
-    sql += `
-WHEN NOT MATCHED THEN INSERT (${insertColList}) VALUES (${insertValues})`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
-      sql += `
-OUTPUT ${outputCols}`;
-    }
-    sql += ";";
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DDL - Table ==========
-  createTable(def) {
-    const table = this.tableName(def.table);
-    const colDefs = def.columns.map((col) => {
-      let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
-      if (col.nullable === true) {
-        colSql += " NULL";
-      } else {
-        colSql += " NOT NULL";
-      }
-      if (col.autoIncrement) {
-        colSql += " IDENTITY(1,1)";
-      }
-      if (col.default !== void 0) {
-        colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
-      }
-      return colSql;
-    });
-    if (def.primaryKey != null && def.primaryKey.length > 0) {
-      const pkCols = def.primaryKey.map((c) => this.expr.wrap(c)).join(", ");
-      const pkName = this.expr.wrap(`PK_${def.table.name}`);
-      colDefs.push(`CONSTRAINT ${pkName} PRIMARY KEY (${pkCols})`);
-    }
-    return { sql: `CREATE TABLE ${table} (
-  ${colDefs.join(",\n  ")}
-)` };
-  }
-  dropTable(def) {
-    return { sql: `DROP TABLE ${this.tableName(def.table)}` };
-  }
-  renameTable(def) {
-    const tableName = this.expr.escapeString(this.tableName(def.table));
-    const newName = this.expr.escapeString(def.newName);
-    return { sql: `EXEC sp_rename '${tableName}', '${newName}'` };
-  }
-  truncate(def) {
-    return { sql: `TRUNCATE TABLE ${this.tableName(def.table)}` };
-  }
-  //#endregion
-  //#region ========== DDL - Column ==========
-  addColumn(def) {
-    const table = this.tableName(def.table);
-    const col = def.column;
-    let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
-    if (col.nullable === true) {
-      colSql += " NULL";
-    } else {
-      colSql += " NOT NULL";
-    }
-    if (col.autoIncrement) {
-      colSql += " IDENTITY(1,1)";
-    }
-    if (col.default !== void 0) {
-      colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
-    }
-    return { sql: `ALTER TABLE ${table} ADD ${colSql}` };
-  }
-  dropColumn(def) {
-    return {
-      sql: `ALTER TABLE ${this.tableName(def.table)} DROP COLUMN ${this.expr.wrap(def.column)}`
-    };
-  }
-  modifyColumn(def) {
-    const table = this.tableName(def.table);
-    const col = def.column;
-    let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
-    if (col.nullable === true) {
-      colSql += " NULL";
-    } else {
-      colSql += " NOT NULL";
-    }
-    return { sql: `ALTER TABLE ${table} ALTER COLUMN ${colSql}` };
-  }
-  renameColumn(def) {
-    const table = this.tableName(def.table);
-    const tableCol = this.expr.escapeString(`${table}.${def.column}`);
-    const newName = this.expr.escapeString(def.newName);
-    return { sql: `EXEC sp_rename '${tableCol}', '${newName}', 'COLUMN'` };
-  }
-  //#endregion
-  //#region ========== DDL - Constraint ==========
-  addPrimaryKey(def) {
-    const table = this.tableName(def.table);
-    const cols = def.columns.map((c) => this.expr.wrap(c)).join(", ");
-    const pkName = `PK_${def.table.name}`;
-    return {
-      sql: `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(pkName)} PRIMARY KEY (${cols})`
-    };
-  }
-  dropPrimaryKey(def) {
-    const table = this.tableName(def.table);
-    const pkName = `PK_${def.table.name}`;
-    return { sql: `ALTER TABLE ${table} DROP CONSTRAINT ${this.expr.wrap(pkName)}` };
-  }
-  addForeignKey(def) {
-    const table = this.tableName(def.table);
-    const fk = def.foreignKey;
-    const fkCols = fk.fkColumns.map((c) => this.expr.wrap(c)).join(", ");
-    const targetTable = this.tableName(fk.targetTable);
-    const targetCols = fk.targetPkColumns.map((c) => this.expr.wrap(c)).join(", ");
-    let sql = `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(fk.name)} FOREIGN KEY (${fkCols}) REFERENCES ${targetTable} (${targetCols})`;
-    const idxName = `IDX_${def.table.name}_${fk.name.replace(/^FK_/, "")}`;
-    sql += `;
-CREATE INDEX ${this.expr.wrap(idxName)} ON ${table} (${fkCols});`;
-    return { sql };
-  }
-  dropForeignKey(def) {
-    return {
-      sql: `ALTER TABLE ${this.tableName(def.table)} DROP CONSTRAINT ${this.expr.wrap(def.foreignKey)}`
-    };
-  }
-  addIndex(def) {
-    const table = this.tableName(def.table);
-    const idx = def.index;
-    const cols = idx.columns.map((c) => `${this.expr.wrap(c.name)} ${c.orderBy}`).join(", ");
-    const unique = idx.unique ? "UNIQUE " : "";
-    return { sql: `CREATE ${unique}INDEX ${this.expr.wrap(idx.name)} ON ${table} (${cols})` };
-  }
-  dropIndex(def) {
-    return { sql: `DROP INDEX ${this.expr.wrap(def.index)} ON ${this.tableName(def.table)}` };
-  }
-  //#endregion
-  //#region ========== DDL - View/Procedure ==========
-  createView(def) {
-    const view = this.tableName(def.view);
-    const selectSql = this.select(def.queryDef).sql;
-    return { sql: `CREATE OR ALTER VIEW ${view} AS ${selectSql}` };
-  }
-  dropView(def) {
-    return { sql: `DROP VIEW IF EXISTS ${this.tableName(def.view)}` };
-  }
-  createProc(def) {
-    var _a;
-    const proc = this.tableName(def.procedure);
-    const paramList = ((_a = def.params) == null ? void 0 : _a.map((p) => {
-      let sql2 = `@${p.name} ${this.expr.renderDataType(p.dataType)}`;
-      if (p.default !== void 0) {
-        sql2 += ` = ${this.expr.escapeValue(p.default)}`;
-      }
-      return sql2;
-    }).join(", ")) ?? "";
-    let sql = `CREATE OR ALTER PROCEDURE ${proc}`;
-    if (paramList) {
-      sql += ` ${paramList}`;
-    }
-    sql += `
-AS
-BEGIN
-`;
-    sql += `SET NOCOUNT ON;
-`;
-    sql += def.query;
-    sql += `
-END`;
-    return { sql };
-  }
-  dropProc(def) {
-    return { sql: `DROP PROCEDURE IF EXISTS ${this.tableName(def.procedure)}` };
-  }
-  execProc(def) {
-    const proc = this.tableName(def.procedure);
-    if (def.params == null || Object.keys(def.params).length === 0) {
-      return { sql: `EXEC ${proc}` };
-    }
-    const params = Object.values(def.params).map((p) => this.expr.render(p)).join(", ");
-    return { sql: `EXEC ${proc} ${params}` };
-  }
-  //#endregion
-  //#region ========== Utils ==========
-  clearSchema(def) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(def.database)) {
-      throw new Error(`Invalid database name: ${def.database}`);
-    }
-    const schemaName = def.schema ?? "dbo";
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
-      throw new Error(`Invalid schema name: ${schemaName}`);
-    }
-    const db = this.expr.wrap(def.database);
-    const schema = this.expr.escapeString(schemaName);
-    return {
-      sql: `
-DECLARE @sql NVARCHAR(MAX);
-SET @sql = N'';
-
--- Drop FK constraints
-SELECT @sql = @sql + N'ALTER TABLE ' + QUOTENAME(OBJECT_SCHEMA_NAME(parent_object_id)) + '.' + QUOTENAME(OBJECT_NAME(parent_object_id)) + N' DROP CONSTRAINT ' + QUOTENAME(name) + N';' + CHAR(13)
-FROM ${db}.sys.foreign_keys
-WHERE OBJECT_SCHEMA_NAME(parent_object_id) = '${schema}';
-
--- Drop tables
-SELECT @sql = @sql + N'DROP TABLE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
-FROM ${db}.sys.tables
-WHERE SCHEMA_NAME(schema_id) = '${schema}';
-
--- Drop views
-SELECT @sql = @sql + N'DROP VIEW ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
-FROM ${db}.sys.views
-WHERE schema_id = SCHEMA_ID('${schema}');
-
--- Drop procedures
-SELECT @sql = @sql + N'DROP PROCEDURE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
-FROM ${db}.sys.procedures
-WHERE SCHEMA_NAME(schema_id) = '${schema}';
-
-EXEC sp_executesql @sql;`
-    };
-  }
-  schemaExists(def) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(def.database)) {
-      throw new Error(`Invalid database name: ${def.database}`);
-    }
-    const schemaName = def.schema ?? "dbo";
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
-      throw new Error(`Invalid schema name: ${schemaName}`);
-    }
-    const dbName = this.expr.escapeString(def.database);
-    const schema = this.expr.escapeString(schemaName);
-    return {
-      sql: `DECLARE @result NVARCHAR(MAX) = NULL;
-IF EXISTS (SELECT 1 FROM sys.databases WHERE name = '${dbName}')
-BEGIN
-  DECLARE @sql NVARCHAR(MAX) = N'SELECT @result = name FROM ' + QUOTENAME('${dbName}') + N'.sys.schemas WHERE name = ''${schema}''';
-  EXEC sp_executesql @sql, N'@result NVARCHAR(MAX) OUTPUT', @result OUTPUT;
-END
-SELECT @result AS name WHERE @result IS NOT NULL`
-    };
-  }
-  switchFk(def) {
-    const table = this.tableName(def.table);
-    if (def.enabled) {
-      return { sql: `ALTER TABLE ${table} WITH CHECK CHECK CONSTRAINT ALL` };
-    }
-    return { sql: `ALTER TABLE ${table} NOCHECK CONSTRAINT ALL` };
-  }
-  //#endregion
+/**
+ * MSSQL QueryBuilder
+ */
+export class MssqlQueryBuilder extends QueryBuilderBase {
+    expr = new MssqlExprRenderer((def) => this.select(def).sql);
+    //#region ========== Utilities ==========
+    /** Render table name */
+    tableName(obj) {
+        const parts = [];
+        if (obj.database != null) {
+            parts.push(this.expr.wrap(obj.database));
+        }
+        if (obj.schema != null) {
+            parts.push(this.expr.wrap(obj.schema));
+        }
+        else if (obj.database != null) {
+            parts.push("[dbo]");
+        }
+        parts.push(this.expr.wrap(obj.name));
+        return parts.join(".");
+    }
+    /** Render OFFSET...FETCH clause */
+    renderLimit(limit) {
+        if (limit == null)
+            return "";
+        const [offset, count] = limit;
+        return ` OFFSET ${offset} ROWS FETCH NEXT ${count} ROWS ONLY`;
+    }
+    renderJoin(join) {
+        const alias = this.expr.wrap(join.as);
+        // Detect if LATERAL JOIN is needed → MSSQL uses OUTER APPLY
+        if (this.needsLateral(join)) {
+            // If from is an array (UNION ALL), use renderFrom(join.from),
+            // otherwise (orderBy, top, select, etc.) use renderFrom(join) to generate subquery
+            const from = Array.isArray(join.from) ? this.renderFrom(join.from) : this.renderFrom(join);
+            return ` OUTER APPLY ${from} AS ${alias}`;
+        }
+        // Normal JOIN
+        const from = this.renderFrom(join.from);
+        const where = join.where != null && join.where.length > 0
+            ? ` ON ${this.expr.renderWhere(join.where)}`
+            : " ON 1=1";
+        return ` LEFT OUTER JOIN ${from} AS ${alias}${where}`;
+    }
+    //#endregion
+    //#region ========== DML - SELECT ==========
+    select(def) {
+        // WITH (CTE)
+        let sql = "";
+        if (def.with != null) {
+            const { name, base, recursive } = def.with;
+            sql += `WITH ${this.expr.wrap(name)} AS (${this.select(base).sql} UNION ALL ${this.select(recursive).sql}) `;
+        }
+        // SELECT
+        sql += "SELECT";
+        if (def.distinct) {
+            sql += " DISTINCT";
+        }
+        // TOP
+        if (def.top != null) {
+            sql += ` TOP ${def.top}`;
+        }
+        // columns
+        if (def.select != null) {
+            const cols = Object.entries(def.select).map(([alias, expr]) => `${this.expr.render(expr)} AS ${this.expr.wrap(alias)}`);
+            sql += ` ${cols.join(", ")}`;
+        }
+        else {
+            sql += " *";
+        }
+        // FROM
+        if (def.from != null) {
+            const from = this.renderFrom(def.from);
+            sql += ` FROM ${from} AS ${this.expr.wrap(def.as)}`;
+            // LOCK (force row-level lock with ROWLOCK - same behavior as MySQL/PostgreSQL FOR UPDATE)
+            if (def.lock) {
+                sql += " WITH (UPDLOCK, ROWLOCK)";
+            }
+        }
+        // JOINs
+        sql += this.renderJoins(def.joins);
+        // WHERE
+        sql += this.renderWhere(def.where);
+        // GROUP BY
+        sql += this.renderGroupBy(def.groupBy);
+        // HAVING
+        sql += this.renderHaving(def.having);
+        // ORDER BY
+        sql += this.renderOrderBy(def.orderBy);
+        // LIMIT (OFFSET...FETCH)
+        sql += this.renderLimit(def.limit);
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - INSERT ==========
+    insert(def) {
+        const table = this.tableName(def.table);
+        if (def.records.length === 0) {
+            throw new Error("INSERT에는 최소 1개의 레코드가 필요합니다.");
+        }
+        const columns = Object.keys(def.records[0]);
+        const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
+        let sql = "";
+        // IDENTITY_INSERT ON (when inserting explicit values into AI column)
+        if (def.overrideIdentity) {
+            sql += `SET IDENTITY_INSERT ${table} ON;\n`;
+        }
+        sql += `INSERT INTO ${table} (${colList})`;
+        // OUTPUT (MSSQL native support)
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
+            sql += ` OUTPUT ${outputCols}`;
+        }
+        sql += ` VALUES`;
+        const valuesList = def.records.map((record) => {
+            const values = columns.map((c) => this.expr.escapeValue(record[c]));
+            return `(${values.join(", ")})`;
+        });
+        sql += ` ${valuesList.join(", ")}`;
+        // IDENTITY_INSERT OFF
+        if (def.overrideIdentity) {
+            sql += `;\nSET IDENTITY_INSERT ${table} OFF;`;
+        }
+        // With overrideIdentity: SET ON → results[0], INSERT → results[1], SET OFF → results[2]
+        return { sql, resultSetIndex: def.overrideIdentity ? 1 : undefined };
+    }
+    insertIfNotExists(def) {
+        const table = this.tableName(def.table);
+        const columns = Object.keys(def.record);
+        const colList = columns.map((c) => this.expr.wrap(c)).join(", ");
+        const values = columns.map((c) => this.expr.escapeValue(def.record[c])).join(", ");
+        // Render existsSelectQuery as SELECT 1 AS _
+        const existsQuerySql = this.select({
+            ...def.existsSelectQuery,
+            select: { _: { type: "value", value: 1 } },
+        }).sql;
+        let sql = `INSERT INTO ${table} (${colList})`;
+        // OUTPUT (MSSQL: OUTPUT must be placed before SELECT)
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
+            sql += ` OUTPUT ${outputCols}`;
+        }
+        sql += ` SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
+        return { sql };
+    }
+    insertInto(def) {
+        const table = this.tableName(def.table);
+        const selectSql = this.select(def.recordsSelectQuery).sql;
+        // Extract columns from INSERT INTO SELECT
+        const selectDef = def.recordsSelectQuery;
+        const colList = selectDef.select != null
+            ? Object.keys(selectDef.select)
+                .map((c) => this.expr.wrap(c))
+                .join(", ")
+            : "*";
+        let sql = `INSERT INTO ${table} (${colList})`;
+        // OUTPUT
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
+            sql += ` OUTPUT ${outputCols}`;
+        }
+        sql += ` ${selectSql}`;
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - UPDATE ==========
+    update(def) {
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.as);
+        // SET
+        const setParts = Object.entries(def.record).map(([col, e]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(e)}`);
+        let sql = "UPDATE";
+        if (def.top != null) {
+            sql += ` TOP ${def.top}`;
+        }
+        sql += ` ${alias} SET ${setParts.join(", ")}`;
+        // OUTPUT
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
+            sql += ` OUTPUT ${outputCols}`;
+        }
+        sql += ` FROM ${table} AS ${alias}`;
+        sql += this.renderJoins(def.joins);
+        sql += this.renderWhere(def.where);
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - DELETE ==========
+    delete(def) {
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.as);
+        let sql = "DELETE";
+        if (def.top != null) {
+            sql += ` TOP ${def.top}`;
+        }
+        sql += ` ${alias}`;
+        // OUTPUT (MSSQL: DELETED for DELETE)
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `DELETED.${this.expr.wrap(c)}`).join(", ");
+            sql += ` OUTPUT ${outputCols}`;
+        }
+        sql += ` FROM ${table} AS ${alias}`;
+        sql += this.renderJoins(def.joins);
+        sql += this.renderWhere(def.where);
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - UPSERT ==========
+    upsert(def) {
+        // MSSQL: Use MERGE
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.existsSelectQuery.as);
+        const existsWhere = def.existsSelectQuery.where;
+        // UPDATE SET part
+        const updateSetParts = Object.entries(def.updateRecord).map(([col, e]) => `${this.expr.wrap(col)} = ${this.expr.render(e)}`);
+        // INSERT part
+        const insertColumns = Object.keys(def.insertRecord);
+        const insertColList = insertColumns.map((c) => this.expr.wrap(c)).join(", ");
+        const insertValues = insertColumns.map((c) => this.expr.render(def.insertRecord[c])).join(", ");
+        let sql = `MERGE ${table} AS ${alias}\n`;
+        sql += `USING (SELECT 1 AS [_]) AS [_src] ON `;
+        sql +=
+            existsWhere != null && existsWhere.length > 0 ? this.expr.renderWhere(existsWhere) : "1=0";
+        if (updateSetParts.length > 0) {
+            sql += `\nWHEN MATCHED THEN UPDATE SET ${updateSetParts.join(", ")}`;
+        }
+        sql += `\nWHEN NOT MATCHED THEN INSERT (${insertColList}) VALUES (${insertValues})`;
+        // OUTPUT
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `INSERTED.${this.expr.wrap(c)}`).join(", ");
+            sql += `\nOUTPUT ${outputCols}`;
+        }
+        sql += ";";
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DDL - Table ==========
+    createTable(def) {
+        const table = this.tableName(def.table);
+        const colDefs = def.columns.map((col) => {
+            let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
+            // nullable: true → NULL, else → NOT NULL
+            if (col.nullable === true) {
+                colSql += " NULL";
+            }
+            else {
+                colSql += " NOT NULL";
+            }
+            if (col.autoIncrement) {
+                colSql += " IDENTITY(1,1)";
+            }
+            if (col.default !== undefined) {
+                colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
+            }
+            return colSql;
+        });
+        // Primary Key with CONSTRAINT name
+        if (def.primaryKey != null && def.primaryKey.length > 0) {
+            const pkCols = def.primaryKey.map((c) => this.expr.wrap(c)).join(", ");
+            const pkName = this.expr.wrap(`PK_${def.table.name}`);
+            colDefs.push(`CONSTRAINT ${pkName} PRIMARY KEY (${pkCols})`);
+        }
+        return { sql: `CREATE TABLE ${table} (\n  ${colDefs.join(",\n  ")}\n)` };
+    }
+    dropTable(def) {
+        return { sql: `DROP TABLE ${this.tableName(def.table)}` };
+    }
+    renameTable(def) {
+        // MSSQL: Use sp_rename
+        const tableName = this.expr.escapeString(this.tableName(def.table));
+        const newName = this.expr.escapeString(def.newName);
+        return { sql: `EXEC sp_rename '${tableName}', '${newName}'` };
+    }
+    truncate(def) {
+        // MSSQL: TRUNCATE automatically resets IDENTITY
+        return { sql: `TRUNCATE TABLE ${this.tableName(def.table)}` };
+    }
+    //#endregion
+    //#region ========== DDL - Column ==========
+    addColumn(def) {
+        const table = this.tableName(def.table);
+        const col = def.column;
+        let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
+        // nullable: true → NULL, else → NOT NULL
+        if (col.nullable === true) {
+            colSql += " NULL";
+        }
+        else {
+            colSql += " NOT NULL";
+        }
+        if (col.autoIncrement) {
+            colSql += " IDENTITY(1,1)";
+        }
+        if (col.default !== undefined) {
+            colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
+        }
+        return { sql: `ALTER TABLE ${table} ADD ${colSql}` };
+    }
+    dropColumn(def) {
+        return {
+            sql: `ALTER TABLE ${this.tableName(def.table)} DROP COLUMN ${this.expr.wrap(def.column)}`,
+        };
+    }
+    modifyColumn(def) {
+        const table = this.tableName(def.table);
+        const col = def.column;
+        let colSql = `${this.expr.wrap(col.name)} ${this.expr.renderDataType(col.dataType)}`;
+        // nullable: true → NULL, else → NOT NULL
+        if (col.nullable === true) {
+            colSql += " NULL";
+        }
+        else {
+            colSql += " NOT NULL";
+        }
+        // MSSQL: ALTER COLUMN (IDENTITY and DEFAULT require separate handling)
+        return { sql: `ALTER TABLE ${table} ALTER COLUMN ${colSql}` };
+    }
+    renameColumn(def) {
+        const table = this.tableName(def.table);
+        // MSSQL: Use sp_rename
+        const tableCol = this.expr.escapeString(`${table}.${def.column}`);
+        const newName = this.expr.escapeString(def.newName);
+        return { sql: `EXEC sp_rename '${tableCol}', '${newName}', 'COLUMN'` };
+    }
+    //#endregion
+    //#region ========== DDL - Constraint ==========
+    addPrimaryKey(def) {
+        const table = this.tableName(def.table);
+        const cols = def.columns.map((c) => this.expr.wrap(c)).join(", ");
+        const pkName = `PK_${def.table.name}`;
+        return {
+            sql: `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(pkName)} PRIMARY KEY (${cols})`,
+        };
+    }
+    dropPrimaryKey(def) {
+        const table = this.tableName(def.table);
+        const pkName = `PK_${def.table.name}`;
+        return { sql: `ALTER TABLE ${table} DROP CONSTRAINT ${this.expr.wrap(pkName)}` };
+    }
+    addForeignKey(def) {
+        const table = this.tableName(def.table);
+        const fk = def.foreignKey;
+        const fkCols = fk.fkColumns.map((c) => this.expr.wrap(c)).join(", ");
+        const targetTable = this.tableName(fk.targetTable);
+        const targetCols = fk.targetPkColumns.map((c) => this.expr.wrap(c)).join(", ");
+        let sql = `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(fk.name)} FOREIGN KEY (${fkCols}) REFERENCES ${targetTable} (${targetCols})`;
+        // MSSQL/PostgreSQL: separate index generation needed for FK
+        const idxName = `IDX_${def.table.name}_${fk.name.replace(/^FK_/, "")}`;
+        sql += `;\nCREATE INDEX ${this.expr.wrap(idxName)} ON ${table} (${fkCols});`;
+        return { sql };
+    }
+    dropForeignKey(def) {
+        return {
+            sql: `ALTER TABLE ${this.tableName(def.table)} DROP CONSTRAINT ${this.expr.wrap(def.foreignKey)}`,
+        };
+    }
+    addIndex(def) {
+        const table = this.tableName(def.table);
+        const idx = def.index;
+        const cols = idx.columns.map((c) => `${this.expr.wrap(c.name)} ${c.orderBy}`).join(", ");
+        const unique = idx.unique ? "UNIQUE " : "";
+        return { sql: `CREATE ${unique}INDEX ${this.expr.wrap(idx.name)} ON ${table} (${cols})` };
+    }
+    dropIndex(def) {
+        return { sql: `DROP INDEX ${this.expr.wrap(def.index)} ON ${this.tableName(def.table)}` };
+    }
+    //#endregion
+    //#region ========== DDL - View/Procedure ==========
+    createView(def) {
+        const view = this.tableName(def.view);
+        const selectSql = this.select(def.queryDef).sql;
+        // MSSQL: CREATE OR ALTER VIEW (2016 SP1+)
+        return { sql: `CREATE OR ALTER VIEW ${view} AS ${selectSql}` };
+    }
+    dropView(def) {
+        return { sql: `DROP VIEW IF EXISTS ${this.tableName(def.view)}` };
+    }
+    createProc(def) {
+        const proc = this.tableName(def.procedure);
+        // Process params
+        const paramList = def.params
+            ?.map((p) => {
+            let sql = `@${p.name} ${this.expr.renderDataType(p.dataType)}`;
+            if (p.default !== undefined) {
+                sql += ` = ${this.expr.escapeValue(p.default)}`;
+            }
+            return sql;
+        })
+            .join(", ") ?? "";
+        let sql = `CREATE OR ALTER PROCEDURE ${proc}`;
+        if (paramList) {
+            sql += ` ${paramList}`;
+        }
+        sql += `\nAS\nBEGIN\n`;
+        sql += `SET NOCOUNT ON;\n`;
+        sql += def.query;
+        sql += `\nEND`;
+        return { sql };
+    }
+    dropProc(def) {
+        return { sql: `DROP PROCEDURE IF EXISTS ${this.tableName(def.procedure)}` };
+    }
+    execProc(def) {
+        const proc = this.tableName(def.procedure);
+        if (def.params == null || Object.keys(def.params).length === 0) {
+            return { sql: `EXEC ${proc}` };
+        }
+        const params = Object.values(def.params)
+            .map((p) => this.expr.render(p))
+            .join(", ");
+        return { sql: `EXEC ${proc} ${params}` };
+    }
+    //#endregion
+    //#region ========== Utils ==========
+    clearSchema(def) {
+        // SQL 인젝션 방지: 식별자 유효성 검사
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(def.database)) {
+            throw new Error(`잘못된 데이터베이스 이름: ${def.database}`);
+        }
+        const schemaName = def.schema ?? "dbo";
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
+            throw new Error(`잘못된 schema 이름: ${schemaName}`);
+        }
+        const db = this.expr.wrap(def.database);
+        const schema = this.expr.escapeString(schemaName);
+        return {
+            sql: `
+DECLARE @sql NVARCHAR(MAX);
+SET @sql = N'';
+
+-- FK 제약조건 삭제
+SELECT @sql = @sql + N'ALTER TABLE ' + QUOTENAME(OBJECT_SCHEMA_NAME(parent_object_id)) + '.' + QUOTENAME(OBJECT_NAME(parent_object_id)) + N' DROP CONSTRAINT ' + QUOTENAME(name) + N';' + CHAR(13)
+FROM ${db}.sys.foreign_keys
+WHERE OBJECT_SCHEMA_NAME(parent_object_id) = '${schema}';
+
+-- 테이블 삭제
+SELECT @sql = @sql + N'DROP TABLE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM ${db}.sys.tables
+WHERE SCHEMA_NAME(schema_id) = '${schema}';
+
+-- 뷰 삭제
+SELECT @sql = @sql + N'DROP VIEW ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM ${db}.sys.views
+WHERE schema_id = SCHEMA_ID('${schema}');
+
+-- 프로시저 삭제
+SELECT @sql = @sql + N'DROP PROCEDURE ' + QUOTENAME(SCHEMA_NAME(schema_id)) + '.' + QUOTENAME(name) + N';' + CHAR(13)
+FROM ${db}.sys.procedures
+WHERE SCHEMA_NAME(schema_id) = '${schema}';
+
+EXEC sp_executesql @sql;`,
+        };
+    }
+    schemaExists(def) {
+        // SQL 인젝션 방지: 식별자 유효성 검사
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(def.database)) {
+            throw new Error(`잘못된 데이터베이스 이름: ${def.database}`);
+        }
+        const schemaName = def.schema ?? "dbo";
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
+            throw new Error(`잘못된 schema 이름: ${schemaName}`);
+        }
+        const dbName = this.expr.escapeString(def.database);
+        const schema = this.expr.escapeString(schemaName);
+        // MSSQL: check database existence then check schema (using dynamic SQL)
+        return {
+            sql: `DECLARE @result NVARCHAR(MAX) = NULL;
+IF EXISTS (SELECT 1 FROM sys.databases WHERE name = '${dbName}')
+BEGIN
+  DECLARE @sql NVARCHAR(MAX) = N'SELECT @result = name FROM ' + QUOTENAME('${dbName}') + N'.sys.schemas WHERE name = ''${schema}''';
+  EXEC sp_executesql @sql, N'@result NVARCHAR(MAX) OUTPUT', @result OUTPUT;
+END
+SELECT @result AS name WHERE @result IS NOT NULL`,
+        };
+    }
+    switchFk(def) {
+        const table = this.tableName(def.table);
+        if (def.enabled) {
+            return { sql: `ALTER TABLE ${table} WITH CHECK CHECK CONSTRAINT ALL` };
+        }
+        return { sql: `ALTER TABLE ${table} NOCHECK CONSTRAINT ALL` };
+    }
 }
-export {
-  MssqlQueryBuilder
-};
-//# sourceMappingURL=mssql-query-builder.js.map
+//# sourceMappingURL=mssql-query-builder.js.map