@sqg/sqg 0.14.0 → 0.16.0

package/dist/sqg.mjs

@@ -29,7 +29,6 @@ import { execSync } from "node:child_process";
 import typescriptPlugin from "prettier/parser-typescript";
 import estree from "prettier/plugins/estree";
 import yoctoSpinner from "yocto-spinner";
-
 //#region src/constants.ts
 /**
 * SQG Constants - Centralized definitions for supported generators
@@ -223,7 +222,7 @@ SQL Annotation Syntax:
   -- EXEC <name>                    Execute statement (INSERT/UPDATE/DELETE)
   -- MIGRATE <number>               Schema migration (run in order)
   -- TESTDATA <name>                Test data setup (not generated)
-  -- TABLE <name> :appender         Table for bulk insert appender (DuckDB only)
+  -- TABLE <name> :appender         Table for bulk insert appender (DuckDB, PostgreSQL)
 
   @set <varName> = <value>          Define a variable
   \${varName}                        Reference a variable in SQL
@@ -244,7 +243,6 @@ Example:
 
   -- TABLE users :appender
 `.trim();
-
 //#endregion
 //#region src/errors.ts
 /**
@@ -302,9 +300,9 @@ var ConfigError = class extends SqgError {
 * Error for invalid generator names
 */
 var InvalidGeneratorError = class extends SqgError {
-	constructor(generatorName, validGenerators$1, suggestion) {
+	constructor(generatorName, validGenerators, suggestion) {
 		const similarMsg = suggestion ? ` Did you mean '${suggestion}'?` : "";
-		super(`Invalid generator '${generatorName}'.${similarMsg} Valid generators: ${validGenerators$1.join(", ")}`, "INVALID_GENERATOR", suggestion ? `Use '${suggestion}' instead` : `Choose from: ${validGenerators$1.join(", ")}`, { generator: generatorName });
+		super(`Invalid generator '${generatorName}'.${similarMsg} Valid generators: ${validGenerators.join(", ")}`, "INVALID_GENERATOR", suggestion ? `Use '${suggestion}' instead` : `Choose from: ${validGenerators.join(", ")}`, { generator: generatorName });
 		this.name = "InvalidGeneratorError";
 	}
 };
@@ -386,7 +384,6 @@ function formatErrorForOutput(err) {
 		}
 	};
 }
-
 //#endregion
 //#region src/init.ts
 /**
@@ -714,7 +711,6 @@ async function initProject(options) {
 	clack.log.message(`  3. Import the generated code from ${output}`);
 	clack.outro("Documentation: https://sqg.dev");
 }
-
 //#endregion
 //#region src/parser/sql-parser.ts
 const parser = LRParser.deserialize({
@@ -735,7 +731,6 @@ const parser = LRParser.deserialize({
 	topRules: { "File": [0, 1] },
 	tokenPrec: 245
 });
-
 //#endregion
 //#region src/sql-query.ts
 var ListType = class {
@@ -896,8 +891,8 @@ function parseSQLQueries(filePath, extraVariables) {
 			let to = -1;
 			class SQLQueryBuilder {
 				sqlParts = [];
-				appendSql(sql$1) {
-					this.sqlParts.push(sql$1);
+				appendSql(sql) {
+					this.sqlParts.push(sql);
 				}
 				appendVariable(varName, value) {
 					this.sqlParts.push({
@@ -913,23 +908,23 @@ function parseSQLQueries(filePath, extraVariables) {
 					return this.sqlParts.filter((part) => typeof part !== "string" && !part.name.startsWith("sources_"));
 				}
 				toSqlWithAnonymousPlaceholders() {
-					let sql$1 = "";
+					let sql = "";
 					const sqlParts = [];
 					for (const part of this.sqlParts) if (typeof part === "string") {
-						sql$1 += part;
+						sql += part;
 						sqlParts.push(part);
 					} else {
-						if (sql$1.length > 0) {
-							const last = sql$1[sql$1.length - 1];
-							if (last !== " " && last !== "=" && last !== ">" && last !== "<") sql$1 += " ";
+						if (sql.length > 0) {
+							const last = sql[sql.length - 1];
+							if (last !== " " && last !== "=" && last !== ">" && last !== "<") sql += " ";
 						}
-						sql$1 += "?";
+						sql += "?";
 						if (part.name.startsWith("sources_")) sqlParts.push(part);
 						else sqlParts.push("?");
 					}
 					return {
 						parameters: this.parameters(),
-						sql: sql$1,
+						sql,
 						sqlParts
 					};
 				}
@@ -999,7 +994,7 @@ function parseSQLQueries(filePath, extraVariables) {
 			}
 			if (queryType === "TABLE") {
 				const hasAppender = modifiers.includes(":appender");
-				const tableName = sqlContentStr.trim() || name;
+				const tableName = sqlContentStr.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || name;
 				const includeColumns = [];
 				for (const mod of modifiers) {
 					const match = mod.match(/:appender\(([^)]+)\)/);
@@ -1036,7 +1031,6 @@ function parseSQLQueries(filePath, extraVariables) {
 		tables
 	};
 }
-
 //#endregion
 //#region src/db/types.ts
 async function initializeDatabase(queries, execQueries, reporter) {
@@ -1058,7 +1052,6 @@ async function initializeDatabase(queries, execQueries, reporter) {
 	if (migrationQueries.length + testdataQueries.length === 0) consola.warn("No migration or testdata queries found");
 	reporter?.onDatabaseInitialized?.();
 }
-
 //#endregion
 //#region src/db/duckdb.ts
 /** Cache of enum type names, keyed by stringified sorted values for lookup */
@@ -1207,7 +1200,6 @@ const duckdb = new class {
 		enumNameCache = /* @__PURE__ */ new Map();
 	}
 }();
-
 //#endregion
 //#region src/db/postgres.ts
 const tempDatabaseName = "sqg-db-temp";
@@ -1445,13 +1437,14 @@ const postgres = new class {
 		for (const table of tables) {
 			reporter?.onTableStart?.(table.tableName);
 			try {
-				table.columns = (await db.query(`SELECT column_name, data_type, is_nullable
+				table.columns = (await db.query(`SELECT column_name, data_type, udt_name, is_nullable, column_default, is_identity
            FROM information_schema.columns
            WHERE table_name = $1
            ORDER BY ordinal_position`, [table.tableName])).rows.map((row) => ({
 					name: row.column_name,
-					type: row.data_type.toUpperCase(),
-					nullable: row.is_nullable === "YES"
+					type: row.udt_name.toUpperCase(),
+					nullable: row.is_nullable === "YES",
+					generated: row.is_identity === "YES" || (row.column_default?.startsWith("nextval") ?? false)
 				}));
 				reporter?.onTableComplete?.(table.tableName, table.columns.length);
 			} catch (error) {
@@ -1466,7 +1459,6 @@ const postgres = new class {
 		this.enumTypeCache = /* @__PURE__ */ new Map();
 	}
 }();
-
 //#endregion
 //#region src/db/sqlite.ts
 const sqlite = new class {
@@ -1548,7 +1540,6 @@ const sqlite = new class {
 		}
 	}
 }();
-
 //#endregion
 //#region src/db/index.ts
 function getDatabaseEngine(engine) {
@@ -1559,7 +1550,6 @@ function getDatabaseEngine(engine) {
 		default: throw new Error(`Unsupported database engine: ${engine}`);
 	}
 }
-
 //#endregion
 //#region src/type-mapping.ts
 /**
@@ -1793,15 +1783,18 @@ var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
 		if (column.type instanceof StructType) return `${path}${this.formatStructTypeName(column.name)}.fromAttributes(getAttr((Struct)${value}))`;
 		const fieldType = this.getTypeName(column);
 		const upperType = column.type?.toString().toUpperCase() ?? "";
-		if (upperType === "TIMESTAMP" || upperType === "DATETIME") return `toLocalDateTime((java.sql.Timestamp)${value})`;
-		if (upperType === "TIMESTAMPTZ") return `toOffsetDateTime((java.sql.Timestamp)${value})`;
+		if (upperType === "TIMESTAMP" || upperType === "DATETIME") return `toLocalDateTime(${value})`;
+		if (upperType === "TIMESTAMPTZ") return `toOffsetDateTime(${value})`;
 		if (upperType === "TIMESTAMP WITH TIME ZONE") return `(OffsetDateTime)${value}`;
-		if (upperType === "DATE") return `toLocalDate((java.sql.Date)${value})`;
-		if (upperType === "TIME") return `toLocalTime((java.sql.Time)${value})`;
+		if (upperType === "DATE") return `toLocalDate(${value})`;
+		if (upperType === "TIME") return `toLocalTime(${value})`;
 		if (upperType.startsWith("_")) {
 			const baseType = upperType.substring(1);
 			return `arrayToList((Array)${value}, ${this.typeMap[baseType] || "Object"}[].class)`;
 		}
+		if (fieldType === "Short") return `${value} != null ? ((Number)${value}).shortValue() : null`;
+		if (fieldType === "Byte") return `${value} != null ? ((Number)${value}).byteValue() : null`;
+		if (upperType === "JSON" || upperType === "JSONB") return `${value} != null ? ${value}.toString() : null`;
 		return `(${fieldType})${value}`;
 	}
 	getInnermostType(type) {
@@ -2098,7 +2091,6 @@ var PythonTypeMapper = class PythonTypeMapper extends TypeMapper {
 		return value;
 	}
 };
-
 //#endregion
 //#region src/generators/base-generator.ts
 var BaseGenerator = class {
@@ -2141,16 +2133,17 @@ var BaseGenerator = class {
 		return q.queryAnonymous;
 	}
 };
-
 //#endregion
 //#region src/generators/java-generator.ts
 var JavaGenerator = class extends BaseGenerator {
-	constructor(template) {
+	engine;
+	constructor(template, engine = "duckdb") {
 		super(template, new JavaTypeMapper());
 		this.template = template;
+		this.engine = engine;
 	}
 	supportsAppenders(engine) {
-		return engine === "duckdb";
+		return engine === "duckdb" || engine === "postgres";
 	}
 	getFunctionName(id) {
 		return camelCase(id);
@@ -2192,6 +2185,18 @@ var JavaGenerator = class extends BaseGenerator {
 		return this.typeMapper.parseValue(column, `rs.getObject(${index + 1})`, path);
 	}
 	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
+		Handlebars.registerHelper("isDuckDB", () => this.engine === "duckdb");
+		Handlebars.registerHelper("isPostgres", () => this.engine === "postgres");
+		Handlebars.registerHelper("pgBulkType", (column) => {
+			return pgBulkInsertType(column.type.toString().toUpperCase());
+		});
+		Handlebars.registerHelper("pgBulkAccessor", (column) => {
+			return pgBulkInsertAccessor(column.type.toString().toUpperCase());
+		});
+		Handlebars.registerHelper("javaVarName", (name) => {
+			const n = camelCase(name);
+			return JavaTypeMapper.javaReservedKeywords.has(n) ? `${n}_` : n;
+		});
 		Handlebars.registerHelper("partsToString", (parts) => this.partsToString(parts));
 		Handlebars.registerHelper("declareTypes", (queryHelper) => {
 			const query = queryHelper.query;
@@ -2283,7 +2288,44 @@ var JavaGenerator = class extends BaseGenerator {
 		}
 	}
 };
-
+const PG_BULK_TYPE_MAP = {
+	SMALLINT: "INT2",
+	INTEGER: "INT4",
+	BIGINT: "INT8",
+	REAL: "FLOAT4",
+	"DOUBLE PRECISION": "FLOAT8",
+	BOOLEAN: "BOOLEAN",
+	TEXT: "TEXT",
+	"CHARACTER VARYING": "TEXT",
+	CHARACTER: "TEXT",
+	NUMERIC: "NUMERIC",
+	DECIMAL: "NUMERIC",
+	DATE: "DATE",
+	"TIME WITHOUT TIME ZONE": "TIME",
+	"TIMESTAMP WITHOUT TIME ZONE": "TIMESTAMP",
+	"TIMESTAMP WITH TIME ZONE": "TIMESTAMPTZ",
+	UUID: "UUID",
+	BYTEA: "BYTEA",
+	JSONB: "JSONB",
+	JSON: "JSONB",
+	INT2: "INT2",
+	INT4: "INT4",
+	INT8: "INT8",
+	FLOAT4: "FLOAT4",
+	FLOAT8: "FLOAT8",
+	BOOL: "BOOLEAN",
+	VARCHAR: "TEXT",
+	TIMESTAMP: "TIMESTAMP",
+	TIMESTAMPTZ: "TIMESTAMPTZ"
+};
+function pgBulkInsertType(sqlType) {
+	if (sqlType.startsWith("_")) return `array(PgBulkInsert.PostgresTypes.${PG_BULK_TYPE_MAP[sqlType.substring(1)] || "TEXT"})`;
+	return PG_BULK_TYPE_MAP[sqlType] || "TEXT";
+}
+function pgBulkInsertAccessor(sqlType) {
+	if (sqlType === "TIMESTAMPTZ") return "offsetDateTime";
+	return "from";
+}
 //#endregion
 //#region src/generators/java-duckdb-arrow-generator.ts
 var JavaDuckDBArrowGenerator = class extends BaseGenerator {
@@ -2297,7 +2339,7 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 		return this.javaGenerator.getFunctionName(id);
 	}
 	async beforeGenerate(projectDir, gen, queries, tables) {
-		const q = queries.filter((q$1) => q$1.isQuery && q$1.isOne || q$1.isMigrate);
+		const q = queries.filter((q) => q.isQuery && q.isOne || q.isMigrate);
 		const name = `${gen.name}-jdbc`;
 		writeGeneratedFile(projectDir, {
 			name,
@@ -2370,7 +2412,6 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 		return this.getClassName(`${query.id}_Result`);
 	}
 };
-
 //#endregion
 //#region src/generators/python-generator.ts
 var PythonGenerator = class extends BaseGenerator {
@@ -2413,7 +2454,7 @@ var PythonGenerator = class extends BaseGenerator {
 		return q.queryAnonymous;
 	}
 	supportsAppenders(_engine) {
-		return this.engine === "duckdb";
+		return this.engine === "duckdb" || this.engine === "postgres";
 	}
 	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
 		const pyMapper = this.typeMapper;
@@ -2513,7 +2554,6 @@ var PythonGenerator = class extends BaseGenerator {
 		}
 	}
 };
-
 //#endregion
 //#region src/generators/typescript-generator.ts
 /** Resolve a ColumnType to its DuckDB type constant name (e.g. "VARCHAR", "INTEGER") for use in generated code. */
@@ -2581,8 +2621,8 @@ var TsGenerator = class extends BaseGenerator {
 		});
 		Handlebars.registerHelper("tsTypeForAppender", (column) => {
 			if (column.type instanceof ListType) {
-				const baseType$1 = "readonly DuckDBValue[]";
-				return column.nullable ? `${baseType$1} | null` : baseType$1;
+				const baseType = "readonly DuckDBValue[]";
+				return column.nullable ? `${baseType} | null` : baseType;
 			}
 			const typeStr = column.type?.toString().toUpperCase() || "";
 			let baseType;
@@ -2705,7 +2745,6 @@ var TsGenerator = class extends BaseGenerator {
 		return value.includes("\n") || value.includes("'") ? `\`${value}\`` : `'${value}'`;
 	}
 };
-
 //#endregion
 //#region src/generators/typescript-duckdb-generator.ts
 /**
@@ -2781,7 +2820,6 @@ var TsDuckDBGenerator = class extends TsGenerator {
 		});
 	}
 };
-
 //#endregion
 //#region src/generators/index.ts
 /**
@@ -2799,7 +2837,7 @@ function getGenerator(generator) {
 			case "typescript/libsql":
 			case "typescript/turso": return new TsGenerator(`templates/${info.template}`);
 			case "typescript/node-api": return new TsDuckDBGenerator(`templates/${info.template}`);
-			case "java/jdbc": return new JavaGenerator(`templates/${info.template}`);
+			case "java/jdbc": return new JavaGenerator(`templates/${info.template}`, info.engine);
 			case "java/arrow": return new JavaDuckDBArrowGenerator(`templates/${info.template}`);
 			case "python/sqlite3": return new PythonGenerator(`templates/${info.template}`, "sqlite");
 			case "python/duckdb": return new PythonGenerator(`templates/${info.template}`, "duckdb");
@@ -2811,7 +2849,6 @@ function getGenerator(generator) {
 		throw new InvalidGeneratorError(fullGenerator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
 	}
 }
-
 //#endregion
 //#region src/sqltool.ts
 const GENERATED_FILE_COMMENT = "This file is generated by SQG (https://sqg.dev). Do not edit manually.";
@@ -2833,22 +2870,22 @@ var Config = class Config {
 		const result = configSchema.safeParse(configObj);
 		if (!result.success) throw new Error(`Error parsing config for query ${name} in ${filePath}: \n${configStr}\n ${result.error}`);
 		const columnMap = /* @__PURE__ */ new Map();
-		for (const [name$1, info] of Object.entries(result.data.result ?? {})) {
+		for (const [name, info] of Object.entries(result.data.result ?? {})) {
 			const parts = info.trim().split(" ").map((part) => part.trim());
 			let type;
 			let nullable = true;
 			if (parts.length === 1) type = parts[0];
 			else if (parts.length === 2) {
 				type = parts[0];
-				if (parts[1].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
+				if (parts[1].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
 				nullable = true;
 			} else if (parts.length === 3) {
 				type = parts[0];
-				if (parts[1].toLocaleLowerCase() !== "not" || parts[2].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
+				if (parts[1].toLocaleLowerCase() !== "not" || parts[2].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
 				nullable = false;
-			} else throw new Error(`Invalid config for column ${name$1} in ${filePath}: \n${configStr}\n ${info}`);
-			columnMap.set(name$1, {
-				name: name$1,
+			} else throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
+			columnMap.set(name, {
+				name,
 				type,
 				nullable
 			});
@@ -2960,8 +2997,9 @@ var TableHelper = class {
 		return this.table.tableName;
 	}
 	get columns() {
-		if (this.table.includeColumns.length > 0) return this.table.columns.filter((c) => this.table.includeColumns.includes(c.name));
-		return this.table.columns;
+		let cols = this.table.columns;
+		if (this.table.includeColumns.length > 0) cols = cols.filter((c) => this.table.includeColumns.includes(c.name));
+		return cols.filter((c) => !c.generated);
 	}
 	get skipGenerateFunction() {
 		return this.table.skipGenerateFunction;
@@ -2975,6 +3013,9 @@ var TableHelper = class {
 	get rowTypeName() {
 		return this.generator.getClassName(`${this.table.id}_row`);
 	}
+	get constantName() {
+		return this.table.id.toUpperCase();
+	}
 	get typeMapper() {
 		return this.generator.typeMapper;
 	}
@@ -3316,12 +3357,11 @@ async function processProject(projectPath, ui) {
 	const projectDir = resolve(dirname(projectPath));
 	return await processProjectFromConfig(parseProjectConfig(projectPath), projectDir, false, ui);
 }
-
 //#endregion
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.14.0"
+	version: process.env.npm_package_version ?? "0.16.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -3647,7 +3687,6 @@ async function startMcpServer() {
 	await server.connect(transport);
 	console.error("SQG MCP server running on stdio");
 }
-
 //#endregion
 //#region src/ui.ts
 /**
@@ -3785,10 +3824,9 @@ function formatMs(ms) {
 	if (ms < 1e3) return `${Math.round(ms)}ms`;
 	return `${(ms / 1e3).toFixed(1)}s`;
 }
-
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.14.0";
+const version = process.env.npm_package_version ?? "0.16.0";
 updateNotifier({ pkg: {
 	name: "@sqg/sqg",
 	version
@@ -3908,6 +3946,13 @@ program.command("init").description("Initialize a new SQG project with example c
 program.command("syntax").description("Show SQL annotation syntax reference").action(() => {
 	console.log(SQL_SYNTAX_REFERENCE);
 });
+program.command("ide").description("Start the SQG IDE — interactive SQL development environment").argument("[project]", "Path to sqg.yaml project config").option("-p, --port <port>", "Server port", "3000").action(async (project, options) => {
+	const { startIde } = await import("./ide-BieFvmwk.mjs");
+	await startIde({
+		project,
+		port: parseInt(options.port, 10)
+	});
+});
 program.command("mcp").description("Start MCP (Model Context Protocol) server for AI assistants").action(async () => {
 	try {
 		await startMcpServer();
@@ -3926,6 +3971,5 @@ try {
 	consola.error(err);
 	exit(1);
 }
-
 //#endregion
-export {  };
+export {};

package/dist/templates/java-jdbc.hbs

@@ -29,8 +29,14 @@ import java.util.function.Function;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 {{#if tables.length}}
+{{#if (isDuckDB)}}
 import org.duckdb.DuckDBAppender;
 import org.duckdb.DuckDBConnection;
+{{else if (isPostgres)}}
+// Requires dependency: de.bytefish:pgbulkinsert:9.0.0
+import de.bytefish.pgbulkinsert.PgBulkInsert;
+import java.io.IOException;
+{{/if}}
 {{/if}}
 
 public class {{className}} {
@@ -61,20 +67,28 @@ public class {{className}} {
         }
     }
 
-    private static LocalDateTime toLocalDateTime(java.sql.Timestamp ts) {
-        return ts != null ? ts.toLocalDateTime() : null;
+    private static LocalDateTime toLocalDateTime(Object ts) {
+        if (ts == null) return null;
+        if (ts instanceof LocalDateTime ldt) return ldt;
+        return ((java.sql.Timestamp) ts).toLocalDateTime();
     }
 
-    private static LocalDate toLocalDate(java.sql.Date d) {
-        return d != null ? d.toLocalDate() : null;
+    private static LocalDate toLocalDate(Object d) {
+        if (d == null) return null;
+        if (d instanceof LocalDate ld) return ld;
+        return ((java.sql.Date) d).toLocalDate();
     }
 
-    private static LocalTime toLocalTime(java.sql.Time t) {
-        return t != null ? t.toLocalTime() : null;
+    private static LocalTime toLocalTime(Object t) {
+        if (t == null) return null;
+        if (t instanceof LocalTime lt) return lt;
+        return ((java.sql.Time) t).toLocalTime();
     }
 
-    private static OffsetDateTime toOffsetDateTime(java.sql.Timestamp ts) {
-        return ts != null ? ts.toInstant().atOffset(java.time.ZoneOffset.UTC) : null;
+    private static OffsetDateTime toOffsetDateTime(Object ts) {
+        if (ts == null) return null;
+        if (ts instanceof OffsetDateTime odt) return odt;
+        return ((java.sql.Timestamp) ts).toInstant().atOffset(java.time.ZoneOffset.UTC);
     }
     
     private static <K> List<K> arrayToList(
@@ -250,18 +264,30 @@ public class {{className}} {
     // ==================== Appenders ====================
     {{#each tables}}
 
+{{#if (isDuckDB)}}
     /** Create an appender for bulk inserts into {{tableName}} */
     public {{className}} {{functionName}}() throws SQLException {
         return new {{className}}(((DuckDBConnection) connection).createAppender(DuckDBConnection.DEFAULT_SCHEMA, "{{tableName}}"));
     }
+{{else if (isPostgres)}}
+    /** Bulk insert rows into {{tableName}} using PostgreSQL COPY BINARY (via PgBulkInsert). */
+    public void bulkInsert{{rowTypeName}}(Iterable<{{rowTypeName}}> rows) throws SQLException, IOException {
+        {{constantName}}_WRITER.saveAll(connection, "{{tableName}}", rows);
+    }
+{{/if}}
     {{/each}}
     {{/if}}
 
 
 {{#each tables}}
 /** Row type for {{tableName}} appender */
-public record {{rowTypeName}}({{#each columns}}{{{appenderType this}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
+{{#if (isPostgres)}}
+public record {{rowTypeName}}({{#each columns}}{{{appenderType this}}} {{javaVarName name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
+{{else}}
+public record {{rowTypeName}}({{#each columns}}{{{appenderType this}}} {{javaVarName name}}{{#unless @last}}, {{/unless}}{{/each}}) {}
+{{/if}}
 
+{{#if (isDuckDB)}}
 /** Appender for bulk inserts into {{tableName}} */
 public static class {{className}} implements AutoCloseable {
     private final DuckDBAppender appender;
@@ -279,17 +305,17 @@ public static class {{className}} implements AutoCloseable {
     public {{className}} append({{rowTypeName}} row) throws SQLException {
         appender.beginRow();
         {{#each columns}}
-        appender.append(row.{{name}}());
+        appender.append(row.{{javaVarName name}}());
         {{/each}}
         appender.endRow();
         return this;
     }
 
     /** Append a single row with individual values */
-    public {{className}} append({{#each columns}}{{{appenderType this}}} {{name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
+    public {{className}} append({{#each columns}}{{{appenderType this}}} {{javaVarName name}}{{#unless @last}}, {{/unless}}{{/each}}) throws SQLException {
         appender.beginRow();
         {{#each columns}}
-        appender.append({{name}});
+        appender.append({{javaVarName name}});
         {{/each}}
         appender.endRow();
         return this;
@@ -309,6 +335,16 @@ public static class {{className}} implements AutoCloseable {
         appender.close();
     }
 }
+{{else if (isPostgres)}}
+private static final PgBulkInsert.PgMapper<{{rowTypeName}}> {{constantName}}_MAPPER =
+    PgBulkInsert.PgMapper.forClass({{rowTypeName}}.class)
+        {{#each columns}}
+        .map("{{name}}", PgBulkInsert.PostgresTypes.{{{pgBulkType this}}}.{{{pgBulkAccessor this}}}({{../rowTypeName}}::{{javaVarName name}}))
+        {{/each}};
+
+private static final PgBulkInsert.PgBulkWriter<{{rowTypeName}}> {{constantName}}_WRITER =
+    new PgBulkInsert.PgBulkWriter<>({{constantName}}_MAPPER);
+{{/if}}
 {{/each}}
 }
 

package/dist/templates/python.hbs

@@ -204,19 +204,21 @@ class {{className}}:
 {{/if}}
 {{/unless}}
 {{/each}}
-{{#if (isDuckDB)}}
 {{#if tables.length}}
     # ==================== Appenders ====================
 {{#each tables}}
 
+{{#if (isDuckDB)}}
     def {{functionName}}(self) -> {{className}}:
         return {{className}}(self._conn.cursor())
+{{else if (isPostgres)}}
+    def {{functionName}}(self) -> {{className}}:
+        return {{className}}(self._conn)
+{{/if}}
 
 {{/each}}
 {{/if}}
-{{/if}}
 
-{{#if (isDuckDB)}}
 {{#each tables}}
 
 @dataclass(frozen=True)
@@ -226,6 +228,7 @@ class {{rowTypeName}}:
 {{/each}}
 
 
+{{#if (isDuckDB)}}
 class {{className}}:
     def __init__(self, cursor: duckdb.DuckDBPyConnection) -> None:
         self._cursor = cursor
@@ -244,10 +247,39 @@ class {{className}}:
 
     def close(self) -> None:
         self._cursor.close()
+{{else if (isPostgres)}}
+class {{className}}:
+    """COPY appender for high-performance bulk inserts into {{tableName}}."""
 
-{{/each}}
+    def __init__(self, conn: psycopg.Connection) -> None:
+        self._conn = conn
+        self._copy: psycopg.Copy | None = None
+
+    def __enter__(self) -> {{className}}:
+        cur = self._conn.cursor()
+        self._copy = cur.copy("COPY {{tableName}} ({{#each columns}}{{name}}{{#unless @last}}, {{/unless}}{{/each}}) FROM STDIN")
+        self._copy.__enter__()
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        if self._copy is not None:
+            self._copy.__exit__(*args)
+            self._copy = None
+
+    def append(self, row: {{rowTypeName}}) -> {{className}}:
+        if self._copy is None:
+            raise RuntimeError("Use as context manager: with appender:")
+        self._copy.write_row(({{#each columns}}row.{{pyVarName name}}, {{/each}}))
+        return self
+
+    def append_many(self, rows: list[{{rowTypeName}}]) -> {{className}}:
+        for row in rows:
+            self.append(row)
+        return self
 {{/if}}
 
+{{/each}}
+
 {{!-- ==================== Inline partials ==================== --}}
 
 {{#*inline "params"}}{{#if (isDuckDB)}}[{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}]{{else}}({{#each parameterNames}}{{this}}, {{/each}}){{/if}}{{/inline}}