sumak 0.0.7 → 0.0.8

package/dist/builder/typed-delete.mjs

@@ -1,11 +1,13 @@
 import { star } from "../ast/expression.mjs";
 import { unwrap } from "../ast/typed-expression.mjs";
 import { DeleteBuilder } from "./delete.mjs";
-import { createColumnProxies, resetParams } from "./eb.mjs";
+import { createColumnProxies } from "./eb.mjs";
 
 export class TypedDeleteBuilder {
 	
 	_builder;
+	
+	_printer;
 	constructor(table) {
 		this._builder = new DeleteBuilder().from(table);
 	}
@@ -13,12 +15,12 @@ export class TypedDeleteBuilder {
 	_with(builder) {
 		const t = new TypedDeleteBuilder("");
 		t._builder = builder;
+		t._printer = this._printer;
 		return t;
 	}
 	
 	where(exprOrCallback) {
 		if (typeof exprOrCallback === "function") {
-			resetParams();
 			const table = this._builder.build().table.name;
 			const cols = createColumnProxies(table);
 			const result = exprOrCallback(cols);
@@ -74,6 +76,13 @@ export class TypedDeleteBuilder {
 		return printer.print(this.build());
 	}
 	
+	toSQL() {
+		if (!this._printer) {
+			throw new Error("toSQL() requires a printer. Use db.deleteFrom() or pass a printer to compile().");
+		}
+		return this._printer.print(this.build());
+	}
+	
 	explain(options) {
 		const node = this.build();
 		const explainNode = {

package/dist/builder/typed-insert.d.mts

@@ -11,8 +11,7 @@ export declare class TypedInsertBuilder<
 	DB,
 	TB extends keyof DB
 > {
-	private _paramIdx;
-	constructor(table: TB & string, paramIdx?: number);
+	constructor(table: TB & string);
 	/**
 	* Insert a single row. Columns/values inferred from Insertable<DB[TB]>.
 	*/
@@ -46,10 +45,6 @@ export declare class TypedInsertBuilder<
 	}[]): TypedInsertBuilder<DB, TB>;
 	/**
 	* ON CONFLICT DO UPDATE — with plain object (auto-parameterized).
-	*
-	* ```ts
-	* .onConflictDoUpdateSet(["email"], { name: "Alice Updated" })
-	* ```
 	*/
 	onConflictDoUpdateSet(columns: (keyof DB[TB] & string)[], values: Partial<Insertable<DB[TB]>>): TypedInsertBuilder<DB, TB>;
 	/** ON CONFLICT ON CONSTRAINT name DO NOTHING */
@@ -78,6 +73,8 @@ export declare class TypedInsertBuilder<
 	$if(condition: boolean, fn: (qb: TypedInsertBuilder<DB, TB>) => TypedInsertBuilder<DB, TB>): TypedInsertBuilder<DB, TB>;
 	build(): InsertNode;
 	compile(printer: Printer): CompiledQuery;
+	/** Compile to SQL using the dialect's printer. */
+	toSQL(): CompiledQuery;
 	/** EXPLAIN this query. */
 	explain(options?: {
 		analyze?: boolean;

package/dist/builder/typed-insert.mjs

@@ -6,27 +6,23 @@ import { InsertBuilder } from "./insert.mjs";
 export class TypedInsertBuilder {
 	
 	_builder;
-	_paramIdx;
-	constructor(table, paramIdx = 0) {
+	
+	_printer;
+	constructor(table) {
 		this._builder = new InsertBuilder().into(table);
-		this._paramIdx = paramIdx;
 	}
 	
-	_withBuilder(builder, paramIdx) {
+	_withBuilder(builder) {
 		const t = new TypedInsertBuilder("");
 		t._builder = builder;
-		t._paramIdx = paramIdx;
+		t._printer = this._printer;
 		return t;
 	}
 	
 	values(row) {
 		const entries = Object.entries(row);
 		const cols = entries.map(([k]) => k);
-		const vals = entries.map(([_, v]) => {
-			const p = param(this._paramIdx, v);
-			this._paramIdx++;
-			return p;
-		});
+		const vals = entries.map(([_, v]) => param(0, v));
 		let builder = this._builder;
 		
 		if (builder.build().columns.length === 0) {
@@ -35,8 +31,8 @@ export class TypedInsertBuilder {
 		builder = new InsertBuilder({
 			...builder.build(),
 			values: [...builder.build().values, vals]
-		}, this._paramIdx);
-		return this._withBuilder(builder, this._paramIdx);
+		});
+		return this._withBuilder(builder);
 	}
 	
 	valuesMany(rows) {
@@ -55,7 +51,7 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: exprs
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
@@ -69,7 +65,7 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: [...this._builder.build().returning, aliased]
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
@@ -77,72 +73,70 @@ export class TypedInsertBuilder {
 		const builder = new InsertBuilder({
 			...this._builder.build(),
 			returning: [star()]
-		}, this._paramIdx);
+		});
 		return new TypedInsertReturningBuilder(builder);
 	}
 	
 	onConflictDoNothing(...columns) {
-		return this._withBuilder(this._builder.onConflictDoNothing(...columns), this._paramIdx);
+		return this._withBuilder(this._builder.onConflictDoNothing(...columns));
 	}
 	
 	onConflictDoUpdate(columns, set) {
 		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), this._paramIdx);
+		}))));
 	}
 	
 	onConflictDoUpdateSet(columns, values) {
 		const set = [];
-		let idx = this._paramIdx;
 		for (const [col, val] of Object.entries(values)) {
 			if (val !== undefined) {
 				set.push({
 					column: col,
-					value: param(idx, val)
+					value: param(0, val)
 				});
-				idx++;
 			}
 		}
-		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set), idx);
+		return this._withBuilder(this._builder.onConflictDoUpdate(columns, set));
 	}
 	
 	onConflictConstraintDoNothing(constraint) {
-		return this._withBuilder(this._builder.onConflictConstraintDoNothing(constraint), this._paramIdx);
+		return this._withBuilder(this._builder.onConflictConstraintDoNothing(constraint));
 	}
 	
 	onConflictConstraintDoUpdate(constraint, set) {
 		return this._withBuilder(this._builder.onConflictConstraintDoUpdate(constraint, set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), this._paramIdx);
+		}))));
 	}
 	
 	orIgnore() {
-		return this._withBuilder(this._builder.orIgnore(), this._paramIdx);
+		return this._withBuilder(this._builder.orIgnore());
 	}
 	
 	orReplace() {
-		return this._withBuilder(this._builder.orReplace(), this._paramIdx);
+		return this._withBuilder(this._builder.orReplace());
 	}
 	
 	onDuplicateKeyUpdate(set) {
 		return this._withBuilder(this._builder.onDuplicateKeyUpdate(set.map((s) => ({
 			column: s.column,
 			value: unwrap(s.value)
-		}))), this._paramIdx);
+		}))));
 	}
 	
 	fromSelect(query) {
-		return this._withBuilder(this._builder.fromSelect(query), this._paramIdx);
+		return this._withBuilder(this._builder.fromSelect(query));
 	}
 	
 	defaultValues() {
-		return this._withBuilder(this._builder.defaultValues(), this._paramIdx);
+		return this._withBuilder(this._builder.defaultValues());
 	}
 	
 	with(name, query, recursive = false) {
-		return this._withBuilder(this._builder.with(name, query, recursive), this._paramIdx);
+		return this._withBuilder(this._builder.with(name, query, recursive));
 	}
 	
 	$if(condition, fn) {
@@ -158,6 +152,13 @@ export class TypedInsertBuilder {
 		return printer.print(this.build());
 	}
 	
+	toSQL() {
+		if (!this._printer) {
+			throw new Error("toSQL() requires a printer. Use db.insertInto() or pass a printer to compile().");
+		}
+		return this._printer.print(this.build());
+	}
+	
 	explain(options) {
 		const node = this.build();
 		const explainNode = {

package/dist/builder/typed-merge.d.mts

@@ -19,8 +19,7 @@ export declare class TypedMergeBuilder<
 > {
 	private _targetTable;
 	private _sourceAlias;
-	private _paramIdx;
-	constructor(targetTable: Target & string, sourceTable: Source & string, sourceAlias: string, on: Expression<boolean>, paramIdx?: number);
+	constructor(targetTable: Target & string, sourceTable: Source & string, sourceAlias: string, on: Expression<boolean>);
 	whenMatchedThenUpdate(values: Updateable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
 	whenMatchedThenDelete(condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;
 	whenNotMatchedThenInsert(row: Insertable<DB[Target]>, condition?: (proxies: MergeProxies<DB, Target, Source>) => Expression<boolean>): TypedMergeBuilder<DB, Target, Source>;

package/dist/builder/typed-merge.mjs

@@ -1,6 +1,6 @@
 import { param } from "../ast/expression.mjs";
 import { unwrap } from "../ast/typed-expression.mjs";
-import { Col, resetParams } from "./eb.mjs";
+import { Col } from "./eb.mjs";
 import { MergeBuilder } from "./merge.mjs";
 function createMergeProxies(targetTable, sourceAlias) {
 	const makeProxy = (prefix) => new Proxy({}, { get(_t, colName) {
@@ -16,15 +16,13 @@ export class TypedMergeBuilder {
 	_builder;
 	_targetTable;
 	_sourceAlias;
-	_paramIdx;
-	constructor(targetTable, sourceTable, sourceAlias, on, paramIdx = 0) {
+	constructor(targetTable, sourceTable, sourceAlias, on) {
 		this._targetTable = targetTable;
 		this._sourceAlias = sourceAlias;
-		this._paramIdx = paramIdx;
 		this._builder = new MergeBuilder().into(targetTable).using(sourceTable, sourceAlias).on(unwrap(on));
 	}
 	
-	_with(builder, paramIdx) {
+	_with(builder) {
 		const t = new TypedMergeBuilder("", "", "", { node: {
 			type: "literal",
 			value: true
@@ -32,57 +30,46 @@ export class TypedMergeBuilder {
 		t._builder = builder;
 		t._targetTable = this._targetTable;
 		t._sourceAlias = this._sourceAlias;
-		t._paramIdx = paramIdx;
 		return t;
 	}
 	whenMatchedThenUpdate(values, condition) {
-		let idx = this._paramIdx;
 		const set = [];
 		for (const [col, val] of Object.entries(values)) {
 			if (val !== undefined) {
 				set.push({
 					column: col,
-					value: param(idx, val)
+					value: param(0, val)
 				});
-				idx++;
 			}
 		}
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenMatchedUpdate(set, condExpr), idx);
+		return this._with(this._builder.whenMatchedUpdate(set, condExpr));
 	}
 	whenMatchedThenDelete(condition) {
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenMatchedDelete(condExpr), this._paramIdx);
+		return this._with(this._builder.whenMatchedDelete(condExpr));
 	}
 	whenNotMatchedThenInsert(row, condition) {
-		let idx = this._paramIdx;
 		const entries = Object.entries(row);
 		const columns = entries.map(([k]) => k);
-		const values = entries.map(([_, v]) => {
-			const p = param(idx, v);
-			idx++;
-			return p;
-		});
+		const values = entries.map(([_, v]) => param(0, v));
 		let condExpr;
 		if (condition) {
-			resetParams();
 			const proxies = createMergeProxies(this._targetTable, this._sourceAlias);
 			condExpr = unwrap(condition(proxies));
 		}
-		return this._with(this._builder.whenNotMatchedInsert(columns, values, condExpr), idx);
+		return this._with(this._builder.whenNotMatchedInsert(columns, values, condExpr));
 	}
 	with(name, query, recursive = false) {
-		return this._with(this._builder.with(name, query, recursive), this._paramIdx);
+		return this._with(this._builder.with(name, query, recursive));
 	}
 	build() {
 		return this._builder.build();

package/dist/builder/typed-select.d.mts

@@ -18,7 +18,8 @@ export declare class TypedSelectBuilder<
 	O
 > {
 	private _table;
-	constructor(builder: SelectBuilder, table?: string);
+	private _printer?;
+	constructor(builder: SelectBuilder, table?: string, printer?: Printer);
 	/** Select specific columns. Narrows O. */
 	select<K extends keyof O & string>(...cols: K[]): TypedSelectBuilder<DB, TB, Pick<O, K>>;
 	/** Select all columns. */
@@ -166,8 +167,10 @@ export declare class TypedSelectBuilder<
 	$if<O2>(condition: boolean, fn: (qb: TypedSelectBuilder<DB, TB, O>) => TypedSelectBuilder<DB, TB, O2>): TypedSelectBuilder<DB, TB, O | O2>;
 	/** Build the AST node. */
 	build(): SelectNode;
-	/** Compile to SQL. */
+	/** Compile to SQL with explicit printer. */
 	compile(printer: Printer): CompiledQuery;
+	/** Compile to SQL using the dialect's printer. */
+	toSQL(): CompiledQuery;
 	/** EXPLAIN this query. */
 	explain(options?: {
 		analyze?: boolean;

package/dist/builder/typed-select.mjs

@@ -1,28 +1,30 @@
 import { unwrap } from "../ast/typed-expression.mjs";
-import { createColumnProxies, resetParams } from "./eb.mjs";
+import { createColumnProxies } from "./eb.mjs";
 import { SelectBuilder } from "./select.mjs";
 
 export class TypedSelectBuilder {
 	
 	_builder;
 	_table;
-	constructor(builder, table) {
+	_printer;
+	constructor(builder, table, printer) {
 		this._builder = builder;
 		this._table = table ?? "";
+		this._printer = printer;
 	}
 	
 	select(...cols) {
-		return new TypedSelectBuilder(this._builder.columns(...cols), this._table);
+		return new TypedSelectBuilder(this._builder.columns(...cols), this._table, this._printer);
 	}
 	
 	selectAll() {
-		return new TypedSelectBuilder(this._builder.allColumns(), this._table);
+		return new TypedSelectBuilder(this._builder.allColumns(), this._table, this._printer);
 	}
 	
 	selectExpr(expr, alias) {
 		const node = unwrap(expr);
 		const aliased = aliasExpr(node, alias);
-		return new TypedSelectBuilder(this._builder.columns(aliased), this._table);
+		return new TypedSelectBuilder(this._builder.columns(aliased), this._table, this._printer);
 	}
 	
 	selectExprs(exprs) {
@@ -32,145 +34,142 @@ export class TypedSelectBuilder {
 			const aliased = aliasExpr(node, alias);
 			builder = builder.columns(aliased);
 		}
-		return new TypedSelectBuilder(builder, this._table);
+		return new TypedSelectBuilder(builder, this._table, this._printer);
 	}
 	
 	distinct() {
-		return new TypedSelectBuilder(this._builder.distinct(), this._table);
+		return new TypedSelectBuilder(this._builder.distinct(), this._table, this._printer);
 	}
 	
 	distinctOn(...cols) {
-		return new TypedSelectBuilder(this._builder.distinctOn(...cols), this._table);
+		return new TypedSelectBuilder(this._builder.distinctOn(...cols), this._table, this._printer);
 	}
 	
 	where(exprOrCallback) {
 		if (typeof exprOrCallback === "function") {
-			resetParams();
 			const cols = createColumnProxies(this._table);
 			const result = exprOrCallback(cols);
-			return new TypedSelectBuilder(this._builder.where(unwrap(result)), this._table);
+			return new TypedSelectBuilder(this._builder.where(unwrap(result)), this._table, this._printer);
 		}
-		return new TypedSelectBuilder(this._builder.where(unwrap(exprOrCallback)), this._table);
+		return new TypedSelectBuilder(this._builder.where(unwrap(exprOrCallback)), this._table, this._printer);
 	}
 	
 	orWhere(exprOrCallback) {
 		if (typeof exprOrCallback === "function") {
-			resetParams();
 			const cols = createColumnProxies(this._table);
 			const result = exprOrCallback(cols);
-			return new TypedSelectBuilder(this._builder.orWhere(unwrap(result)), this._table);
+			return new TypedSelectBuilder(this._builder.orWhere(unwrap(result)), this._table, this._printer);
 		}
-		return new TypedSelectBuilder(this._builder.orWhere(unwrap(exprOrCallback)), this._table);
+		return new TypedSelectBuilder(this._builder.orWhere(unwrap(exprOrCallback)), this._table, this._printer);
 	}
 	
 	innerJoin(table, onOrCallback) {
 		const on = resolveJoinOn(onOrCallback, this._table, table);
-		return new TypedSelectBuilder(this._builder.innerJoin(table, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.innerJoin(table, unwrap(on)), this._table, this._printer);
 	}
 	
 	leftJoin(table, onOrCallback) {
 		const on = resolveJoinOn(onOrCallback, this._table, table);
-		return new TypedSelectBuilder(this._builder.leftJoin(table, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.leftJoin(table, unwrap(on)), this._table, this._printer);
 	}
 	
 	rightJoin(table, onOrCallback) {
 		const on = resolveJoinOn(onOrCallback, this._table, table);
-		return new TypedSelectBuilder(this._builder.rightJoin(table, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.rightJoin(table, unwrap(on)), this._table, this._printer);
 	}
 	
 	groupBy(...cols) {
 		const resolved = cols.map((c) => typeof c === "string" ? c : unwrap(c));
-		return new TypedSelectBuilder(this._builder.groupBy(...resolved), this._table);
+		return new TypedSelectBuilder(this._builder.groupBy(...resolved), this._table, this._printer);
 	}
 	
 	having(exprOrCallback) {
 		if (typeof exprOrCallback === "function") {
-			resetParams();
 			const cols = createColumnProxies(this._table);
 			const result = exprOrCallback(cols);
-			return new TypedSelectBuilder(this._builder.having(unwrap(result)), this._table);
+			return new TypedSelectBuilder(this._builder.having(unwrap(result)), this._table, this._printer);
 		}
-		return new TypedSelectBuilder(this._builder.having(unwrap(exprOrCallback)), this._table);
+		return new TypedSelectBuilder(this._builder.having(unwrap(exprOrCallback)), this._table, this._printer);
 	}
 	
 	orderBy(col, direction = "ASC", nulls) {
 		const expr = typeof col === "string" ? col : unwrap(col);
-		return new TypedSelectBuilder(this._builder.orderBy(expr, direction, nulls), this._table);
+		return new TypedSelectBuilder(this._builder.orderBy(expr, direction, nulls), this._table, this._printer);
 	}
 	
 	limit(n) {
 		return new TypedSelectBuilder(this._builder.limit({
 			type: "literal",
 			value: n
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	offset(n) {
 		return new TypedSelectBuilder(this._builder.offset({
 			type: "literal",
 			value: n
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	forSystemTime(clause) {
-		return new TypedSelectBuilder(this._builder.forSystemTime(clause), this._table);
+		return new TypedSelectBuilder(this._builder.forSystemTime(clause), this._table, this._printer);
 	}
 	
 	forUpdate() {
-		return new TypedSelectBuilder(this._builder.forUpdate(), this._table);
+		return new TypedSelectBuilder(this._builder.forUpdate(), this._table, this._printer);
 	}
 	
 	forShare() {
-		return new TypedSelectBuilder(this._builder.forShare(), this._table);
+		return new TypedSelectBuilder(this._builder.forShare(), this._table, this._printer);
 	}
 	
 	forNoKeyUpdate() {
-		return new TypedSelectBuilder(this._builder.forNoKeyUpdate(), this._table);
+		return new TypedSelectBuilder(this._builder.forNoKeyUpdate(), this._table, this._printer);
 	}
 	
 	forKeyShare() {
-		return new TypedSelectBuilder(this._builder.forKeyShare(), this._table);
+		return new TypedSelectBuilder(this._builder.forKeyShare(), this._table, this._printer);
 	}
 	
 	skipLocked() {
-		return new TypedSelectBuilder(this._builder.skipLocked(), this._table);
+		return new TypedSelectBuilder(this._builder.skipLocked(), this._table, this._printer);
 	}
 	
 	noWait() {
-		return new TypedSelectBuilder(this._builder.noWait(), this._table);
+		return new TypedSelectBuilder(this._builder.noWait(), this._table, this._printer);
 	}
 	
 	with(name, query, recursive = false) {
-		return new TypedSelectBuilder(this._builder.with(name, query, recursive), this._table);
+		return new TypedSelectBuilder(this._builder.with(name, query, recursive), this._table, this._printer);
 	}
 	
 	union(query) {
-		return new TypedSelectBuilder(this._builder.union(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.union(query.build()), this._table, this._printer);
 	}
 	
 	unionAll(query) {
-		return new TypedSelectBuilder(this._builder.unionAll(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.unionAll(query.build()), this._table, this._printer);
 	}
 	
 	intersect(query) {
-		return new TypedSelectBuilder(this._builder.intersect(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.intersect(query.build()), this._table, this._printer);
 	}
 	
 	intersectAll(query) {
-		return new TypedSelectBuilder(this._builder.intersectAll(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.intersectAll(query.build()), this._table, this._printer);
 	}
 	
 	except(query) {
-		return new TypedSelectBuilder(this._builder.except(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.except(query.build()), this._table, this._printer);
 	}
 	
 	exceptAll(query) {
-		return new TypedSelectBuilder(this._builder.exceptAll(query.build()), this._table);
+		return new TypedSelectBuilder(this._builder.exceptAll(query.build()), this._table, this._printer);
 	}
 	
 	fullJoin(table, onOrCallback) {
 		const on = resolveJoinOn(onOrCallback, this._table, table);
-		return new TypedSelectBuilder(this._builder.join("FULL", table, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.join("FULL", table, unwrap(on)), this._table, this._printer);
 	}
 	
 	innerJoinLateral(subquery, alias, on) {
@@ -179,7 +178,7 @@ export class TypedSelectBuilder {
 			query: subquery.build(),
 			alias
 		};
-		return new TypedSelectBuilder(this._builder.innerJoinLateral(sub, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.innerJoinLateral(sub, unwrap(on)), this._table, this._printer);
 	}
 	
 	leftJoinLateral(subquery, alias, on) {
@@ -188,7 +187,7 @@ export class TypedSelectBuilder {
 			query: subquery.build(),
 			alias
 		};
-		return new TypedSelectBuilder(this._builder.leftJoinLateral(sub, unwrap(on)), this._table);
+		return new TypedSelectBuilder(this._builder.leftJoinLateral(sub, unwrap(on)), this._table, this._printer);
 	}
 	
 	innerJoinAs(table, alias, onCallback) {
@@ -202,7 +201,7 @@ export class TypedSelectBuilder {
 			type: "table_ref",
 			name: table,
 			alias
-		}, unwrap(on)), this._table);
+		}, unwrap(on)), this._table, this._printer);
 	}
 	
 	leftJoinAs(table, alias, onCallback) {
@@ -216,11 +215,11 @@ export class TypedSelectBuilder {
 			type: "table_ref",
 			name: table,
 			alias
-		}, unwrap(on)), this._table);
+		}, unwrap(on)), this._table, this._printer);
 	}
 	
 	crossJoin(table) {
-		return new TypedSelectBuilder(this._builder.join("CROSS", table), this._table);
+		return new TypedSelectBuilder(this._builder.join("CROSS", table), this._table, this._printer);
 	}
 	
 	crossJoinLateral(subquery, alias) {
@@ -229,56 +228,56 @@ export class TypedSelectBuilder {
 			query: subquery.build(),
 			alias
 		};
-		return new TypedSelectBuilder(this._builder.crossJoinLateral(sub), this._table);
+		return new TypedSelectBuilder(this._builder.crossJoinLateral(sub), this._table, this._printer);
 	}
 	
 	clearWhere() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			where: undefined
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearOrderBy() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			orderBy: []
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearLimit() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			limit: undefined
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearOffset() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			offset: undefined
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearGroupBy() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			groupBy: []
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearHaving() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			having: undefined
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	clearSelect() {
 		return new TypedSelectBuilder(new SelectBuilder({
 			...this._builder.build(),
 			columns: []
-		}), this._table);
+		}), this._table, this._printer);
 	}
 	
 	$call(fn) {
@@ -300,6 +299,13 @@ export class TypedSelectBuilder {
 		return printer.print(this.build());
 	}
 	
+	toSQL() {
+		if (!this._printer) {
+			throw new Error("toSQL() requires a printer. Use db.selectFrom() or pass a printer to compile().");
+		}
+		return this._printer.print(this.build());
+	}
+	
 	explain(options) {
 		const node = this.build();
 		const explainNode = {