kysely 0.26.0 → 0.26.2

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -6,7 +6,7 @@ import { SelectExpression, SelectArg } from '../parser/select-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { QueryNode } from '../operation-node/query-node.js';
-import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult } from '../util/type-utils.js';
+import { DrainOuterGeneric, NarrowPartial, Nullable, ShallowRecord, SimplifyResult, SimplifySingleResult, SqlBool } from '../util/type-utils.js';
 import { UpdateQueryNode } from '../operation-node/update-query-node.js';
 import { UpdateObject, UpdateObjectFactory } from '../parser/update-set-parser.js';
 import { Compilable } from '../util/compilable.js';
@@ -14,7 +14,7 @@ import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
 import { UpdateResult } from './update-result.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
-import { WhereExpressionFactory, WhereInterface } from './where-interface.js';
+import { WhereInterface } from './where-interface.js';
 import { ReturningInterface } from './returning-interface.js';
 import { NoResultErrorConstructor } from './no-result-error.js';
 import { Selectable } from '../util/column-type.js';
@@ -23,6 +23,7 @@ import { AliasedExpression, Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { Streamable } from '../util/streamable.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyof DB, O> implements WhereInterface<DB, TB>, ReturningInterface<DB, TB, O>, OperationNodeSource, Compilable<O>, Explainable, Streamable<O> {
     #private;
     constructor(props: UpdateQueryBuilderProps);
@@ -79,24 +80,53 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
      *
-     * To combine conditions using `OR`, you can use the expression builder:
+     * You can use the `and` function to create a simple equality
+     * filter using an object
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where(({ or, and, cmpr }) => or([
-     *     and([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('last_name', '=', 'Aniston')
-     *     ]),
-     *     and([
-     *       cmpr('first_name', '=', 'Sylvester'),
-     *       cmpr('last_name', '=', 'Stallone')
-     *     ])
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
      *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
      *   .execute()
      * ```
      *
@@ -106,19 +136,23 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * select *
      * from "person"
      * where (
-     *   ("first_name" = $1 AND "last_name" = $2)
-     *   OR
-     *   ("first_name" = $3 AND "last_name" = $4)
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
      * const firstName: string | undefined = 'Jennifer'
      * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
      *
      * let query = db
      *   .selectFrom('person')
@@ -134,6 +168,23 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -186,7 +237,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -198,10 +249,10 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
      *       selectFrom('pet')
@@ -276,8 +327,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(factory: WhereExpressionFactory<DB, TB>): UpdateQueryBuilder<DB, UT, TB, O>;
-    where(expression: Expression<any>): UpdateQueryBuilder<DB, UT, TB, O>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): UpdateQueryBuilder<DB, UT, TB, O>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -544,7 +594,38 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * update "person" set "first_name" = $1, "last_name" = $2 where "id" = $3
      * ```
      *
-     * On PostgreSQL you ca chain `returning` to the query to get
+     * <!-- siteExample("update", "Complex values", 20) -->
+     *
+     * As always, you can provide a callback to the `set` method to get access
+     * to an expression builder:
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set((eb) => ({
+     *     age: eb('age', '+', 1),
+     *     first_name: eb.selectFrom('pet').select('name').limit(1),
+     *     last_name: 'updated',
+     *   }))
+     *   .where('id', '=', '1')
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * update "person"
+     * set
+     *   "first_name" = (select "name" from "pet" limit $1),
+     *   "age" = "age" + $2,
+     *   "last_name" = $3
+     * where
+     *   "id" = $4
+     * ```
+     *
+     * On PostgreSQL you can chain `returning` to the query to get
      * the updated rows' columns (or any other expression) as the
      * return value:
      *
@@ -726,7 +807,7 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * }
      * ```
      */
-    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<DB, UT, TB, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
+    $if<O2>(condition: boolean, func: (qb: this) => UpdateQueryBuilder<any, any, any, O2>): O2 extends UpdateResult ? UpdateQueryBuilder<DB, UT, TB, UpdateResult> : O2 extends O & infer E ? UpdateQueryBuilder<DB, UT, TB, O & Partial<E>> : UpdateQueryBuilder<DB, UT, TB, Partial<O2>>;
     /**
      * Change the output type of the query.
      *

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

@@ -20,13 +20,13 @@ class UpdateQueryBuilder {
     where(...args) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseFilter)(args)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseValueBinaryOperationOrExpression)(args)),
         });
     }
     whereRef(lhs, op, rhs) {
         return new UpdateQueryBuilder({
             ...this.#props,
-            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialComparison)(lhs, op, rhs)),
+            queryNode: query_node_js_1.QueryNode.cloneWithWhere(this.#props.queryNode, (0, binary_operation_parser_js_1.parseReferentialBinaryOperation)(lhs, op, rhs)),
         });
     }
     clearWhere() {

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

@@ -1,8 +1,7 @@
-import { Expression } from '../expression/expression.js';
 import { ComparisonOperatorExpression, OperandValueExpressionOrList } from '../parser/binary-operation-parser.js';
 import { ReferenceExpression } from '../parser/reference-parser.js';
 import { SqlBool } from '../util/type-utils.js';
-import { ExpressionBuilder } from '../expression/expression-builder.js';
+import { ExpressionOrFactory } from '../parser/expression-parser.js';
 export interface WhereInterface<DB, TB extends keyof DB> {
     /**
      * Adds a `where` expression to the query.
@@ -57,24 +56,53 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "OR where", 30) -->
+     * <!-- siteExample("where", "Object filter", 30) -->
      *
-     * To combine conditions using `OR`, you can use the expression builder:
+     * You can use the `and` function to create a simple equality
+     * filter using an object
      *
      * ```ts
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll()
-     *   .where(({ or, and, cmpr }) => or([
-     *     and([
-     *       cmpr('first_name', '=', 'Jennifer'),
-     *       cmpr('last_name', '=', 'Aniston')
-     *     ]),
-     *     and([
-     *       cmpr('first_name', '=', 'Sylvester'),
-     *       cmpr('last_name', '=', 'Stallone')
-     *     ])
+     *   .where((eb) => eb.and({
+     *     first_name: 'Jennifer',
+     *     last_name: eb.ref('first_name')
+     *   }))
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select *
+     * from "person"
+     * where (
+     *   "first_name" = $1
+     *   and "last_name" = "first_name"
+     * )
+     * ```
+     *
+     * <!-- siteExample("where", "OR where", 40) -->
+     *
+     * To combine conditions using `OR`, you can use the expression builder.
+     * There are two ways to create `OR` expressions. Both are shown in this
+     * example:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .selectAll()
+     *   // 1. Using the `or` method on the expression builder:
+     *   .where((eb) => eb.or([
+     *     eb('first_name', '=', 'Jennifer'),
+     *     eb('first_name', '=', 'Sylvester')
      *   ]))
+     *   // 2. Chaining expressions using the `or` method on the
+     *   // created expressions:
+     *   .where((eb) =>
+     *     eb('last_name', '=', 'Aniston').or('last_name', '=', 'Stallone')
+     *   )
      *   .execute()
      * ```
      *
@@ -84,19 +112,23 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select *
      * from "person"
      * where (
-     *   ("first_name" = $1 AND "last_name" = $2)
-     *   OR
-     *   ("first_name" = $3 AND "last_name" = $4)
+     *   ("first_name" = $1 or "first_name" = $2)
+     *   and
+     *   ("last_name" = $3 or "last_name" = $4)
      * )
      * ```
      *
-     * <!-- siteExample("where", "Conditional where calls", 40) -->
+     * <!-- siteExample("where", "Conditional where calls", 50) -->
      *
      * You can add expressions conditionally like this:
      *
      * ```ts
+     * import { Expression, SqlBool } from 'kysely'
+     *
      * const firstName: string | undefined = 'Jennifer'
      * const lastName: string | undefined = 'Aniston'
+     * const under18 = true
+     * const over60 = true
      *
      * let query = db
      *   .selectFrom('person')
@@ -112,6 +144,23 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      *   query = query.where('last_name', '=', lastName)
      * }
      *
+     * if (under18 || over60) {
+     *   // Conditional OR expressions can be added like this.
+     *   query = query.where((eb) => {
+     *     const ors: Expression<SqlBool>[] = []
+     *
+     *     if (under18) {
+     *       ors.push(eb('age', '<', 18))
+     *     }
+     *
+     *     if (over60) {
+     *       ors.push(eb('age', '>', 60))
+     *     }
+     *
+     *     return eb.or(ors)
+     *   })
+     * }
+     *
      * const persons = await query.execute()
      * ```
      *
@@ -164,7 +213,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * select * from "person" where "id" in ($1, $2, $3)
      * ```
      *
-     * <!-- siteExample("where", "Complex where clause", 50) -->
+     * <!-- siteExample("where", "Complex where clause", 60) -->
      *
      * For complex `where` expressions you can pass in a single callback and
      * use the `ExpressionBuilder` to build your expression:
@@ -176,10 +225,10 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * const persons = await db
      *   .selectFrom('person')
      *   .selectAll('person')
-     *   .where(({ cmpr, or, and, not, exists, selectFrom }) => and([
+     *   .where(({ eb, or, and, not, exists, selectFrom }) => and([
      *     or([
-     *       cmpr('first_name', '=', firstName),
-     *       cmpr('age', '<', maxAge)
+     *       eb('first_name', '=', firstName),
+     *       eb('age', '<', maxAge)
      *     ]),
      *     not(exists(
      *       selectFrom('pet')
@@ -254,8 +303,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      * ```
      */
     where<RE extends ReferenceExpression<DB, TB>>(lhs: RE, op: ComparisonOperatorExpression, rhs: OperandValueExpressionOrList<DB, TB, RE>): WhereInterface<DB, TB>;
-    where(factory: WhereExpressionFactory<DB, TB>): WhereInterface<DB, TB>;
-    where(expression: Expression<any>): WhereInterface<DB, TB>;
+    where(expression: ExpressionOrFactory<DB, TB, SqlBool>): WhereInterface<DB, TB>;
     /**
      * Adds a `where` clause where both sides of the operator are references
      * to columns.
@@ -328,4 +376,3 @@ export interface WhereInterface<DB, TB extends keyof DB> {
      */
     clearWhere(): WhereInterface<DB, TB>;
 }
-export type WhereExpressionFactory<DB, TB extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => Expression<SqlBool>;

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

@@ -87,6 +87,7 @@ import { JSONReferenceNode } from '../operation-node/json-reference-node.js';
 import { JSONPathNode } from '../operation-node/json-path-node.js';
 import { JSONPathLegNode } from '../operation-node/json-path-leg-node.js';
 import { JSONOperatorChainNode } from '../operation-node/json-operator-chain-node.js';
+import { TupleNode } from '../operation-node/tuple-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -113,6 +114,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitOr(node: OrNode): void;
     protected visitValue(node: ValueNode): void;
     protected visitValueList(node: ValueListNode): void;
+    protected visitTuple(node: TupleNode): void;
     protected visitPrimitiveValueList(node: PrimitiveValueListNode): void;
     protected visitParens(node: ParensNode): void;
     protected visitJoin(node: JoinNode): void;
@@ -194,4 +196,5 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected sanitizeIdentifier(identifier: string): string;
     protected addParameter(parameter: unknown): void;
     protected appendImmediateValue(value: unknown): void;
+    protected sortSelectModifiers(arr: SelectModifierNode[]): ReadonlyArray<SelectModifierNode>;
 }

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

@@ -4,6 +4,7 @@ exports.DefaultQueryCompiler = void 0;
 const insert_query_node_js_1 = require("../operation-node/insert-query-node.js");
 const operation_node_visitor_js_1 = require("../operation-node/operation-node-visitor.js");
 const operator_node_js_1 = require("../operation-node/operator-node.js");
+const parens_node_js_1 = require("../operation-node/parens-node.js");
 const query_node_js_1 = require("../operation-node/query-node.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const create_view_node_js_1 = require("../operation-node/create-view-node.js");
@@ -29,6 +30,7 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitSelectQuery(node) {
         const wrapInParens = this.parentNode !== undefined &&
+            !parens_node_js_1.ParensNode.is(this.parentNode) &&
             !insert_query_node_js_1.InsertQueryNode.is(this.parentNode) &&
             !create_view_node_js_1.CreateViewNode.is(this.parentNode) &&
             !set_operation_node_js_1.SetOperationNode.is(this.parentNode);
@@ -43,20 +45,23 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.visitNode(node.with);
             this.append(' ');
         }
-        this.append('select ');
+        this.append('select');
         if (node.distinctOn) {
-            this.compileDistinctOn(node.distinctOn);
             this.append(' ');
+            this.compileDistinctOn(node.distinctOn);
         }
-        if (node.frontModifiers && node.frontModifiers.length > 0) {
-            this.compileList(node.frontModifiers, ' ');
+        if (node.frontModifiers?.length) {
             this.append(' ');
+            this.compileList(node.frontModifiers, ' ');
         }
         if (node.selections) {
+            this.append(' ');
             this.compileList(node.selections);
+        }
+        if (node.from) {
             this.append(' ');
+            this.visitNode(node.from);
         }
-        this.visitNode(node.from);
         if (node.joins) {
             this.append(' ');
             this.compileList(node.joins, ' ');
@@ -89,9 +94,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.offset);
         }
-        if (node.endModifiers && node.endModifiers.length > 0) {
+        if (node.endModifiers?.length) {
             this.append(' ');
-            this.compileList(node.endModifiers, ' ');
+            this.compileList(this.sortSelectModifiers([...node.endModifiers]), ' ');
         }
         if (wrapInParens) {
             this.append(')');
@@ -273,6 +278,11 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.compileList(node.values);
         this.append(')');
     }
+    visitTuple(node) {
+        this.append('(');
+        this.compileList(node.values);
+        this.append(')');
+    }
     visitPrimitiveValueList(node) {
         this.append('(');
         const { values } = node;
@@ -653,6 +663,12 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     visitCommonTableExpression(node) {
         this.visitNode(node.name);
         this.append(' as ');
+        if ((0, object_utils_js_1.isBoolean)(node.materialized)) {
+            if (!node.materialized) {
+                this.append('not ');
+            }
+            this.append('materialized ');
+        }
         this.visitNode(node.expression);
     }
     visitCommonTableExpressionName(node) {
@@ -1056,6 +1072,13 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             throw new Error(`invalid immediate value ${value}`);
         }
     }
+    sortSelectModifiers(arr) {
+        arr.sort((left, right) => left.modifier && right.modifier
+            ? SELECT_MODIFIER_PRIORITY[left.modifier] -
+                SELECT_MODIFIER_PRIORITY[right.modifier]
+            : 1);
+        return (0, object_utils_js_1.freeze)(arr);
+    }
 }
 exports.DefaultQueryCompiler = DefaultQueryCompiler;
 const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({
@@ -1067,6 +1090,15 @@ const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({
     SkipLocked: 'skip locked',
     Distinct: 'distinct',
 });
+const SELECT_MODIFIER_PRIORITY = (0, object_utils_js_1.freeze)({
+    ForKeyShare: 1,
+    ForNoKeyUpdate: 1,
+    ForUpdate: 1,
+    ForShare: 1,
+    NoWait: 2,
+    SkipLocked: 2,
+    Distinct: 0,
+});
 const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     InnerJoin: 'inner join',
     LeftJoin: 'left join',

package/dist/cjs/query-creator.d.ts

@@ -10,6 +10,8 @@ import { InsertResult } from './query-builder/insert-result.js';
 import { DeleteResult } from './query-builder/delete-result.js';
 import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
+import { CTEBuilderCallback } from './query-builder/cte-builder.js';
+import { SelectArg, SelectExpression, Selection } from './parser/select-parser.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -125,6 +127,54 @@ export declare class QueryCreator<DB> {
     selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB, TE>, {}>;
     selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    /**
+     * Creates a `select` query builder without a `from` clause.
+     *
+     * If you want to create a `select from` query, use the `selectFrom` method instead.
+     * This one can be used to create a plain `select` statement without a `from` clause.
+     *
+     * This method accepts the same inputs as {@link SelectQueryBuilder.select}. See its
+     * documentation for more examples.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = db.select((eb) => [
+     *   eb.selectFrom('person')
+     *     .select('id')
+     *     .where('first_name', '=', 'Jennifer')
+     *     .limit(1)
+     *     .as('jennifer_id'),
+     *
+     *   eb.selectFrom('pet')
+     *     .select('id')
+     *     .where('name', '=', 'Doggo')
+     *     .limit(1)
+     *     .as('doggo_id')
+     *   ])
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.jennifer_id)
+     * console.log(result.doggo_id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select (
+     *   select "id"
+     *   from "person"
+     *   where "first_name" = $1
+     *   limit $2
+     * ) as "jennifer_id", (
+     *   select "id"
+     *   from "pet"
+     *   where "name" = $3
+     *   limit $4
+     * ) as "doggo_id"
+     * ```
+     */
+    selectNoFrom<SE extends SelectExpression<DB, never>>(selection: SelectArg<DB, never, SE>): SelectQueryBuilder<DB, never, Selection<DB, never, SE>>;
     /**
      * Creates an insert query.
      *
@@ -310,14 +360,36 @@ export declare class QueryCreator<DB> {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The first argument can also be a callback. The callback is passed
+     * a `CTEBuilder` instance that can be used to configure the CTE:
+     *
+     * ```ts
+     * await db
+     *   .with(
+     *     (cte) => cte('jennifers').materialized(),
+     *     (db) => db
+     *       .selectFrom('person')
+     *       .where('first_name', '=', 'Jennifer')
+     *       .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
-    with<N extends string, E extends CommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    with<N extends string, E extends CommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Creates a recursive `with` query (Common Table Expression).
      *
+     * Note that recursiveness is a property of the whole `with` statement.
+     * You cannot have recursive and non-recursive CTEs in a same `with` statement.
+     * Therefore the recursiveness is determined by the **first** `with` or
+     * `withRecusive` call you make.
+     *
      * See the {@link with} method for examples and more documentation.
      */
-    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(nameOrBuilder: N | CTEBuilderCallback<N>, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Returns a copy of this query creator instance with the given plugin installed.
      */