pqb 0.68.0 → 0.69.0

package/dist/index.js

@@ -1704,6 +1704,44 @@ const columnCode = (type, ctx, key, code) => {
 	if (data.modifyQuery && !ctx.migration) addCode(code, `.modifyQuery(${data.modifyQuery.toString()})`);
 	return code.length === 1 && typeof code[0] === "string" ? code[0] : code;
 };
+/**
+* generic utility to add a parser to the query object
+* @param query - the query object, it will be mutated
+* @param key - the name of the column in the data loaded by the query
+* @param parser - function to process the value of the column with.
+*/
+const setParserToQuery = (query, key, parser) => {
+	if (parser) if (query.parsers) query.parsers[key] = parser;
+	else query.parsers = { [key]: parser };
+	else if (query.parsers) delete query.parsers[key];
+};
+const getQueryParsers = (q, hookSelect) => {
+	if (hookSelect) {
+		const parsers = { ...q.q.parsers };
+		const { defaultParsers } = q.q;
+		if (defaultParsers) for (const [key, value] of hookSelect) {
+			const parser = defaultParsers[key];
+			if (parser) parsers[value.as || key] = parser;
+		}
+		return parsers;
+	}
+	return q.q.select ? q.q.parsers : q.q.defaultParsers;
+};
+const addColumnParserToQuery = (q, key, column) => {
+	if (column._parse) setObjectValueImmutable(q, "parsers", key, column._parse);
+};
+const setValueParserToQuery = (q, column) => {
+	addColumnParserToQuery(q, "v", column);
+};
+const getValueParser = (parsers) => {
+	return parsers?.v;
+};
+const setValueParser = (q, parser) => {
+	setObjectValueImmutable(q, "parsers", "v", parser);
+};
+const addParserForRawExpression = (q, key, raw) => {
+	if (raw.result.value) addColumnParserToQuery(q.q, key, raw.result.value);
+};
 var CustomTypeColumn = class extends Column {
 	constructor(schema, typeName, typeSchema, extension) {
 		super(schema, schema.unknown(), schema.unknown(), schema.unknown());
@@ -1751,9 +1789,6 @@ var EnumColumn = class extends Column {
 		return `"${index === -1 ? name : `${name.slice(0, index)}"."${name.slice(index + 1)}`}"`;
 	}
 };
-const addColumnParserToQuery = (q, key, column) => {
-	if (column._parse) setObjectValueImmutable(q, "parsers", key, column._parse);
-};
 const setColumnDefaultParse = (column, parse) => {
 	column.data.parse = parse;
 	column._parse = (input) => input === null ? null : parse(input);
@@ -1795,174 +1830,6 @@ const setColumnEncode = (column, fn, inputSchema) => {
 const getColumnBaseType = (column, domainsMap, type) => {
 	return column instanceof EnumColumn ? "text" : column instanceof DomainColumn ? domainsMap[column.dataType]?.dataType : type;
 };
-const getValueKey = Symbol("get");
-let moveMutativeQueryToCte$1;
-const setMoveMutativeQueryToCte = (fn) => {
-	moveMutativeQueryToCte$1 = fn;
-};
-let prepareSubQueryForSql$1;
-const setPrepareSubQueryForSql = (fn) => {
-	prepareSubQueryForSql$1 = fn;
-};
-let dbClass;
-const setDb = (db) => {
-	dbClass = db;
-};
-function setQueryOperators(query, operators) {
-	const q = query.q;
-	if (q.operators !== operators) {
-		q.operators = operators;
-		Object.assign(query, operators);
-	}
-	return query;
-}
-/**
-* Makes operator function that has `_op` property.
-*
-* @param _op - function to turn the operator call into SQL.
-*/
-const make = (_op) => {
-	return Object.assign(function(value) {
-		const { q } = this;
-		const val = prepareOpArg(this, value);
-		(q.chain ??= []).push(_op, val || value);
-		if (q.parsers?.[getValueKey]) setObjectValueImmutable(q, "parsers", getValueKey, void 0);
-		return setQueryOperators(this, boolean);
-	}, { _op });
-};
-const makeVarArg = (_op) => {
-	return Object.assign(function(...args) {
-		const { q } = this;
-		args.forEach((arg, i) => {
-			const val = prepareOpArg(this, arg);
-			if (val) args[i] = val;
-		});
-		(q.chain ??= []).push(_op, args);
-		if (q.parsers?.[getValueKey]) setObjectValueImmutable(q, "parsers", getValueKey, void 0);
-		return setQueryOperators(this, boolean);
-	}, { _op });
-};
-const prepareOpArg = (q, arg) => {
-	return arg instanceof dbClass ? prepareSubQueryForSql$1(q, arg) : void 0;
-};
-const quoteValue = (arg, ctx, quotedAs, IN) => {
-	if (arg && typeof arg === "object") {
-		if (IN && isIterable(arg)) return `(${(Array.isArray(arg) ? arg : [...arg]).map((value) => addValue(ctx.values, value)).join(", ")})`;
-		if (isExpression(arg)) return arg.toSQL(ctx, quotedAs);
-		if ("toSQL" in arg) return `(${moveMutativeQueryToCte$1(ctx, arg)})`;
-		if (!(arg instanceof Date) && !Array.isArray(arg)) arg = JSON.stringify(arg);
-	}
-	return addValue(ctx.values, arg);
-};
-const quoteLikeValue = (arg, ctx, quotedAs, jsonArray) => {
-	if (arg && typeof arg === "object") {
-		if (!jsonArray && Array.isArray(arg)) return `(${arg.map((value) => addValue(ctx.values, value)).join(", ")})`;
-		if (isExpression(arg)) return arg.toSQL(ctx, quotedAs);
-		if ("toSQL" in arg) return `replace(replace((${moveMutativeQueryToCte$1(ctx, arg)}), '%', '\\\\%'), '_', '\\\\_')`;
-	}
-	return addValue(ctx.values, arg.replace(/[%_]/g, "\\$&"));
-};
-const base = {
-	equals: make((key, value, ctx, quotedAs) => value === null ? `${key} IS NULL` : `${key} = ${quoteValue(value, ctx, quotedAs)}`),
-	not: make((key, value, ctx, quotedAs) => value === null ? `${key} IS NOT NULL` : `${key} <> ${quoteValue(value, ctx, quotedAs)}`),
-	in: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "false" : `${key} IN ${quoteValue(value, ctx, quotedAs, true)}`),
-	notIn: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "true" : `NOT ${key} IN ${quoteValue(value, ctx, quotedAs, true)}`)
-};
-const ord = {
-	...base,
-	lt: make((key, value, ctx, quotedAs) => `${key} < ${quoteValue(value, ctx, quotedAs)}`),
-	lte: make((key, value, ctx, quotedAs) => `${key} <= ${quoteValue(value, ctx, quotedAs)}`),
-	gt: make((key, value, ctx, quotedAs) => `${key} > ${quoteValue(value, ctx, quotedAs)}`),
-	gte: make((key, value, ctx, quotedAs) => `${key} >= ${quoteValue(value, ctx, quotedAs)}`),
-	between: make((key, [from, to], ctx, quotedAs) => `${key} BETWEEN ${quoteValue(from, ctx, quotedAs)} AND ${quoteValue(to, ctx, quotedAs)}`)
-};
-const boolean = {
-	...ord,
-	and: make((key, value, ctx, quotedAs) => `${key} AND ${value.q.expr.toSQL(ctx, quotedAs)}`),
-	or: make((key, value, ctx, quotedAs) => `(${key}) OR (${value.q.expr.toSQL(ctx, quotedAs)})`)
-};
-const text = {
-	...base,
-	contains: make((key, value, ctx, quotedAs) => `${key} ILIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
-	containsSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
-	startsWith: make((key, value, ctx, quotedAs) => `${key} ILIKE ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
-	startsWithSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
-	endsWith: make((key, value, ctx, quotedAs) => `${key} ILIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)}`),
-	endsWithSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)}`)
-};
-const ordinalText = {
-	...ord,
-	...text
-};
-const encodeJsonPath = (ctx, path) => addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
-const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${addValue(ctx.values, path)}${options?.vars ? `, ${addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
-const shouldEncodeJson = (ctx) => ctx.q.adapter.driverAdapter.schemaConfig?.jsonEncodedByDriver === false;
-const quoteJsonValue = (arg, ctx, quotedAs, IN) => {
-	if (arg && typeof arg === "object") {
-		if (IN && Array.isArray(arg)) return `(${arg.map((value) => shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(value)) : addValue(ctx.values, value)).join(", ")})`;
-		if (Array.isArray(arg)) return shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(arg)) : addValue(ctx.values, arg);
-		if (isExpression(arg)) return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
-		if ("toSQL" in arg) return `to_jsonb((${moveMutativeQueryToCte$1(ctx, arg)}))`;
-	}
-	return addValue(ctx.values, JSON.stringify(arg)) + "::jsonb";
-};
-const serializeJsonValue = (arg, ctx, quotedAs) => {
-	if (arg && typeof arg === "object") {
-		if (isExpression(arg)) return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
-		if ("toSQL" in arg) return `to_jsonb((${moveMutativeQueryToCte$1(ctx, arg)}))`;
-	}
-	return addValue(ctx.values, JSON.stringify(arg));
-};
-const Operators = {
-	any: base,
-	boolean,
-	ordinalText,
-	number: ord,
-	date: ord,
-	time: ord,
-	text,
-	json: {
-		...ord,
-		equals: make((key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NULL` : `${key} = ${quoteJsonValue(value, ctx, quotedAs)}`),
-		not: make((key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NOT NULL` : `${key} != ${quoteJsonValue(value, ctx, quotedAs)}`),
-		in: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "false" : `${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`),
-		notIn: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "true" : `NOT ${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`),
-		jsonPathQueryFirst: Object.assign(function(path, options) {
-			const { q, columnTypes } = this;
-			const chain = q.chain ??= [];
-			chain.push(jsonPathQueryOp, [path, options]);
-			if (q.parsers?.[getValueKey]) setObjectValueImmutable(q, "parsers", getValueKey, void 0);
-			if (options?.type) {
-				const type = options.type(columnTypes);
-				addColumnParserToQuery(q, getValueKey, type);
-				chain.push = (...args) => {
-					chain.push = Array.prototype.push;
-					chain.push((s) => `${s}::${type.dataType}`, emptyArray);
-					return chain.push(...args);
-				};
-				return setQueryOperators(this, type.operators);
-			}
-			return this;
-		}, { _op: jsonPathQueryOp }),
-		jsonSupersetOf: make((key, value, ctx, quotedAs) => `${key} @> ${quoteValue(value, ctx, quotedAs)}`),
-		jsonSubsetOf: make((key, value, ctx, quotedAs) => `${key} <@ ${quoteValue(value, ctx, quotedAs)}`),
-		jsonSet: makeVarArg((key, [path, value], ctx, quotedAs) => `jsonb_set(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)})`),
-		jsonReplace: makeVarArg((key, [path, value], ctx, quotedAs) => `jsonb_set(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)}, false)`),
-		jsonInsert: makeVarArg((key, [path, value, options], ctx, quotedAs) => `jsonb_insert(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)}${options?.after ? ", true" : ""})`),
-		jsonRemove: makeVarArg((key, [path], ctx) => `(${key} #- ${encodeJsonPath(ctx, path)})`)
-	},
-	array: {
-		...ord,
-		has: make((key, value, ctx, quotedAs) => `${quoteValue(value, ctx, quotedAs)} = ANY(${key})`),
-		hasEvery: make((key, value, ctx, quotedAs) => `${key} @> ${quoteValue(value, ctx, quotedAs)}`),
-		hasSome: make((key, value, ctx, quotedAs) => `${key} && ${quoteValue(value, ctx, quotedAs)}`),
-		containedIn: make((key, value, ctx, quotedAs) => `${key} <@ ${quoteValue(value, ctx, quotedAs)}`),
-		length: make((key, value, ctx, quotedAs) => {
-			const expr = `COALESCE(array_length(${key}, 1), 0)`;
-			return typeof value === "number" ? `${expr} = ${quoteValue(value, ctx, quotedAs)}` : Object.keys(value).map((key) => ord[key]._op(expr, value[key], ctx, quotedAs)).join(" AND ");
-		})
-	}
-};
 const dateToString = (value) => value.toISOString();
 const dateTimeEncode = (value) => {
 	return typeof value === "number" ? new Date(value) : value;
@@ -2090,7 +1957,6 @@ var ArrayColumn = class ArrayColumn extends Column {
 		this.dataType = "array";
 		this.operators = Operators.array;
 		item.data.isNullable = true;
-		setColumnDefaultParse(this, (input) => parse$1.call(this, input));
 		if (defaultEncode) setColumnDefaultEncode(this, defaultEncode);
 		this.data.item = item instanceof ArrayColumn ? item.data.item : item;
 		this.data.name = item.data.name;
@@ -2116,54 +1982,6 @@ var ArrayColumn = class ArrayColumn extends Column {
 		return columnCode(this, ctx, key, code);
 	}
 };
-const parse$1 = function(source) {
-	if (typeof source !== "string") return source;
-	const entries = [];
-	parsePostgresArray(source, entries, this.data.item.data.parseItem);
-	return entries;
-};
-/**
-* based on https://github.com/bendrucker/postgres-array/tree/master
-* and slightly optimized
-*/
-const parsePostgresArray = (source, entries, transform) => {
-	let pos = 0;
-	if (source[0] === "[") {
-		pos = source.indexOf("=") + 1;
-		if (!pos) pos = source.length;
-	}
-	if (source[pos] === "{") pos++;
-	let recorded = "";
-	while (pos < source.length) {
-		const character = source[pos++];
-		if (character === "{") {
-			const innerEntries = [];
-			entries.push(innerEntries);
-			pos += parsePostgresArray(source.slice(pos - 1), innerEntries, transform) - 1;
-		} else if (character === "}") {
-			if (recorded) entries.push(recorded === "NULL" ? null : transform ? transform(recorded) : recorded);
-			return pos;
-		} else if (character === "\"") {
-			let esc = false;
-			let rec = "";
-			while (pos < source.length) {
-				let char;
-				while ((char = source[pos++]) === "\\") if (!(esc = !esc)) rec += "\\";
-				if (esc) esc = false;
-				else if (char === "\"") break;
-				rec += char;
-			}
-			entries.push(transform ? transform(rec) : rec);
-			recorded = "";
-		} else if (character === ",") {
-			if (recorded) {
-				entries.push(recorded === "NULL" ? null : transform ? transform(recorded) : recorded);
-				recorded = "";
-			}
-		} else recorded += character;
-	}
-	return pos;
-};
 const encodeJson = (x) => x === null ? x : JSON.stringify(x);
 var JSONColumn = class extends Column {
 	constructor(schema, __inputType, encodedByDriver = true) {
@@ -2419,6 +2237,202 @@ const defaultSchemaConfig = (options) => {
 	return schemaConfig;
 };
 const internalSchemaConfig = defaultSchemaConfig();
+var BooleanColumn = class BooleanColumn extends Column {
+	static get instance() {
+		return this._instance ??= new BooleanColumn(internalSchemaConfig);
+	}
+	static get instanceSkipValueToArray() {
+		let instance = this._instanceSkipValueToArray;
+		if (!instance) {
+			instance = this._instanceSkipValueToArray = Object.create(this.instance);
+			instance.data.skipValueToArray = true;
+		}
+		return instance;
+	}
+	constructor(schema) {
+		super(schema, schema.boolean());
+		this.dataType = "bool";
+		this.operators = Operators.boolean;
+		this.data.alias = "boolean";
+		this.data.parseItem = parseItem;
+	}
+	toCode(ctx, key) {
+		return columnCode(this, ctx, key, "boolean()");
+	}
+};
+const parseItem = (input) => input[0] === "t";
+let moveMutativeQueryToCte$1;
+const setMoveMutativeQueryToCte = (fn) => {
+	moveMutativeQueryToCte$1 = fn;
+};
+let prepareSubQueryForSql$1;
+const setPrepareSubQueryForSql = (fn) => {
+	prepareSubQueryForSql$1 = fn;
+};
+let dbClass;
+const setDb = (db) => {
+	dbClass = db;
+};
+function setQueryOperators(query, operators) {
+	const q = query.q;
+	if (q.operators !== operators) {
+		q.operators = operators;
+		Object.assign(query, operators);
+	}
+	return query;
+}
+/**
+* Makes operator function that has `_op` property.
+*
+* @param _op - function to turn the operator call into SQL.
+*/
+const make = (_op) => {
+	return Object.assign(function(value) {
+		const { q } = this;
+		const val = prepareOpArg(this, value);
+		(q.chain ??= []).push(_op, val || value);
+		if (getValueParser(q.parsers)) setValueParser(q, void 0);
+		q.getColumn = BooleanColumn.instance;
+		return setQueryOperators(this, boolean);
+	}, { _op });
+};
+const makeVarArg = (_op) => {
+	return Object.assign(function(...args) {
+		const { q } = this;
+		args.forEach((arg, i) => {
+			const val = prepareOpArg(this, arg);
+			if (val) args[i] = val;
+		});
+		(q.chain ??= []).push(_op, args);
+		if (getValueParser(q.parsers)) setValueParser(q, void 0);
+		return setQueryOperators(this, boolean);
+	}, { _op });
+};
+const prepareOpArg = (q, arg) => {
+	return arg instanceof dbClass ? prepareSubQueryForSql$1(q, arg) : void 0;
+};
+const quoteValue = (arg, ctx, quotedAs, IN) => {
+	if (arg && typeof arg === "object") {
+		if (IN && isIterable(arg)) return `(${(Array.isArray(arg) ? arg : [...arg]).map((value) => addValue(ctx.values, value)).join(", ")})`;
+		if (isExpression(arg)) return arg.toSQL(ctx, quotedAs);
+		if ("toSQL" in arg) return `(${moveMutativeQueryToCte$1(ctx, arg)})`;
+		if (!(arg instanceof Date) && !Array.isArray(arg)) arg = JSON.stringify(arg);
+	}
+	return addValue(ctx.values, arg);
+};
+const quoteLikeValue = (arg, ctx, quotedAs, jsonArray) => {
+	if (arg && typeof arg === "object") {
+		if (!jsonArray && Array.isArray(arg)) return `(${arg.map((value) => addValue(ctx.values, value)).join(", ")})`;
+		if (isExpression(arg)) return arg.toSQL(ctx, quotedAs);
+		if ("toSQL" in arg) return `replace(replace((${moveMutativeQueryToCte$1(ctx, arg)}), '%', '\\\\%'), '_', '\\\\_')`;
+	}
+	return addValue(ctx.values, arg.replace(/[%_]/g, "\\$&"));
+};
+const base = {
+	equals: make((key, value, ctx, quotedAs) => value === null ? `${key} IS NULL` : `${key} = ${quoteValue(value, ctx, quotedAs)}`),
+	not: make((key, value, ctx, quotedAs) => value === null ? `${key} IS NOT NULL` : `${key} <> ${quoteValue(value, ctx, quotedAs)}`),
+	isDistinctFrom: make((key, value, ctx, quotedAs) => `${key} IS DISTINCT FROM ${quoteValue(value, ctx, quotedAs)}`),
+	isNotDistinctFrom: make((key, value, ctx, quotedAs) => `${key} IS NOT DISTINCT FROM ${quoteValue(value, ctx, quotedAs)}`),
+	in: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "false" : `${key} IN ${quoteValue(value, ctx, quotedAs, true)}`),
+	notIn: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "true" : `NOT ${key} IN ${quoteValue(value, ctx, quotedAs, true)}`)
+};
+const ord = {
+	...base,
+	lt: make((key, value, ctx, quotedAs) => `${key} < ${quoteValue(value, ctx, quotedAs)}`),
+	lte: make((key, value, ctx, quotedAs) => `${key} <= ${quoteValue(value, ctx, quotedAs)}`),
+	gt: make((key, value, ctx, quotedAs) => `${key} > ${quoteValue(value, ctx, quotedAs)}`),
+	gte: make((key, value, ctx, quotedAs) => `${key} >= ${quoteValue(value, ctx, quotedAs)}`),
+	between: make((key, [from, to], ctx, quotedAs) => `${key} BETWEEN ${quoteValue(from, ctx, quotedAs)} AND ${quoteValue(to, ctx, quotedAs)}`)
+};
+const boolean = {
+	...ord,
+	and: make((key, value, ctx, quotedAs) => `${key} AND ${value.q.expr.toSQL(ctx, quotedAs)}`),
+	or: make((key, value, ctx, quotedAs) => `(${key}) OR (${value.q.expr.toSQL(ctx, quotedAs)})`)
+};
+const text = {
+	...base,
+	contains: make((key, value, ctx, quotedAs) => `${key} ILIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
+	containsSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
+	startsWith: make((key, value, ctx, quotedAs) => `${key} ILIKE ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
+	startsWithSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE ${quoteLikeValue(value, ctx, quotedAs)} || '%'`),
+	endsWith: make((key, value, ctx, quotedAs) => `${key} ILIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)}`),
+	endsWithSensitive: make((key, value, ctx, quotedAs) => `${key} LIKE '%' || ${quoteLikeValue(value, ctx, quotedAs)}`)
+};
+const ordinalText = {
+	...ord,
+	...text
+};
+const encodeJsonPath = (ctx, path) => addValue(ctx.values, `{${Array.isArray(path) ? path.join(", ") : path}}`);
+const jsonPathQueryOp = (key, [path, options], ctx) => `jsonb_path_query_first(${key}, ${addValue(ctx.values, path)}${options?.vars ? `, ${addValue(ctx.values, JSON.stringify(options.vars))}${options.silent ? ", true" : ""}` : options?.silent ? ", NULL, true" : ""})`;
+const shouldEncodeJson = (ctx) => ctx.q.adapter.driverAdapter.schemaConfig?.jsonEncodedByDriver === false;
+const quoteJsonValue = (arg, ctx, quotedAs, IN) => {
+	if (arg && typeof arg === "object") {
+		if (IN && Array.isArray(arg)) return `(${arg.map((value) => shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(value)) : addValue(ctx.values, value)).join(", ")})`;
+		if (Array.isArray(arg)) return shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(arg)) : addValue(ctx.values, arg);
+		if (isExpression(arg)) return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
+		if ("toSQL" in arg) return `to_jsonb((${moveMutativeQueryToCte$1(ctx, arg)}))`;
+	}
+	return shouldEncodeJson(ctx) ? addValue(ctx.values, JSON.stringify(arg)) : addValue(ctx.values, arg);
+};
+const serializeJsonValue = (arg, ctx, quotedAs) => {
+	if (arg && typeof arg === "object") {
+		if (isExpression(arg)) return "to_jsonb(" + arg.toSQL(ctx, quotedAs) + ")";
+		if ("toSQL" in arg) return `to_jsonb((${moveMutativeQueryToCte$1(ctx, arg)}))`;
+	}
+	return addValue(ctx.values, JSON.stringify(arg));
+};
+const Operators = {
+	any: base,
+	boolean,
+	ordinalText,
+	number: ord,
+	date: ord,
+	time: ord,
+	text,
+	json: {
+		...ord,
+		equals: make((key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NULL` : `${key} = ${quoteJsonValue(value, ctx, quotedAs)}`),
+		not: make((key, value, ctx, quotedAs) => value === null ? `nullif(${key}, 'null'::jsonb) IS NOT NULL` : `${key} != ${quoteJsonValue(value, ctx, quotedAs)}`),
+		isDistinctFrom: make((key, value, ctx, quotedAs) => `${key} IS DISTINCT FROM ${quoteJsonValue(value, ctx, quotedAs)}`),
+		isNotDistinctFrom: make((key, value, ctx, quotedAs) => `${key} IS NOT DISTINCT FROM ${quoteJsonValue(value, ctx, quotedAs)}`),
+		in: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "false" : `${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`),
+		notIn: make((key, value, ctx, quotedAs) => Array.isArray(value) && !value.length ? "true" : `NOT ${key} IN ${quoteJsonValue(value, ctx, quotedAs, true)}`),
+		jsonPathQueryFirst: Object.assign(function(path, options) {
+			const { q, columnTypes } = this;
+			const chain = q.chain ??= [];
+			chain.push(jsonPathQueryOp, [path, options]);
+			if (getValueParser(q.parsers)) setValueParser(q, void 0);
+			if (options?.type) {
+				const type = options.type(columnTypes);
+				setValueParserToQuery(q, type);
+				chain.push = (...args) => {
+					chain.push = Array.prototype.push;
+					chain.push((s) => `${s}::${type.dataType}`, emptyArray);
+					return chain.push(...args);
+				};
+				return setQueryOperators(this, type.operators);
+			}
+			return this;
+		}, { _op: jsonPathQueryOp }),
+		jsonSupersetOf: make((key, value, ctx, quotedAs) => `${key} @> ${quoteValue(value, ctx, quotedAs)}`),
+		jsonSubsetOf: make((key, value, ctx, quotedAs) => `${key} <@ ${quoteValue(value, ctx, quotedAs)}`),
+		jsonSet: makeVarArg((key, [path, value], ctx, quotedAs) => `jsonb_set(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)})`),
+		jsonReplace: makeVarArg((key, [path, value], ctx, quotedAs) => `jsonb_set(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)}, false)`),
+		jsonInsert: makeVarArg((key, [path, value, options], ctx, quotedAs) => `jsonb_insert(${key}, ${encodeJsonPath(ctx, path)}, ${serializeJsonValue(value, ctx, quotedAs)}${options?.after ? ", true" : ""})`),
+		jsonRemove: makeVarArg((key, [path], ctx) => `(${key} #- ${encodeJsonPath(ctx, path)})`)
+	},
+	array: {
+		...ord,
+		has: make((key, value, ctx, quotedAs) => `${quoteValue(value, ctx, quotedAs)} = ANY(${key})`),
+		hasEvery: make((key, value, ctx, quotedAs) => `${key} @> ${quoteValue(value, ctx, quotedAs)}`),
+		hasSome: make((key, value, ctx, quotedAs) => `${key} && ${quoteValue(value, ctx, quotedAs)}`),
+		containedIn: make((key, value, ctx, quotedAs) => `${key} <@ ${quoteValue(value, ctx, quotedAs)}`),
+		length: make((key, value, ctx, quotedAs) => {
+			const expr = `COALESCE(array_length(${key}, 1), 0)`;
+			return typeof value === "number" ? `${expr} = ${quoteValue(value, ctx, quotedAs)}` : Object.keys(value).map((key) => ord[key]._op(expr, value[key], ctx, quotedAs)).join(" AND ");
+		})
+	}
+};
 var TextBaseColumn = class extends Column {
 	constructor(schema, schemaType = schema.stringSchema()) {
 		super(schema, schemaType);
@@ -2778,22 +2792,6 @@ var CitextColumn = class extends TextBaseColumn {
 		return textColumnToCode(this, ctx, key);
 	}
 };
-var BooleanColumn = class BooleanColumn extends Column {
-	static get instance() {
-		return this._instance ??= new BooleanColumn(internalSchemaConfig);
-	}
-	constructor(schema) {
-		super(schema, schema.boolean());
-		this.dataType = "bool";
-		this.operators = Operators.boolean;
-		this.data.alias = "boolean";
-		this.data.parseItem = parseItem;
-	}
-	toCode(ctx, key) {
-		return columnCode(this, ctx, key, "boolean()");
-	}
-};
-const parseItem = (input) => input[0] === "t";
 var SimpleRawSQL = class extends RawSql {
 	makeSQL() {
 		return this._sql;
@@ -3430,29 +3428,6 @@ var QueryHooks = class {
 	}
 };
 /**
-* generic utility to add a parser to the query object
-* @param query - the query object, it will be mutated
-* @param key - the name of the column in the data loaded by the query
-* @param parser - function to process the value of the column with.
-*/
-const setParserToQuery = (query, key, parser) => {
-	if (parser) if (query.parsers) query.parsers[key] = parser;
-	else query.parsers = { [key]: parser };
-	else if (query.parsers) delete query.parsers[key];
-};
-const getQueryParsers = (q, hookSelect) => {
-	if (hookSelect) {
-		const parsers = { ...q.q.parsers };
-		const { defaultParsers } = q.q;
-		if (defaultParsers) for (const [key, value] of hookSelect) {
-			const parser = defaultParsers[key];
-			if (parser) parsers[value.as || key] = parser;
-		}
-		return parsers;
-	}
-	return q.q.select ? q.q.parsers : q.q.defaultParsers;
-};
-/**
 * In snake case mode, or when columns have custom names,
 * use this method to exchange a db column name to its runtime key.
 */
@@ -4503,7 +4478,7 @@ const requirePrimaryKeys = (q, message) => {
 };
 const collectPrimaryKeys = (q) => {
 	const primaryKeys = [];
-	const { shape } = q.q;
+	const { shape } = q;
 	for (const key in shape) if (shape[key].data.primaryKey) primaryKeys.push(key);
 	const pkey = q.internal.tableData.primaryKey;
 	if (pkey) primaryKeys.push(...pkey.columns);
@@ -4745,7 +4720,7 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
 		}
 		const { tableHook, cteHooks } = sql;
 		const { returnType = "all" } = query;
-		const tempReturnType = tableHook?.select || cteHooks?.hasSelect || returnType === "rows" && (q.q.batchParsers || adapter.driverAdapter.noFieldsForArrays) || checkIfNeedResultAllForMutativeQueriesSelectRelations(sql) ? "all" : returnType;
+		const tempReturnType = tableHook?.select || cteHooks?.hasSelect || q.q.batchParsers || adapter.driverAdapter.noFieldsForArrays || checkIfNeedResultAllForMutativeQueriesSelectRelations(sql) ? "all" : returnType;
 		let result;
 		let queryResult;
 		let cteData;
@@ -5001,12 +4976,25 @@ const execQuery = (adapter, method, sql, startingSavepoint, releasingSavepoint,
 	});
 };
 const handleResult = (q, returnType, result, sql, isSubQuery) => {
-	const parsers = getQueryParsers(q, sql.tableHook?.select);
+	let parsers = getQueryParsers(q, sql.tableHook?.select);
 	switch (returnType) {
 		case "all": {
 			if (q.q.throwOnNotFound && result.rows.length === 0) throw new NotFoundError(q);
 			const { rows } = result;
-			if (parsers) for (const row of rows) parseRecord(parsers, row);
+			if (q.q.returnType === "value" || q.q.returnType === "valueOrThrow") {
+				if (!rows.length) if (!q.q.select) return rows;
+				else {
+					if (q.q.returnType === "valueOrThrow") throw new NotFoundError(q);
+					return [{ value: q.q.notFoundDefault }];
+				}
+				if (parsers) {
+					const parser = getValueParser(parsers);
+					if (parser) {
+						const hookSelect = sql.tableHook?.select;
+						for (const row of rows) for (const key in row) if (!hookSelect?.has(key)) row[key] = parser(row[key]);
+					}
+				}
+			} else if (parsers) for (const row of rows) parseRecord(parsers, row);
 			return rows;
 		}
 		case "one": {
@@ -5028,7 +5016,7 @@ const handleResult = (q, returnType, result, sql, isSubQuery) => {
 		}
 		case "pluck": {
 			const { rows } = result;
-			parsePluck(parsers, isSubQuery, rows);
+			parsePluck(q, parsers, isSubQuery, rows);
 			return rows;
 		}
 		case "value": {
@@ -5065,14 +5053,26 @@ const parseRows = (parsers, fields, rows) => {
 		if (parser) for (const row of rows) row[i] = parser(row[i]);
 	}
 };
-const parsePluck = (parsers, isSubQuery, rows) => {
-	const pluck = parsers?.pluck;
-	if (pluck) for (let i = 0; i < rows.length; i++) rows[i] = pluck(isSubQuery ? rows[i] : rows[i][0]);
+const parsePluck = (query, parsers, isSubQuery, rows) => {
+	const valueToArray = query.q.getColumn?.data?.valueToArray;
+	const parse = parsers?.pluck;
+	if (parse) if (valueToArray) for (let i = 0; i < rows.length; i++) {
+		const value = isSubQuery ? rows[i] : rows[i][0];
+		rows[i] = value === null ? void 0 : value[0] === null ? null : parse(value[0]);
+	}
+	else for (let i = 0; i < rows.length; i++) {
+		const value = isSubQuery ? rows[i] : rows[i][0];
+		rows[i] = value === null ? value : parse(value);
+	}
+	else if (valueToArray) for (let i = 0; i < rows.length; i++) {
+		const value = isSubQuery ? rows[i] : rows[i][0];
+		rows[i] = value === null ? void 0 : value[0];
+	}
 	else if (!isSubQuery) for (let i = 0; i < rows.length; i++) rows[i] = rows[i][0];
 };
 const parseValue = (value, parsers) => {
-	const parser = parsers?.[getValueKey];
-	return parser ? parser(value) : value;
+	const parse = getValueParser(parsers);
+	return parse ? parse(value) : value;
 };
 const filterResult = (q, returnType, queryResult, result, tempColumns, hasAfterHook) => {
 	if (returnType === "all") return filterAllResult(result, tempColumns, hasAfterHook);
@@ -5105,7 +5105,7 @@ const filterResult = (q, returnType, queryResult, result, tempColumns, hasAfterH
 	}
 };
 const getFirstResultKey = (q, queryResult) => {
-	if (q.q.select) return queryResult.fields[0].name;
+	if (q.q.select) return queryResult.fields[0] ? queryResult.fields[0].name : "value";
 	else for (const key in q.q.selectedComputeds) return key;
 };
 const filterAllResult = (result, tempColumns, hasAfterHook) => {
@@ -5364,7 +5364,7 @@ function queryFrom(self, arg) {
 	if (typeof arg === "string") {
 		data.as ||= arg;
 		const w = data.withShapes?.[arg];
-		data.shape = w?.shape ?? anyShape;
+		data.selectShape = w?.shape ?? anyShape;
 		data.runtimeComputeds = w?.computeds;
 		const parsers = {};
 		data.defaultParsers = parsers;
@@ -5375,7 +5375,7 @@ function queryFrom(self, arg) {
 			arg = arg.slice(i + 1);
 		} else if (w) data.schema = void 0;
 	} else if (Array.isArray(arg)) {
-		const shape = { ...data.shape };
+		const shape = { ...data.selectShape };
 		const joinedParsers = {};
 		for (const item of arg) if (typeof item === "string") {
 			const w = data.withShapes[item];
@@ -5397,7 +5397,7 @@ function queryFrom(self, arg) {
 	} else {
 		const q = prepareSubQueryForSql(self, arg);
 		data.as ||= q.q.as || q.table || "t";
-		data.shape = getShapeFromSelect(q, true);
+		data.selectShape = getShapeFromSelect(q, true);
 		data.defaultParsers = getQueryParsers(q);
 		data.batchParsers = q.q.batchParsers;
 	}
@@ -5594,7 +5594,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, shape, whereExists,
 		const j = joinTo.qb.baseQuery.clone();
 		j.table = first;
 		j.q = {
-			shape: w.shape,
+			selectShape: w.shape,
 			runtimeComputeds: w.computeds,
 			adapter: joinToQ.adapter,
 			handleResult: joinToQ.handleResult,
@@ -5676,7 +5676,7 @@ const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo, shape) => {
 	q.q.joinedShapes = joinedShapes;
 	q.q.joinTo = joinTo;
 	if (q.q.scopes) q.q.scopes = void 0;
-	if (shape) q.q.shape = shape;
+	if (shape) q.q.selectShape = shape;
 	return q;
 };
 const isRelationQuery = (q) => "joinQuery" in q;
@@ -6503,7 +6503,7 @@ const _chain = (fromQuery, toQuery, rel) => {
 	}];
 	_applyRelationAliases(self, q);
 	q.joinedShapes = {
-		[getQueryAs(self)]: self.q.shape,
+		[getQueryAs(self)]: self.q.selectShape,
 		...self.q.joinedShapes
 	};
 	rel.modifyRelatedQuery?.(query)?.(self);
@@ -6540,131 +6540,78 @@ const resolveSubQueryCallback = (q, cb) => {
 	_setSubQueryAliases(arg);
 	return cb(arg);
 };
-/**
-* Acts as {@link simpleExistingColumnToSQL} except that the column is optional and will return quoted key if no column.
-*/
-function simpleColumnToSQL(ctx, key, column, quotedAs) {
-	if (!column) return `"${key}"`;
-	const { data } = column;
-	return data.computed ? `(${data.computed.toSQL(ctx, quotedAs)})` : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-}
-function simpleExistingColumnToSQL(ctx, key, column, quotedAs) {
-	const { data } = column;
-	return data.computed ? `(${data.computed.toSQL(ctx, quotedAs)})` : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-}
-const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
-	let index = column.indexOf(".");
-	if (index === -1) {
-		const joinAs = data.valuesJoinedAs?.[column];
-		if (joinAs) {
-			column = joinAs + "." + column;
-			index = joinAs.length;
+function simpleColumnToSQL(ctx, queryData, shape, key, column, quotedAs, select, as, jsonList, useSelectList, skipSelectSql, skipValueToArray) {
+	let sql;
+	let dontAlias;
+	if (useSelectList && queryData.select) {
+		for (const s of queryData.select) if (typeof s === "object" && "selectAs" in s) {
+			if (key in s.selectAs) {
+				dontAlias = true;
+				sql = simpleColumnToSQL(ctx, queryData, shape, key, shape[key], void 0, void 0, void 0, void 0, void 0, void 0, true);
+				break;
+			}
 		}
 	}
-	if (index !== -1) return columnWithDotToSql(ctx, data, shape, column, index, quotedAs, select);
-	return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
-};
-const selectedColumnToSql = (ctx, data, shape, column, quotedAs) => {
-	const index = column.indexOf(".");
-	return index !== -1 ? selectedColumnWithDotToSql(ctx, data, shape, column, index, quotedAs) : selectedSimpleColumnToSql(ctx, column, shape[column], quotedAs);
-};
-const selectedSimpleColumnToSql = (ctx, key, column, quotedAs) => {
-	if (!column) return `"${key}"`;
-	const { data } = column;
-	return data.selectSql ? `(${data.selectSql.toSQL(ctx, quotedAs)})` : `${quotedAs ? `${quotedAs}.` : ""}"${data.name || key}"`;
-};
-/**
-* in a case when ordering or grouping by a column which was selected as expression:
-* ```ts
-* table.select({ x: (q) => q.sum('x') }).group('x').order('x')
-* ```
-* the column must not be prefixed with a table name.
-*/
-const maybeSelectedColumnToSql = (ctx, data, column, quotedAs) => {
-	const index = column.indexOf(".");
-	if (index !== -1) return columnWithDotToSql(ctx, data, data.shape, column, index, quotedAs);
-	else {
-		if (data.joinedShapes?.[column]) return `"${column}"."${column}"`;
-		if (data.select) {
-			for (const s of data.select) if (typeof s === "object" && "selectAs" in s) {
-				if (column in s.selectAs) return simpleColumnToSQL(ctx, column, data.shape[column]);
+	if (!sql) if (!column) {
+		dontAlias = key === as;
+		sql = `${quotedAs ? `${quotedAs}.` : ""}"${key}"`;
+	} else {
+		if (jsonList && as) jsonList[as] = column && getSelectedColumnData(column);
+		const { data } = column;
+		if (select && data.selectSql && !skipSelectSql) sql = `(${data.selectSql.toSQL(ctx, quotedAs)})`;
+		else if (data.computed) sql = `(${data.computed.toSQL(ctx, quotedAs)})`;
+		else {
+			const name = data.name || key;
+			dontAlias = name === as;
+			if (!select) {
+				const joinAs = !select && queryData.valuesJoinedAs?.[key];
+				if (joinAs) quotedAs = `"${joinAs}"`;
 			}
+			sql = `${quotedAs ? `${quotedAs}.` : ""}"${name}"`;
 		}
-		return simpleColumnToSQL(ctx, column, data.shape[column], quotedAs);
-	}
-};
-const columnWithDotToSql = (ctx, data, shape, column, index, quotedAs, select) => {
-	const table = column.slice(0, index);
-	const key = column.slice(index + 1);
-	if (key === "*") {
-		const shape = data.joinedShapes?.[table];
-		return shape ? select ? makeRowToJson(ctx, table, shape, true) : `"${table}".*` : column;
-	}
-	const tableName = _getQueryAliasOrName(data, table);
-	const quoted = `"${table}"`;
-	const col = quoted === quotedAs ? shape[key] : data.joinedShapes?.[tableName]?.[key];
-	if (col) {
-		if (col.data.name) return `"${tableName}"."${col.data.name}"`;
-		if (col.data.computed) return `(${col.data.computed.toSQL(ctx, quoted)})`;
-		return `"${tableName}"."${key}"`;
-	}
-	return `"${tableName}"."${key}"`;
-};
-const selectedColumnWithDotToSql = (ctx, data, shape, column, index, quotedAs) => {
-	const table = column.slice(0, index);
-	const key = column.slice(index + 1);
-	if (key === "*") {
-		const shape = data.joinedShapes?.[table];
-		return shape ? makeRowToJson(ctx, table, shape, true) : column;
-	}
-	const tableName = _getQueryAliasOrName(data, table);
-	const quoted = `"${table}"`;
-	const col = quoted === quotedAs ? shape[key] : data.joinedShapes?.[tableName]?.[key];
-	if (col) {
-		if (col.data.selectSql) return `(${col.data.selectSql.toSQL(ctx, quoted)})`;
-		if (col.data.name) return `"${tableName}"."${col.data.name}"`;
 	}
-	return `"${tableName}"."${key}"`;
-};
-const columnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
-	const index = column.indexOf(".");
-	return index !== -1 ? tableColumnToSqlWithAs(ctx, data, column, column.slice(0, index), column.slice(index + 1), as, quotedAs, select, jsonList) : ownColumnToSqlWithAs(ctx, data, column, as, quotedAs, select, jsonList);
-};
-const tableColumnToSqlWithAs = (ctx, data, column, table, key, as, quotedAs, select, jsonList) => {
+	if (!select && !useSelectList && column?.data.valueToArray && !column.data.skipValueToArray) sql += "[1]";
+	else if (queryData.getColumn?.data.valueToArray && !skipValueToArray) sql = `array[${sql}]`;
+	if (as && !dontAlias) sql = `${sql} "${as}"`;
+	return sql;
+}
+const tableColumnToSql = (ctx, queryData, shape, table, key, quotedAs, select, as, jsonList, skipValueToArray) => {
+	let sql;
+	let dontAlias;
 	if (key === "*") {
-		if (jsonList) jsonList[as] = void 0;
-		const shape = data.joinedShapes?.[table];
-		if (shape) {
-			if (select) return makeRowToJson(ctx, table, shape, true) + ` "${as}"`;
-			return `"${table}"."${table}" "${as}"`;
+		if (jsonList && as) jsonList[as] = void 0;
+		const shape = queryData.joinedShapes?.[table];
+		if (shape) sql = select ? makeRowToJson(ctx, table, shape, true) : `"${table}".*`;
+		else {
+			sql = `"${table}"."${key}"`;
+			dontAlias = true;
 		}
-		return column;
-	}
-	const tableName = _getQueryAliasOrName(data, table);
-	const quoted = `"${table}"`;
-	const col = quoted === quotedAs ? data.shape[key] : data.joinedShapes?.[tableName][key];
-	if (jsonList) jsonList[as] = col && getSelectedColumnData(col);
-	if (col) {
-		if (col.data.selectSql) return `(${col.data.selectSql.toSQL(ctx, quoted)}) "${as}"`;
-		if (col.data.name && col.data.name !== key) return `"${tableName}"."${col.data.name}" "${as}"`;
+	} else {
+		const tableName = _getQueryAliasOrName(queryData, table);
+		const quoted = `"${table}"`;
+		const col = quoted === quotedAs ? shape[key] : queryData.joinedShapes?.[tableName]?.[key];
+		if (jsonList && as) jsonList[as] = col && getSelectedColumnData(col);
+		if (col?.data.selectSql) sql = `(${col.data.selectSql.toSQL(ctx, quoted)})`;
+		else if (col?.data.name) sql = `"${tableName}"."${col.data.name}"`;
+		else if (col?.data.computed) sql = `(${col.data.computed.toSQL(ctx, quoted)})`;
+		else {
+			sql = `"${tableName}"."${key}"`;
+			dontAlias = key === as;
+		}
+		if (!select && col?.data.valueToArray && !col.data.skipValueToArray) sql += "[1]";
+		else if (queryData.getColumn?.data.valueToArray && !skipValueToArray) sql = `array[${sql}]`;
 	}
-	return `"${tableName}"."${key}"${key === as ? "" : ` "${as}"`}`;
+	if (as && !dontAlias) sql = `${sql} "${as}"`;
+	return sql;
 };
-const ownColumnToSqlWithAs = (ctx, data, column, as, quotedAs, select, jsonList) => {
-	if (!select && data.joinedShapes?.[column]) {
-		if (jsonList) jsonList[as] = void 0;
-		return `"${column}"."${column}" "${as}"`;
-	}
-	const col = data.shape[column];
-	if (jsonList) jsonList[as] = col && getSelectedColumnData(col);
-	if (col) {
-		if (col.data.selectSql) return `(${col.data.selectSql.toSQL(ctx, quotedAs)}) "${as}"`;
-		if (col.data.name && col.data.name !== column) return `${quotedAs ? `${quotedAs}.` : ""}"${col.data.name}"${col.data.name === as ? "" : ` "${as}"`}`;
-	}
-	return `${quotedAs ? `${quotedAs}.` : ""}"${column}"${column === as ? "" : ` "${as}"`}`;
+const columnToSqlNotSelect = (ctx, data, shape, column, quotedAs, useSelectList) => columnToSql(ctx, data, shape, column, quotedAs, void 0, void 0, void 0, useSelectList, true);
+const columnToSql = (ctx, data, shape, column, quotedAs, select, as, jsonList, useSelectList, skipValueToArray) => {
+	let index = column.indexOf(".");
+	if (index !== -1) return tableColumnToSql(ctx, data, shape, column.slice(0, index), column.slice(index + 1), quotedAs, select, as, jsonList, skipValueToArray);
+	return simpleColumnToSQL(ctx, data, shape, column, shape[column], quotedAs, select, as, jsonList, useSelectList, void 0, skipValueToArray);
 };
-const rawOrColumnToSql = (ctx, data, expr, quotedAs, shape = data.shape, select) => {
-	return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select) : expr.toSQL(ctx, quotedAs);
+const rawOrColumnToSql = (ctx, data, shape, expr, quotedAs, select, skipValueToArray) => {
+	return typeof expr === "string" ? columnToSql(ctx, data, shape, expr, quotedAs, select, void 0, void 0, void 0, skipValueToArray) : expr.toSQL(ctx, quotedAs);
 };
 const processJoinItem = (ctx, table, query, args, quotedAs) => {
 	let target;
@@ -6724,7 +6671,7 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
 				joinedShapes: {
 					...query.joinedShapes,
 					...q.q.joinedShapes,
-					[table.q.as || table.table]: table.q.shape
+					[table.q.as || table.table]: table.q.selectShape
 				}
 			}, joinAs);
 			if (whereSql) if (on) on += ` AND ${whereSql}`;
@@ -6773,17 +6720,17 @@ const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, join
 	const [leftColumn, opOrRightColumn, maybeRightColumn] = args;
 	const op = maybeRightColumn ? opOrRightColumn : "=";
 	const rightColumn = maybeRightColumn ? maybeRightColumn : opOrRightColumn;
-	return `${rawOrColumnToSql(ctx, query, leftColumn, target, joinShape)} ${op} ${rawOrColumnToSql(ctx, query, rightColumn, quotedAs, query.shape)}`;
+	return `${rawOrColumnToSql(ctx, query, joinShape, leftColumn, target)} ${op} ${rawOrColumnToSql(ctx, query, query.selectShape, rightColumn, quotedAs)}`;
 };
 const getObjectOrRawConditions = (ctx, query, data, quotedAs, joinAs, joinShape) => {
 	if (data === true) return "true";
 	else if (isExpression(data)) return data.toSQL(ctx, quotedAs);
 	else {
 		const pairs = [];
-		const shape = query.shape;
+		const shape = query.selectShape;
 		for (const key in data) {
 			const value = data[key];
-			pairs.push(`${columnToSql(ctx, query, joinShape, key, joinAs)} = ${rawOrColumnToSql(ctx, query, value, quotedAs, shape)}`);
+			pairs.push(`${columnToSqlNotSelect(ctx, query, joinShape, key, joinAs)} = ${rawOrColumnToSql(ctx, query, shape, value, quotedAs)}`);
 		}
 		return pairs.join(", ");
 	}
@@ -6815,11 +6762,11 @@ var SelectItemExpression = class extends Expression {
 	}
 	makeSQL(ctx, quotedAs) {
 		const q = this.q;
-		return typeof this.item === "string" ? this.item === "*" ? selectAllSql(q, quotedAs, void 0, ctx).join(", ") : selectedColumnToSql(ctx, q, q.shape, this.item, quotedAs) : this.item.toSQL(ctx, quotedAs);
+		return typeof this.item === "string" ? this.item === "*" ? selectAllSql(q, quotedAs, void 0, ctx).join(", ") : columnToSql(ctx, q, q.selectShape, this.item, quotedAs, true, void 0, void 0, void 0, true) : this.item.toSQL(ctx, quotedAs);
 	}
 };
 const _getSelectableColumn = (q, arg) => {
-	let type = q.q.shape[arg];
+	let type = q.q.selectShape[arg];
 	if (!type) {
 		const index = arg.indexOf(".");
 		if (index !== -1) {
@@ -6836,30 +6783,17 @@ const _get = (query, returnType, arg) => {
 	const q = query.q;
 	if (q.returning) q.returning = void 0;
 	q.returnType = returnType;
-	let type;
 	let value = arg;
-	if (typeof value === "function") {
-		const item = processSelectAsArg(query, getQueryAs(query), "value", value);
-		if (item !== false) value = item;
-	}
-	if (typeof value === "string") {
-		const joinedAs = q.valuesJoinedAs?.[value];
-		type = joinedAs ? q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, value);
-		q.getColumn = type;
-		const selected = setParserForSelectedString(query, joinedAs ? joinedAs + "." + value : value, getQueryAs(query), getValueKey);
-		q.select = selected ? [q.expr = new SelectItemExpression(query, selected, type)] : void 0;
-	} else if (isExpression(value)) {
-		type = value.result.value;
-		q.getColumn = type;
-		addParserForRawExpression(query, getValueKey, value);
-		q.select = [q.expr = value];
-	} else {
-		const selected = value;
-		q.getColumn = selected.q.getColumn;
-		if (q.getColumn) addColumnParserToQuery(q, getValueKey, q.getColumn);
-		q.select = selected ? [{ selectAs: { value: selected } }] : void 0;
+	const selectAs = {};
+	let column;
+	const selected = processSelectAsArg(query, selectAs, getQueryAs(query), "v", value, void 0, returnType);
+	if (selected !== false) {
+		q.getColumn = column = selected;
+		value = selectAs.v || value;
 	}
-	return setQueryOperators(query, type?.operators || Operators.any);
+	if (typeof value === "string") value = selectAs.v && new SelectItemExpression(query, selectAs.v, column);
+	q.select = isExpression(value) ? [q.expr = value] : value ? [{ selectAs: { v: value } }] : void 0;
+	return setQueryOperators(query, column?.operators || Operators.any);
 };
 function _queryGet(self, arg) {
 	return _get(self, "valueOrThrow", arg);
@@ -7108,13 +7042,13 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
 						(selected ??= {})[key] = `"${tableName}"`;
 						(selectedAs ??= {})[key] = key;
 					}
-					sql = tableColumnToSqlWithAs(ctx, table.q, item, tableName, key, key === "*" ? tableName : key, quotedAs, true, jsonList);
+					sql = tableColumnToSql(ctx, query, query.selectShape, tableName, key, quotedAs, true, key === "*" ? tableName : key, jsonList);
 				} else {
 					if (hookSelect?.get(item)) {
 						(selected ??= {})[item] = quotedAs;
 						(selectedAs ??= {})[item] = item;
 					}
-					sql = ownColumnToSqlWithAs(ctx, table.q, item, item, quotedAs, true, jsonList);
+					sql = simpleColumnToSQL(ctx, query, query.selectShape, item, query.selectShape[item], quotedAs, true, item, jsonList);
 				}
 			}
 			list.push(sql);
@@ -7126,7 +7060,9 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
 				if (hookSelect) (selected ??= {})[as] = true;
 				const value = obj[as];
 				if (typeof value === "object") if (isExpression(value)) {
-					list.push(`${value.toSQL(ctx, quotedAs)} "${as}"`);
+					let sql = value.toSQL(ctx, quotedAs);
+					if (value.q.getColumn?.data.valueToArray) sql = `array[${sql}]`;
+					list.push(`${sql} "${as}"`);
 					if (jsonList) jsonList[as] = value.result.value;
 					aliases?.push(as);
 				} else if (delayedRelationSelect && isRelationQuery(value)) setMutativeQueriesSelectRelationsSqlState(delayedRelationSelect, as, value);
@@ -7136,13 +7072,14 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
 				}
 				else if (value) {
 					if (hookSelect) (selectedAs ??= {})[value] = as;
-					list.push(columnToSqlWithAs(ctx, table.q, value, as, quotedAs, true, jsonList));
+					list.push(columnToSql(ctx, table.q, table.q.selectShape, value, quotedAs, true, as, jsonList));
 					aliases?.push(as);
 				}
 			}
 		} else {
 			ctx.selectedCount++;
-			const sql = item.toSQL(ctx, quotedAs);
+			let sql = item.toSQL(ctx, quotedAs);
+			if (item.q.getColumn?.data.valueToArray) sql = `array[${sql}]`;
 			if (hookSelect && item instanceof SelectItemExpression && typeof item.item === "string" && item.item !== "*") {
 				const i = item.item.indexOf(".");
 				let key;
@@ -7150,7 +7087,7 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
 					if (item.item.slice(0, i) === table.table) key = item.item.slice(i + 1);
 				} else key = item.item;
 				if (key) {
-					const column = item.q.shape[key];
+					const column = item.q.selectShape[key];
 					(selectedAs ??= {})[key] = column?.data.name || key;
 				}
 			}
@@ -7172,12 +7109,12 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
 				quotedTable = `"${tableName}"`;
 				columnName = select.slice(index + 1);
 				col = table.q.joinedShapes?.[tableName]?.[columnName];
-				sql = selectedColumnToSql(ctx, table.q, table.q.shape, select, void 0);
+				sql = columnToSql(ctx, table.q, table.shape, select, void 0, true, void 0, void 0, void 0, true);
 			} else {
 				quotedTable = quotedAs;
 				columnName = select;
-				col = query.shape[select];
-				sql = selectedColumnToSql(ctx, table.q, query.shape, select, quotedAs);
+				col = table.shape[select];
+				sql = columnToSql(ctx, table.q, table.shape, select, quotedAs, true, void 0, void 0, void 0, true);
 			}
 		} else {
 			columnName = column;
@@ -7222,15 +7159,15 @@ const internalSelectAllSql = (ctx, query, quotedAs, jsonList) => {
 		jsonList[key] = getSelectedColumnData(column);
 	}
 	let columnsCount;
-	if (query.shape !== anyShape) {
+	if (query.selectShape !== anyShape) {
 		columnsCount = 0;
-		for (const key in query.shape) if (!query.shape[key].data.explicitSelect) columnsCount++;
+		for (const key in query.selectShape) if (!query.selectShape[key].data.explicitSelect) columnsCount++;
 		ctx.selectedCount += columnsCount;
 	}
 	return selectAllSql(query, quotedAs, columnsCount, ctx);
 };
 const selectAllSql = (q, quotedAs, columnsCount, ctx) => {
-	return q.join?.length || q.updateFrom || q.updateMany ? q.selectAllColumns?.map((item) => selectAllColumnToSql(item, ctx, quotedAs, true)) || (isEmptySelect(q.shape, columnsCount) ? [] : [`${quotedAs}.*`]) : q.selectAllColumns ? q.selectAllColumns.map((item) => selectAllColumnToSql(item, ctx, quotedAs)) : isEmptySelect(q.shape, columnsCount) ? [] : ["*"];
+	return q.join?.length || q.updateFrom || q.updateMany ? q.selectAllColumns?.map((item) => selectAllColumnToSql(item, ctx, quotedAs, true)) || (isEmptySelect(q.selectShape, columnsCount) ? [] : [`${quotedAs}.*`]) : q.selectAllColumns ? q.selectAllColumns.map((item) => selectAllColumnToSql(item, ctx, quotedAs)) : isEmptySelect(q.selectShape, columnsCount) ? [] : ["*"];
 };
 const selectAllColumnToSql = (item, ctx, quotedAs, prefix) => {
 	if (typeof item !== "string") return item(ctx, quotedAs);
@@ -7406,9 +7343,9 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
 			ands.push(`NOT ${processAnds(arr, ctx, table, query, quotedAs, true)}`);
 		} else if (key === "ON") if (Array.isArray(value)) {
 			const item = value;
-			const leftColumn = columnToSql(ctx, query, query.shape, item[0], quotedAs);
+			const leftColumn = columnToSqlNotSelect(ctx, query, query.selectShape, item[0], quotedAs);
 			const leftPath = item[1];
-			const rightColumn = columnToSql(ctx, query, query.shape, item[2], quotedAs);
+			const rightColumn = columnToSqlNotSelect(ctx, query, query.selectShape, item[2], quotedAs);
 			const rightPath = item[3];
 			ands.push(`jsonb_path_query_first(${leftColumn}, ${addValue(ctx.values, leftPath)}) = jsonb_path_query_first(${rightColumn}, ${addValue(ctx.values, rightPath)})`);
 		} else {
@@ -7417,7 +7354,7 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
 			const q = item.useOuterAliases ? {
 				joinedShapes: query.joinedShapes,
 				aliases: _getQueryOuterAliases(query),
-				shape: query.shape
+				selectShape: query.selectShape
 			} : query;
 			ands.push(`${onColumnToSql(ctx, q, joinAs, item.from)} ${item.op || "="} ${onColumnToSql(ctx, q, joinAs, item.to)}`);
 		}
@@ -7441,31 +7378,26 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
 			ands.push(`${search.vectorSQL} @@ "${search.as}"`);
 		} else if (typeof value === "object" && value && !(value instanceof Date) && !Array.isArray(value)) whereExprOrQuery(ctx, ands, query, key, value, quotedAs);
 		else {
-			const column = columnToSql(ctx, query, query.shape, key, quotedAs);
+			const column = columnToSqlNotSelect(ctx, query, query.selectShape, key, quotedAs);
 			ands.push(`${column} ${value === null ? "IS NULL" : `= ${addValue(ctx.values, value)}`}`);
 		}
 	}
 };
 const whereExprOrQuery = (ctx, ands, query, key, value, quotedAs) => {
-	if (isExpression(value)) ands.push(`${columnToSql(ctx, query, query.shape, key, quotedAs)} = ${value.toSQL(ctx, quotedAs)}`);
+	if (isExpression(value)) ands.push(`${columnToSqlNotSelect(ctx, query, query.selectShape, key, quotedAs)} = ${value.toSQL(ctx, quotedAs)}`);
 	else {
-		let column = query.shape[key];
-		let quotedColumn;
-		if (column) quotedColumn = simpleExistingColumnToSQL(ctx, key, column, quotedAs);
-		else if (!column) {
+		let column = query.selectShape[key];
+		if (!column) {
 			const index = key.indexOf(".");
-			if (index !== -1) {
+			if (index === -1) column = query.joinedShapes?.[key]?.value;
+			else if (index !== -1) {
 				const table = key.slice(0, index);
-				const quoted = `"${table}"`;
 				const name = key.slice(index + 1);
-				column = quotedAs === quoted ? query.shape[name] : query.joinedShapes?.[table]?.[name];
-				quotedColumn = simpleColumnToSQL(ctx, name, column, quoted);
-			} else {
-				column = query.joinedShapes?.[key]?.value;
-				quotedColumn = `"${key}"."${key}"`;
+				column = quotedAs === `"${table}"` ? query.selectShape[name] : query.joinedShapes?.[table]?.[name];
 			}
-			if (!column || !quotedColumn) throw new Error(`Unknown column ${key} provided to condition`);
 		}
+		if (!column) throw new Error(`Unknown column ${key} provided to condition`);
+		const quotedColumn = columnToSqlNotSelect(ctx, query, query.selectShape, key, quotedAs);
 		if (value instanceof ctx.qb.constructor) {
 			const subQuerySql = moveMutativeQueryToCte(ctx, value);
 			ands.push(`${quotedColumn} = (${subQuerySql})`);
@@ -7477,7 +7409,7 @@ const whereExprOrQuery = (ctx, ands, query, key, value, quotedAs) => {
 		}
 	}
 };
-const onColumnToSql = (ctx, query, joinAs, column) => columnToSql(ctx, query, query.shape, column, joinAs);
+const onColumnToSql = (ctx, query, joinAs, column) => columnToSqlNotSelect(ctx, query, query.selectShape, column, joinAs);
 const getJoinItemSource = (joinItem) => {
 	return typeof joinItem === "string" ? joinItem : getQueryAs(joinItem);
 };
@@ -7489,13 +7421,14 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
 		value = `(${value})`;
 	} else if (isExpression(arg.values)) value = arg.values.toSQL(ctx, quotedAs);
 	else value = `(${moveMutativeQueryToCte(ctx, arg.values)})`;
-	const columnsSql = arg.columns.map((column) => columnToSql(ctx, query, query.shape, column, quotedAs)).join(", ");
+	const columnsSql = arg.columns.map((column) => columnToSqlNotSelect(ctx, query, query.selectShape, column, quotedAs)).join(", ");
 	ands.push(`${multiple ? `(${columnsSql})` : columnsSql} IN ${value}`);
 };
 const MAX_BINDING_PARAMS = 65533;
 const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
 	let { columns } = query;
-	const { shape, hookCreateSet } = query;
+	const shape = q.shape;
+	const { hookCreateSet } = query;
 	const QueryClass = ctx.qb.constructor;
 	let { insertFrom, queryColumnsCount, values } = query;
 	let hookSetSql;
@@ -7532,7 +7465,7 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
 		insertSql: `INSERT INTO ${quoteTableWithSchema(q)}${quotedColumns.length ? "(" + quotedColumns.join(", ") + ")" : ""}`
 	};
 	ctx.sql.push(null, null);
-	const hasOnConflictWhere = pushOnConflictSql(ctx, query, quotedAs, columns, quotedColumns, runtimeDefaultColumns);
+	const hasOnConflictWhere = pushOnConflictSql(ctx, q, query, quotedAs, columns, quotedColumns, runtimeDefaultColumns);
 	const upsert = query.type === "upsert";
 	if (upsert || insertFrom && !isRelationQuery(q) || hasOnConflictWhere) pushWhereStatementSql(ctx, q, query, quotedAs);
 	sqlState.relationSelectState = newMutativeQueriesSelectRelationsSqlState(q);
@@ -7599,9 +7532,9 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
 		values: ctx.values
 	};
 };
-const pushOnConflictSql = (ctx, query, quotedAs, columns, quotedColumns, runtimeDefaultColumns) => {
+const pushOnConflictSql = (ctx, q, query, quotedAs, columns, quotedColumns, runtimeDefaultColumns) => {
 	if (!query.onConflict) return false;
-	const { shape } = query;
+	const shape = q.shape;
 	ctx.sql.push("ON CONFLICT");
 	const { target } = query.onConflict;
 	if (target) if (typeof target === "string") ctx.sql.push(`("${shape[target]?.data.name || target}")`);
@@ -7814,7 +7747,7 @@ const pushUpdateSqlWithoutValuesJoinedAs = (ctx, query, q, quotedAs, isSubSql) =
 	let updateManyValuesSql;
 	if (q.updateMany) {
 		for (const key of q.updateMany.primaryKeys) usedSetKeys.add(key);
-		updateManyValuesSql = makeUpdateManyValuesSql(ctx, query, q, q.updateMany, set, usedSetKeys, quotedAs);
+		updateManyValuesSql = makeUpdateManyValuesSql(ctx, query, q.updateMany, set, usedSetKeys, quotedAs);
 	}
 	if (!set.length) pushSelectForEmptySet(ctx, query, q, quotedAs, from, isSubSql, updateManyValuesSql, relationSelectState);
 	else {
@@ -7889,7 +7822,7 @@ const processData = (ctx, query, set, data, hookSet, usedSetKeys, quotedAs) => {
 };
 const applySet = (ctx, query, set, item, skipColumns, usedSetKeys, quotedAs) => {
 	const QueryClass = ctx.qb.constructor;
-	const shape = query.q.shape;
+	const shape = query.shape;
 	for (const key in item) {
 		if (usedSetKeys.has(key)) continue;
 		usedSetKeys.add(key);
@@ -7905,12 +7838,12 @@ const processValue = (ctx, query, QueryClass, key, value, quotedAs) => {
 			const subQuery = value;
 			if (subQuery.q.subQuery === 1) return selectToSql(ctx, query, subQuery.q, quotedAs);
 			return `(${moveMutativeQueryToCte(ctx, subQuery)})`;
-		} else if ("op" in value && "arg" in value) return `"${query.q.shape[key].data.name || key}" ${value.op} ${addValue(ctx.values, value.arg)}`;
+		} else if ("op" in value && "arg" in value) return `"${query.shape[key].data.name || key}" ${value.op} ${addValue(ctx.values, value.arg)}`;
 	}
 	return addValue(ctx.values, value);
 };
-const makeUpdateManyValuesSql = (ctx, query, q, updateMany, set, usedSetKeys, quotedAs) => {
-	const { shape } = q;
+const makeUpdateManyValuesSql = (ctx, query, updateMany, set, usedSetKeys, quotedAs) => {
+	const shape = query.shape;
 	const keysSet = /* @__PURE__ */ new Set();
 	const valueRows = [];
 	const quotedColumnNames = [];
@@ -8019,13 +7952,13 @@ const addOrder = (ctx, data, column, quotedAs, dir) => {
 		const order = dir || (!search.order || search.order === true ? emptyObject : search.order);
 		return `${order.coverDensity ? "ts_rank_cd" : "ts_rank"}(${order.weights ? `${addValue(ctx.values, `{${order.weights}}`)}, ` : ""}${search.vectorSQL}, "${column}"${order.normalization !== void 0 ? `, ${addValue(ctx.values, order.normalization)}` : ""}) ${order.dir || "DESC"}`;
 	}
-	return `${maybeSelectedColumnToSql(ctx, data, column, quotedAs)} ${dir || "ASC"}`;
+	return `${columnToSqlNotSelect(ctx, data, data.selectShape, column, quotedAs, true)} ${dir || "ASC"}`;
 };
 const windowToSql = (ctx, data, window, quotedAs) => {
 	if (typeof window === "string") return `"${window}"`;
 	if (isExpression(window)) return `(${window.toSQL(ctx, quotedAs)})`;
 	const sql = [];
-	if (window.partitionBy) sql.push(`PARTITION BY ${Array.isArray(window.partitionBy) ? window.partitionBy.map((partitionBy) => rawOrColumnToSql(ctx, data, partitionBy, quotedAs)).join(", ") : rawOrColumnToSql(ctx, data, window.partitionBy, quotedAs)}`);
+	if (window.partitionBy) sql.push(`PARTITION BY ${Array.isArray(window.partitionBy) ? window.partitionBy.map((partitionBy) => rawOrColumnToSql(ctx, data, data.selectShape, partitionBy, quotedAs, void 0, true)).join(", ") : rawOrColumnToSql(ctx, data, data.selectShape, window.partitionBy, quotedAs, void 0, true)}`);
 	if (window.order) sql.push(`ORDER BY ${orderByToSql(ctx, data, window.order, quotedAs)}`);
 	return `(${sql.join(" ")})`;
 };
@@ -8046,12 +7979,6 @@ var FnExpression = class extends Expression {
 		this.result = { value };
 		this.q = query.q;
 		this.q.expr = this;
-		Object.assign(query, value.operators);
-		query.q.returnType = "valueOrThrow";
-		query.q.returnsOne = true;
-		query.q.getColumn = value;
-		query.q.select = [this];
-		addColumnParserToQuery(query.q, getValueKey, value);
 	}
 	makeSQL(ctx, quotedAs) {
 		const sql = [`${this.fn}(`];
@@ -8080,7 +8007,7 @@ var FnExpression = class extends Expression {
 			const whereSql = whereToSql(ctx, this.query, {
 				and: options.filter ? [options.filter] : void 0,
 				or: options.filterOr?.map((item) => [item]),
-				shape: q.shape,
+				selectShape: q.selectShape,
 				joinedShapes: q.joinedShapes
 			}, quotedAs);
 			if (whereSql) sql.push(` FILTER (WHERE ${whereSql})`);
@@ -8091,16 +8018,22 @@ var FnExpression = class extends Expression {
 };
 const fnArgToSql = (ctx, data, arg, quotedAs) => {
 	if (typeof arg === "string") {
-		if (arg.endsWith(".*") || data.valuesJoinedAs?.[arg]) return columnToSql(ctx, data, data.shape, arg, quotedAs);
-		return selectedColumnToSql(ctx, data, data.shape, arg, quotedAs);
+		if (arg.endsWith(".*") || data.valuesJoinedAs?.[arg]) return columnToSql(ctx, data, data.selectShape, arg, quotedAs, void 0, void 0, void 0, void 0, true);
+		return columnToSql(ctx, data, data.selectShape, arg, quotedAs, true, void 0, void 0, void 0, true);
 	}
 	return arg.toSQL(ctx, quotedAs);
 };
 function makeFnExpression(self, type, fn, args, options) {
 	const q = extendQuery(self, type.operators);
 	q.baseQuery.type = ExpressionTypeMethod.prototype.type;
-	new FnExpression(q, fn, args, options, type);
+	q.q.select = [new FnExpression(q, fn, args, options, type)];
+	q.q.getColumn = type;
+	Object.assign(q, type.operators);
+	setValueParserToQuery(q.q, type);
+	q.q.returnType = "valueOrThrow";
+	q.q.returnsOne = true;
 	q.q.transform = void 0;
+	q.q.batchParsers = void 0;
 	return q;
 }
 const isSelectingCount = (q) => {
@@ -8109,17 +8042,14 @@ const isSelectingCount = (q) => {
 };
 const intNullable = new IntegerColumn(internalSchemaConfig).nullable().parse(parseInt);
 const floatNullable = new RealColumn(internalSchemaConfig).nullable().parse(parseFloat);
-const booleanNullable = BooleanColumn.instance.nullable();
+const booleanNullable = BooleanColumn.instanceSkipValueToArray.nullable();
 const textNullable = TextColumn.instance.nullable();
 const jsonTextNullable = JSONTextColumn.instance.nullable();
 const xmlNullable = XMLColumn.instance.nullable();
 const stringAsNumberNullable = new NumberAsStringBaseColumn(internalSchemaConfig).nullable();
+intNullable.data.skipValueToArray = floatNullable.data.skipValueToArray = textNullable.data.skipValueToArray = jsonTextNullable.data.skipValueToArray = xmlNullable.data.skipValueToArray = stringAsNumberNullable.data.skipValueToArray = true;
 const numericResultColumn = (q, arg) => {
-	const query = q;
-	let column = (typeof arg === "string" ? _getSelectableColumn(query, arg) : arg.result.value) instanceof NumberBaseColumn ? floatNullable : stringAsNumberNullable;
-	const parse = typeof arg === "string" && query.q.parsers?.[arg];
-	if (parse) column = column.parse(parse);
-	return column;
+	return (typeof arg === "string" ? _getSelectableColumn(q, arg) : arg.result.value) instanceof NumberBaseColumn ? floatNullable : stringAsNumberNullable;
 };
 var AggregateMethods = class {
 	/**
@@ -8135,6 +8065,7 @@ var AggregateMethods = class {
 		const q = _queryGetOptional(_clone(this), new RawSql("true"));
 		q.q.notFoundDefault = false;
 		q.q.coalesceValue = new RawSql("false");
+		q.q.getColumn = BooleanColumn.instanceSkipValueToArray;
 		return q;
 	}
 	/**
@@ -8896,7 +8827,7 @@ const createSelect = (q) => {
 * @param createHandlers - collects column `create` functions per column having it, and collects row indexes having a value for this column
 */
 const processCreateItem = (q, item, rowIndex, ctx, encoders, createHandlers) => {
-	const { shape } = q.q;
+	const shape = q.shape;
 	for (const key in item) {
 		const column = shape[key];
 		if (!column) continue;
@@ -9447,7 +9378,7 @@ var OnConflictQueryBuilder = class {
 const pushDistinctSql = (ctx, table, distinct, quotedAs) => {
 	ctx.sql.push("DISTINCT");
 	if (distinct.length) {
-		const columns = distinct?.map((item) => rawOrColumnToSql(ctx, table.q, item, quotedAs));
+		const columns = distinct?.map((item) => rawOrColumnToSql(ctx, table.q, table.q.selectShape, item, quotedAs));
 		ctx.sql.push(`ON (${columns?.join(", ") || ""})`);
 	}
 };
@@ -9481,20 +9412,20 @@ const searchSourcesToSql = (ctx, data, sources, sql, quotedAs) => {
 	return sql;
 };
 const getSearchLang = (ctx, data, source, quotedAs) => {
-	return source.langSQL ??= "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english");
+	return source.langSQL ??= "languageColumn" in source ? columnToSqlNotSelect(ctx, data, data.selectShape, source.languageColumn, quotedAs) : isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english");
 };
 const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
 	let sql = source.textSQL;
 	if (sql) return sql;
-	if ("in" in source) if (typeof source.in === "string") sql = columnToSql(ctx, data, data.shape, source.in, quotedAs);
-	else if (Array.isArray(source.in)) sql = `concat_ws(' ', ${source.in.map((column) => columnToSql(ctx, data, data.shape, column, quotedAs)).join(", ")})`;
+	if ("in" in source) if (typeof source.in === "string") sql = columnToSqlNotSelect(ctx, data, data.selectShape, source.in, quotedAs);
+	else if (Array.isArray(source.in)) sql = `concat_ws(' ', ${source.in.map((column) => columnToSqlNotSelect(ctx, data, data.selectShape, column, quotedAs)).join(", ")})`;
 	else {
 		sql = [];
-		for (const key in source.in) sql.push(columnToSql(ctx, data, data.shape, key, quotedAs));
+		for (const key in source.in) sql.push(columnToSqlNotSelect(ctx, data, data.selectShape, key, quotedAs));
 	}
 	else if ("vector" in source) {
 		if (forHeadline) throw new Error("Cannot use a search based on a vector column for a search headline");
-		sql = columnToSql(ctx, data, data.shape, source.vector, quotedAs);
+		sql = columnToSqlNotSelect(ctx, data, data.selectShape, source.vector, quotedAs);
 	} else if (typeof source.text === "string") sql = addValue(ctx.values, source.text);
 	else sql = source.text.toSQL(ctx, quotedAs);
 	return source.textSQL = sql;
@@ -9710,7 +9641,7 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen, dontAddTabl
 					if (isExpression(item)) return item.toSQL(ctx, quotedAs);
 					else {
 						const i = aliases.indexOf(item);
-						return i !== -1 ? i + 1 : columnToSql(ctx, table.q, table.shape, item, quotedAs);
+						return i !== -1 ? i + 1 : columnToSqlNotSelect(ctx, table.q, table.shape, item, quotedAs);
 					}
 				});
 				sql.push(`GROUP BY ${group.join(", ")}`);
@@ -10132,19 +10063,11 @@ const _joinLateral = (self, type, joinQuery, as, innerJoinLateral) => {
 	}
 	if (!existingValue) {
 		const joinedAs = getQueryAs(query);
-		setObjectValueImmutable(joinQuery.q, "joinedShapes", joinedAs, query.q.shape);
+		setObjectValueImmutable(joinQuery.q, "joinedShapes", joinedAs, query.q.selectShape);
 	}
 	const shape = getShapeFromSelect(joinQuery, true);
 	setObjectValueImmutable(query.q, "joinedShapes", joinAs, shape);
-	const parsers = getQueryParsers(joinQuery);
-	if (joinValue) {
-		setObjectValueImmutable(query.q, "valuesJoinedAs", joinAs, joinValueAs);
-		if (parsers && getValueKey in parsers) {
-			const parse = parsers[getValueKey];
-			setParserToQuery(query.q, joinAs, parse);
-			parsers[joinAs] = parse;
-		}
-	}
+	if (joinValue) setObjectValueImmutable(query.q, "valuesJoinedAs", joinAs, joinValueAs);
 	setObjectValueImmutable(query.q, "joinedParsers", joinValueAs || joinAs, getQueryParsers(joinQuery));
 	if (joinQuery.q.batchParsers) setObjectValueImmutable(query.q, "joinedBatchParsers", joinAs, joinQuery.q.batchParsers);
 	if (joinValueAs) {
@@ -10904,15 +10827,12 @@ var OnMethods = class {
 const setSelectRelation = (q) => {
 	q.selectRelation = true;
 };
-const addParserForRawExpression = (q, key, raw) => {
-	if (raw.result.value) addColumnParserToQuery(q.q, key, raw.result.value);
-};
 const addParsersForSelectJoined = (q, arg, as = arg) => {
 	const parsers = q.q.joinedParsers?.[arg];
 	if (parsers) setParserToQuery(q.q, as, (row) => parseRecord(parsers, row));
 	const batchParsers = q.q.joinedBatchParsers?.[arg];
 	if (batchParsers) pushQueryArrayImmutable(q, "batchParsers", batchParsers.map((x) => ({
-		path: [as, ...x.path],
+		path: [{ key: as }, ...x.path],
 		fn: x.fn
 	})));
 };
@@ -10920,19 +10840,24 @@ const addParserForSelectItem = (query, as, key, arg, columnAlias, joinQuery) =>
 	if (typeof arg === "object") {
 		const { q } = arg;
 		if (q.batchParsers) pushQueryArrayImmutable(query, "batchParsers", q.batchParsers.map((bp) => ({
-			path: [key, ...bp.path],
+			path: [{
+				key,
+				returnType: q.returnType
+			}, ...bp.path],
 			fn: bp.fn
 		})));
 		const parsers = isExpression(arg) ? void 0 : getQueryParsers(arg);
 		if (parsers || q.hookSelect || q.transform || q.returnType === "oneOrThrow" || q.returnType === "valueOrThrow" || q.returnType === "one" || q.returnType === "value") pushQueryValueImmutable(query, "batchParsers", {
-			path: [key],
+			path: [{
+				key,
+				returnType: q.returnType
+			}],
 			fn: (path, queryResult) => {
 				const { rows } = queryResult;
 				const originalReturnType = q.returnType || "all";
 				let returnType = originalReturnType;
 				const { hookSelect } = q;
 				const batches = [];
-				const last = path.length;
 				if (returnType === "value" || returnType === "valueOrThrow") {
 					if (hookSelect) batches.push = (item) => {
 						if (!(key in item)) returnType = returnType === "value" ? "one" : "oneOrThrow";
@@ -10940,7 +10865,7 @@ const addParserForSelectItem = (query, as, key, arg, columnAlias, joinQuery) =>
 						return batches.push(item);
 					};
 				}
-				collectNestedSelectBatches(batches, rows, path, last);
+				collectNestedSelectBatches(batches, rows, path);
 				switch (returnType) {
 					case "all":
 						if (parsers) for (const { data } of batches) for (const one of data) parseRecord(parsers, one);
@@ -10965,16 +10890,28 @@ const addParserForSelectItem = (query, as, key, arg, columnAlias, joinQuery) =>
 					}
 					case "value":
 					case "valueOrThrow": {
-						const notNullable = !q.getColumn?.data.isNullable;
-						const parse = parsers?.[getValueKey];
-						if (parse) if (returnType === "value") for (const item of batches) item.parent[item.key] = item.data = item.data === null ? q.notFoundDefault : parse(item.data);
+						const data = q.getColumn?.data;
+						const notNullable = !data?.isNullable;
+						const valueToArray = data?.valueToArray;
+						const parse = getValueParser(parsers);
+						if (parse) if (returnType === "value") if (valueToArray) for (const item of batches) item.parent[item.key] = item.data = item.data ? item.data[0] === null ? null : parse(item.data[0]) : q.notFoundDefault;
+						else for (const item of batches) item.parent[item.key] = item.data = item.data === null ? q.notFoundDefault : parse(item.data);
+						else if (valueToArray) for (const item of batches) {
+							if (!item.data) throw new NotFoundError(arg);
+							item.parent[item.key] = item.data = item.data[0] === null ? null : parse(item.data[0]);
+						}
 						else for (const item of batches) {
 							if (notNullable && item.data === null) throw new NotFoundError(arg);
 							item.parent[item.key] = item.data = parse(item.data);
 						}
 						else if (returnType === "value") {
-							for (const item of batches) if (item.data === null) item.parent[item.key] = item.data = q.notFoundDefault;
-						} else if (notNullable) {
+							if (valueToArray) for (const item of batches) item.parent[item.key] = item.data = item.data ? item.data[0] : q.notFoundDefault;
+							else for (const item of batches) if (item.data === void 0) item.parent[item.key] = item.data = q.notFoundDefault;
+						} else if (valueToArray) for (const item of batches) {
+							if (!item.data) throw new NotFoundError(arg);
+							item.parent[item.key] = item.data = item.data[0];
+						}
+						else if (notNullable) {
 							for (const { data } of batches) if (data === null) throw new NotFoundError(arg);
 						}
 						if (hookSelect) for (const batch of batches) batch.data = [batch.data];
@@ -11012,59 +10949,52 @@ const addParserForSelectItem = (query, as, key, arg, columnAlias, joinQuery) =>
 		}
 		return arg;
 	}
-	return setParserForSelectedString(query, arg, as, key, columnAlias);
+	const joinedAs = query.q.valuesJoinedAs?.[arg];
+	return setParserForSelectedString(query, joinedAs ? joinedAs + "." + arg : arg, as, key, columnAlias);
 };
-const collectNestedSelectBatches = (batches, rows, path, last) => {
-	const stack = rows.map((row) => ({
-		data: row,
-		parent: row,
-		i: 0,
-		key: path[0]
-	}));
-	while (stack.length > 0) {
-		const item = stack.pop();
-		const { i } = item;
-		if (i === last) {
-			batches.push(item);
-			continue;
-		}
-		const { data } = item;
-		const key = path[i];
-		if (Array.isArray(data)) for (let key = 0; key < data.length; key++) stack.push({
-			data: data[key],
-			parent: data,
-			key,
-			i
-		});
-		else if (data && typeof data === "object") stack.push({
-			data: data[key],
-			parent: data,
-			key,
-			i: i + 1
-		});
+const collectNestedSelectBatches = (batches, rows, path) => {
+	const last = path.length - 1;
+	const { key, returnType } = path[0];
+	for (const row of rows) processNestedSelectPathEntry(batches, path, key, returnType, 0, last, row);
+};
+const processNestedSelectPathEntry = (batches, path, thisKey, thisReturnType, i, last, parent) => {
+	const data = parent[thisKey];
+	if (i === last) batches.push({
+		data,
+		parent,
+		key: thisKey
+	});
+	else {
+		const { key, returnType } = path[++i];
+		if (!thisReturnType || thisReturnType === "all") for (const row of data) processNestedSelectPathEntry(batches, path, key, returnType, i, last, row);
+		else processNestedSelectPathEntry(batches, path, key, returnType, i, last, data);
 	}
 };
 const emptyArrSQL = new RawSql("'[]'");
 const processSelectArg = (q, as, arg, columnAs) => {
-	if (typeof arg === "string") return setParserForSelectedString(q, arg, as, columnAs);
+	const query = q;
+	if (typeof arg === "string") return setParserForSelectedString(query, arg, as, columnAs);
 	const selectAs = {};
+	const selectShape = query.q.selectShape = { ...query.q.selectShape };
 	for (const key in arg) {
-		const item = processSelectAsArg(q, as, key, arg[key]);
-		if (item === false) return false;
-		selectAs[key] = item;
+		const item = processSelectAsArg(q, selectAs, as, key, arg[key], key);
+		if (item) selectShape[key] = item;
+		else if (item === false) return false;
 	}
 	return { selectAs };
 };
-const processSelectAsArg = (q, as, key, arg) => {
+const processSelectAsArg = (q, selectAs, as, key, arg, columnAlias, outerReturnType) => {
 	const query = q;
 	let value = arg;
 	let joinQuery;
+	let column;
 	if (typeof value === "function") {
 		value = resolveSubQueryCallback(q, value);
 		if (isQueryNone(value)) {
 			if (value.q.innerJoinLateral) return false;
 		}
-		if (!isExpression(value)) {
+		if (isExpression(value)) column = value.result.value;
+		else {
 			if (isRelationQuery(value) && value.q.subQuery !== 1) {
 				joinQuery = true;
 				setSelectRelation(query.q);
@@ -11085,10 +11015,27 @@ const processSelectAsArg = (q, as, key, arg) => {
 				const as = _joinLateral(q, innerJoinLateral || query.q.returnType === "valueOrThrow" ? "JOIN" : "LEFT JOIN", subQuery, key, innerJoinLateral && returnType !== "one" && returnType !== "oneOrThrow");
 				if (as) value.q.joinedForSelect = _copyQueryAliasToQuery(value, q, as);
 			}
+			if (value.q.getColumn?.data.skipValueToArray) value.q.notFoundDefault ??= null;
+			else if (!value.q.type && (value.q.returnType === "value" || value.q.returnType === "valueOrThrow")) {
+				const column = Object.create(value.q.getColumn || UnknownColumn.instance);
+				column.data = {
+					...column.data,
+					name: void 0,
+					valueToArray: true
+				};
+				value.q.getColumn = column;
+				if (value.q.expr) value.q.expr.q.getColumn = column;
+			}
+			if (outerReturnType === "value" && value.q.returnType === "valueOrThrow") value.q.returnType = "value";
+			column = value.q.getColumn;
 			value = prepareSubQueryForSql(q, value);
 		}
-	}
-	return addParserForSelectItem(query, as, key, value, key, joinQuery);
+	} else if (typeof value === "string") {
+		const joinedAs = query.q.valuesJoinedAs?.[value];
+		column = joinedAs ? query.q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, value);
+	} else column = value.result.value;
+	selectAs[key] = addParserForSelectItem(query, as, key, value, columnAlias, joinQuery);
+	return column;
 };
 const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
 	const { q } = query;
@@ -11106,7 +11053,7 @@ const setParserForSelectedString = (query, arg, as, columnAs, columnAlias) => {
 	const batchParsers = q.joinedBatchParsers?.[table];
 	if (batchParsers) {
 		let cloned = false;
-		for (const bp of batchParsers) if (bp.path[0] === column) {
+		for (const bp of batchParsers) if (bp.path[0].key === column) {
 			if (!cloned) {
 				q.batchParsers = [...q.batchParsers || []];
 				cloned = true;
@@ -11144,7 +11091,7 @@ const selectColumn = (query, q, key, columnAs, columnAlias) => {
 };
 const getShapeFromSelect = (q, isSubQuery) => {
 	const query = q.q;
-	const { shape } = query;
+	const { selectShape: shape } = query;
 	let select;
 	if (query.selectedComputeds) {
 		select = query.select ? [...query.select] : [];
@@ -11621,14 +11568,14 @@ var RefExpression = class extends Expression {
 	makeSQL(ctx) {
 		const q = this.q;
 		const as = q.as || this.table;
-		return columnToSql(ctx, q, q.shape, this.ref, as && `"${as}"`);
+		return columnToSqlNotSelect(ctx, q, q.selectShape, this.ref, as && `"${as}"`);
 	}
 };
 const _queryUpdateMany = (self, primaryKeys, data, strict) => {
 	const query = self;
 	throwIfReadOnly(query);
 	const { q } = query;
-	const { shape } = q;
+	const shape = query.shape;
 	q.type = "update";
 	setUpdateReturning(q);
 	if (!data.length) return _queryNone(query);
@@ -11684,7 +11631,7 @@ const _queryUpdate = (updateSelf, arg) => {
 	q.type = "update";
 	const set = { ...arg };
 	pushQueryValueImmutable(query, "updateData", set);
-	const { shape } = q;
+	const shape = query.shape;
 	let selectQuery;
 	for (const key in arg) {
 		const item = shape[key];
@@ -12357,7 +12304,7 @@ var ColumnRefExpression = class extends Expression {
 		Object.assign(this, value.operators);
 	}
 	makeSQL(ctx, quotedAs) {
-		return simpleExistingColumnToSQL(ctx, this.name, this.result.value, quotedAs);
+		return simpleColumnToSQL(ctx, emptyObject, emptyObject, this.name, this.result.value, quotedAs, void 0, void 0, void 0, void 0, true);
 	}
 };
 var OrExpression = class extends Expression {
@@ -12444,16 +12391,16 @@ var QueryExpressions = class {
 	*/
 	ref(arg) {
 		const q = _clone(this);
-		const { shape } = q.q;
+		const { selectShape } = q.q;
 		let column;
 		const index = arg.indexOf(".");
 		if (index !== -1) {
 			const as = q.q.as || q.table;
 			const table = getFullColumnTable(q, arg, index, as);
 			const col = arg.slice(index + 1);
-			if (table === as) column = shape[col];
+			if (table === as) column = selectShape[col];
 			else column = q.q.joinedShapes?.[table][col];
-		} else column = shape[arg];
+		} else column = selectShape[arg];
 		return new RefExpression(column || UnknownColumn.instance, q, arg);
 	}
 	val(value) {
@@ -12496,7 +12443,7 @@ var QueryExpressions = class {
 	* @param options
 	*/
 	fn(fn, args, options) {
-		return makeFnExpression(this, emptyObject, fn, args, options);
+		return makeFnExpression(this, UnknownColumn.instance, fn, args, options);
 	}
 	or(...args) {
 		return new OrExpression(args);
@@ -12509,7 +12456,7 @@ const _appendQueryOnUpsertCreate = (main, append, asFn) => {
 	return pushQueryValueImmutable(pushQueryValueImmutable(main, "upsertCreateAppendQueries", prepareSubQueryForSql(main, append)), "upsertCreateAsFns", asFn);
 };
 const mergableObjects = new Set([
-	"shape",
+	"selectShape",
 	"withShapes",
 	"defaultParsers",
 	"parsers",
@@ -12713,7 +12660,7 @@ var Headline = class extends Expression {
 		const { source, params } = this;
 		const q = this.q;
 		const lang = getSearchLang(ctx, q, source, quotedAs);
-		const text = params?.text ? params.text instanceof Expression ? params.text.toSQL(ctx, quotedAs) : columnToSql(ctx, q, q.shape, params.text, quotedAs) : getSearchText(ctx, q, source, quotedAs, true);
+		const text = params?.text ? params.text instanceof Expression ? params.text.toSQL(ctx, quotedAs) : columnToSqlNotSelect(ctx, q, q.selectShape, params.text, quotedAs) : getSearchText(ctx, q, source, quotedAs, true);
 		const options = params?.options ? `, ${params.options instanceof Expression ? params.options.toSQL(ctx, quotedAs) : addValue(ctx.values, params.options)}` : "";
 		return `ts_headline(${lang}, ${text}, "${source.as}"${options})`;
 	}
@@ -13039,10 +12986,12 @@ var QueryPluck = class {
 		const q = _clone(this);
 		q.q.returnType = "pluck";
 		let selected;
-		if (typeof select === "function") {
-			const item = processSelectAsArg(q, q.q.as || q.table, "pluck", select);
-			if (item !== false) selected = isExpression(item) ? item : { selectAs: { pluck: item } };
-		} else selected = addParserForSelectItem(q, q.q.as || q.table, "pluck", select);
+		const selectAs = {};
+		const item = processSelectAsArg(q, selectAs, q.q.as || q.table, "pluck", select, void 0, "value");
+		if (item !== false) {
+			q.q.getColumn = item;
+			selected = typeof selectAs.pluck === "object" && !isExpression(selectAs.pluck) ? { selectAs } : selectAs.pluck;
+		}
 		q.q.select = selected ? [selected] : void 0;
 		return q;
 	}
@@ -13980,7 +13929,7 @@ var Db = class extends QueryMethods {
 		};
 		this.q = {
 			adapter: adapterNotInTransaction,
-			shape,
+			selectShape: shape,
 			handleResult,
 			logger,
 			log: logParamToLogObject(logger, options.log),
@@ -14318,7 +14267,7 @@ const makeColumnInfoSql = (query, column) => {
 	const values = [];
 	const schema = getQuerySchema(query);
 	let text = `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(values, query.table)} AND table_catalog = current_database() AND table_schema = ${schema ? addValue(values, schema) : "current_schema()"}`;
-	if (column) text += ` AND column_name = ${addValue(values, query.q.shape[column]?.data.name || column)}`;
+	if (column) text += ` AND column_name = ${addValue(values, query.shape[column]?.data.name || column)}`;
 	return {
 		text,
 		values
@@ -14374,7 +14323,7 @@ const makeCopySql = (table, copy) => {
 	const ctx = newToSqlCtx(table);
 	const { q } = table;
 	const quotedAs = `"${q.as || table.table}"`;
-	const columns = copy.columns ? `(${copy.columns.map((item) => `"${q.shape[item]?.data.name || item}"`).join(", ")})` : "";
+	const columns = copy.columns ? `(${copy.columns.map((item) => `"${table.shape[item]?.data.name || item}"`).join(", ")})` : "";
 	const target = "from" in copy ? copy.from : copy.to;
 	const quotedTable = quoteTableWithSchema(table);
 	ctx.sql.push(`COPY ${quotedTable}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? escapeString(target) : `PROGRAM ${escapeString(target.program)}`}`);