@simplysm/orm-common 13.0.99 → 14.0.1

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

@@ -1,484 +1,575 @@
 import { Uuid } from "@simplysm/core-common";
 import { QueryBuilderBase } from "../base/query-builder-base.js";
 import { MysqlExprRenderer } from "./mysql-expr-renderer.js";
-class MysqlQueryBuilder extends QueryBuilderBase {
-  expr = new MysqlExprRenderer((def) => this.select(def).sql);
-  //#region ========== Utilities ==========
-  /** Render table name (MySQL: ignores schema, uses database.table only) */
-  tableName(obj) {
-    if (obj.database != null) {
-      return `${this.expr.wrap(obj.database)}.${this.expr.wrap(obj.name)}`;
-    }
-    return this.expr.wrap(obj.name);
-  }
-  /** Render LIMIT clause */
-  renderLimit(limit, top) {
-    if (limit != null) {
-      const [offset, count] = limit;
-      return ` LIMIT ${offset}, ${count}`;
-    }
-    if (top != null) {
-      return ` LIMIT ${top}`;
-    }
-    return "";
-  }
-  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 ` LEFT OUTER JOIN LATERAL ${from2} AS ${alias} ON TRUE`;
-    }
-    const from = this.renderFrom(join.from);
-    const where = join.where != null && join.where.length > 0 ? ` ON ${this.expr.renderWhere(join.where)}` : " ON TRUE";
-    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.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 += 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, def.top);
-    if (def.lock) {
-      sql += " FOR UPDATE";
-    }
-    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(", ");
-    if (def.output == null) {
-      const valuesList = def.records.map((record) => {
-        const values = columns.map((c) => this.expr.escapeValue(record[c]));
-        return `(${values.join(", ")})`;
-      });
-      return { sql: `INSERT INTO ${table} (${colList}) VALUES ${valuesList.join(", ")}` };
-    }
-    const output = def.output;
-    const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
-    const statements = [];
-    for (const record of def.records) {
-      const values = columns.map((c) => this.expr.escapeValue(record[c])).join(", ");
-      statements.push(`INSERT INTO ${table} (${colList}) VALUES (${values})`);
-      const whereForSelect = output.pkColNames.map((pk) => {
-        const wrappedPk = this.expr.wrap(pk);
-        if (pk === output.aiColName) {
-          return `${wrappedPk} = LAST_INSERT_ID()`;
-        }
-        return `${wrappedPk} = ${this.expr.escapeValue(record[pk])}`;
-      });
-      statements.push(`SELECT ${outputCols} FROM ${table} WHERE ${whereForSelect.join(" AND ")}`);
-    }
-    return {
-      sql: statements.join(";\n"),
-      resultSetIndex: 1,
-      resultSetStride: 2
-    };
-  }
-  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;
-    if (def.output == null) {
-      const sql = `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
-      return { sql };
-    }
-    const output = def.output;
-    const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
-    const whereForSelect = output.pkColNames.map((pk) => {
-      const wrappedPk = this.expr.wrap(pk);
-      if (pk === output.aiColName) {
-        return `${wrappedPk} = LAST_INSERT_ID()`;
-      }
-      return `${wrappedPk} = ${this.expr.escapeValue(def.record[pk])}`;
-    });
-    const statements = [
-      `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`,
-      `SET @sd_affected = ROW_COUNT()`,
-      `SELECT ${outputCols} FROM ${table} WHERE ${whereForSelect.join(" AND ")} AND @sd_affected > 0`
-    ];
-    return { sql: statements.join(";\n"), resultSetIndex: 2 };
-  }
-  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(", ") : "*";
-    if (def.output == null) {
-      return { sql: `INSERT INTO ${table} (${colList}) ${selectSql}` };
-    }
-    const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-    if (def.output.aiColName != null) {
-      const aiCol = this.expr.wrap(def.output.aiColName);
-      const statements2 = [
-        `INSERT INTO ${table} (${colList}) ${selectSql}`,
-        `SET @sd_first_id = LAST_INSERT_ID(), @sd_count = ROW_COUNT()`,
-        `SELECT ${outputCols} FROM ${table} WHERE ${aiCol} >= @sd_first_id AND ${aiCol} < @sd_first_id + @sd_count`
-      ];
-      return { sql: statements2.join(";\n"), resultSetIndex: 2 };
-    }
-    const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
-    const pkSelectDef = {
-      ...def.recordsSelectQuery,
-      select: Object.fromEntries(
-        def.output.pkColNames.map((pk) => [pk, def.recordsSelectQuery.select[pk]])
-      )
-    };
-    const pkSelectSql = this.select(pkSelectDef).sql;
-    const pkConditions = def.output.pkColNames.map((pk) => {
-      const wrappedPk = this.expr.wrap(pk);
-      return `${table}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
-    });
-    const statements = [
-      `CREATE TEMPORARY TABLE ${tempTableName} AS ${pkSelectSql}`,
-      `INSERT INTO ${table} (${colList}) ${selectSql}`,
-      `SELECT ${outputCols} FROM ${table}, ${tempTableName} WHERE ${pkConditions.join(" AND ")}`,
-      `DROP TEMPORARY TABLE ${tempTableName}`
-    ];
-    return { sql: statements.join(";\n"), resultSetIndex: 2 };
-  }
-  //#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, expr]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(expr)}`
-    );
-    if (def.output == null) {
-      let sql = `UPDATE ${table} AS ${alias}`;
-      sql += this.renderJoins(def.joins);
-      sql += ` SET ${setParts.join(", ")}`;
-      sql += this.renderWhere(def.where);
-      if (def.limit != null || def.top != null) {
-        sql += this.renderLimit(def.limit, def.top);
-      }
-      return { sql };
-    }
-    const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
-    const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
-    const pkSelectCols = def.output.pkColNames.map((pk) => `${alias}.${this.expr.wrap(pk)} AS ${this.expr.wrap(pk)}`).join(", ");
-    let createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${pkSelectCols} FROM ${table} AS ${alias}`;
-    createTempSql += this.renderJoins(def.joins);
-    createTempSql += this.renderWhere(def.where);
-    let updateSql = `UPDATE ${table} AS ${alias}`;
-    updateSql += this.renderJoins(def.joins);
-    updateSql += ` SET ${setParts.join(", ")}`;
-    updateSql += this.renderWhere(def.where);
-    if (def.top != null) updateSql += ` LIMIT ${def.top}`;
-    const pkConditions = def.output.pkColNames.map((pk) => {
-      const wrappedPk = this.expr.wrap(pk);
-      return `${alias}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
-    });
-    const selectSql = `SELECT ${outputCols} FROM ${table} AS ${alias}, ${tempTableName} WHERE ${pkConditions.join(" AND ")}`;
-    const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
-    const statements = [createTempSql, updateSql, selectSql, dropSql];
-    return { sql: statements.join(";\n"), resultSetIndex: 2 };
-  }
-  //#endregion
-  //#region ========== DML - DELETE ==========
-  delete(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.as);
-    if (def.output == null) {
-      let sql = `DELETE ${alias} FROM ${table} AS ${alias}`;
-      sql += this.renderJoins(def.joins);
-      sql += this.renderWhere(def.where);
-      if (def.limit != null || def.top != null) {
+/**
+ * MySQL QueryBuilder
+ *
+ * MySQL specifics:
+ * - No OUTPUT support: workaround via multi-statement pattern (INSERT + SET @var + SELECT)
+ * - INSERT OUTPUT: uses LAST_INSERT_ID() for AI column, extracts PK from record for non-AI
+ * - UPDATE/UPSERT OUTPUT: saves PK to temp table first since WHERE condition may change after UPDATE, then SELECT
+ * - DELETE OUTPUT: saves output columns to temp table before delete
+ * - switchFk: global setting (SET FOREIGN_KEY_CHECKS), table parameter is ignored
+ * - Index is automatically created when adding FK
+ */
+export class MysqlQueryBuilder extends QueryBuilderBase {
+    expr = new MysqlExprRenderer((def) => this.select(def).sql);
+    //#region ========== Utilities ==========
+    /** Render table name (MySQL: ignores schema, uses database.table only) */
+    tableName(obj) {
+        if (obj.database != null) {
+            return `${this.expr.wrap(obj.database)}.${this.expr.wrap(obj.name)}`;
+        }
+        return this.expr.wrap(obj.name);
+    }
+    /** Render LIMIT clause */
+    renderLimit(limit, top) {
+        if (limit != null) {
+            const [offset, count] = limit;
+            return ` LIMIT ${offset}, ${count}`;
+        }
+        if (top != null) {
+            return ` LIMIT ${top}`;
+        }
+        return "";
+    }
+    renderJoin(join) {
+        const alias = this.expr.wrap(join.as);
+        // Detect if LATERAL JOIN is needed
+        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 ` LEFT OUTER JOIN LATERAL ${from} AS ${alias} ON TRUE`;
+        }
+        // Normal JOIN
+        const from = this.renderFrom(join.from);
+        const where = join.where != null && join.where.length > 0
+            ? ` ON ${this.expr.renderWhere(join.where)}`
+            : " ON TRUE";
+        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";
+        }
+        // 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
+        if (def.lock) {
+            // MySQL: SELECT ... FOR UPDATE (appended at the end)
+        }
+        // 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
         sql += this.renderLimit(def.limit, def.top);
-      }
-      return { sql };
-    }
-    const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
-    const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
-    let createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${outputCols} FROM ${table} AS ${alias}`;
-    createTempSql += this.renderJoins(def.joins);
-    createTempSql += this.renderWhere(def.where);
-    let deleteSql = `DELETE ${alias} FROM ${table} AS ${alias}`;
-    deleteSql += this.renderJoins(def.joins);
-    deleteSql += this.renderWhere(def.where);
-    if (def.top != null) deleteSql += ` LIMIT ${def.top}`;
-    const selectSql = `SELECT * FROM ${tempTableName}`;
-    const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
-    const statements = [createTempSql, deleteSql, selectSql, dropSql];
-    return { sql: statements.join(";\n"), resultSetIndex: 2 };
-  }
-  //#endregion
-  //#region ========== DML - UPSERT ==========
-  upsert(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.existsSelectQuery.as);
-    const existsQuerySql = this.select(def.existsSelectQuery).sql;
-    const updateSetParts = Object.entries(def.updateRecord).map(
-      ([col, e]) => `${alias}.${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(", ");
-    const whereCondition = def.existsSelectQuery.where != null && def.existsSelectQuery.where.length > 0 ? this.expr.renderWhere(def.existsSelectQuery.where) : "1=1";
-    if (def.output == null) {
-      const statements2 = [
-        `UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")} WHERE ${whereCondition}`,
-        `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`
-      ];
-      return { sql: statements2.join(";\n") };
-    }
-    const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-    const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
-    const pkSelectCols = def.output.pkColNames.map((pk) => this.expr.wrap(pk)).join(", ");
-    const createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${pkSelectCols} FROM ${table} AS ${alias} WHERE ${whereCondition}`;
-    const updateSql = `UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")} WHERE ${whereCondition}`;
-    const insertSql = `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`;
-    const output = def.output;
-    const updatePkConditions = output.pkColNames.map((pk) => {
-      const wrappedPk = this.expr.wrap(pk);
-      return `${table}.${wrappedPk} IN (SELECT ${wrappedPk} FROM ${tempTableName})`;
-    });
-    const selectUpdateSql = `SELECT ${outputCols} FROM ${table} WHERE ${updatePkConditions.join(" AND ")}`;
-    const insertPkConditions = output.pkColNames.map((pk) => {
-      const wrappedPk = this.expr.wrap(pk);
-      if (pk === output.aiColName) {
-        return `${wrappedPk} = LAST_INSERT_ID()`;
-      }
-      const pkExpr = def.insertRecord[pk];
-      return `${wrappedPk} = ${this.expr.render(pkExpr)}`;
-    });
-    const selectInsertSql = `SELECT ${outputCols} FROM ${table} WHERE ${insertPkConditions.join(" AND ")} AND NOT EXISTS (SELECT 1 FROM ${tempTableName})`;
-    const selectSql = `${selectUpdateSql} UNION ALL ${selectInsertSql}`;
-    const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
-    const statements = [createTempSql, updateSql, insertSql, selectSql, dropSql];
-    return { sql: statements.join(";\n"), resultSetIndex: 3 };
-  }
-  //#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 += " AUTO_INCREMENT";
-      }
-      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) {
-    return { sql: `RENAME TABLE ${this.tableName(def.table)} TO ${this.expr.wrap(def.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 += " AUTO_INCREMENT";
-    }
-    if (col.default !== void 0) {
-      colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
-    }
-    return { sql: `ALTER TABLE ${table} ADD COLUMN ${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";
-    }
-    if (col.autoIncrement) {
-      colSql += " AUTO_INCREMENT";
-    }
-    if (col.default !== void 0) {
-      colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
-    }
-    return { sql: `ALTER TABLE ${table} MODIFY COLUMN ${colSql}` };
-  }
-  renameColumn(def) {
-    const table = this.tableName(def.table);
-    return {
-      sql: `ALTER TABLE ${table} RENAME COLUMN ${this.expr.wrap(def.column)} TO ${this.expr.wrap(def.newName)}`
-    };
-  }
-  //#endregion
-  //#region ========== DDL - Constraint ==========
-  addPrimaryKey(def) {
-    const table = this.tableName(def.table);
-    const cols = def.columns.map((c) => this.expr.wrap(c)).join(", ");
-    return { sql: `ALTER TABLE ${table} ADD PRIMARY KEY (${cols})` };
-  }
-  dropPrimaryKey(def) {
-    return { sql: `ALTER TABLE ${this.tableName(def.table)} DROP PRIMARY KEY` };
-  }
-  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(", ");
-    return {
-      sql: `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(fk.name)} FOREIGN KEY (${fkCols}) REFERENCES ${targetTable} (${targetCols})`
-    };
-  }
-  dropForeignKey(def) {
-    return {
-      sql: `ALTER TABLE ${this.tableName(def.table)} DROP FOREIGN KEY ${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 REPLACE 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 = `IN ${this.expr.wrap(p.name)} ${this.expr.renderDataType(p.dataType)}`;
-      if (p.default !== void 0) {
-        sql2 += ` DEFAULT ${this.expr.escapeValue(p.default)}`;
-      }
-      return sql2;
-    }).join(", ")) ?? "";
-    let sql = `CREATE PROCEDURE ${proc}(${paramList})
-`;
-    sql += `BEGIN
-`;
-    sql += def.query;
-    if (!def.query.trim().endsWith(";")) {
-      sql += ";";
-    }
-    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: `CALL ${proc}()` };
-    }
-    const params = Object.values(def.params).map((p) => this.expr.render(p)).join(", ");
-    return { sql: `CALL ${proc}(${params})` };
-  }
-  //#endregion
-  //#region ========== Utils ==========
-  clearSchema(def) {
-    if (!/^[a-zA-Z0-9_]+$/.test(def.database)) {
-      throw new Error(`Invalid database name: ${def.database}`);
-    }
-    const dbName = this.expr.escapeString(def.database);
-    return {
-      sql: `
-SET FOREIGN_KEY_CHECKS = 0;
-SET @tables = NULL;
-SELECT GROUP_CONCAT(table_name) INTO @tables FROM information_schema.tables WHERE table_schema = '${dbName}';
-SET @drop_stmt = IF(@tables IS NULL, 'SELECT 1', CONCAT('DROP TABLE IF EXISTS ', @tables));
-PREPARE stmt FROM @drop_stmt;
-EXECUTE stmt;
-DEALLOCATE PREPARE stmt;
-SET FOREIGN_KEY_CHECKS = 1`
-    };
-  }
-  schemaExists(def) {
-    const dbName = this.expr.escapeString(def.database);
-    return {
-      sql: `SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = '${dbName}'`
-    };
-  }
-  /** MySQL only supports global setting (table parameter is ignored) */
-  switchFk(def) {
-    return def.enabled ? { sql: "SET FOREIGN_KEY_CHECKS = 1" } : { sql: "SET FOREIGN_KEY_CHECKS = 0" };
-  }
-  //#endregion
+        // LOCK (FOR UPDATE at end)
+        if (def.lock) {
+            sql += " FOR UPDATE";
+        }
+        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(", ");
+        // No OUTPUT needed: simple batch INSERT
+        if (def.output == null) {
+            const valuesList = def.records.map((record) => {
+                const values = columns.map((c) => this.expr.escapeValue(record[c]));
+                return `(${values.join(", ")})`;
+            });
+            return { sql: `INSERT INTO ${table} (${colList}) VALUES ${valuesList.join(", ")}` };
+        }
+        // OUTPUT needed: execute INSERT + SELECT via multi-statement
+        // Result sets: [INSERT result, SELECT result, INSERT result, SELECT result, ...]
+        // → Extract only SELECT results with resultSetIndex=1, resultSetStride=2
+        const output = def.output;
+        const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
+        const statements = [];
+        for (const record of def.records) {
+            const values = columns.map((c) => this.expr.escapeValue(record[c])).join(", ");
+            statements.push(`INSERT INTO ${table} (${colList}) VALUES (${values})`);
+            // SELECT by PK (uses LAST_INSERT_ID() for aiColName)
+            const whereForSelect = output.pkColNames.map((pk) => {
+                const wrappedPk = this.expr.wrap(pk);
+                if (pk === output.aiColName) {
+                    return `${wrappedPk} = LAST_INSERT_ID()`;
+                }
+                return `${wrappedPk} = ${this.expr.escapeValue(record[pk])}`;
+            });
+            statements.push(`SELECT ${outputCols} FROM ${table} WHERE ${whereForSelect.join(" AND ")}`);
+        }
+        return {
+            sql: statements.join(";\n"),
+            resultSetIndex: 1,
+            resultSetStride: 2,
+        };
+    }
+    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;
+        // No OUTPUT needed: simple INSERT IF NOT EXISTS
+        if (def.output == null) {
+            const sql = `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
+            return { sql };
+        }
+        // OUTPUT needed: multi-statement (INSERT + SET @affected + SELECT)
+        const output = def.output;
+        const outputCols = output.columns.map((c) => this.expr.wrap(c)).join(", ");
+        // SELECT WHERE condition for OUTPUT
+        const whereForSelect = output.pkColNames.map((pk) => {
+            const wrappedPk = this.expr.wrap(pk);
+            if (pk === output.aiColName) {
+                return `${wrappedPk} = LAST_INSERT_ID()`;
+            }
+            return `${wrappedPk} = ${this.expr.escapeValue(def.record[pk])}`;
+        });
+        // multi-statement: INSERT → SET @affected → SELECT (result only if inserted)
+        const statements = [
+            `INSERT INTO ${table} (${colList}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`,
+            `SET @sd_affected = ROW_COUNT()`,
+            `SELECT ${outputCols} FROM ${table} WHERE ${whereForSelect.join(" AND ")} AND @sd_affected > 0`,
+        ];
+        // results[0]=INSERT, results[1]=SET(empty result), results[2]=SELECT
+        return { sql: statements.join(";\n"), resultSetIndex: 2 };
+    }
+    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(", ")
+            : "*";
+        // No OUTPUT needed: simple INSERT INTO SELECT
+        if (def.output == null) {
+            return { sql: `INSERT INTO ${table} (${colList}) ${selectSql}` };
+        }
+        // OUTPUT needed: multi-statement
+        const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+        // When PK is AI: query range via LAST_INSERT_ID() + ROW_COUNT()
+        if (def.output.aiColName != null) {
+            const aiCol = this.expr.wrap(def.output.aiColName);
+            const statements = [
+                `INSERT INTO ${table} (${colList}) ${selectSql}`,
+                `SET @sd_first_id = LAST_INSERT_ID(), @sd_count = ROW_COUNT()`,
+                `SELECT ${outputCols} FROM ${table} WHERE ${aiCol} >= @sd_first_id AND ${aiCol} < @sd_first_id + @sd_count`,
+            ];
+            // results[0]=INSERT, results[1]=SET(empty result), results[2]=SELECT
+            return { sql: statements.join(";\n"), resultSetIndex: 2 };
+        }
+        // PK is not AI: save PKs to temp table then query
+        const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
+        // Generate SELECT extracting only PK columns from recordsSelectQuery
+        const pkSelectDef = {
+            ...def.recordsSelectQuery,
+            select: Object.fromEntries(def.output.pkColNames.map((pk) => [pk, def.recordsSelectQuery.select[pk]])),
+        };
+        const pkSelectSql = this.select(pkSelectDef).sql;
+        // SELECT from target using PK from temp table
+        const pkConditions = def.output.pkColNames.map((pk) => {
+            const wrappedPk = this.expr.wrap(pk);
+            return `${table}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
+        });
+        const statements = [
+            `CREATE TEMPORARY TABLE ${tempTableName} AS ${pkSelectSql}`,
+            `INSERT INTO ${table} (${colList}) ${selectSql}`,
+            `SELECT ${outputCols} FROM ${table}, ${tempTableName} WHERE ${pkConditions.join(" AND ")}`,
+            `DROP TEMPORARY TABLE ${tempTableName}`,
+        ];
+        // results[0]=CREATE, results[1]=INSERT, results[2]=SELECT, results[3]=DROP
+        return { sql: statements.join(";\n"), resultSetIndex: 2 };
+    }
+    //#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, expr]) => `${alias}.${this.expr.wrap(col)} = ${this.expr.render(expr)}`);
+        // No OUTPUT needed: simple UPDATE
+        if (def.output == null) {
+            let sql = `UPDATE ${table} AS ${alias}`;
+            sql += this.renderJoins(def.joins);
+            sql += ` SET ${setParts.join(", ")}`;
+            sql += this.renderWhere(def.where);
+            if (def.limit != null || def.top != null) {
+                sql += this.renderLimit(def.limit, def.top);
+            }
+            return { sql };
+        }
+        // OUTPUT needed: multi-statement (save PK to temp table + UPDATE + SELECT + DROP)
+        const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
+        const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
+        // Save target PKs to temp table (since WHERE condition may change after UPDATE)
+        const pkSelectCols = def.output.pkColNames
+            .map((pk) => `${alias}.${this.expr.wrap(pk)} AS ${this.expr.wrap(pk)}`)
+            .join(", ");
+        let createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${pkSelectCols} FROM ${table} AS ${alias}`;
+        createTempSql += this.renderJoins(def.joins);
+        createTempSql += this.renderWhere(def.where);
+        // UPDATE
+        let updateSql = `UPDATE ${table} AS ${alias}`;
+        updateSql += this.renderJoins(def.joins);
+        updateSql += ` SET ${setParts.join(", ")}`;
+        updateSql += this.renderWhere(def.where);
+        if (def.top != null)
+            updateSql += ` LIMIT ${def.top}`;
+        // SELECT using PK from temp table (query updated values)
+        const pkConditions = def.output.pkColNames.map((pk) => {
+            const wrappedPk = this.expr.wrap(pk);
+            return `${alias}.${wrappedPk} = ${tempTableName}.${wrappedPk}`;
+        });
+        const selectSql = `SELECT ${outputCols} FROM ${table} AS ${alias}, ${tempTableName} WHERE ${pkConditions.join(" AND ")}`;
+        // Drop temp table
+        const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
+        const statements = [createTempSql, updateSql, selectSql, dropSql];
+        return { sql: statements.join(";\n"), resultSetIndex: 2 };
+    }
+    //#endregion
+    //#region ========== DML - DELETE ==========
+    delete(def) {
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.as);
+        // No OUTPUT needed: simple DELETE
+        if (def.output == null) {
+            let sql = `DELETE ${alias} FROM ${table} AS ${alias}`;
+            sql += this.renderJoins(def.joins);
+            sql += this.renderWhere(def.where);
+            if (def.limit != null || def.top != null) {
+                sql += this.renderLimit(def.limit, def.top);
+            }
+            return { sql };
+        }
+        // OUTPUT needed: multi-statement (save to temp table before delete + DELETE + SELECT + DROP)
+        const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
+        const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
+        // Save to temp table before delete
+        let createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${outputCols} FROM ${table} AS ${alias}`;
+        createTempSql += this.renderJoins(def.joins);
+        createTempSql += this.renderWhere(def.where);
+        // Execute DELETE
+        let deleteSql = `DELETE ${alias} FROM ${table} AS ${alias}`;
+        deleteSql += this.renderJoins(def.joins);
+        deleteSql += this.renderWhere(def.where);
+        if (def.top != null)
+            deleteSql += ` LIMIT ${def.top}`;
+        // Return results from temp table
+        const selectSql = `SELECT * FROM ${tempTableName}`;
+        // Drop temp table
+        const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
+        const statements = [createTempSql, deleteSql, selectSql, dropSql];
+        return { sql: statements.join(";\n"), resultSetIndex: 2 };
+    }
+    //#endregion
+    //#region ========== DML - UPSERT ==========
+    upsert(def) {
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.existsSelectQuery.as);
+        const existsQuerySql = this.select(def.existsSelectQuery).sql;
+        // UPDATE SET part (alias.column format)
+        const updateSetParts = Object.entries(def.updateRecord).map(([col, e]) => `${alias}.${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(", ");
+        // Extract WHERE condition (from existsSelectQuery's where)
+        const whereCondition = def.existsSelectQuery.where != null && def.existsSelectQuery.where.length > 0
+            ? this.expr.renderWhere(def.existsSelectQuery.where)
+            : "1=1";
+        // No OUTPUT needed: multi-statement (UPDATE + INSERT WHERE NOT EXISTS)
+        if (def.output == null) {
+            // UPDATE: updates if exists
+            // INSERT SELECT WHERE NOT EXISTS: inserts if not exists
+            const statements = [
+                `UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")} WHERE ${whereCondition}`,
+                `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`,
+            ];
+            return { sql: statements.join(";\n") };
+        }
+        // OUTPUT needed: multi-statement (CREATE TEMP + UPDATE + INSERT + SELECT + DROP)
+        const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+        const tempTableName = this.expr.wrap("SD_TEMP_" + Uuid.generate().toString().replace(/-/g, ""));
+        // Save target PKs to temp table (since WHERE condition may change after UPDATE)
+        const pkSelectCols = def.output.pkColNames.map((pk) => this.expr.wrap(pk)).join(", ");
+        const createTempSql = `CREATE TEMPORARY TABLE ${tempTableName} AS SELECT ${pkSelectCols} FROM ${table} AS ${alias} WHERE ${whereCondition}`;
+        // UPDATE (update if exists)
+        const updateSql = `UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")} WHERE ${whereCondition}`;
+        // INSERT (NOT EXISTS Pattern)
+        const insertSql = `INSERT INTO ${table} (${insertColList}) SELECT ${insertValues} WHERE NOT EXISTS (${existsQuerySql})`;
+        // SELECT: query UPDATE result or INSERT result (merged with UNION ALL)
+        // UPDATE case: query by PK from temp table
+        const output = def.output;
+        const updatePkConditions = output.pkColNames.map((pk) => {
+            const wrappedPk = this.expr.wrap(pk);
+            return `${table}.${wrappedPk} IN (SELECT ${wrappedPk} FROM ${tempTableName})`;
+        });
+        const selectUpdateSql = `SELECT ${outputCols} FROM ${table} WHERE ${updatePkConditions.join(" AND ")}`;
+        // INSERT case: query by PK from insertRecord (LAST_INSERT_ID() for AI, only when temp table is empty)
+        const insertPkConditions = output.pkColNames.map((pk) => {
+            const wrappedPk = this.expr.wrap(pk);
+            if (pk === output.aiColName) {
+                return `${wrappedPk} = LAST_INSERT_ID()`;
+            }
+            const pkExpr = def.insertRecord[pk];
+            return `${wrappedPk} = ${this.expr.render(pkExpr)}`;
+        });
+        const selectInsertSql = `SELECT ${outputCols} FROM ${table} WHERE ${insertPkConditions.join(" AND ")} AND NOT EXISTS (SELECT 1 FROM ${tempTableName})`;
+        const selectSql = `${selectUpdateSql} UNION ALL ${selectInsertSql}`;
+        // DROP
+        const dropSql = `DROP TEMPORARY TABLE ${tempTableName}`;
+        const statements = [createTempSql, updateSql, insertSql, selectSql, dropSql];
+        return { sql: statements.join(";\n"), resultSetIndex: 3 };
+    }
+    //#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 += " AUTO_INCREMENT";
+            }
+            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) {
+        return { sql: `RENAME TABLE ${this.tableName(def.table)} TO ${this.expr.wrap(def.newName)}` };
+    }
+    truncate(def) {
+        // MySQL: TRUNCATE automatically resets AUTO_INCREMENT
+        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 += " AUTO_INCREMENT";
+        }
+        if (col.default !== undefined) {
+            colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
+        }
+        return { sql: `ALTER TABLE ${table} ADD COLUMN ${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";
+        }
+        if (col.autoIncrement) {
+            colSql += " AUTO_INCREMENT";
+        }
+        if (col.default !== undefined) {
+            colSql += ` DEFAULT ${this.expr.escapeValue(col.default)}`;
+        }
+        return { sql: `ALTER TABLE ${table} MODIFY COLUMN ${colSql}` };
+    }
+    renameColumn(def) {
+        const table = this.tableName(def.table);
+        // MySQL 8.0+: RENAME COLUMN supported
+        return {
+            sql: `ALTER TABLE ${table} RENAME COLUMN ${this.expr.wrap(def.column)} TO ${this.expr.wrap(def.newName)}`,
+        };
+    }
+    //#endregion
+    //#region ========== DDL - Constraint ==========
+    addPrimaryKey(def) {
+        const table = this.tableName(def.table);
+        const cols = def.columns.map((c) => this.expr.wrap(c)).join(", ");
+        return { sql: `ALTER TABLE ${table} ADD PRIMARY KEY (${cols})` };
+    }
+    dropPrimaryKey(def) {
+        return { sql: `ALTER TABLE ${this.tableName(def.table)} DROP PRIMARY KEY` };
+    }
+    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(", ");
+        // MySQL automatically creates index when adding FK, so no separate index needed
+        return {
+            sql: `ALTER TABLE ${table} ADD CONSTRAINT ${this.expr.wrap(fk.name)} FOREIGN KEY (${fkCols}) REFERENCES ${targetTable} (${targetCols})`,
+        };
+    }
+    dropForeignKey(def) {
+        return {
+            sql: `ALTER TABLE ${this.tableName(def.table)} DROP FOREIGN KEY ${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 REPLACE 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 = `IN ${this.expr.wrap(p.name)} ${this.expr.renderDataType(p.dataType)}`;
+            if (p.default !== undefined) {
+                sql += ` DEFAULT ${this.expr.escapeValue(p.default)}`;
+            }
+            return sql;
+        })
+            .join(", ") ?? "";
+        let sql = `CREATE PROCEDURE ${proc}(${paramList})\n`;
+        sql += `BEGIN\n`;
+        sql += def.query;
+        if (!def.query.trim().endsWith(";")) {
+            sql += ";";
+        }
+        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: `CALL ${proc}()` };
+        }
+        const params = Object.values(def.params)
+            .map((p) => this.expr.render(p))
+            .join(", ");
+        return { sql: `CALL ${proc}(${params})` };
+    }
+    //#endregion
+    //#region ========== Utils ==========
+    clearSchema(def) {
+        // MySQL: DROP all tables (in MySQL, database and schema are synonymous)
+        // Query table list from information_schema then DROP
+        // SQL 인젝션 방지: 식별자 유효성 검사
+        if (!/^[a-zA-Z0-9_]+$/.test(def.database)) {
+            throw new Error(`잘못된 데이터베이스 이름: ${def.database}`);
+        }
+        const dbName = this.expr.escapeString(def.database);
+        return {
+            sql: `
+SET FOREIGN_KEY_CHECKS = 0;
+SET @tables = NULL;
+SELECT GROUP_CONCAT(table_name) INTO @tables FROM information_schema.tables WHERE table_schema = '${dbName}';
+SET @drop_stmt = IF(@tables IS NULL, 'SELECT 1', CONCAT('DROP TABLE IF EXISTS ', @tables));
+PREPARE stmt FROM @drop_stmt;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;
+SET FOREIGN_KEY_CHECKS = 1`,
+        };
+    }
+    schemaExists(def) {
+        // MySQL: database and schema are synonymous
+        const dbName = this.expr.escapeString(def.database);
+        return {
+            sql: `SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = '${dbName}'`,
+        };
+    }
+    /** MySQL only supports global setting (table parameter is ignored) */
+    switchFk(def) {
+        return def.enabled
+            ? { sql: "SET FOREIGN_KEY_CHECKS = 1" }
+            : { sql: "SET FOREIGN_KEY_CHECKS = 0" };
+    }
 }
-export {
-  MysqlQueryBuilder
-};
-//# sourceMappingURL=mysql-query-builder.js.map
+//# sourceMappingURL=mysql-query-builder.js.map