@simplysm/orm-common 13.0.100 → 14.0.1

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

@@ -1,464 +1,515 @@
 import { QueryBuilderBase } from "../base/query-builder-base.js";
 import { PostgresqlExprRenderer } from "./postgresql-expr-renderer.js";
-class PostgresqlQueryBuilder extends QueryBuilderBase {
-  expr = new PostgresqlExprRenderer((def) => this.select(def).sql);
-  //#region ========== Utilities ==========
-  /** Render table name (PostgreSQL: database is handled by connection, uses schema.table only) */
-  tableName(obj) {
-    const schema = obj.schema ?? "public";
-    return `${this.expr.wrap(schema)}.${this.expr.wrap(obj.name)}`;
-  }
-  /** Render LIMIT...OFFSET clause */
-  renderLimit(limit, top) {
-    if (limit != null) {
-      const [offset, count] = limit;
-      return ` LIMIT ${count} OFFSET ${offset}`;
-    }
-    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 RECURSIVE ${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)}`;
-    }
-    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(", ");
-    const valuesList = def.records.map((record) => {
-      const values = columns.map((c) => this.expr.escapeValue(record[c]));
-      return `(${values.join(", ")})`;
-    });
-    let sql = `INSERT INTO ${table} (${colList})`;
-    sql += ` VALUES ${valuesList.join(", ")}`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-      sql += ` RETURNING ${outputCols}`;
-    }
-    return { sql };
-  }
-  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}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-      sql += ` RETURNING ${outputCols}`;
-    }
-    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}) ${selectSql}`;
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-      sql += ` RETURNING ${outputCols}`;
-    }
-    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]) => `${this.expr.wrap(col)} = ${this.expr.render(e)}`
-    );
-    let sql = `UPDATE ${table} AS ${alias} SET ${setParts.join(", ")}`;
-    if (def.joins != null && def.joins.length > 0) {
-      const joinTables = def.joins.map((j) => {
-        const from = this.renderFrom(j.from);
-        return `${from} AS ${this.expr.wrap(j.as)}`;
-      });
-      sql += ` FROM ${joinTables.join(", ")}`;
-      const joinConditions = def.joins.filter((j) => j.where != null && j.where.length > 0).map((j) => this.expr.renderWhere(j.where));
-      if (joinConditions.length > 0) {
-        const whereCondition = def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
-        const allConditions = whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
-        sql += ` WHERE ${allConditions.join(" AND ")}`;
-      } else {
-        sql += this.renderWhere(def.where);
-      }
-    } else {
-      sql += this.renderWhere(def.where);
-    }
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
-      sql += ` RETURNING ${outputCols}`;
-    }
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - DELETE ==========
-  delete(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.as);
-    let sql = `DELETE FROM ${table} AS ${alias}`;
-    if (def.joins != null && def.joins.length > 0) {
-      const joinTables = def.joins.map((j) => {
-        const from = this.renderFrom(j.from);
-        return `${from} AS ${this.expr.wrap(j.as)}`;
-      });
-      sql += ` USING ${joinTables.join(", ")}`;
-      const joinConditions = def.joins.filter((j) => j.where != null && j.where.length > 0).map((j) => this.expr.renderWhere(j.where));
-      if (joinConditions.length > 0) {
-        const whereCondition = def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
-        const allConditions = whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
-        sql += ` WHERE ${allConditions.join(" AND ")}`;
-      } else {
+/**
+ * PostgreSQL QueryBuilder
+ *
+ * PostgreSQL specifics:
+ * - OUTPUT: uses RETURNING clause (native support)
+ * - TRUNCATE: RESTART IDENTITY option required
+ * - UPSERT: CTE approach (INSERT ... ON CONFLICT only supports single unique constraint)
+ * - AUTO_INCREMENT: GENERATED BY DEFAULT AS IDENTITY (allows explicit value assignment)
+ * - Separate index generation needed when adding FK (unlike MySQL)
+ */
+export class PostgresqlQueryBuilder extends QueryBuilderBase {
+    expr = new PostgresqlExprRenderer((def) => this.select(def).sql);
+    //#region ========== Utilities ==========
+    /** Render table name (PostgreSQL: database is handled by connection, uses schema.table only) */
+    tableName(obj) {
+        const schema = obj.schema ?? "public";
+        return `${this.expr.wrap(schema)}.${this.expr.wrap(obj.name)}`;
+    }
+    /** Render LIMIT...OFFSET clause */
+    renderLimit(limit, top) {
+        if (limit != null) {
+            const [offset, count] = limit;
+            return ` LIMIT ${count} OFFSET ${offset}`;
+        }
+        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 RECURSIVE ${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)}`;
+        }
+        // JOINs
+        sql += this.renderJoins(def.joins);
+        // WHERE
         sql += this.renderWhere(def.where);
-      }
-    } else {
-      sql += this.renderWhere(def.where);
-    }
-    if (def.output != null) {
-      const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
-      sql += ` RETURNING ${outputCols}`;
-    }
-    return { sql };
-  }
-  //#endregion
-  //#region ========== DML - UPSERT ==========
-  upsert(def) {
-    const table = this.tableName(def.table);
-    const alias = this.expr.wrap(def.existsSelectQuery.as);
-    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(", ");
-    const whereCondition = def.existsSelectQuery.where != null && def.existsSelectQuery.where.length > 0 ? this.expr.renderWhere(def.existsSelectQuery.where) : "TRUE";
-    const outputCols = def.output != null ? def.output.columns.map((c) => this.expr.wrap(c)).join(", ") : "*";
-    let sql = `WITH matched AS (
-`;
-    sql += `  SELECT ${alias}.* FROM ${table} AS ${alias} WHERE ${whereCondition}
-`;
-    sql += `),
-`;
-    sql += `updated AS (
-`;
-    sql += `  UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")}
-`;
-    sql += `  WHERE ${whereCondition}
-`;
-    sql += `  RETURNING ${outputCols}
-`;
-    sql += `),
-`;
-    sql += `inserted AS (
-`;
-    sql += `  INSERT INTO ${table} (${insertColList})
-`;
-    sql += `  SELECT ${insertValues}
-`;
-    sql += `  WHERE NOT EXISTS (SELECT 1 FROM matched)
-`;
-    sql += `  RETURNING ${outputCols}
-`;
-    sql += `)
-`;
-    sql += `SELECT * FROM updated UNION ALL SELECT * FROM inserted`;
-    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 += " GENERATED BY DEFAULT AS IDENTITY";
-      }
-      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: `ALTER TABLE ${this.tableName(def.table)} RENAME TO ${this.expr.wrap(def.newName)}`
-    };
-  }
-  truncate(def) {
-    return { sql: `TRUNCATE TABLE ${this.tableName(def.table)} RESTART IDENTITY` };
-  }
-  //#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 += " GENERATED BY DEFAULT AS IDENTITY";
-    }
-    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;
-    const parts = [];
-    parts.push(
-      `ALTER COLUMN ${this.expr.wrap(col.name)} TYPE ${this.expr.renderDataType(col.dataType)}`
-    );
-    if (col.nullable === false) {
-      parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} SET NOT NULL`);
-    } else {
-      parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} DROP NOT NULL`);
-    }
-    if (col.default !== void 0) {
-      parts.push(
-        `ALTER COLUMN ${this.expr.wrap(col.name)} SET DEFAULT ${this.expr.escapeValue(col.default)}`
-      );
-    }
-    return { sql: `ALTER TABLE ${table} ${parts.join(", ")}` };
-  }
-  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(", ");
-    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) {
-    const schema = def.table.schema ?? "public";
-    return { sql: `DROP INDEX ${this.expr.wrap(schema)}.${this.expr.wrap(def.index)}` };
-  }
-  //#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 = `${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 returnClause = "VOID";
-    if (def.returns && def.returns.length > 0) {
-      const returnFields = def.returns.map((r) => `${this.expr.wrap(r.name)} ${this.expr.renderDataType(r.dataType)}`).join(", ");
-      returnClause = `TABLE(${returnFields})`;
-    }
-    let sql = `CREATE OR REPLACE FUNCTION ${proc}(${paramList})
-`;
-    sql += `RETURNS ${returnClause} AS $$
-`;
-    sql += `BEGIN
-`;
-    sql += def.query;
-    if (!def.query.trim().endsWith(";")) {
-      sql += ";";
-    }
-    sql += `
-END;
-`;
-    sql += `$$ LANGUAGE plpgsql`;
-    return { sql };
-  }
-  dropProc(def) {
-    return { sql: `DROP FUNCTION 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: `SELECT ${proc}()` };
-    }
-    const params = Object.values(def.params).map((p) => this.expr.render(p)).join(", ");
-    return { sql: `SELECT ${proc}(${params})` };
-  }
-  //#endregion
-  //#region ========== Utils ==========
-  clearSchema(def) {
-    const schemaName = def.schema ?? "public";
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
-      throw new Error(`Invalid schema name: ${schemaName}`);
-    }
-    const schema = this.expr.escapeString(schemaName);
-    return {
-      sql: `
-DO $$
-DECLARE
-  r RECORD;
-BEGIN
-  -- Drop FK constraints
-  FOR r IN (SELECT conname, conrelid::regclass AS tablename
-            FROM pg_constraint
-            WHERE contype = 'f' AND connamespace = '${schema}'::regnamespace)
-  LOOP
-    EXECUTE 'ALTER TABLE ' || r.tablename || ' DROP CONSTRAINT ' || quote_ident(r.conname);
-  END LOOP;
-
-  -- Drop tables
-  FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = '${schema}')
-  LOOP
-    EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
-  END LOOP;
-
-  -- Drop views
-  FOR r IN (SELECT viewname FROM pg_views WHERE schemaname = '${schema}')
-  LOOP
-    EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.viewname) || ' CASCADE';
-  END LOOP;
-
-  -- Drop functions
-  FOR r IN (SELECT proname, pg_get_function_identity_arguments(oid) AS args
-            FROM pg_proc WHERE pronamespace = '${schema}'::regnamespace)
-  LOOP
-    EXECUTE 'DROP FUNCTION IF EXISTS ' || quote_ident(r.proname) || '(' || r.args || ') CASCADE';
-  END LOOP;
-END $$`
-    };
-  }
-  schemaExists(def) {
-    const schemaName = def.schema ?? "public";
-    const schema = this.expr.escapeString(schemaName);
-    return { sql: `SELECT nspname FROM pg_namespace WHERE nspname = '${schema}'` };
-  }
-  switchFk(def) {
-    const table = this.tableName(def.table);
-    if (def.enabled) {
-      return { sql: `ALTER TABLE ${table} ENABLE TRIGGER ALL` };
-    }
-    return { sql: `ALTER TABLE ${table} DISABLE TRIGGER ALL` };
-  }
-  //#endregion
+        // 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);
+        // 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(", ");
+        const valuesList = def.records.map((record) => {
+            const values = columns.map((c) => this.expr.escapeValue(record[c]));
+            return `(${values.join(", ")})`;
+        });
+        let sql = `INSERT INTO ${table} (${colList})`;
+        // GENERATED BY DEFAULT AS IDENTITY, so no additional clause needed for explicit value insertion
+        // overrideIdentity parameter is kept for MSSQL (SET IDENTITY_INSERT) compatibility, but
+        // PostgreSQL's GENERATED BY DEFAULT automatically allows explicit values
+        // (note: OVERRIDING SYSTEM VALUE would be needed if GENERATED ALWAYS was used)
+        sql += ` VALUES ${valuesList.join(", ")}`;
+        // RETURNING (PostgreSQL native support)
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+            sql += ` RETURNING ${outputCols}`;
+        }
+        return { sql };
+    }
+    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}) SELECT ${values} WHERE NOT EXISTS (${existsQuerySql})`;
+        // RETURNING
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+            sql += ` RETURNING ${outputCols}`;
+        }
+        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}) ${selectSql}`;
+        // RETURNING
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+            sql += ` RETURNING ${outputCols}`;
+        }
+        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]) => `${this.expr.wrap(col)} = ${this.expr.render(e)}`);
+        let sql = `UPDATE ${table} AS ${alias} SET ${setParts.join(", ")}`;
+        // PostgreSQL: JOINs are handled via FROM clause
+        if (def.joins != null && def.joins.length > 0) {
+            const joinTables = def.joins.map((j) => {
+                const from = this.renderFrom(j.from);
+                return `${from} AS ${this.expr.wrap(j.as)}`;
+            });
+            sql += ` FROM ${joinTables.join(", ")}`;
+            // Add JOIN ON conditions to WHERE
+            const joinConditions = def.joins
+                .filter((j) => j.where != null && j.where.length > 0)
+                .map((j) => this.expr.renderWhere(j.where));
+            if (joinConditions.length > 0) {
+                const whereCondition = def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
+                const allConditions = whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
+                sql += ` WHERE ${allConditions.join(" AND ")}`;
+            }
+            else {
+                sql += this.renderWhere(def.where);
+            }
+        }
+        else {
+            sql += this.renderWhere(def.where);
+        }
+        // RETURNING
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => `${alias}.${this.expr.wrap(c)}`).join(", ");
+            sql += ` RETURNING ${outputCols}`;
+        }
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - DELETE ==========
+    delete(def) {
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.as);
+        let sql = `DELETE FROM ${table} AS ${alias}`;
+        // PostgreSQL: JOINs are handled via USING clause
+        if (def.joins != null && def.joins.length > 0) {
+            const joinTables = def.joins.map((j) => {
+                const from = this.renderFrom(j.from);
+                return `${from} AS ${this.expr.wrap(j.as)}`;
+            });
+            sql += ` USING ${joinTables.join(", ")}`;
+            // Add JOIN ON conditions to WHERE
+            const joinConditions = def.joins
+                .filter((j) => j.where != null && j.where.length > 0)
+                .map((j) => this.expr.renderWhere(j.where));
+            if (joinConditions.length > 0) {
+                const whereCondition = def.where != null && def.where.length > 0 ? this.expr.renderWhere(def.where) : null;
+                const allConditions = whereCondition != null ? [whereCondition, ...joinConditions] : joinConditions;
+                sql += ` WHERE ${allConditions.join(" AND ")}`;
+            }
+            else {
+                sql += this.renderWhere(def.where);
+            }
+        }
+        else {
+            sql += this.renderWhere(def.where);
+        }
+        // RETURNING (PostgreSQL: also supported for DELETE)
+        if (def.output != null) {
+            const outputCols = def.output.columns.map((c) => this.expr.wrap(c)).join(", ");
+            sql += ` RETURNING ${outputCols}`;
+        }
+        return { sql };
+    }
+    //#endregion
+    //#region ========== DML - UPSERT ==========
+    upsert(def) {
+        // PostgreSQL: CTE approach (uses CTE for generality since ON CONFLICT only supports single unique constraint)
+        const table = this.tableName(def.table);
+        const alias = this.expr.wrap(def.existsSelectQuery.as);
+        // 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(", ");
+        // WHERE condition
+        const whereCondition = def.existsSelectQuery.where != null && def.existsSelectQuery.where.length > 0
+            ? this.expr.renderWhere(def.existsSelectQuery.where)
+            : "TRUE";
+        // OUTPUT column
+        const outputCols = def.output != null ? def.output.columns.map((c) => this.expr.wrap(c)).join(", ") : "*";
+        // CTE-based UPSERT
+        let sql = `WITH matched AS (\n`;
+        sql += `  SELECT ${alias}.* FROM ${table} AS ${alias} WHERE ${whereCondition}\n`;
+        sql += `),\n`;
+        sql += `updated AS (\n`;
+        sql += `  UPDATE ${table} AS ${alias} SET ${updateSetParts.join(", ")}\n`;
+        sql += `  WHERE ${whereCondition}\n`;
+        sql += `  RETURNING ${outputCols}\n`;
+        sql += `),\n`;
+        sql += `inserted AS (\n`;
+        sql += `  INSERT INTO ${table} (${insertColList})\n`;
+        sql += `  SELECT ${insertValues}\n`;
+        sql += `  WHERE NOT EXISTS (SELECT 1 FROM matched)\n`;
+        sql += `  RETURNING ${outputCols}\n`;
+        sql += `)\n`;
+        sql += `SELECT * FROM updated UNION ALL SELECT * FROM inserted`;
+        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 += " GENERATED BY DEFAULT AS IDENTITY";
+            }
+            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: `ALTER TABLE ${this.tableName(def.table)} RENAME TO ${this.expr.wrap(def.newName)}`,
+        };
+    }
+    truncate(def) {
+        // PostgreSQL: reset sequence with RESTART IDENTITY
+        return { sql: `TRUNCATE TABLE ${this.tableName(def.table)} RESTART IDENTITY` };
+    }
+    //#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 += " GENERATED BY DEFAULT AS IDENTITY";
+        }
+        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;
+        // PostgreSQL: ALTER COLUMN requires multiple ALTER statements
+        const parts = [];
+        // Change TYPE
+        parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} TYPE ${this.expr.renderDataType(col.dataType)}`);
+        // Change NULL constraint
+        if (col.nullable === false) {
+            parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} SET NOT NULL`);
+        }
+        else {
+            parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} DROP NOT NULL`);
+        }
+        // Change DEFAULT
+        if (col.default !== undefined) {
+            parts.push(`ALTER COLUMN ${this.expr.wrap(col.name)} SET DEFAULT ${this.expr.escapeValue(col.default)}`);
+        }
+        return { sql: `ALTER TABLE ${table} ${parts.join(", ")}` };
+    }
+    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(", ");
+        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})`;
+        // 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) {
+        // PostgreSQL: indexes are unique at schema level so table name is not needed, but schema must be specified
+        const schema = def.table.schema ?? "public";
+        return { sql: `DROP INDEX ${this.expr.wrap(schema)}.${this.expr.wrap(def.index)}` };
+    }
+    //#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 = `${this.expr.wrap(p.name)} ${this.expr.renderDataType(p.dataType)}`;
+            if (p.default !== undefined) {
+                sql += ` DEFAULT ${this.expr.escapeValue(p.default)}`;
+            }
+            return sql;
+        })
+            .join(", ") ?? "";
+        // Process returns
+        let returnClause = "VOID";
+        if (def.returns && def.returns.length > 0) {
+            const returnFields = def.returns
+                .map((r) => `${this.expr.wrap(r.name)} ${this.expr.renderDataType(r.dataType)}`)
+                .join(", ");
+            returnClause = `TABLE(${returnFields})`;
+        }
+        let sql = `CREATE OR REPLACE FUNCTION ${proc}(${paramList})\n`;
+        sql += `RETURNS ${returnClause} AS $$\n`;
+        sql += `BEGIN\n`;
+        sql += def.query;
+        if (!def.query.trim().endsWith(";")) {
+            sql += ";";
+        }
+        sql += `\nEND;\n`;
+        sql += `$$ LANGUAGE plpgsql`;
+        return { sql };
+    }
+    dropProc(def) {
+        return { sql: `DROP FUNCTION 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: `SELECT ${proc}()` };
+        }
+        const params = Object.values(def.params)
+            .map((p) => this.expr.render(p))
+            .join(", ");
+        return { sql: `SELECT ${proc}(${params})` };
+    }
+    //#endregion
+    //#region ========== Utils ==========
+    clearSchema(def) {
+        const schemaName = def.schema ?? "public";
+        // SQL 인젝션 방지: schema 이름 유효성 검사
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(schemaName)) {
+            throw new Error(`잘못된 schema 이름: ${schemaName}`);
+        }
+        const schema = this.expr.escapeString(schemaName);
+        return {
+            sql: `
+DO $$
+DECLARE
+  r RECORD;
+BEGIN
+  -- FK 제약조건 삭제
+  FOR r IN (SELECT conname, conrelid::regclass AS tablename
+            FROM pg_constraint
+            WHERE contype = 'f' AND connamespace = '${schema}'::regnamespace)
+  LOOP
+    EXECUTE 'ALTER TABLE ' || r.tablename || ' DROP CONSTRAINT ' || quote_ident(r.conname);
+  END LOOP;
+
+  -- 테이블 삭제
+  FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = '${schema}')
+  LOOP
+    EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.tablename) || ' CASCADE';
+  END LOOP;
+
+  -- 뷰 삭제
+  FOR r IN (SELECT viewname FROM pg_views WHERE schemaname = '${schema}')
+  LOOP
+    EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.viewname) || ' CASCADE';
+  END LOOP;
+
+  -- 함수 삭제
+  FOR r IN (SELECT proname, pg_get_function_identity_arguments(oid) AS args
+            FROM pg_proc WHERE pronamespace = '${schema}'::regnamespace)
+  LOOP
+    EXECUTE 'DROP FUNCTION IF EXISTS ' || quote_ident(r.proname) || '(' || r.args || ') CASCADE';
+  END LOOP;
+END $$`,
+        };
+    }
+    schemaExists(def) {
+        const schemaName = def.schema ?? "public";
+        const schema = this.expr.escapeString(schemaName);
+        return { sql: `SELECT nspname FROM pg_namespace WHERE nspname = '${schema}'` };
+    }
+    switchFk(def) {
+        const table = this.tableName(def.table);
+        if (def.enabled) {
+            // PostgreSQL: enable all FK triggers on the table
+            return { sql: `ALTER TABLE ${table} ENABLE TRIGGER ALL` };
+        }
+        // PostgreSQL: disable all FK triggers on the table
+        return { sql: `ALTER TABLE ${table} DISABLE TRIGGER ALL` };
+    }
 }
-export {
-  PostgresqlQueryBuilder
-};
-//# sourceMappingURL=postgresql-query-builder.js.map
+//# sourceMappingURL=postgresql-query-builder.js.map