@sqg/sqg 0.13.0 → 0.14.0

package/README.md

@@ -12,8 +12,8 @@ queries with it and then generate the code from the same file.
 ## Features
 
 - **Type-safe by design** - Generates fully-typed code with accurate column types inferred from your database
-- **Multiple database engines** - Supports SQLite, DuckDB, and (soon) PostgreSQL
-- **Multiple language targets** - Generate TypeScript or Java code from the same SQL files
+- **Multiple database engines** - Supports SQLite, DuckDB, and PostgreSQL
+- **Multiple language targets** - Generate TypeScript, Java, or Python code from the same SQL files
 - **Arrow API support** - Can generate Apache Arrow API bindings for DuckDB (Java)
 - **DBeaver compatible** - Works seamlessly with DBeaver for database development and testing
 - **Complex type support** - DuckDB: Handles structs, lists, and maps
@@ -129,11 +129,13 @@ console.log(user?.name);
 
 | Language | Database | API | Generator | Status |
 |----------|----------|-----|-----------|--------|
-| TypeScript | SQLite   | better-sqlite3 | `typescript/better-sqlite3` | Tested |
+| TypeScript | SQLite   | better-sqlite3 | `typescript/sqlite` | Tested |
 | TypeScript | DuckDB   | @duckdb/node-api | `typescript/duckdb` | Tested |
-| Java | Any (JDBC) | JDBC | `java/jdbc` | Tested |
-| Java | DuckDB   | Apache Arrow | `java/duckdb-arrow` | Tested |
-| TypeScript | PostgreSQL | pg (node-postgres) | `typescript/pg` | under development |
+| Java | SQLite/DuckDB/PostgreSQL | JDBC | `java/sqlite`, `java/duckdb`, `java/postgres` | Tested |
+| Java | DuckDB   | Apache Arrow | `java/duckdb/arrow` | Tested |
+| Python | SQLite | sqlite3 | `python/sqlite` | Tested |
+| Python | DuckDB | duckdb | `python/duckdb` | Tested |
+| Python | PostgreSQL | psycopg3 | `python/postgres` | Tested |
 
 ## CLI Commands
 

package/dist/sqg.mjs

@@ -13,7 +13,7 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import YAML from "yaml";
-import { camelCase, pascalCase } from "es-toolkit/string";
+import { camelCase, pascalCase, snakeCase } from "es-toolkit/string";
 import Handlebars from "handlebars";
 import { z } from "zod";
 import { DuckDBEnumType, DuckDBInstance, DuckDBListType, DuckDBMapType, DuckDBStructType } from "@duckdb/node-api";
@@ -25,6 +25,7 @@ import types from "pg-types";
 import BetterSqlite3 from "better-sqlite3";
 import prettier from "prettier/standalone";
 import prettierPluginJava from "prettier-plugin-java";
+import { execSync } from "node:child_process";
 import typescriptPlugin from "prettier/parser-typescript";
 import estree from "prettier/plugins/estree";
 import yoctoSpinner from "yocto-spinner";
@@ -115,6 +116,30 @@ const GENERATORS = {
 		description: "Java with JDBC for PostgreSQL",
 		extension: ".java",
 		template: "java-jdbc.hbs"
+	},
+	"python/sqlite/sqlite3": {
+		language: "python",
+		engine: "sqlite",
+		driver: "sqlite3",
+		description: "Python with sqlite3 standard library",
+		extension: ".py",
+		template: "python.hbs"
+	},
+	"python/duckdb/duckdb": {
+		language: "python",
+		engine: "duckdb",
+		driver: "duckdb",
+		description: "Python with duckdb driver",
+		extension: ".py",
+		template: "python.hbs"
+	},
+	"python/postgres/psycopg": {
+		language: "python",
+		engine: "postgres",
+		driver: "psycopg",
+		description: "Python with psycopg3 driver",
+		extension: ".py",
+		template: "python.hbs"
 	}
 };
 /** Default drivers for language/engine combinations */
@@ -123,7 +148,10 @@ const DEFAULT_DRIVERS = {
 	"typescript/duckdb": "node-api",
 	"java/sqlite": "jdbc",
 	"java/duckdb": "jdbc",
-	"java/postgres": "jdbc"
+	"java/postgres": "jdbc",
+	"python/sqlite": "sqlite3",
+	"python/duckdb": "duckdb",
+	"python/postgres": "psycopg"
 };
 /** List of all full generator names */
 const GENERATOR_NAMES = Object.keys(GENERATORS);
@@ -1033,6 +1061,11 @@ async function initializeDatabase(queries, execQueries, reporter) {
 
 //#endregion
 //#region src/db/duckdb.ts
+/** Cache of enum type names, keyed by stringified sorted values for lookup */
+let enumNameCache = /* @__PURE__ */ new Map();
+function enumCacheKey(values) {
+	return values.join("\0");
+}
 function convertType(type) {
 	if (type instanceof DuckDBListType) return new ListType(convertType(type.valueType));
 	if (type instanceof DuckDBStructType) return new StructType(type.entryTypes.map((t, index) => ({
@@ -1049,7 +1082,10 @@ function convertType(type) {
 		type: convertType(type.valueType),
 		nullable: true
 	});
-	if (type instanceof DuckDBEnumType) return new EnumType(type.values);
+	if (type instanceof DuckDBEnumType) {
+		const name = type.alias ?? enumNameCache.get(enumCacheKey(type.values));
+		return new EnumType(type.values, name);
+	}
 	return type.toString();
 }
 const duckdb = new class {
@@ -1065,6 +1101,21 @@ const duckdb = new class {
 				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
 			}
 		}, reporter);
+		await this.loadEnumCache();
+	}
+	async loadEnumCache() {
+		enumNameCache = /* @__PURE__ */ new Map();
+		try {
+			const result = await this.connection.runAndReadAll("SELECT type_name, labels FROM duckdb_types() WHERE logical_type = 'ENUM' AND internal = false");
+			for (const row of result.getRows()) {
+				const typeName = row[0];
+				const labels = row[1];
+				if (typeName && labels?.items) enumNameCache.set(enumCacheKey(labels.items), typeName);
+			}
+			consola.debug("DuckDB enum types:", Object.fromEntries(enumNameCache));
+		} catch (e) {
+			consola.debug("Failed to load DuckDB enum types:", e.message);
+		}
 	}
 	async executeQueries(queries, reporter) {
 		const connection = this.connection;
@@ -1099,7 +1150,11 @@ const duckdb = new class {
 				query.parameterTypes = paramTypes;
 				consola.debug("Parameter types:", Object.fromEntries(paramTypes));
 			}
-			for (let i = 0; i < stmt.parameterCount; i++) stmt.bindValue(i + 1, statement.parameters[i].value);
+			for (let i = 0; i < stmt.parameterCount; i++) {
+				let value = statement.parameters[i].value;
+				if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+				stmt.bindValue(i + 1, value);
+			}
 			if (query.isQuery) {
 				const result = await stmt.stream();
 				const columnNames = result.columnNames();
@@ -1149,6 +1204,7 @@ const duckdb = new class {
 	}
 	close() {
 		this.connection.closeSync();
+		enumNameCache = /* @__PURE__ */ new Map();
 	}
 }();
 
@@ -1894,6 +1950,154 @@ var TypeScriptTypeMapper = class extends TypeMapper {
 		return value;
 	}
 };
+/**
+* Type mapper for generating Python types from SQL column types.
+* Maps SQL types to Python types (e.g., INTEGER -> int, VARCHAR -> str).
+* Generates frozen dataclasses for struct types and handles Python reserved keywords.
+*/
+var PythonTypeMapper = class PythonTypeMapper extends TypeMapper {
+	constructor() {
+		super();
+	}
+	typeMap = {
+		INTEGER: "int",
+		INT: "int",
+		INT2: "int",
+		INT4: "int",
+		TINYINT: "int",
+		SMALLINT: "int",
+		BIGINT: "int",
+		INT8: "int",
+		HUGEINT: "int",
+		UHUGEINT: "int",
+		UTINYINT: "int",
+		USMALLINT: "int",
+		UINTEGER: "int",
+		UBIGINT: "int",
+		SERIAL: "int",
+		BIGSERIAL: "int",
+		REAL: "float",
+		DOUBLE: "float",
+		FLOAT: "float",
+		FLOAT4: "float",
+		FLOAT8: "float",
+		TEXT: "str",
+		VARCHAR: "str",
+		INTERVAL: "str",
+		BIT: "str",
+		UUID: "str",
+		BOOLEAN: "bool",
+		BOOL: "bool",
+		BLOB: "bytes",
+		BYTEA: "bytes",
+		DATE: "datetime.date",
+		TIMESTAMP: "datetime.datetime",
+		DATETIME: "datetime.datetime",
+		TIMESTAMPTZ: "datetime.datetime",
+		"TIMESTAMP WITH TIME ZONE": "datetime.datetime",
+		TIMESTAMP_S: "datetime.datetime",
+		TIMESTAMP_MS: "datetime.datetime",
+		TIMESTAMP_NS: "datetime.datetime",
+		TIME: "datetime.time",
+		"TIME WITH TIME ZONE": "datetime.time",
+		NUMERIC: "Decimal",
+		DECIMAL: "Decimal",
+		BIGNUM: "Decimal",
+		JSON: "Any",
+		JSONB: "Any",
+		NULL: "None",
+		UNKNOWN: "Any"
+	};
+	static pythonReservedKeywords = new Set([
+		"False",
+		"None",
+		"True",
+		"and",
+		"as",
+		"assert",
+		"async",
+		"await",
+		"break",
+		"class",
+		"continue",
+		"def",
+		"del",
+		"elif",
+		"else",
+		"except",
+		"finally",
+		"for",
+		"from",
+		"global",
+		"if",
+		"import",
+		"in",
+		"is",
+		"lambda",
+		"nonlocal",
+		"not",
+		"or",
+		"pass",
+		"raise",
+		"return",
+		"try",
+		"while",
+		"with",
+		"yield"
+	]);
+	mapPrimitiveType(type, nullable) {
+		const upperType = type.toString().toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return nullable ? `${mappedType} | None` : mappedType;
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) return nullable ? "Decimal | None" : "Decimal";
+		if (upperType.startsWith("ENUM(")) return nullable ? "str | None" : "str";
+		if (upperType.startsWith("UNION(")) return nullable ? "Any | None" : "Any";
+		return nullable ? "Any | None" : "Any";
+	}
+	formatListType(elementType) {
+		return `list[${elementType}]`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Struct`;
+	}
+	formatMapTypeName(_fieldName) {
+		return "dict";
+	}
+	generateStructDeclaration(column, path = "") {
+		if (!(column.type instanceof StructType)) throw new Error(`Expected StructType ${column}`);
+		const structName = this.formatStructTypeName(column.name);
+		const newPath = `${path}${structName}.`;
+		const children = column.type.fields.map((field) => {
+			return this.getDeclarations({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			}, newPath);
+		}).filter(Boolean).join("\n\n");
+		const fields = column.type.fields.map((field) => {
+			const fieldType = this.getTypeName(field);
+			return `    ${this.varName(field.name)}: ${fieldType}`;
+		}).join("\n");
+		let result = "";
+		if (children) result += `${children}\n\n`;
+		result += `@dataclass(frozen=True)\nclass ${structName}:\n${fields}`;
+		return result;
+	}
+	varName(str) {
+		const name = snakeCase(str);
+		if (PythonTypeMapper.pythonReservedKeywords.has(name)) return `${name}_`;
+		return name;
+	}
+	parseValue(column, value, _path) {
+		if (column.type instanceof StructType) return `${this.formatStructTypeName(column.name)}(${column.type.fields.map((field) => {
+			const pyName = this.varName(field.name);
+			const dictAccess = `${value}["${field.name}"]`;
+			if (field.type instanceof StructType) return `${pyName}=${this.parseValue(field, dictAccess, _path)}`;
+			return `${pyName}=${dictAccess}`;
+		}).join(", ")})`;
+		return value;
+	}
+};
 
 //#endregion
 //#region src/generators/base-generator.ts
@@ -2167,6 +2371,149 @@ var JavaDuckDBArrowGenerator = class extends BaseGenerator {
 	}
 };
 
+//#endregion
+//#region src/generators/python-generator.ts
+var PythonGenerator = class extends BaseGenerator {
+	engine;
+	constructor(template, engine) {
+		super(template, new PythonTypeMapper());
+		this.engine = engine;
+	}
+	get isDuckDB() {
+		return this.engine === "duckdb";
+	}
+	get isPostgres() {
+		return this.engine === "postgres";
+	}
+	getFunctionName(id) {
+		return snakeCase(id);
+	}
+	getFilename(sqlFileName) {
+		return `${snakeCase(sqlFileName)}.py`;
+	}
+	getClassName(name) {
+		return pascalCase(name);
+	}
+	rowType(query) {
+		if (query.isPluck) return this.mapType({
+			...query.columns[0],
+			name: query.id
+		});
+		return this.getClassName(`${query.id}_row`);
+	}
+	getStatement(q) {
+		if (this.isDuckDB) return q.queryPositional;
+		if (this.isPostgres) {
+			const anon = q.queryAnonymous;
+			return {
+				...anon,
+				sql: anon.sql.replace(/\?/g, "%s")
+			};
+		}
+		return q.queryAnonymous;
+	}
+	supportsAppenders(_engine) {
+		return this.engine === "duckdb";
+	}
+	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
+		const pyMapper = this.typeMapper;
+		Handlebars.registerHelper("isDuckDB", () => this.isDuckDB);
+		Handlebars.registerHelper("isPostgres", () => this.isPostgres);
+		Handlebars.registerHelper("connType", () => {
+			if (this.isDuckDB) return "duckdb.DuckDBPyConnection";
+			if (this.isPostgres) return "psycopg.Connection";
+			return "sqlite3.Connection";
+		});
+		Handlebars.registerHelper("quote", (value) => {
+			if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
+			return `"${value}"`;
+		});
+		Handlebars.registerHelper("pyType", (column) => {
+			return this.getPyType(column);
+		});
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return "";
+			const columns = queryHelper.columns;
+			const rowTypeName = this.getClassName(`${query.id}_row`);
+			const nestedDecls = [];
+			for (const col of columns) {
+				const decl = this.typeMapper.getDeclarations(col);
+				if (decl) nestedDecls.push(decl);
+			}
+			const fields = columns.map((col) => {
+				const pyType = this.getPyType(col);
+				return `    ${pyMapper.varName(col.name)}: ${pyType}`;
+			}).join("\n");
+			let result = "";
+			if (nestedDecls.length > 0) result += `${nestedDecls.join("\n\n")}\n\n`;
+			result += `@dataclass(frozen=True)\nclass ${rowTypeName}:\n${fields}`;
+			return new Handlebars.SafeString(result);
+		});
+		Handlebars.registerHelper("constructRow", (queryHelper) => {
+			const query = queryHelper.query;
+			const columns = queryHelper.columns;
+			return `${this.getClassName(`${query.id}_row`)}(${columns.map((col, i) => {
+				const pyName = pyMapper.varName(col.name);
+				const value = `row[${i}]`;
+				return `${pyName}=${this.typeMapper.parseValue(col, value, "")}`;
+			}).join(", ")})`;
+		});
+		Handlebars.registerHelper("pyTypeOrNone", (column) => {
+			const t = this.getPyType(column);
+			if (t.endsWith(" | None")) return t;
+			return `${t} | None`;
+		});
+		Handlebars.registerHelper("pyVarName", (name) => {
+			return pyMapper.varName(name);
+		});
+		Handlebars.registerHelper("needsDatetime", (queries) => this.queryColumnsContainType(queries, "datetime."));
+		Handlebars.registerHelper("needsDecimal", (queries) => this.queryColumnsContainType(queries, "Decimal"));
+	}
+	queryColumnsContainType(queries, substring) {
+		for (const qh of queries) {
+			if (!qh.isQuery || qh.skipGenerateFunction) continue;
+			for (const col of qh.columns) if (this.getPyType(col).includes(substring)) return true;
+		}
+		return false;
+	}
+	getPyType(column) {
+		const t = column.type;
+		if (t instanceof ListType) {
+			const base = `list[${this.getPyType({
+				name: column.name,
+				type: t.baseType,
+				nullable: true
+			})}]`;
+			return column.nullable ? `${base} | None` : base;
+		}
+		if (t instanceof MapType) {
+			const base = `dict[${this.getPyType({
+				name: "key",
+				type: t.keyType.type,
+				nullable: false
+			})}, ${this.getPyType({
+				name: "value",
+				type: t.valueType.type,
+				nullable: true
+			})}]`;
+			return column.nullable ? `${base} | None` : base;
+		}
+		if (t instanceof StructType) {
+			const structName = `${pascalCase(column.name)}Struct`;
+			return column.nullable ? `${structName} | None` : structName;
+		}
+		return this.typeMapper.getTypeName(column);
+	}
+	async afterGenerate(outputPath) {
+		try {
+			execSync(`ruff format "${outputPath}"`, { stdio: "ignore" });
+		} catch {
+			consola.debug("ruff not available, skipping format for:", outputPath);
+		}
+	}
+};
+
 //#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. */
@@ -2454,6 +2801,9 @@ function getGenerator(generator) {
 			case "typescript/node-api": return new TsDuckDBGenerator(`templates/${info.template}`);
 			case "java/jdbc": return new JavaGenerator(`templates/${info.template}`);
 			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");
+			case "python/psycopg": return new PythonGenerator(`templates/${info.template}`, "postgres");
 			default: throw new Error(`No generator class for ${key}`);
 		}
 	} catch {
@@ -2971,7 +3321,7 @@ async function processProject(projectPath, ui) {
 //#region src/mcp-server.ts
 const server = new Server({
 	name: "sqg-mcp",
-	version: process.env.npm_package_version ?? "0.13.0"
+	version: process.env.npm_package_version ?? "0.14.0"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -3438,7 +3788,7 @@ function formatMs(ms) {
 
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.13.0";
+const version = process.env.npm_package_version ?? "0.14.0";
 updateNotifier({ pkg: {
 	name: "@sqg/sqg",
 	version

package/dist/templates/python.hbs

@@ -0,0 +1,256 @@
+# {{generatedComment}}
+from __future__ import annotations
+
+{{#if (isDuckDB)}}
+import duckdb
+{{else if (isPostgres)}}
+import psycopg
+{{else}}
+import sqlite3
+{{/if}}
+from dataclasses import dataclass
+from typing import Any
+{{#if (needsDatetime queries)}}
+import datetime
+{{/if}}
+{{#if (needsDecimal queries)}}
+from decimal import Decimal
+{{/if}}
+
+{{#each queries}}
+{{#unless skipGenerateFunction}}
+{{#if isQuery}}
+{{#unless isPluck}}
+{{{declareTypes this}}}
+
+{{/unless}}
+{{/if}}
+{{/unless}}
+{{/each}}
+
+class {{className}}:
+    def __init__(self, conn: {{{connType}}}) -> None:
+        self._conn = conn
+
+    @staticmethod
+    def get_migrations() -> list[str]:
+        return [
+{{#each migrations}}
+            {{{quote sqlQuery}}},
+{{/each}}
+        ]
+
+{{#if config.migrations}}
+    @staticmethod
+    def apply_migrations(conn: {{{connType}}}, project_name: str = "{{projectName}}") -> None:
+{{#if (isDuckDB)}}
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS _sqg_migrations (
+                project TEXT NOT NULL,
+                migration_id TEXT NOT NULL,
+                applied_at TIMESTAMP NOT NULL DEFAULT now(),
+                PRIMARY KEY (project, migration_id)
+            )""")
+        conn.begin()
+        try:
+            applied = set(
+                row[0]
+                for row in conn.execute(
+                    "SELECT migration_id FROM _sqg_migrations WHERE project = $1",
+                    [project_name],
+                ).fetchall()
+            )
+            migrations: list[tuple[str, str]] = [
+{{#each migrations}}
+                ("{{{id}}}", {{{quote sqlQuery}}}),
+{{/each}}
+            ]
+            for mid, sql in migrations:
+                if mid not in applied:
+                    conn.execute(sql)
+                    conn.execute(
+                        "INSERT INTO _sqg_migrations (project, migration_id) VALUES ($1, $2)",
+                        [project_name, mid],
+                    )
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+{{else if (isPostgres)}}
+        with conn.cursor() as cur:
+            cur.execute("""
+                CREATE TABLE IF NOT EXISTS _sqg_migrations (
+                    project TEXT NOT NULL,
+                    migration_id TEXT NOT NULL,
+                    applied_at TIMESTAMP NOT NULL DEFAULT now(),
+                    PRIMARY KEY (project, migration_id)
+                )""")
+            conn.commit()
+            cur.execute(
+                "SELECT migration_id FROM _sqg_migrations WHERE project = %s",
+                (project_name,),
+            )
+            applied = set(row[0] for row in cur.fetchall())
+            migrations: list[tuple[str, str]] = [
+{{#each migrations}}
+                ("{{{id}}}", {{{quote sqlQuery}}}),
+{{/each}}
+            ]
+            for mid, sql in migrations:
+                if mid not in applied:
+                    cur.execute(sql)
+                    cur.execute(
+                        "INSERT INTO _sqg_migrations (project, migration_id) VALUES (%s, %s)",
+                        (project_name, mid),
+                    )
+            conn.commit()
+{{else}}
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS _sqg_migrations (
+                project TEXT NOT NULL,
+                migration_id TEXT NOT NULL,
+                applied_at TEXT NOT NULL DEFAULT (datetime('now')),
+                PRIMARY KEY (project, migration_id)
+            )""")
+        applied = set(
+            row[0]
+            for row in conn.execute(
+                "SELECT migration_id FROM _sqg_migrations WHERE project = ?",
+                (project_name,),
+            ).fetchall()
+        )
+        migrations: list[tuple[str, str]] = [
+{{#each migrations}}
+            ("{{{id}}}", {{{quote sqlQuery}}}),
+{{/each}}
+        ]
+        for mid, sql in migrations:
+            if mid not in applied:
+                conn.executescript(sql)
+                conn.execute(
+                    "INSERT INTO _sqg_migrations (project, migration_id) VALUES (?, ?)",
+                    (project_name, mid),
+                )
+        conn.commit()
+{{/if}}
+{{/if}}
+
+{{#each queries}}
+{{#unless skipGenerateFunction}}
+{{#if isQuery}}
+{{#if isPluck}}
+{{#if isOne}}
+    def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> {{{pyTypeOrNone (lookup columns 0)}}}:
+        row = self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchone()
+        if row is None:
+            return None
+        return row[0]
+
+    def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> tuple[Any, ...] | None:
+        return self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchone()
+
+{{else}}
+    def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[{{{pyType (lookup columns 0)}}}]:
+        rows = self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchall()
+        return [r[0] for r in rows]
+
+    def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[tuple[Any, ...]]:
+        return self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchall()
+
+{{/if}}
+{{else}}
+{{#if isOne}}
+    def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> {{{rowType}}} | None:
+        row = self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchone()
+        if row is None:
+            return None
+        return {{{constructRow this}}}
+
+    def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> tuple[Any, ...] | None:
+        return self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchone()
+
+{{else}}
+    def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[{{{rowType}}}]:
+        rows = self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchall()
+        return [{{{constructRow this}}} for row in rows]
+
+    def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[tuple[Any, ...]]:
+        return self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        ).fetchall()
+
+{{/if}}
+{{/if}}
+{{else}}
+    def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> None:
+        self._conn.execute(
+            {{{quote sqlQuery}}}, {{> params}}
+        )
+
+{{/if}}
+{{/unless}}
+{{/each}}
+{{#if (isDuckDB)}}
+{{#if tables.length}}
+    # ==================== Appenders ====================
+{{#each tables}}
+
+    def {{functionName}}(self) -> {{className}}:
+        return {{className}}(self._conn.cursor())
+
+{{/each}}
+{{/if}}
+{{/if}}
+
+{{#if (isDuckDB)}}
+{{#each tables}}
+
+@dataclass(frozen=True)
+class {{rowTypeName}}:
+{{#each columns}}
+    {{pyVarName name}}: {{{pyType this}}}
+{{/each}}
+
+
+class {{className}}:
+    def __init__(self, cursor: duckdb.DuckDBPyConnection) -> None:
+        self._cursor = cursor
+
+    def append(self, row: {{rowTypeName}}) -> {{className}}:
+        self._cursor.execute(
+            "INSERT INTO {{tableName}} VALUES ({{> placeholders}})",
+            [{{#each columns}}row.{{pyVarName name}}{{#unless @last}}, {{/unless}}{{/each}}],
+        )
+        return self
+
+    def append_many(self, rows: list[{{rowTypeName}}]) -> {{className}}:
+        for row in rows:
+            self.append(row)
+        return self
+
+    def close(self) -> None:
+        self._cursor.close()
+
+{{/each}}
+{{/if}}
+
+{{!-- ==================== Inline partials ==================== --}}
+
+{{#*inline "params"}}{{#if (isDuckDB)}}[{{#each parameterNames}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}]{{else}}({{#each parameterNames}}{{this}}, {{/each}}){{/if}}{{/inline}}
+
+
+{{#*inline "placeholders"}}{{#each columns}}${{plusOne @index}}{{#unless @last}}, {{/unless}}{{/each}}{{/inline}}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "bin": {
-    "sqg": "./dist/sqg.mjs"
+    "sqg": "dist/sqg.mjs"
   },
   "files": [
     "dist"
@@ -20,6 +20,19 @@
   "bugs": {
     "url": "https://github.com/sqg-dev/sqg/issues"
   },
+  "scripts": {
+    "prepublishOnly": "pnpm run build",
+    "build": "tsc --noEmit && tsdown && cp -r src/templates dist",
+    "lezer-gen": "lezer-generator src/parser/sql.grammar -o src/parser/sql-parser.ts",
+    "test-grammar": "tsx src/test-grammar.ts",
+    "check": "biome check --write src/",
+    "check:errors": "pnpm biome check --write --diagnostic-level=error src/",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "sqg": "tsx src/sqg.ts"
+  },
   "keywords": [
     "sql",
     "codegen",
@@ -37,56 +50,45 @@
   ],
   "author": "Uwe Maurer",
   "license": "Apache-2.0",
+  "packageManager": "pnpm@10.26.0",
   "dependencies": {
-    "@biomejs/biome": "2.3.3",
+    "@biomejs/biome": "catalog:",
     "@clack/prompts": "^1.1.0",
-    "@duckdb/node-api": "1.4.3-r.2",
-    "@duckdb/node-bindings-linux-x64": "1.4.3-r.2",
-    "@lezer-unofficial/printer": "^1.0.1",
-    "@lezer/common": "^1.5.0",
-    "@lezer/generator": "^1.8.0",
-    "@lezer/lr": "^1.4.6",
-    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@duckdb/node-api": "catalog:",
+    "@duckdb/node-bindings-linux-x64": "catalog:",
+    "@lezer-unofficial/printer": "catalog:",
+    "@lezer/common": "catalog:",
+    "@lezer/generator": "catalog:",
+    "@lezer/lr": "catalog:",
+    "@modelcontextprotocol/sdk": "catalog:",
     "@testcontainers/postgresql": "^10.21.0",
-    "better-sqlite3": "^12.5.0",
-    "commander": "^14.0.2",
-    "consola": "^3.4.2",
-    "dotenv": "^17.2.3",
-    "es-toolkit": "^1.43.0",
-    "handlebars": "^4.7.8",
-    "pg": "^8.16.3",
-    "pg-types": "^4.1.0",
+    "better-sqlite3": "catalog:",
+    "commander": "catalog:",
+    "consola": "catalog:",
+    "dotenv": "catalog:",
+    "es-toolkit": "catalog:",
+    "handlebars": "catalog:",
+    "pg": "catalog:",
+    "pg-types": "catalog:",
     "picocolors": "^1.1.1",
-    "prettier": "^3.7.4",
-    "prettier-plugin-java": "^2.7.7",
+    "prettier": "catalog:",
+    "prettier-plugin-java": "catalog:",
     "update-notifier": "^7.3.1",
-    "yaml": "^2.8.2",
+    "yaml": "catalog:",
     "yocto-spinner": "^1.1.0",
-    "zod": "^4.3.5"
+    "zod": "catalog:"
   },
   "devDependencies": {
     "@libsql/client": "^0.17.0",
     "@tursodatabase/database": "^0.4.3",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^25.0.3",
-    "@types/pg": "^8.16.0",
+    "@types/better-sqlite3": "catalog:",
+    "@types/node": "catalog:",
+    "@types/pg": "catalog:",
     "@types/update-notifier": "^6.0.8",
-    "@vitest/ui": "^4.0.16",
-    "tsdown": "0.18.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
-  },
-  "scripts": {
-    "build": "tsc --noEmit && tsdown && cp -r src/templates dist",
-    "lezer-gen": "lezer-generator src/parser/sql.grammar -o src/parser/sql-parser.ts",
-    "test-grammar": "tsx src/test-grammar.ts",
-    "check": "biome check --write src/",
-    "check:errors": "pnpm biome check --write --diagnostic-level=error src/",
-    "test": "vitest",
-    "coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui",
-    "test:run": "vitest run",
-    "sqg": "tsx src/sqg.ts"
+    "@vitest/ui": "catalog:",
+    "tsdown": "catalog:",
+    "tsx": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
   }
-}
+}