kysely 0.23.4 → 0.24.0

package/dist/esm/query-builder/update-query-builder.js

@@ -1,16 +1,15 @@
 /// <reference types="./update-query-builder.d.ts" />
 import { parseJoin, } from '../parser/join-parser.js';
 import { parseTableExpressionOrList, } from '../parser/table-parser.js';
-import { parseSelectExpressionOrList, parseSelectAll, } from '../parser/select-parser.js';
+import { parseSelectArg, parseSelectAll, } from '../parser/select-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
-import { parseUpdateObject } from '../parser/update-set-parser.js';
+import { parseUpdateExpression, } from '../parser/update-set-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { UpdateResult } from './update-result.js';
-import { NoResultError } from './no-result-error.js';
-import { ExplainNode } from '../operation-node/explain-node.js';
-import { parseReferentialFilter, parseWhere, } from '../parser/binary-operation-parser.js';
+import { isNoResultErrorConstructor, NoResultError, } from './no-result-error.js';
+import { parseReferentialComparison, parseWhere, } from '../parser/binary-operation-parser.js';
 import { parseExists, parseNotExists, } from '../parser/unary-operation-parser.js';
 export class UpdateQueryBuilder {
     #props;
@@ -26,7 +25,7 @@ export class UpdateQueryBuilder {
     whereRef(lhs, op, rhs) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
     orWhere(...args) {
@@ -38,7 +37,7 @@ export class UpdateQueryBuilder {
     orWhereRef(lhs, op, rhs) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialFilter(lhs, op, rhs)),
+            queryNode: QueryNode.cloneWithOrWhere(this.#props.queryNode, parseReferentialComparison(lhs, op, rhs)),
         });
     }
     whereExists(arg) {
@@ -101,103 +100,16 @@ export class UpdateQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
-    /**
-     * Sets the values to update for an {@link Kysely.updateTable | update} query.
-     *
-     * This method takes an object whose keys are column names and values are
-     * values to update. In addition to the column's type, the values can be
-     * raw {@link sql} snippets or select queries.
-     *
-     * The return value of an update query is an instance of {@link UpdateResult}.
-     * You can use the {@link returning} method on supported databases to get out
-     * the updated rows.
-     *
-     * ### Examples
-     *
-     * Update a row in `person` table:
-     *
-     * ```ts
-     * const result = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
-     *   })
-     *   .where('id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3
-     * ```
-     *
-     * On PostgreSQL you ca chain `returning` to the query to get
-     * the updated rows' columns (or any other expression) as the
-     * return value:
-     *
-     * ```ts
-     * const row = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: 'Aniston'
-     *   })
-     *   .where('id', '=', 1)
-     *   .returning('id')
-     *   .executeTakeFirstOrThrow()
-     *
-     * row.id
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3 returning "id"
-     * ```
-     *
-     * In addition to primitives, the values can also be raw sql expressions or
-     * select queries:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const result = await db
-     *   .updateTable('person')
-     *   .set({
-     *     first_name: 'Jennifer',
-     *     last_name: sql`${'Ani'} || ${'ston'}`,
-     *     age: db.selectFrom('person').select(sql`avg(age)`),
-     *   })
-     *   .where('id', '=', 1)
-     *   .executeTakeFirst()
-     *
-     * console.log(result.numUpdatedRows)
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * update "person" set
-     * "first_name" = $1,
-     * "last_name" = $2 || $3,
-     * "age" = (select avg(age) from "person")
-     * where "id" = $4
-     * ```
-     */
-    set(row) {
+    set(update) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateObject(row)),
+            queryNode: UpdateQueryNode.cloneWithUpdates(this.#props.queryNode, parseUpdateExpression(update)),
         });
     }
     returning(selection) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectExpressionOrList(selection)),
+            queryNode: QueryNode.cloneWithReturning(this.#props.queryNode, parseSelectArg(selection)),
         });
     }
     returningAll() {
@@ -207,7 +119,8 @@ export class UpdateQueryBuilder {
         });
     }
     /**
-     * Simply calls the given function passing `this` as the only argument.
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
      *
      * If you want to conditionally call a method on `this`, see
      * the {@link $if} method.
@@ -384,7 +297,7 @@ export class UpdateQueryBuilder {
         return [
             new UpdateResult(
             // TODO: remove numUpdatedOrDeletedRows.
-            (result.numAffectedRows ?? result.numUpdatedOrDeletedRows)),
+            result.numAffectedRows ?? result.numUpdatedOrDeletedRows ?? BigInt(0)),
         ];
     }
     /**
@@ -400,37 +313,30 @@ export class UpdateQueryBuilder {
      * the query returned no result.
      *
      * By default an instance of {@link NoResultError} is thrown, but you can
-     * provide a custom error class as the only argument to throw a different
+     * provide a custom error class, or callback as the only argument to throw a different
      * error.
      */
     async executeTakeFirstOrThrow(errorConstructor = NoResultError) {
         const result = await this.executeTakeFirst();
         if (result === undefined) {
-            throw new errorConstructor(this.toOperationNode());
+            const error = isNoResultErrorConstructor(errorConstructor)
+                ? new errorConstructor(this.toOperationNode())
+                : errorConstructor(this.toOperationNode());
+            throw error;
         }
         return result;
     }
-    /**
-     * Executes query with `explain` statement before `update` keyword.
-     *
-     * ```ts
-     * const explained = await db
-     *  .updateTable('person')
-     *  .set(updates)
-     *  .where('id', '=', 123)
-     *  .explain('json')
-     * ```
-     *
-     * The generated SQL (MySQL):
-     *
-     * ```sql
-     * explain format=json update `person` set `first_name` = ?, `last_name` = ? where `id` = ?
-     * ```
-     */
+    async *stream(chunkSize = 100) {
+        const compiledQuery = this.compile();
+        const stream = this.#props.executor.stream(compiledQuery, chunkSize, this.#props.queryId);
+        for await (const item of stream) {
+            yield* item.rows;
+        }
+    }
     async explain(format, options) {
         const builder = new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: UpdateQueryNode.cloneWithExplain(this.#props.queryNode, ExplainNode.create(format, options?.toOperationNode())),
+            queryNode: QueryNode.cloneWithExplain(this.#props.queryNode, format, options),
         });
         return await builder.execute();
     }

package/dist/esm/query-builder/update-result.js

@@ -8,3 +8,6 @@ export class UpdateResult {
         return this.#numUpdatedRows;
     }
 }
+Object.defineProperty(UpdateResult.prototype, 'numUpdatedRows', {
+    enumerable: true,
+});

package/dist/esm/query-builder/where-interface.d.ts

@@ -1,56 +1,42 @@
 import { Expression } from '../expression/expression.js';
-import { ComparisonOperatorExpression, OperandValueExpressionOrList, WhereGrouper } from '../parser/binary-operation-parser.js';
+import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { ExistsExpression } from '../parser/unary-operation-parser.js';
+import { SqlBool } from '../util/type-utils.js';
+import { WhereExpressionBuilder } from './deprecated-where-expression-builder.js';
 export interface WhereInterface<DB, TB extends keyof DB> {
     /**
-     * Adds a `where` clause to the query.
+     * Adds a `where` expression to the query.
      *
-     * Also see {@link orWhere}, {@link whereExists} and {@link whereRef}.
+     * Calling this method multiple times will combine the expressions using `and`.
      *
-     * ### Examples
+     * Also see {@link whereRef}
      *
-     * Find a row by column value:
+     * ### Examples
      *
      * ```ts
      * const person = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where('id', '=', 100)
+     *   .where('first_name', '=', 'Jennifer')
+     *   .where('age', '>', 40)
      *   .executeTakeFirst()
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" where "id" = $1
+     * select * from "person" where "first_name" = $1 and "age" > $2
      * ```
      *
      * Operator can be any supported operator or if the typings don't support it
-     * you can always use
+     * you can always use:
      *
      * ```ts
      * sql`your operator`
      * ```
      *
-     * The next example uses the `>` operator:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '>', 100)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" > $1
-     * ```
-     *
-     * `where` methods don't change the type of the query. You can add
-     * conditional statements easily by doing something like this:
+     * You can add expressions conditionally like this:
      *
      * ```ts
      * let query = db
@@ -63,16 +49,16 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   query = query.where('first_name', '=', firstName)
      * }
      *
+     * if (lastName) {
+     *   query = query.where('last_name', '=', lastName)
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
-     * This is true for basically all methods execpt the `select` and
-     * `returning`, that __do__ change the return type of the query.
-     *
-     * Both the first and third argument can also be subqueries.
-     * A subquery is defined by passing a function and calling
-     * the `selectFrom` method of the object passed into the
-     * function:
+     * Both the first and third argument can also be arbitrary expressions like
+     * subqueries. An expression can defined by passing a function and calling
+     * the methods of the {@link ExpressionBuilder} passed to the callback:
      *
      * ```ts
      * const persons = await db
@@ -103,8 +89,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ```
      *
      * A `where in` query can be built by using the `in` operator and an array
-     * of values. The values in the array can also be subqueries or raw
-     * {@link sql} expressions.
+     * of values. The values in the array can also be expressions:
      *
      * ```ts
      * const persons = await db
@@ -120,40 +105,53 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * If everything else fails, you can always use the {@link sql} tag
-     * as any of the arguments, including the operator:
+     * For complex `where` expressions you can pass in a single callback and
+     * use the {@link ExpressionBuilder} to build your expression:
      *
      * ```ts
-     * import { sql } from 'kysely'
-     *
      * const persons = await db
      *   .selectFrom('person')
-     *   .selectAll()
-     *   .where(
-     *     sql`coalesce(first_name, last_name)`,
-     *     'like',
-     *     '%' + name + '%',
-     *   )
-     *   .execute()
+     *   .selectAll('person')
+     *   .where(({ cmpr, or, and, not, exists, selectFrom, val }) => and([
+     *     or([
+     *       cmpr('first_name', '=', firstName),
+     *       cmpr('age', '<', maxAge)
+     *     ]),
+     *     not(exists(
+     *       selectFrom('pet').select('pet.id').whereRef('pet.owner_id', '=', 'person.id')
+     *     ))
+     *   ]))
      * ```
      *
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person"
-     * where coalesce(first_name, last_name) like $1
+     * select "person".*
+     * from "person"
+     * where (
+     *   (
+     *     "first_name" = $1
+     *     or "age" < $2
+     *   )
+     *   and not exists (
+     *     select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id"
+     *   )
+     * )
      * ```
      *
-     * If you only pass one function argument to this method, it can be
-     * used to create parentheses around other where statements:
+     * If everything else fails, you can always use the {@link sql} tag
+     * as any of the arguments, including the operator:
      *
      * ```ts
+     * import { sql } from 'kysely'
+     *
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
+     *   .where(
+     *     sql`coalesce(first_name, last_name)`,
+     *     'like',
+     *     '%' + name + '%',
      *   )
      *   .execute()
      * ```
@@ -161,7 +159,8 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * The generated SQL (PostgreSQL):
      *
      * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
+     * select * from "person"
+     * where coalesce(first_name, last_name) like $1
      * ```
      *
      * In all examples above the columns were known at compile time
@@ -183,12 +182,12 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   .selectFrom('person')
      *   .selectAll()
      *   .where(ref(columnFromUserInput), '=', 1)
-     *   .orWhere(sql.id(columnFromUserInput), '=', 2)
+     *   .where(sql.id(columnFromUserInput), '=', 2)
      *   .execute()
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    where(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
+    where(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>;
     where(expression: Expression<any>): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
@@ -220,7 +219,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .select((qb) => qb
+     *   .select((eb) => eb
      *     .selectFrom('pet')
      *     .select('name')
      *     .whereRef('pet.owner_id', '=', 'person.id')
@@ -243,152 +242,39 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     whereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Adds an `or where` clause to the query. Otherwise works just like {@link where}.
-     *
-     * It's often necessary to wrap `or where` clauses in parentheses to control
-     * precendence. You can use the one argument version of the `where` method
-     * for that. See the examples.
-     *
-     * ### Examples
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where('id', '=', 1)
-     *   .orWhere('id', '=', 2)
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" where "id" = 1 or "id" = 2
-     * ```
-     *
-     * Grouping with parentheses:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where((qb) => qb
-     *     .where('id', '=', 1)
-     *     .orWhere('id', '=', 2)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
-     * ```
-     *
-     * Even the first `where` can be an `orWhere`. This is useful
-     * if you are looping through a set of conditions:
-     *
-     * ```ts
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .where((qb) => qb
-     *     .orWhere('id', '=', 1)
-     *     .orWhere('id', '=', 2)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person" (where "id" = 1 or "id" = 2)
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhere<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    orWhere(grouper: WhereGrouper<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
+    orWhere(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>;
+    /**
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
+     */
     orWhere(expression: Expression<any>): WhereInterface<DB, TB>;
     /**
-     * Adds an `or where` clause to the query. Otherwise works just like {@link whereRef}.
-     *
-     * Also see {@link orWhere} and {@link where}.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereRef(lhs: ReferenceExpression<DB, TB>, op: ComparisonOperatorExpression, rhs: ReferenceExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Adds a `where exists` clause to the query.
-     *
-     * You can either use a subquery or a raw {@link sql} snippet.
-     *
-     * ### Examples
-     *
-     * The query below selets all persons that own a pet named Catto:
-     *
-     * ```ts
-     * const petName = 'Catto'
-     * const persons = await db
-     *   .selectFrom('person')
-     *   .selectAll()
-     *   .whereExists((qb) => qb
-     *     .selectFrom('pet')
-     *     .select('pet.id')
-     *     .whereRef('person.id', '=', 'pet.owner_id')
-     *     .where('pet.name', '=', petName)
-     *   )
-     *   .execute()
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select "pet"."id"
-     *   from "pet"
-     *   where "person"."id" = "pet"."owner_id"
-     *   and "pet"."name" = $1
-     * )
-     * ```
-     *
-     * The same query as in the previous example but with using raw {@link sql}:
-     *
-     * ```ts
-     * import { sql } from 'kysely'
-     *
-     * const petName = 'Catto'
-     * db.selectFrom('person')
-     *   .selectAll()
-     *   .whereExists(
-     *     sql`(select pet.id from pet where person.id = pet.owner_id and pet.name = ${petName})`
-     *   )
-     * ```
-     *
-     * The generated SQL (PostgreSQL):
-     *
-     * ```sql
-     * select * from "person"
-     * where exists (
-     *   select pet.id
-     *   from pet
-     *   where person.id = pet.owner_id
-     *   and pet.name = $1
-     * )
-     * ```
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Just like {@link whereExists} but creates a `not exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     whereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Just like {@link whereExists} but creates an `or exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Just like {@link whereExists} but creates an `or not exists` clause.
+     * @deprecated Follow [these](https://github.com/koskimas/kysely/releases/tag/0.24.0) instructions to migrate
      */
     orWhereNotExists(arg: ExistsExpression<DB, TB>): WhereInterface<DB, TB>;
     /**
-     * Clears all where clauses from the query.
+     * Clears all where expressions from the query.
      *
      * ### Examples
      *
@@ -407,3 +293,4 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     clearWhere(): WhereInterface<DB, TB>;
 }
+export declare type WhereExpressionFactory<DB, TB extends keyof DB> = (eb: WhereExpressionBuilder<DB, TB>) => Expression<SqlBool> | WhereExpressionBuilder<DB, TB>;

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -80,6 +80,7 @@ import { SetOperationNode } from '../operation-node/set-operation-node.js';
 import { BinaryOperationNode } from '../operation-node/binary-operation-node.js';
 import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
 import { UsingNode } from '../operation-node/using-node.js';
+import { FunctionNode } from '../operation-node/function-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -166,7 +167,9 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitPartitionByItem(node: PartitionByItemNode): void;
     protected visitBinaryOperation(node: BinaryOperationNode): void;
     protected visitUnaryOperation(node: UnaryOperationNode): void;
+    protected isMinusOperator(node: OperationNode): node is OperatorNode;
     protected visitUsing(node: UsingNode): void;
+    protected visitFunction(node: FunctionNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -1,6 +1,7 @@
 /// <reference types="./default-query-compiler.d.ts" />
 import { InsertQueryNode } from '../operation-node/insert-query-node.js';
 import { OperationNodeVisitor } from '../operation-node/operation-node-visitor.js';
+import { OperatorNode } from '../operation-node/operator-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { freeze, isString, isNumber, isBoolean, isNull, isDate, isBigInt, } from '../util/object-utils.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
@@ -550,6 +551,10 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.visitNode(node.expression);
             this.append(')');
         }
+        if (node.where) {
+            this.append(' ');
+            this.visitNode(node.where);
+        }
     }
     visitDropIndex(node) {
         this.append('drop index ');
@@ -862,7 +867,7 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.distinct) {
             this.append('distinct ');
         }
-        this.visitNode(node.column);
+        this.visitNode(node.aggregated);
         this.append(')');
         if (node.filter) {
             this.append(' filter(');
@@ -903,13 +908,24 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
     }
     visitUnaryOperation(node) {
         this.visitNode(node.operator);
-        this.append(' ');
+        if (!this.isMinusOperator(node.operator)) {
+            this.append(' ');
+        }
         this.visitNode(node.operand);
     }
+    isMinusOperator(node) {
+        return OperatorNode.is(node) && node.operator === '-';
+    }
     visitUsing(node) {
         this.append('using ');
         this.compileList(node.tables);
     }
+    visitFunction(node) {
+        this.append(node.func);
+        this.append('(');
+        this.compileList(node.arguments);
+        this.append(')');
+    }
     append(str) {
         this.#sql += str;
     }