@sqg/sqg 0.20.0 → 0.21.1

package/README.md

@@ -117,12 +117,15 @@ console.log(user?.name);
 | Annotation | Description |
 |------------|-------------|
 | `-- MIGRATE name` | Schema migration (CREATE TABLE, etc.) |
+| `-- BASELINE name` | Schema created outside SQG (ETL, sibling service). Runs before migrations for type-checking; **not** emitted in `getMigrations()` |
+| `-- BASELINE name :source=pg` | Schema of a `type: postgres` source. Applied natively to a managed testcontainer and attached into DuckDB for introspection (DuckDB generators; needs Docker) |
 | `-- QUERY name` | SELECT query returning rows |
 | `-- QUERY name :one` | Query returning single row or undefined |
 | `-- QUERY name :pluck` | Return single (first) column value |
 | `-- QUERY name :result=Foo` | Name the row type (Java). Add it to ONE query and every same-shape query shares it. Full-table `SELECT *` reuses the `TABLE` row type without annotation. |
 | `-- EXEC name` | INSERT/UPDATE/DELETE (no result rows) |
 | `-- TESTDATA name` | Test data, runs after migrations |
+| `-- TABLE name :appender` | Generate a type-safe bulk insert appender (DuckDB, PostgreSQL) |
 | `@set var = value` | Define parameter with sample value |
 | `${var}` | Reference parameter in query |
 

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { LRParser } from "@lezer/lr";
 import { homedir } from "node:os";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
-import { camelCase, pascalCase, snakeCase } from "es-toolkit/string";
+import { camelCase, escapeRegExp, pascalCase, snakeCase } from "es-toolkit/string";
 import Handlebars from "handlebars";
 import YAML from "yaml";
 import { z } from "zod";
@@ -229,6 +229,7 @@ SQL Annotation Syntax:
   -- QUERY <name> [:one] [:pluck]   Select query (returns rows)
   -- EXEC <name> [:batch]           Execute statement (INSERT/UPDATE/DELETE)
   -- BASELINE <name>                Schema created outside SQG (runs before migrations, not tracked)
+  -- BASELINE <name> :source=<src>  Schema of a 'type: postgres' source (applied to a managed testcontainer, attached into DuckDB)
   -- MIGRATE <name>                 Schema migration (runs in source order; name is any identifier, e.g. "1" or "add_email")
   -- TESTDATA <name>                Test data setup (not generated)
   -- TABLE <name> :appender         Table for bulk insert appender (DuckDB, PostgreSQL)
@@ -242,6 +243,7 @@ Modifiers:
   :all          Return all rows (default)
   :batch        Generate a JDBC batch method for an EXEC (Java only)
   :appender     Generate bulk insert appender for TABLE annotation
+  :source=Name  Mark a BASELINE block as the schema of a postgres source (Name)
   :result=Name  Name (and share) the row type (Java only). Annotate ONE query
                 with :result=Name — every other query in the same file with the
                 same column shape automatically gets the same name; you do NOT
@@ -1496,6 +1498,19 @@ var PythonGenerator = class extends BaseGenerator {
 			if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
 			return `"${value}"`;
 		});
+		Handlebars.registerHelper("sqlExpr", (queryHelper) => {
+			const parts = queryHelper.sqlQueryParts;
+			if (!parts.some((p) => typeof p !== "string" && p.name.startsWith("sources_"))) {
+				const value = queryHelper.sqlQuery;
+				if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
+				return `"${value}"`;
+			}
+			let out = "f\"\"\"";
+			for (const part of parts) if (typeof part === "string") out += part.replace(/\\/g, "\\\\").replace(/\{/g, "{{").replace(/\}/g, "}}");
+			else if (part.name.startsWith("sources_")) out += ` '{${part.name}}'`;
+			else out += "?";
+			return `${out}"""`;
+		});
 		Handlebars.registerHelper("pyType", (column) => {
 			return this.getPyType(column);
 		});
@@ -1620,6 +1635,7 @@ var TsGenerator = class extends BaseGenerator {
 	async beforeGenerate(_projectDir, gen, _queries, _tables) {
 		if (this.typeMapper instanceof TypeScriptTypeMapper) this.typeMapper.safeIntegers = !!gen.config?.safeIntegers;
 		Handlebars.registerHelper("quote", (value) => this.quote(value));
+		Handlebars.registerHelper("sqlExpr", (queryHelper) => this.sqlExpr(queryHelper));
 		Handlebars.registerHelper("appendMethod", (column) => {
 			if (column.type instanceof ListType) return "List";
 			const typeStr = column.type?.toString().toUpperCase() || "";
@@ -1772,6 +1788,22 @@ var TsGenerator = class extends BaseGenerator {
 	quote(value) {
 		return value.includes("\n") || value.includes("'") ? `\`${value}\`` : `'${value}'`;
 	}
+	/**
+	* Build the SQL expression for a query. Without file `sources`, this is the
+	* plain quoted SQL string (unchanged). When a `${sources_x}` reference is
+	* present it is interpolated into a template literal as a runtime argument
+	* (the value is supplied by the caller, not bound), mirroring the Java
+	* generator — `ATTACH '` + arg + `'` style.
+	*/
+	sqlExpr(queryHelper) {
+		const parts = queryHelper.sqlQueryParts;
+		if (!parts.some((p) => typeof p !== "string" && p.name.startsWith("sources_"))) return this.quote(queryHelper.sqlQuery);
+		let out = "`";
+		for (const part of parts) if (typeof part === "string") out += part.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+		else if (part.name.startsWith("sources_")) out += ` '\${${part.name}}'`;
+		else out += "?";
+		return `${out}\``;
+	}
 };
 //#endregion
 //#region src/generators/typescript-duckdb-generator.ts
@@ -1878,6 +1910,69 @@ function getGenerator(generator) {
 	}
 }
 //#endregion
+//#region src/sources.ts
+/**
+* For each `type: postgres` source: start a throwaway Postgres testcontainer,
+* run the source's schema (the BASELINE blocks tagged `:source=<name>`) natively
+* against it so introspection sees true Postgres types, and return the connection
+* info to ATTACH into DuckDB.
+*
+* The synthesized ATTACH (done by the DuckDB adapter) and these schema blocks are
+* not emitted into generated code — at runtime the application attaches the real
+* production database under the same alias.
+*/
+async function preparePostgresSources(sources, queries, reporter) {
+	const containers = [];
+	const attachments = [];
+	const teardown = async () => {
+		for (const container of containers) try {
+			await container.stop();
+		} catch {}
+	};
+	try {
+		for (const source of sources) {
+			if (source.url) {
+				attachments.push({
+					alias: source.name,
+					connectionUri: source.url
+				});
+				continue;
+			}
+			reporter?.onContainerStarting?.();
+			let container;
+			try {
+				container = await new PostgreSqlContainer(source.image).withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
+			} catch (e) {
+				throw new DatabaseError(`Could not start a Postgres container for source '${source.name}': ${e.message}`, "postgres", "Postgres sources need Docker to introspect schema. Start Docker, or set 'url' on the source to point at an existing Postgres database (e.g. url: $DATABASE_URL).");
+			}
+			containers.push(container);
+			const connectionUri = container.getConnectionUri();
+			reporter?.onContainerStarted?.(connectionUri);
+			const schemaBlocks = queries.filter((q) => q.isBaseline && q.sourceTarget === source.name);
+			const client = new Client({ connectionString: connectionUri });
+			await client.connect();
+			try {
+				for (const block of schemaBlocks) await client.query(block.rawQuery);
+			} catch (e) {
+				throw new DatabaseError(`Failed to apply schema for postgres source '${source.name}': ${e.message}`, "postgres", `Check that the BASELINE blocks tagged ':source=${source.name}' are valid PostgreSQL.`);
+			} finally {
+				await client.end();
+			}
+			attachments.push({
+				alias: source.name,
+				connectionUri
+			});
+		}
+	} catch (e) {
+		await teardown();
+		throw e;
+	}
+	return {
+		attachments,
+		teardown
+	};
+}
+//#endregion
 //#region src/sqltool.ts
 const GENERATED_FILE_COMMENT = "This file is generated by SQG (https://sqg.dev). Do not edit manually.";
 const configSchema = z.object({ result: z.record(z.string(), z.string()).optional() });
@@ -2054,18 +2149,23 @@ var TableHelper = class {
 		return this.generator.typeMapper;
 	}
 };
-function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config) {
+function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config, postgresSourceNames = []) {
 	const templateSrc = readFileSync(templatePath, "utf-8");
 	const template = Handlebars.compile(templateSrc);
 	Handlebars.registerHelper("mapType", (column) => generator.mapType(column));
 	Handlebars.registerHelper("plusOne", (value) => value + 1);
 	const migrations = queries.filter((q) => q.isMigrate).map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q)));
 	const tableHelpers = generator.supportsAppenders(engine) ? tables.filter((t) => !t.skipGenerateFunction).map((t) => new TableHelper(t, generator)) : [];
+	const attachers = engine === "duckdb" ? postgresSourceNames.map((sourceName) => ({
+		alias: sourceName,
+		functionName: generator.getFunctionName(`attach_${sourceName}`)
+	})) : [];
 	return template({
 		generatedComment: GENERATED_FILE_COMMENT,
 		migrations,
 		queries: queries.map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
 		tables: tableHelpers,
+		attachers,
 		className: generator.getClassName(name),
 		projectName,
 		config
@@ -2090,13 +2190,16 @@ const ProjectSchema = z.object({
 			template: z.string().optional().describe("Custom Handlebars template path"),
 			output: z.string().min(1, "Output path is required").describe("Output file or directory path"),
 			config: z.any().optional().describe("Generator-specific configuration")
-		})).min(1, "At least one generator is required").describe("Code generators to run")
-	})).min(1, "At least one SQL configuration is required").describe("SQL file configurations"),
+		}).strict()).min(1, "At least one generator is required").describe("Code generators to run")
+	}).strict()).min(1, "At least one SQL configuration is required").describe("SQL file configurations"),
 	sources: z.array(z.object({
-		path: z.string().describe("Path to source file (supports $HOME)"),
-		name: z.string().optional().describe("Variable name override")
-	})).optional().describe("External source files to include as variables")
-});
+		type: z.enum(["file", "postgres"]).optional().describe("Source type: 'file' (default) or 'postgres'"),
+		path: z.string().optional().describe("Path to source file for file sources (supports $HOME)"),
+		name: z.string().optional().describe("Variable name (file sources) or DuckDB attach alias (postgres sources)"),
+		image: z.string().optional().describe("Docker image for postgres sources (default: postgres:16-alpine)"),
+		url: z.string().optional().describe("Postgres source: connect to this existing database for introspection instead of starting a container. Use a literal DSN or '$ENV_VAR' to read from the environment. When set, ':source=' BASELINE blocks are not applied (the live schema is used), which avoids schema drift.")
+	}).strict().refine((s) => s.type === "postgres" ? !!s.name : !!s.path, { message: "file sources require 'path'; postgres sources require 'name'" })).optional().describe("External sources: files inlined as variables, or postgres databases attached for introspection")
+}).strict();
 var ExtraVariable = class {
 	constructor(name, value) {
 		this.name = name;
@@ -2104,7 +2207,7 @@ var ExtraVariable = class {
 	}
 };
 function createExtraVariables(sources, suppressLogging = false) {
-	return sources.map((source) => {
+	return sources.filter((source) => source.type !== "postgres").map((source) => {
 		const path = source.path;
 		const resolvedPath = path.replace("$HOME", homedir());
 		const varName = `sources_${(source.name ?? basename(path, extname(resolvedPath))).replace(/\s+/g, "_")}`;
@@ -2112,6 +2215,27 @@ function createExtraVariables(sources, suppressLogging = false) {
 		return new ExtraVariable(varName, `'${resolvedPath}'`);
 	});
 }
+/**
+* Resolve a postgres source `url`. A value of the form `$VAR` or `${VAR}` is
+* read from the environment (so credentials need not live in sqg.yaml); any
+* other value is treated as a literal DSN.
+*/
+function resolveSourceUrl(url, sourceName) {
+	const match = url.match(/^\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?$/);
+	if (!match) return url;
+	const envName = match[1];
+	const value = process.env[envName];
+	if (!value) throw new SqgError(`Postgres source '${sourceName}' references environment variable '${envName}' which is not set`, "CONFIG_VALIDATION_ERROR", `Set ${envName} to the database connection string, or use a literal DSN in the 'url' field`);
+	return value;
+}
+/** Postgres sources resolved from the project config (with image defaulted). */
+function getPostgresSources(sources) {
+	return sources.filter((source) => source.type === "postgres").map((source) => ({
+		name: source.name,
+		image: source.image ?? "postgres:16-alpine",
+		url: source.url ? resolveSourceUrl(source.url, source.name) : void 0
+	}));
+}
 function buildProjectFromCliOptions(options) {
 	if (!isValidGenerator(options.generator)) {
 		const similar = findSimilarGenerators(options.generator);
@@ -2250,7 +2374,7 @@ function assignResultTypeNames(queries, tables, projectDir = process.cwd()) {
 		}
 		const fullMatch = tryFullTableMatch(group.queries[0], tablesByName);
 		if (fullMatch) {
-			claim(fullMatch, shape, group.queries[0], `full-table match`);
+			claim(fullMatch, shape, group.queries[0], "full-table match");
 			for (const q of group.queries) q.resultTypeName = fullMatch;
 			continue;
 		}
@@ -2303,14 +2427,14 @@ function validateQueries(queries) {
 		};
 	}
 }
-async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false) {
+async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false, postgresSourceNames = []) {
 	await generator.beforeGenerate(projectDir, gen, queries, tables);
 	const templatePath = join(dirname(new URL(import.meta.url).pathname), gen.template ?? generator.template);
 	const name = gen.name ?? basename(file, extname(file));
 	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.projectName ?? name, {
 		migrations: true,
 		...gen.config
-	});
+	}, postgresSourceNames);
 	if (writeToStdout) {
 		process.stdout.write(sourceFile);
 		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
@@ -2411,6 +2535,11 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 	const results = [];
 	try {
 		const extraVariables = createExtraVariables(project.sources ?? [], writeToStdout);
+		const pgSources = getPostgresSources(project.sources ?? []);
+		const pgSourceNames = new Set(pgSources.map((s) => s.name));
+		if (pgSources.length > 0) {
+			if (!project.sql.some((sql) => sql.gen.some((gen) => getGeneratorEngine(gen.generator) === "duckdb"))) throw new SqgError("Postgres sources require a DuckDB generator (they are attached into DuckDB for introspection)", "CONFIG_VALIDATION_ERROR", "Add a 'typescript/duckdb' or 'java/duckdb' generator, or remove the postgres sources");
+		}
 		const files = [];
 		for (const sql of project.sql) {
 			const gensByEngine = /* @__PURE__ */ new Map();
@@ -2428,18 +2557,31 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 					const parseResult = parseSQLQueries(fullPath, extraVariables);
 					queries = parseResult.queries;
 					tables = parseResult.tables;
+					for (const q of queries) if (q.sourceTarget && !pgSourceNames.has(q.sourceTarget)) throw SqgError.inQuery(`BASELINE block targets unknown postgres source '${q.sourceTarget}'`, "CONFIG_VALIDATION_ERROR", q.id, sqlFile, { suggestion: `Declare a source with 'type: postgres, name: ${q.sourceTarget}' in sqg.yaml` });
 				} catch (e) {
 					if (e instanceof SqgError) throw e;
 					throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
 				}
+				const referencedPgSources = pgSources.filter((source) => {
+					const catalogRef = new RegExp(`\\b${escapeRegExp(source.name)}\\.`);
+					return queries.some((q) => q.sourceTarget === source.name || catalogRef.test(q.rawQuery));
+				});
+				const referencedPgSourceNames = referencedPgSources.map((s) => s.name);
 				for (const [engine, gens] of gensByEngine) {
 					const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
 					const reporterAny = reporter;
 					if (reporterAny?.setQueryTotal) reporterAny.setQueryTotal(executableQueries.length);
+					let preparedSources;
 					try {
 						const dbEngine = getDatabaseEngine(engine);
+						let attachments;
+						if (engine === "duckdb" && referencedPgSources.length > 0) {
+							ui?.startPhase("Starting postgres source containers...");
+							preparedSources = await preparePostgresSources(referencedPgSources, queries, reporter);
+							attachments = preparedSources.attachments;
+						}
 						ui?.startPhase(`Initializing ${engine} database...`);
-						await dbEngine.initializeDatabase(queries, reporter);
+						await dbEngine.initializeDatabase(queries, reporter, { attachments });
 						ui?.startPhase(`Introspecting ${executableQueries.length} queries...`);
 						await dbEngine.executeQueries(queries, reporter);
 						if (tables.length > 0) await dbEngine.introspectTables(tables, reporter);
@@ -2456,6 +2598,8 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 							file: sqlFile,
 							engine
 						});
+					} finally {
+						if (preparedSources) await preparedSources.teardown();
 					}
 					ui?.startPhase("Generating code...");
 					const genStart = performance.now();
@@ -2464,7 +2608,7 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 						const outputPath = await writeGeneratedFile(projectDir, {
 							...gen,
 							projectName: project.name
-						}, generator, sqlFile, queries, tables, engine, writeToStdout);
+						}, generator, sqlFile, queries, tables, engine, writeToStdout, referencedPgSourceNames);
 						if (outputPath !== null) {
 							files.push(outputPath);
 							results.push({
@@ -2537,6 +2681,13 @@ var SQLQuery = class {
 	parameterTypes;
 	/** Explicit row-type name from `:result=Name` modifier, when present. */
 	resultTypeOverride;
+	/**
+	* Name of the postgres `source` this block targets, from a `:source=name`
+	* modifier on a BASELINE block. Such blocks define the schema of an external
+	* postgres source and run natively against that source's container during
+	* generation (not against the DuckDB introspection connection).
+	*/
+	sourceTarget;
 	/** Final row-type identifier assigned by assignResultTypeNames (after introspection). */
 	resultTypeName;
 	constructor(filename, id, rawQuery, queryAnonymous, queryNamed, queryPositional, type, isOne, isPluck, isBatch, variables, config, line) {
@@ -2653,6 +2804,8 @@ function parseSQLQueries(filePath, extraVariables) {
 			const isPluck = modifiers.includes(":pluck");
 			const isBatch = modifiers.includes(":batch");
 			const resultTypeOverride = modifiers.find((m) => m.startsWith(":result="))?.slice(8);
+			const sourceTarget = modifiers.find((m) => m.startsWith(":source="))?.slice(8);
+			if (sourceTarget && queryType !== "BASELINE") throw SqgError.inQuery(`The ':source=' modifier is only valid on BASELINE blocks, not ${queryType}`, "SQL_PARSE_ERROR", name, filePath, { suggestion: "Move the schema for a postgres source into a '-- BASELINE <name> :source=<source>' block" });
 			let configStr = getStr("Config", true);
 			if (configStr?.endsWith("*/")) configStr = configStr.slice(0, -2);
 			let config = null;
@@ -2692,8 +2845,12 @@ function parseSQLQueries(filePath, extraVariables) {
 					});
 				}
 				trim() {
-					const lastPart = this.sqlParts.length > 0 ? this.sqlParts[this.sqlParts.length - 1] : null;
-					if (lastPart && typeof lastPart === "string") this.sqlParts[this.sqlParts.length - 1] = lastPart.trimEnd();
+					const isBlankString = (p) => typeof p === "string" && p.trim() === "";
+					while (this.sqlParts.length > 0 && isBlankString(this.sqlParts[0])) this.sqlParts.shift();
+					if (this.sqlParts.length > 0 && typeof this.sqlParts[0] === "string") this.sqlParts[0] = this.sqlParts[0].trimStart();
+					while (this.sqlParts.length > 0 && isBlankString(this.sqlParts[this.sqlParts.length - 1])) this.sqlParts.pop();
+					const lastIdx = this.sqlParts.length - 1;
+					if (lastIdx >= 0 && typeof this.sqlParts[lastIdx] === "string") this.sqlParts[lastIdx] = this.sqlParts[lastIdx].trimEnd();
 				}
 				parameters() {
 					return this.sqlParts.filter((part) => typeof part !== "string" && !part.name.startsWith("sources_"));
@@ -2808,6 +2965,7 @@ function parseSQLQueries(filePath, extraVariables) {
 			});
 			const query = new SQLQuery(filePath, name, sqlContentStr, sql.toSqlWithAnonymousPlaceholders(), sql.toSqlWithNamedPlaceholders(), sql.toSqlWithPositionalPlaceholders(), queryType, isOne, isPluck, isBatch, variables, config, annotationLine);
 			query.resultTypeOverride = resultTypeOverride;
+			query.sourceTarget = sourceTarget;
 			checkDuplicate(queryType, name);
 			queries.push(query);
 			consola.debug(`Added query: ${name} (${queryType})`);
@@ -2824,7 +2982,7 @@ function parseSQLQueries(filePath, extraVariables) {
 //#endregion
 //#region src/db/types.ts
 async function initializeDatabase(queries, execQueries, reporter) {
-	const baselineQueries = queries.filter((q) => q.isBaseline);
+	const baselineQueries = queries.filter((q) => q.isBaseline && !q.sourceTarget);
 	for (const query of baselineQueries) try {
 		await execQueries(query);
 	} catch (error) {
@@ -2880,9 +3038,17 @@ function convertType(type) {
 const duckdb = new class {
 	db;
 	connection;
-	async initializeDatabase(queries, reporter) {
+	async initializeDatabase(queries, reporter, options) {
 		this.db = await DuckDBInstance.create(":memory:");
 		this.connection = await this.db.connect();
+		for (const attachment of options?.attachments ?? []) {
+			const sql = `ATTACH '${attachment.connectionUri}' AS ${attachment.alias} (TYPE postgres)`;
+			try {
+				await this.connection.run(sql);
+			} catch (e) {
+				throw new DatabaseError(`Failed to attach source '${attachment.alias}': ${e.message}`, "duckdb", "Check that the postgres source container started and is reachable.");
+			}
+		}
 		await initializeDatabase(queries, async (query) => {
 			try {
 				await this.connection.run(query.rawQuery);

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, snakeCase } from "es-toolkit/string";
+import { camelCase, escapeRegExp, pascalCase, snakeCase } from "es-toolkit/string";
 import Handlebars from "handlebars";
 import { z } from "zod";
 import { DuckDBEnumType, DuckDBInstance, DuckDBListType, DuckDBMapType, DuckDBStructType } from "@duckdb/node-api";
@@ -221,6 +221,7 @@ SQL Annotation Syntax:
   -- QUERY <name> [:one] [:pluck]   Select query (returns rows)
   -- EXEC <name> [:batch]           Execute statement (INSERT/UPDATE/DELETE)
   -- BASELINE <name>                Schema created outside SQG (runs before migrations, not tracked)
+  -- BASELINE <name> :source=<src>  Schema of a 'type: postgres' source (applied to a managed testcontainer, attached into DuckDB)
   -- MIGRATE <name>                 Schema migration (runs in source order; name is any identifier, e.g. "1" or "add_email")
   -- TESTDATA <name>                Test data setup (not generated)
   -- TABLE <name> :appender         Table for bulk insert appender (DuckDB, PostgreSQL)
@@ -234,6 +235,7 @@ Modifiers:
   :all          Return all rows (default)
   :batch        Generate a JDBC batch method for an EXEC (Java only)
   :appender     Generate bulk insert appender for TABLE annotation
+  :source=Name  Mark a BASELINE block as the schema of a postgres source (Name)
   :result=Name  Name (and share) the row type (Java only). Annotate ONE query
                 with :result=Name — every other query in the same file with the
                 same column shape automatically gets the same name; you do NOT
@@ -783,6 +785,13 @@ var SQLQuery = class {
 	parameterTypes;
 	/** Explicit row-type name from `:result=Name` modifier, when present. */
 	resultTypeOverride;
+	/**
+	* Name of the postgres `source` this block targets, from a `:source=name`
+	* modifier on a BASELINE block. Such blocks define the schema of an external
+	* postgres source and run natively against that source's container during
+	* generation (not against the DuckDB introspection connection).
+	*/
+	sourceTarget;
 	/** Final row-type identifier assigned by assignResultTypeNames (after introspection). */
 	resultTypeName;
 	constructor(filename, id, rawQuery, queryAnonymous, queryNamed, queryPositional, type, isOne, isPluck, isBatch, variables, config, line) {
@@ -899,6 +908,8 @@ function parseSQLQueries(filePath, extraVariables) {
 			const isPluck = modifiers.includes(":pluck");
 			const isBatch = modifiers.includes(":batch");
 			const resultTypeOverride = modifiers.find((m) => m.startsWith(":result="))?.slice(8);
+			const sourceTarget = modifiers.find((m) => m.startsWith(":source="))?.slice(8);
+			if (sourceTarget && queryType !== "BASELINE") throw SqgError.inQuery(`The ':source=' modifier is only valid on BASELINE blocks, not ${queryType}`, "SQL_PARSE_ERROR", name, filePath, { suggestion: "Move the schema for a postgres source into a '-- BASELINE <name> :source=<source>' block" });
 			let configStr = getStr("Config", true);
 			if (configStr?.endsWith("*/")) configStr = configStr.slice(0, -2);
 			let config = null;
@@ -938,8 +949,12 @@ function parseSQLQueries(filePath, extraVariables) {
 					});
 				}
 				trim() {
-					const lastPart = this.sqlParts.length > 0 ? this.sqlParts[this.sqlParts.length - 1] : null;
-					if (lastPart && typeof lastPart === "string") this.sqlParts[this.sqlParts.length - 1] = lastPart.trimEnd();
+					const isBlankString = (p) => typeof p === "string" && p.trim() === "";
+					while (this.sqlParts.length > 0 && isBlankString(this.sqlParts[0])) this.sqlParts.shift();
+					if (this.sqlParts.length > 0 && typeof this.sqlParts[0] === "string") this.sqlParts[0] = this.sqlParts[0].trimStart();
+					while (this.sqlParts.length > 0 && isBlankString(this.sqlParts[this.sqlParts.length - 1])) this.sqlParts.pop();
+					const lastIdx = this.sqlParts.length - 1;
+					if (lastIdx >= 0 && typeof this.sqlParts[lastIdx] === "string") this.sqlParts[lastIdx] = this.sqlParts[lastIdx].trimEnd();
 				}
 				parameters() {
 					return this.sqlParts.filter((part) => typeof part !== "string" && !part.name.startsWith("sources_"));
@@ -1054,6 +1069,7 @@ function parseSQLQueries(filePath, extraVariables) {
 			});
 			const query = new SQLQuery(filePath, name, sqlContentStr, sql.toSqlWithAnonymousPlaceholders(), sql.toSqlWithNamedPlaceholders(), sql.toSqlWithPositionalPlaceholders(), queryType, isOne, isPluck, isBatch, variables, config, annotationLine);
 			query.resultTypeOverride = resultTypeOverride;
+			query.sourceTarget = sourceTarget;
 			checkDuplicate(queryType, name);
 			queries.push(query);
 			consola.debug(`Added query: ${name} (${queryType})`);
@@ -1070,7 +1086,7 @@ function parseSQLQueries(filePath, extraVariables) {
 //#endregion
 //#region src/db/types.ts
 async function initializeDatabase(queries, execQueries, reporter) {
-	const baselineQueries = queries.filter((q) => q.isBaseline);
+	const baselineQueries = queries.filter((q) => q.isBaseline && !q.sourceTarget);
 	for (const query of baselineQueries) try {
 		await execQueries(query);
 	} catch (error) {
@@ -1126,9 +1142,17 @@ function convertType(type) {
 const duckdb = new class {
 	db;
 	connection;
-	async initializeDatabase(queries, reporter) {
+	async initializeDatabase(queries, reporter, options) {
 		this.db = await DuckDBInstance.create(":memory:");
 		this.connection = await this.db.connect();
+		for (const attachment of options?.attachments ?? []) {
+			const sql = `ATTACH '${attachment.connectionUri}' AS ${attachment.alias} (TYPE postgres)`;
+			try {
+				await this.connection.run(sql);
+			} catch (e) {
+				throw new DatabaseError(`Failed to attach source '${attachment.alias}': ${e.message}`, "duckdb", "Check that the postgres source container started and is reachable.");
+			}
+		}
 		await initializeDatabase(queries, async (query) => {
 			try {
 				await this.connection.run(query.rawQuery);
@@ -2726,6 +2750,19 @@ var PythonGenerator = class extends BaseGenerator {
 			if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
 			return `"${value}"`;
 		});
+		Handlebars.registerHelper("sqlExpr", (queryHelper) => {
+			const parts = queryHelper.sqlQueryParts;
+			if (!parts.some((p) => typeof p !== "string" && p.name.startsWith("sources_"))) {
+				const value = queryHelper.sqlQuery;
+				if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
+				return `"${value}"`;
+			}
+			let out = "f\"\"\"";
+			for (const part of parts) if (typeof part === "string") out += part.replace(/\\/g, "\\\\").replace(/\{/g, "{{").replace(/\}/g, "}}");
+			else if (part.name.startsWith("sources_")) out += ` '{${part.name}}'`;
+			else out += "?";
+			return `${out}"""`;
+		});
 		Handlebars.registerHelper("pyType", (column) => {
 			return this.getPyType(column);
 		});
@@ -2850,6 +2887,7 @@ var TsGenerator = class extends BaseGenerator {
 	async beforeGenerate(_projectDir, gen, _queries, _tables) {
 		if (this.typeMapper instanceof TypeScriptTypeMapper) this.typeMapper.safeIntegers = !!gen.config?.safeIntegers;
 		Handlebars.registerHelper("quote", (value) => this.quote(value));
+		Handlebars.registerHelper("sqlExpr", (queryHelper) => this.sqlExpr(queryHelper));
 		Handlebars.registerHelper("appendMethod", (column) => {
 			if (column.type instanceof ListType) return "List";
 			const typeStr = column.type?.toString().toUpperCase() || "";
@@ -3002,6 +3040,22 @@ var TsGenerator = class extends BaseGenerator {
 	quote(value) {
 		return value.includes("\n") || value.includes("'") ? `\`${value}\`` : `'${value}'`;
 	}
+	/**
+	* Build the SQL expression for a query. Without file `sources`, this is the
+	* plain quoted SQL string (unchanged). When a `${sources_x}` reference is
+	* present it is interpolated into a template literal as a runtime argument
+	* (the value is supplied by the caller, not bound), mirroring the Java
+	* generator — `ATTACH '` + arg + `'` style.
+	*/
+	sqlExpr(queryHelper) {
+		const parts = queryHelper.sqlQueryParts;
+		if (!parts.some((p) => typeof p !== "string" && p.name.startsWith("sources_"))) return this.quote(queryHelper.sqlQuery);
+		let out = "`";
+		for (const part of parts) if (typeof part === "string") out += part.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+		else if (part.name.startsWith("sources_")) out += ` '\${${part.name}}'`;
+		else out += "?";
+		return `${out}\``;
+	}
 };
 //#endregion
 //#region src/generators/typescript-duckdb-generator.ts
@@ -3108,6 +3162,69 @@ function getGenerator(generator) {
 	}
 }
 //#endregion
+//#region src/sources.ts
+/**
+* For each `type: postgres` source: start a throwaway Postgres testcontainer,
+* run the source's schema (the BASELINE blocks tagged `:source=<name>`) natively
+* against it so introspection sees true Postgres types, and return the connection
+* info to ATTACH into DuckDB.
+*
+* The synthesized ATTACH (done by the DuckDB adapter) and these schema blocks are
+* not emitted into generated code — at runtime the application attaches the real
+* production database under the same alias.
+*/
+async function preparePostgresSources(sources, queries, reporter) {
+	const containers = [];
+	const attachments = [];
+	const teardown = async () => {
+		for (const container of containers) try {
+			await container.stop();
+		} catch {}
+	};
+	try {
+		for (const source of sources) {
+			if (source.url) {
+				attachments.push({
+					alias: source.name,
+					connectionUri: source.url
+				});
+				continue;
+			}
+			reporter?.onContainerStarting?.();
+			let container;
+			try {
+				container = await new PostgreSqlContainer(source.image).withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
+			} catch (e) {
+				throw new DatabaseError(`Could not start a Postgres container for source '${source.name}': ${e.message}`, "postgres", "Postgres sources need Docker to introspect schema. Start Docker, or set 'url' on the source to point at an existing Postgres database (e.g. url: $DATABASE_URL).");
+			}
+			containers.push(container);
+			const connectionUri = container.getConnectionUri();
+			reporter?.onContainerStarted?.(connectionUri);
+			const schemaBlocks = queries.filter((q) => q.isBaseline && q.sourceTarget === source.name);
+			const client = new Client({ connectionString: connectionUri });
+			await client.connect();
+			try {
+				for (const block of schemaBlocks) await client.query(block.rawQuery);
+			} catch (e) {
+				throw new DatabaseError(`Failed to apply schema for postgres source '${source.name}': ${e.message}`, "postgres", `Check that the BASELINE blocks tagged ':source=${source.name}' are valid PostgreSQL.`);
+			} finally {
+				await client.end();
+			}
+			attachments.push({
+				alias: source.name,
+				connectionUri
+			});
+		}
+	} catch (e) {
+		await teardown();
+		throw e;
+	}
+	return {
+		attachments,
+		teardown
+	};
+}
+//#endregion
 //#region src/sqltool.ts
 const GENERATED_FILE_COMMENT = "This file is generated by SQG (https://sqg.dev). Do not edit manually.";
 const configSchema = z.object({ result: z.record(z.string(), z.string()).optional() });
@@ -3284,18 +3401,23 @@ var TableHelper = class {
 		return this.generator.typeMapper;
 	}
 };
-function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config) {
+function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config, postgresSourceNames = []) {
 	const templateSrc = readFileSync(templatePath, "utf-8");
 	const template = Handlebars.compile(templateSrc);
 	Handlebars.registerHelper("mapType", (column) => generator.mapType(column));
 	Handlebars.registerHelper("plusOne", (value) => value + 1);
 	const migrations = queries.filter((q) => q.isMigrate).map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q)));
 	const tableHelpers = generator.supportsAppenders(engine) ? tables.filter((t) => !t.skipGenerateFunction).map((t) => new TableHelper(t, generator)) : [];
+	const attachers = engine === "duckdb" ? postgresSourceNames.map((sourceName) => ({
+		alias: sourceName,
+		functionName: generator.getFunctionName(`attach_${sourceName}`)
+	})) : [];
 	return template({
 		generatedComment: GENERATED_FILE_COMMENT,
 		migrations,
 		queries: queries.map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
 		tables: tableHelpers,
+		attachers,
 		className: generator.getClassName(name),
 		projectName,
 		config
@@ -3320,13 +3442,16 @@ const ProjectSchema = z.object({
 			template: z.string().optional().describe("Custom Handlebars template path"),
 			output: z.string().min(1, "Output path is required").describe("Output file or directory path"),
 			config: z.any().optional().describe("Generator-specific configuration")
-		})).min(1, "At least one generator is required").describe("Code generators to run")
-	})).min(1, "At least one SQL configuration is required").describe("SQL file configurations"),
+		}).strict()).min(1, "At least one generator is required").describe("Code generators to run")
+	}).strict()).min(1, "At least one SQL configuration is required").describe("SQL file configurations"),
 	sources: z.array(z.object({
-		path: z.string().describe("Path to source file (supports $HOME)"),
-		name: z.string().optional().describe("Variable name override")
-	})).optional().describe("External source files to include as variables")
-});
+		type: z.enum(["file", "postgres"]).optional().describe("Source type: 'file' (default) or 'postgres'"),
+		path: z.string().optional().describe("Path to source file for file sources (supports $HOME)"),
+		name: z.string().optional().describe("Variable name (file sources) or DuckDB attach alias (postgres sources)"),
+		image: z.string().optional().describe("Docker image for postgres sources (default: postgres:16-alpine)"),
+		url: z.string().optional().describe("Postgres source: connect to this existing database for introspection instead of starting a container. Use a literal DSN or '$ENV_VAR' to read from the environment. When set, ':source=' BASELINE blocks are not applied (the live schema is used), which avoids schema drift.")
+	}).strict().refine((s) => s.type === "postgres" ? !!s.name : !!s.path, { message: "file sources require 'path'; postgres sources require 'name'" })).optional().describe("External sources: files inlined as variables, or postgres databases attached for introspection")
+}).strict();
 var ExtraVariable = class {
 	constructor(name, value) {
 		this.name = name;
@@ -3334,7 +3459,7 @@ var ExtraVariable = class {
 	}
 };
 function createExtraVariables(sources, suppressLogging = false) {
-	return sources.map((source) => {
+	return sources.filter((source) => source.type !== "postgres").map((source) => {
 		const path = source.path;
 		const resolvedPath = path.replace("$HOME", homedir());
 		const varName = `sources_${(source.name ?? basename(path, extname(resolvedPath))).replace(/\s+/g, "_")}`;
@@ -3342,6 +3467,27 @@ function createExtraVariables(sources, suppressLogging = false) {
 		return new ExtraVariable(varName, `'${resolvedPath}'`);
 	});
 }
+/**
+* Resolve a postgres source `url`. A value of the form `$VAR` or `${VAR}` is
+* read from the environment (so credentials need not live in sqg.yaml); any
+* other value is treated as a literal DSN.
+*/
+function resolveSourceUrl(url, sourceName) {
+	const match = url.match(/^\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?$/);
+	if (!match) return url;
+	const envName = match[1];
+	const value = process.env[envName];
+	if (!value) throw new SqgError(`Postgres source '${sourceName}' references environment variable '${envName}' which is not set`, "CONFIG_VALIDATION_ERROR", `Set ${envName} to the database connection string, or use a literal DSN in the 'url' field`);
+	return value;
+}
+/** Postgres sources resolved from the project config (with image defaulted). */
+function getPostgresSources(sources) {
+	return sources.filter((source) => source.type === "postgres").map((source) => ({
+		name: source.name,
+		image: source.image ?? "postgres:16-alpine",
+		url: source.url ? resolveSourceUrl(source.url, source.name) : void 0
+	}));
+}
 function buildProjectFromCliOptions(options) {
 	if (!isValidGenerator(options.generator)) {
 		const similar = findSimilarGenerators(options.generator);
@@ -3480,7 +3626,7 @@ function assignResultTypeNames(queries, tables, projectDir = process.cwd()) {
 		}
 		const fullMatch = tryFullTableMatch(group.queries[0], tablesByName);
 		if (fullMatch) {
-			claim(fullMatch, shape, group.queries[0], `full-table match`);
+			claim(fullMatch, shape, group.queries[0], "full-table match");
 			for (const q of group.queries) q.resultTypeName = fullMatch;
 			continue;
 		}
@@ -3533,14 +3679,14 @@ function validateQueries(queries) {
 		};
 	}
 }
-async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false) {
+async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false, postgresSourceNames = []) {
 	await generator.beforeGenerate(projectDir, gen, queries, tables);
 	const templatePath = join(dirname(new URL(import.meta.url).pathname), gen.template ?? generator.template);
 	const name = gen.name ?? basename(file, extname(file));
 	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.projectName ?? name, {
 		migrations: true,
 		...gen.config
-	});
+	}, postgresSourceNames);
 	if (writeToStdout) {
 		process.stdout.write(sourceFile);
 		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
@@ -3641,6 +3787,11 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 	const results = [];
 	try {
 		const extraVariables = createExtraVariables(project.sources ?? [], writeToStdout);
+		const pgSources = getPostgresSources(project.sources ?? []);
+		const pgSourceNames = new Set(pgSources.map((s) => s.name));
+		if (pgSources.length > 0) {
+			if (!project.sql.some((sql) => sql.gen.some((gen) => getGeneratorEngine(gen.generator) === "duckdb"))) throw new SqgError("Postgres sources require a DuckDB generator (they are attached into DuckDB for introspection)", "CONFIG_VALIDATION_ERROR", "Add a 'typescript/duckdb' or 'java/duckdb' generator, or remove the postgres sources");
+		}
 		const files = [];
 		for (const sql of project.sql) {
 			const gensByEngine = /* @__PURE__ */ new Map();
@@ -3658,18 +3809,31 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 					const parseResult = parseSQLQueries(fullPath, extraVariables);
 					queries = parseResult.queries;
 					tables = parseResult.tables;
+					for (const q of queries) if (q.sourceTarget && !pgSourceNames.has(q.sourceTarget)) throw SqgError.inQuery(`BASELINE block targets unknown postgres source '${q.sourceTarget}'`, "CONFIG_VALIDATION_ERROR", q.id, sqlFile, { suggestion: `Declare a source with 'type: postgres, name: ${q.sourceTarget}' in sqg.yaml` });
 				} catch (e) {
 					if (e instanceof SqgError) throw e;
 					throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
 				}
+				const referencedPgSources = pgSources.filter((source) => {
+					const catalogRef = new RegExp(`\\b${escapeRegExp(source.name)}\\.`);
+					return queries.some((q) => q.sourceTarget === source.name || catalogRef.test(q.rawQuery));
+				});
+				const referencedPgSourceNames = referencedPgSources.map((s) => s.name);
 				for (const [engine, gens] of gensByEngine) {
 					const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
 					const reporterAny = reporter;
 					if (reporterAny?.setQueryTotal) reporterAny.setQueryTotal(executableQueries.length);
+					let preparedSources;
 					try {
 						const dbEngine = getDatabaseEngine(engine);
+						let attachments;
+						if (engine === "duckdb" && referencedPgSources.length > 0) {
+							ui?.startPhase("Starting postgres source containers...");
+							preparedSources = await preparePostgresSources(referencedPgSources, queries, reporter);
+							attachments = preparedSources.attachments;
+						}
 						ui?.startPhase(`Initializing ${engine} database...`);
-						await dbEngine.initializeDatabase(queries, reporter);
+						await dbEngine.initializeDatabase(queries, reporter, { attachments });
 						ui?.startPhase(`Introspecting ${executableQueries.length} queries...`);
 						await dbEngine.executeQueries(queries, reporter);
 						if (tables.length > 0) await dbEngine.introspectTables(tables, reporter);
@@ -3686,6 +3850,8 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 							file: sqlFile,
 							engine
 						});
+					} finally {
+						if (preparedSources) await preparedSources.teardown();
 					}
 					ui?.startPhase("Generating code...");
 					const genStart = performance.now();
@@ -3694,7 +3860,7 @@ async function processProjectFromConfig(project, projectDir, writeToStdout = fal
 						const outputPath = await writeGeneratedFile(projectDir, {
 							...gen,
 							projectName: project.name
-						}, generator, sqlFile, queries, tables, engine, writeToStdout);
+						}, generator, sqlFile, queries, tables, engine, writeToStdout, referencedPgSourceNames);
 						if (outputPath !== null) {
 							files.push(outputPath);
 							results.push({
@@ -3728,7 +3894,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.20.0"
+	version: process.env.npm_package_version ?? "0.21.1"
 }, { capabilities: {
 	tools: {},
 	resources: {}
@@ -4199,7 +4365,7 @@ function formatMs(ms) {
 }
 //#endregion
 //#region src/sqg.ts
-const version = process.env.npm_package_version ?? "0.20.0";
+const version = process.env.npm_package_version ?? "0.21.1";
 updateNotifier({ pkg: {
 	name: "@sqg/sqg",
 	version

package/dist/templates/better-sqlite3.hbs

@@ -69,7 +69,7 @@ export class {{className}} {
     {{#unless skipGenerateFunction}}
     {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): {{> returnType }} {
         const stmt = this.prepare<[{{> paramTypes}}], {{> resultType}}>('{{id}}', 
-            {{{quote sqlQuery}}}{{#if isPluck}}, true{{/if}});
+            {{{sqlExpr this}}}{{#if isPluck}}, true{{/if}});
         {{> execute}}
     }
     {{/unless}}

package/dist/templates/java-jdbc.hbs

@@ -223,6 +223,17 @@ public class {{className}} {
 
     {{{declareEnums queries}}}
 
+    {{#each attachers}}
+    /** Attach the "{{alias}}" postgres source under the same alias used during generation. Loads the postgres extension (idempotent) so callers need not rely on DuckDB autoloading. */
+    public void {{functionName}}(String connectionString) throws SQLException {
+        try (var stmt = connection.createStatement()) {
+            stmt.execute("INSTALL postgres");
+            stmt.execute("LOAD postgres");
+            stmt.execute("ATTACH '" + connectionString + "' AS {{alias}} (TYPE postgres)");
+        }
+    }
+
+    {{/each}}
     {{#each queries}}
     {{#unless skipGenerateFunction}}
     {{>columnTypesRecord}}

package/dist/templates/python.hbs

@@ -135,6 +135,18 @@ class {{className}}:
 {{/if}}
 {{/if}}
 
+{{#each attachers}}
+    def {{functionName}}(self, connection_string: str) -> None:
+        """Attach the "{{alias}}" postgres source under the same alias used during generation.
+
+        Loads the postgres extension (idempotent) so callers need not rely on
+        DuckDB autoloading.
+        """
+        self._conn.execute("INSTALL postgres")
+        self._conn.execute("LOAD postgres")
+        self._conn.execute(f"ATTACH '{connection_string}' AS {{alias}} (TYPE postgres)")
+
+{{/each}}
 {{#each queries}}
 {{#unless skipGenerateFunction}}
 {{#if isQuery}}
@@ -142,7 +154,7 @@ class {{className}}:
 {{#if isOne}}
     def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> {{{pyTypeOrNone (lookup columns 0)}}}:
         row = self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchone()
         if row is None:
             return None
@@ -150,19 +162,19 @@ class {{className}}:
 
     def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> tuple[Any, ...] | None:
         return self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchone()
 
 {{else}}
     def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[{{{pyType (lookup columns 0)}}}]:
         rows = self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> 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}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchall()
 
 {{/if}}
@@ -170,7 +182,7 @@ class {{className}}:
 {{#if isOne}}
     def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> {{{rowType}}} | None:
         row = self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchone()
         if row is None:
             return None
@@ -178,19 +190,19 @@ class {{className}}:
 
     def {{functionName}}_raw(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> tuple[Any, ...] | None:
         return self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchone()
 
 {{else}}
     def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> list[{{{rowType}}}]:
         rows = self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> 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}}
+            {{{sqlExpr this}}}, {{> params}}
         ).fetchall()
 
 {{/if}}
@@ -198,7 +210,7 @@ class {{className}}:
 {{else}}
     def {{functionName}}(self{{#each variables}}, {{name}}: {{{type}}}{{/each}}) -> None:
         self._conn.execute(
-            {{{quote sqlQuery}}}, {{> params}}
+            {{{sqlExpr this}}}, {{> params}}
         )
 
 {{/if}}

package/dist/templates/typescript-duckdb.hbs

@@ -58,10 +58,19 @@ export class {{className}} {
         );
     }
 
+    {{#each attachers}}
+    /** Attach the "{{alias}}" postgres source under the same alias used during generation. Loads the postgres extension (idempotent) so callers need not rely on DuckDB autoloading. */
+    async {{functionName}}(connectionString: string): Promise<void> {
+        await this.conn.run("INSTALL postgres");
+        await this.conn.run("LOAD postgres");
+        await this.conn.run(`ATTACH '${connectionString}' AS {{alias}} (TYPE postgres)`);
+    }
+
+    {{/each}}
     {{#each queries}}
     {{#unless skipGenerateFunction}}
     async {{functionName}}({{#each variables}}{{name}}: {{type}}{{#unless @last}}, {{/unless}}{{/each}}): Promise<{{> returnType }}> {
-        const sql = {{{quote sqlQuery}}};
+        const sql = {{{sqlExpr this}}};
         {{#if (hasListParams this)}}
         const stmt = await this.conn.prepare(sql);
         {{{bindStatements this}}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sqg/sqg",
-  "version": "0.20.0",
+  "version": "0.21.1",
   "description": "SQG - SQL Query Generator - Type-safe code generation from SQL (https://sqg.dev)",
   "type": "module",
   "main": "dist/index.mjs",