Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit b5c605a

Browse files
igalklebanovigalklebanov
authoredJul 14, 2023
Merge branch 'master' into json-recipe
2 parents 2c1bb3e + 57ca6e5 commit b5c605a

37 files changed

+4266
-90
lines changed
 

‎.github/workflows/test.yml

+3
Original file line numberDiff line numberDiff line change
@@ -57,3 +57,6 @@ jobs:
5757

5858
- name: Run esbuild test
5959
run: npm run test:esbuild
60+
61+
- name: Run cloudflare workers test
62+
run: npm run test:cloudflare-workers

‎package.json

+1
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,7 @@
4040
"test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
4141
"test:browser": "npm run build && npm run test:browser:build && node test/browser/test.js",
4242
"test:bun": "npm run build && cd test/bun && bun install && bun run test",
43+
"test:cloudflare-workers": "npm run build && cd test/cloudflare-workers && npm ci && npm test",
4344
"test:deno": "npm run build && deno run --allow-env --allow-read --allow-net test/deno/local.test.ts && deno run --allow-env --allow-read --allow-net test/deno/cdn.test.ts",
4445
"test:typings": "tsd test/typings",
4546
"test:esmimports": "node scripts/check-esm-imports.js",

‎site/docs/examples/WHERE/0030-or-where.mdx ‎site/docs/examples/WHERE/0040-or-where.mdx

+1-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ import {
1515

1616
import {
1717
orWhere
18-
} from './0030-or-where'
18+
} from './0040-or-where'
1919

2020
<div style={{ marginBottom: '1em' }}>
2121
<Playground code={orWhere} setupCode={exampleSetup} />

‎site/docs/examples/WHERE/0040-conditional-where-calls.mdx ‎site/docs/examples/WHERE/0050-conditional-where-calls.mdx

+1-1
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ import {
1313

1414
import {
1515
conditionalWhereCalls
16-
} from './0040-conditional-where-calls'
16+
} from './0050-conditional-where-calls'
1717

1818
<div style={{ marginBottom: '1em' }}>
1919
<Playground code={conditionalWhereCalls} setupCode={exampleSetup} />

‎site/docs/examples/WHERE/0050-complex-where-clause.mdx ‎site/docs/examples/WHERE/0060-complex-where-clause.mdx

+1-1
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ import {
1414

1515
import {
1616
complexWhereClause
17-
} from './0050-complex-where-clause'
17+
} from './0060-complex-where-clause'
1818

1919
<div style={{ marginBottom: '1em' }}>
2020
<Playground code={complexWhereClause} setupCode={exampleSetup} />

‎site/docs/getting-started/Instantiation.tsx

+3-3
Original file line numberDiff line numberDiff line change
@@ -47,9 +47,9 @@ const dialect = new MysqlDialect({
4747
sqlite: (packageManager) =>
4848
isDialectSupported('sqlite', packageManager)
4949
? `import * as SQLite from '${DRIVER_NPM_PACKAGE_NAMES.sqlite}'
50-
import { Kysely, SQLiteDialect } from 'kysely'
50+
import { Kysely, SqliteDialect } from 'kysely'
5151
52-
const dialect = new SQLiteDialect({
52+
const dialect = new SqliteDialect({
5353
database: new SQLite(':memory:'),
5454
})`
5555
: `/* Kysely doesn't support SQLite + ${
@@ -67,7 +67,7 @@ const dialectClassNames: Record<
6767
postgresql: () => 'PostgresDialect',
6868
mysql: () => 'MysqlDialect',
6969
sqlite: (packageManager) =>
70-
isDialectSupported('sqlite', packageManager) ? 'SQLiteDialect' : null,
70+
isDialectSupported('sqlite', packageManager) ? 'SqliteDialect' : null,
7171
}
7272

7373
export function Instantiation(

‎src/expression/expression-builder.ts

+73-41
Original file line numberDiff line numberDiff line change
@@ -29,14 +29,15 @@ import { QueryExecutor } from '../query-executor/query-executor.js'
2929
import {
3030
BinaryOperatorExpression,
3131
ComparisonOperatorExpression,
32+
FilterObject,
3233
OperandValueExpression,
3334
OperandValueExpressionOrList,
35+
parseFilterList,
36+
parseFilterObject,
3437
parseValueBinaryOperation,
3538
parseValueBinaryOperationOrExpression,
3639
} from '../parser/binary-operation-parser.js'
3740
import { Expression } from './expression.js'
38-
import { AndNode } from '../operation-node/and-node.js'
39-
import { OrNode } from '../operation-node/or-node.js'
4041
import { ParensNode } from '../operation-node/parens-node.js'
4142
import { ExpressionWrapper } from './expression-wrapper.js'
4243
import {
@@ -51,10 +52,9 @@ import {
5152
parseValueExpressionOrList,
5253
} from '../parser/value-parser.js'
5354
import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js'
54-
import { ValueNode } from '../operation-node/value-node.js'
5555
import { CaseBuilder } from '../query-builder/case-builder.js'
5656
import { CaseNode } from '../operation-node/case-node.js'
57-
import { isUndefined } from '../util/object-utils.js'
57+
import { isReadonlyArray, isUndefined } from '../util/object-utils.js'
5858
import { JSONPathBuilder } from '../query-builder/json-path-builder.js'
5959

6060
export interface ExpressionBuilder<DB, TB extends keyof DB> {
@@ -577,15 +577,42 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
577577
* ```sql
578578
* select "person".*
579579
* from "person"
580-
* where "first_name" = $1
581-
* and "first_name" = $2
582-
* and "first_name" = $3
580+
* where (
581+
* "first_name" = $1
582+
* and "first_name" = $2
583+
* and "first_name" = $3
584+
* )
585+
* ```
586+
*
587+
* Optionally you can use the simpler object notation if you only need
588+
* equality comparisons:
589+
*
590+
* ```ts
591+
* db.selectFrom('person')
592+
* .selectAll('person')
593+
* .where((eb) => eb.and({
594+
* first_name: 'Jennifer',
595+
* last_name: 'Aniston'
596+
* }))
597+
* ```
598+
*
599+
* The generated SQL (PostgreSQL):
600+
*
601+
* ```sql
602+
* select "person".*
603+
* from "person"
604+
* where (
605+
* "first_name" = $1
606+
* and "last_name" = $2
607+
* )
583608
* ```
584609
*/
585610
and(
586611
exprs: ReadonlyArray<Expression<SqlBool>>
587612
): ExpressionWrapper<DB, TB, SqlBool>
588613

614+
and(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>
615+
589616
/**
590617
* Combines two or more expressions using the logical `or` operator.
591618
*
@@ -600,7 +627,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
600627
* ```ts
601628
* db.selectFrom('person')
602629
* .selectAll('person')
603-
* .where((eb) => or([
630+
* .where((eb) => eb.or([
604631
* eb('first_name', '=', 'Jennifer'),
605632
* eb('fist_name', '=', 'Arnold'),
606633
* eb('fist_name', '=', 'Sylvester')
@@ -612,15 +639,42 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
612639
* ```sql
613640
* select "person".*
614641
* from "person"
615-
* where "first_name" = $1
616-
* or "first_name" = $2
617-
* or "first_name" = $3
642+
* where (
643+
* "first_name" = $1
644+
* or "first_name" = $2
645+
* or "first_name" = $3
646+
* )
647+
* ```
648+
*
649+
* Optionally you can use the simpler object notation if you only need
650+
* equality comparisons:
651+
*
652+
* ```ts
653+
* db.selectFrom('person')
654+
* .selectAll('person')
655+
* .where((eb) => eb.or({
656+
* first_name: 'Jennifer',
657+
* last_name: 'Aniston'
658+
* }))
659+
* ```
660+
*
661+
* The generated SQL (PostgreSQL):
662+
*
663+
* ```sql
664+
* select "person".*
665+
* from "person"
666+
* where (
667+
* "first_name" = $1
668+
* or "last_name" = $2
669+
* )
618670
* ```
619671
*/
620672
or(
621673
exprs: ReadonlyArray<Expression<SqlBool>>
622674
): ExpressionWrapper<DB, TB, SqlBool>
623675

676+
or(exprs: Readonly<FilterObject<DB, TB>>): ExpressionWrapper<DB, TB, SqlBool>
677+
624678
/**
625679
* Wraps the expression in parentheses.
626680
*
@@ -812,45 +866,23 @@ export function createExpressionBuilder<DB, TB extends keyof DB>(
812866
},
813867

814868
and(
815-
exprs: ReadonlyArray<Expression<SqlBool>>
869+
exprs: ReadonlyArray<Expression<SqlBool>> | Readonly<FilterObject<DB, TB>>
816870
): ExpressionWrapper<DB, TB, SqlBool> {
817-
if (exprs.length === 0) {
818-
return new ExpressionWrapper(ValueNode.createImmediate(true))
819-
} else if (exprs.length === 1) {
820-
return new ExpressionWrapper(exprs[0].toOperationNode())
821-
}
822-
823-
let node = AndNode.create(
824-
exprs[0].toOperationNode(),
825-
exprs[1].toOperationNode()
826-
)
827-
828-
for (let i = 2; i < exprs.length; ++i) {
829-
node = AndNode.create(node, exprs[i].toOperationNode())
871+
if (isReadonlyArray(exprs)) {
872+
return new ExpressionWrapper(parseFilterList(exprs, 'and'))
830873
}
831874

832-
return new ExpressionWrapper(ParensNode.create(node))
875+
return new ExpressionWrapper(parseFilterObject(exprs, 'and'))
833876
},
834877

835878
or(
836-
exprs: ReadonlyArray<Expression<SqlBool>>
879+
exprs: ReadonlyArray<Expression<SqlBool>> | Readonly<FilterObject<DB, TB>>
837880
): ExpressionWrapper<DB, TB, SqlBool> {
838-
if (exprs.length === 0) {
839-
return new ExpressionWrapper(ValueNode.createImmediate(false))
840-
} else if (exprs.length === 1) {
841-
return new ExpressionWrapper(exprs[0].toOperationNode())
842-
}
843-
844-
let node = OrNode.create(
845-
exprs[0].toOperationNode(),
846-
exprs[1].toOperationNode()
847-
)
848-
849-
for (let i = 2; i < exprs.length; ++i) {
850-
node = OrNode.create(node, exprs[i].toOperationNode())
881+
if (isReadonlyArray(exprs)) {
882+
return new ExpressionWrapper(parseFilterList(exprs, 'or'))
851883
}
852884

853-
return new ExpressionWrapper(ParensNode.create(node))
885+
return new ExpressionWrapper(parseFilterObject(exprs, 'or'))
854886
},
855887

856888
parens(...args: any[]) {

‎src/index.ts

+1
Original file line numberDiff line numberDiff line change
@@ -244,5 +244,6 @@ export {
244244
ComparisonOperatorExpression,
245245
OperandValueExpression,
246246
OperandValueExpressionOrList,
247+
FilterObject,
247248
} from './parser/binary-operation-parser.js'
248249
export { ExistsExpression } from './parser/unary-operation-parser.js'

‎src/operation-node/common-table-expression-node.ts

+16
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,15 @@ import { freeze } from '../util/object-utils.js'
22
import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js'
33
import { OperationNode } from './operation-node.js'
44

5+
type CommonTableExpressionNodeProps = Pick<
6+
CommonTableExpressionNode,
7+
'materialized'
8+
>
9+
510
export interface CommonTableExpressionNode extends OperationNode {
611
readonly kind: 'CommonTableExpressionNode'
712
readonly name: CommonTableExpressionNameNode
13+
readonly materialized?: boolean
814
readonly expression: OperationNode
915
}
1016

@@ -26,4 +32,14 @@ export const CommonTableExpressionNode = freeze({
2632
expression,
2733
})
2834
},
35+
36+
cloneWith(
37+
node: CommonTableExpressionNode,
38+
props: CommonTableExpressionNodeProps
39+
): CommonTableExpressionNode {
40+
return freeze({
41+
...node,
42+
...props,
43+
})
44+
},
2945
})

‎src/operation-node/operation-node-transformer.ts

+1
Original file line numberDiff line numberDiff line change
@@ -642,6 +642,7 @@ export class OperationNodeTransformer {
642642
return requireAllProps<CommonTableExpressionNode>({
643643
kind: 'CommonTableExpressionNode',
644644
name: this.transformNode(node.name),
645+
materialized: node.materialized,
645646
expression: this.transformNode(node.expression),
646647
})
647648
}

‎src/parser/binary-operation-parser.ts

+71-8
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,27 @@
11
import { BinaryOperationNode } from '../operation-node/binary-operation-node.js'
2-
import { isBoolean, isNull, isString } from '../util/object-utils.js'
3-
import { isOperationNodeSource } from '../operation-node/operation-node-source.js'
2+
import {
3+
isBoolean,
4+
isNull,
5+
isString,
6+
isUndefined,
7+
} from '../util/object-utils.js'
8+
import {
9+
OperationNodeSource,
10+
isOperationNodeSource,
11+
} from '../operation-node/operation-node-source.js'
412
import {
513
OperatorNode,
614
ComparisonOperator,
7-
ArithmeticOperator,
815
BinaryOperator,
916
Operator,
1017
OPERATORS,
1118
} from '../operation-node/operator-node.js'
1219
import {
1320
ExtractTypeFromReferenceExpression,
21+
ExtractTypeFromStringReference,
1422
parseReferenceExpression,
1523
ReferenceExpression,
24+
StringReference,
1625
} from './reference-parser.js'
1726
import {
1827
parseValueExpression,
@@ -23,6 +32,10 @@ import {
2332
import { ValueNode } from '../operation-node/value-node.js'
2433
import { OperationNode } from '../operation-node/operation-node.js'
2534
import { Expression } from '../expression/expression.js'
35+
import { SelectType } from '../util/column-type.js'
36+
import { AndNode } from '../operation-node/and-node.js'
37+
import { ParensNode } from '../operation-node/parens-node.js'
38+
import { OrNode } from '../operation-node/or-node.js'
2639

2740
export type OperandValueExpression<
2841
DB,
@@ -47,9 +60,13 @@ export type ComparisonOperatorExpression =
4760
| ComparisonOperator
4861
| Expression<unknown>
4962

50-
export type ArithmeticOperatorExpression =
51-
| ArithmeticOperator
52-
| Expression<unknown>
63+
export type FilterObject<DB, TB extends keyof DB> = {
64+
[R in StringReference<DB, TB>]?: ValueExpressionOrList<
65+
DB,
66+
TB,
67+
SelectType<ExtractTypeFromStringReference<DB, TB, R>>
68+
>
69+
}
5370

5471
export function parseValueBinaryOperationOrExpression(
5572
args: any[]
@@ -68,7 +85,7 @@ export function parseValueBinaryOperation(
6885
operator: BinaryOperatorExpression,
6986
right: OperandValueExpressionOrList<any, any, any>
7087
): BinaryOperationNode {
71-
if (isIsOperator(operator) && isNullOrBoolean(right)) {
88+
if (isIsOperator(operator) && needsIsOperator(right)) {
7289
return BinaryOperationNode.create(
7390
parseReferenceExpression(left),
7491
parseOperator(operator),
@@ -82,6 +99,7 @@ export function parseValueBinaryOperation(
8299
parseValueExpressionOrList(right)
83100
)
84101
}
102+
85103
export function parseReferentialBinaryOperation(
86104
left: ReferenceExpression<any, any>,
87105
operator: BinaryOperatorExpression,
@@ -94,13 +112,50 @@ export function parseReferentialBinaryOperation(
94112
)
95113
}
96114

115+
export function parseFilterObject(
116+
obj: Readonly<FilterObject<any, any>>,
117+
combinator: 'and' | 'or'
118+
): OperationNode {
119+
return parseFilterList(
120+
Object.entries(obj)
121+
.filter(([, v]) => !isUndefined(v))
122+
.map(([k, v]) =>
123+
parseValueBinaryOperation(k, needsIsOperator(v) ? 'is' : '=', v)
124+
),
125+
combinator
126+
)
127+
}
128+
129+
export function parseFilterList(
130+
list: ReadonlyArray<OperationNodeSource | OperationNode>,
131+
combinator: 'and' | 'or'
132+
): OperationNode {
133+
const combine = combinator === 'and' ? AndNode.create : OrNode.create
134+
135+
if (list.length === 0) {
136+
return ValueNode.createImmediate(combinator === 'and')
137+
}
138+
139+
let node = toOperationNode(list[0])
140+
141+
for (let i = 1; i < list.length; ++i) {
142+
node = combine(node, toOperationNode(list[i]))
143+
}
144+
145+
if (list.length > 1) {
146+
return ParensNode.create(node)
147+
}
148+
149+
return node
150+
}
151+
97152
function isIsOperator(
98153
operator: BinaryOperatorExpression
99154
): operator is 'is' | 'is not' {
100155
return operator === 'is' || operator === 'is not'
101156
}
102157

103-
function isNullOrBoolean(value: unknown): value is null | boolean {
158+
function needsIsOperator(value: unknown): value is null | boolean {
104159
return isNull(value) || isBoolean(value)
105160
}
106161

@@ -115,3 +170,11 @@ function parseOperator(operator: OperatorExpression): OperationNode {
115170

116171
throw new Error(`invalid operator ${JSON.stringify(operator)}`)
117172
}
173+
174+
function toOperationNode(
175+
nodeOrSource: OperationNode | OperationNodeSource
176+
): OperationNode {
177+
return isOperationNodeSource(nodeOrSource)
178+
? nodeOrSource.toOperationNode()
179+
: nodeOrSource
180+
}

‎src/parser/expression-parser.ts

+4-4
Original file line numberDiff line numberDiff line change
@@ -29,13 +29,13 @@ export type AliasedExpressionOrFactory<DB, TB extends keyof DB> =
2929
| AliasedExpression<any, any>
3030
| AliasedExpressionFactory<DB, TB>
3131

32-
type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (
32+
export type ExpressionFactory<DB, TB extends keyof DB, V> = (
3333
eb: ExpressionBuilder<DB, TB>
34-
) => SelectQueryBuilder<any, any, V>
34+
) => Expression<V>
3535

36-
type ExpressionFactory<DB, TB extends keyof DB, V> = (
36+
type SelectQueryBuilderFactory<DB, TB extends keyof DB, V> = (
3737
eb: ExpressionBuilder<DB, TB>
38-
) => Expression<V>
38+
) => SelectQueryBuilder<any, any, V>
3939

4040
type AliasedExpressionFactory<DB, TB extends keyof DB> = (
4141
eb: ExpressionBuilder<DB, TB>

‎src/parser/join-parser.ts

+1-2
Original file line numberDiff line numberDiff line change
@@ -43,8 +43,7 @@ function parseCallbackJoin(
4343
from: TableExpression<any, any>,
4444
callback: JoinCallbackExpression<any, any, any>
4545
): JoinNode {
46-
const joinBuilder = callback(createJoinBuilder(joinType, from))
47-
return joinBuilder.toOperationNode()
46+
return callback(createJoinBuilder(joinType, from)).toOperationNode()
4847
}
4948

5049
function parseSingleOnJoin(

‎src/parser/set-operation-parser.ts

+7-2
Original file line numberDiff line numberDiff line change
@@ -3,11 +3,16 @@ import {
33
SetOperator,
44
SetOperationNode,
55
} from '../operation-node/set-operation-node.js'
6+
import { ExpressionFactory, parseExpression } from './expression-parser.js'
7+
8+
export type SetOperandExpression<DB, O> =
9+
| Expression<O>
10+
| ExpressionFactory<DB, never, O>
611

712
export function parseSetOperation(
813
operator: SetOperator,
9-
expression: Expression<any>,
14+
expression: SetOperandExpression<any, any>,
1015
all: boolean
1116
) {
12-
return SetOperationNode.create(operator, expression.toOperationNode(), all)
17+
return SetOperationNode.create(operator, parseExpression(expression), all)
1318
}

‎src/parser/with-parser.ts

+27-8
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,15 @@
11
import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js'
22
import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js'
33
import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js'
4-
import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js'
54
import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js'
65
import { QueryCreator } from '../query-creator.js'
7-
import { createQueryCreator } from './parse-utils.js'
86
import { Expression } from '../expression/expression.js'
97
import { ShallowRecord } from '../util/type-utils.js'
8+
import { OperationNode } from '../operation-node/operation-node.js'
9+
import { createQueryCreator } from './parse-utils.js'
10+
import { isFunction } from '../util/object-utils.js'
11+
import { CTEBuilder, CTEBuilderCallback } from '../query-builder/cte-builder.js'
12+
import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js'
1013

1114
export type CommonTableExpression<DB, CN extends string> = (
1215
creator: QueryCreator<DB>
@@ -91,23 +94,39 @@ type ExtractColumnNamesFromColumnList<R extends string> =
9194
: R
9295

9396
export function parseCommonTableExpression(
94-
name: string,
95-
expression: CommonTableExpression<any, any>
97+
nameOrBuilderCallback: string | CTEBuilderCallback<string>,
98+
expression: CommonTableExpression<any, string>
9699
): CommonTableExpressionNode {
97-
const builder = expression(createQueryCreator())
100+
const expressionNode = expression(createQueryCreator()).toOperationNode()
101+
102+
if (isFunction(nameOrBuilderCallback)) {
103+
return nameOrBuilderCallback(
104+
cteBuilderFactory(expressionNode)
105+
).toOperationNode()
106+
}
98107

99108
return CommonTableExpressionNode.create(
100-
parseCommonTableExpressionName(name),
101-
builder.toOperationNode()
109+
parseCommonTableExpressionName(nameOrBuilderCallback),
110+
expressionNode
102111
)
103112
}
104113

114+
function cteBuilderFactory(expressionNode: OperationNode) {
115+
return (name: string) => {
116+
return new CTEBuilder({
117+
node: CommonTableExpressionNode.create(
118+
parseCommonTableExpressionName(name),
119+
expressionNode
120+
),
121+
})
122+
}
123+
}
124+
105125
function parseCommonTableExpressionName(
106126
name: string
107127
): CommonTableExpressionNameNode {
108128
if (name.includes('(')) {
109129
const parts = name.split(/[\(\)]/)
110-
111130
const table = parts[0]
112131
const columns = parts[1].split(',').map((it) => it.trim())
113132

‎src/query-builder/cte-builder.ts

+54
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
import { OperationNodeSource } from '../operation-node/operation-node-source.js'
2+
import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js'
3+
import { preventAwait } from '../util/prevent-await.js'
4+
import { freeze } from '../util/object-utils.js'
5+
6+
export class CTEBuilder<N extends string> implements OperationNodeSource {
7+
readonly #props: CTEBuilderProps
8+
9+
constructor(props: CTEBuilderProps) {
10+
this.#props = freeze(props)
11+
}
12+
13+
/**
14+
* Makes the common table expression materialized.
15+
*/
16+
materialized(): CTEBuilder<N> {
17+
return new CTEBuilder({
18+
...this.#props,
19+
node: CommonTableExpressionNode.cloneWith(this.#props.node, {
20+
materialized: true,
21+
}),
22+
})
23+
}
24+
25+
/**
26+
* Makes the common table expression not materialized.
27+
*/
28+
notMaterialized(): CTEBuilder<N> {
29+
return new CTEBuilder({
30+
...this.#props,
31+
node: CommonTableExpressionNode.cloneWith(this.#props.node, {
32+
materialized: false,
33+
}),
34+
})
35+
}
36+
37+
toOperationNode(): CommonTableExpressionNode {
38+
return this.#props.node
39+
}
40+
}
41+
42+
preventAwait(
43+
CTEBuilder,
44+
"don't await CTEBuilder instances. They are never executed directly and are always just a part of a query."
45+
)
46+
47+
interface CTEBuilderProps {
48+
readonly node: CommonTableExpressionNode
49+
}
50+
51+
export type CTEBuilderCallback<N extends string> = (
52+
// N2 is needed for proper inference. Don't remove it.
53+
cte: <N2 extends string>(name: N2) => CTEBuilder<N2>
54+
) => CTEBuilder<N>

‎src/query-builder/json-path-builder.ts

+3
Original file line numberDiff line numberDiff line change
@@ -151,6 +151,9 @@ export class JSONPathBuilder<S, O = S> {
151151
? null | NonNullable<NonNullable<O>[K]>
152152
: null extends O
153153
? null | NonNullable<NonNullable<O>[K]>
154+
: // when the object has non-specific keys, e.g. Record<string, T>, should infer `T | null`!
155+
string extends keyof NonNullable<O>
156+
? null | NonNullable<NonNullable<O>[K]>
154157
: NonNullable<O>[K]
155158
>(key: K): TraversedJSONPathBuilder<S, O2> {
156159
return this.#createBuilderWithPathLeg('Member', key)

‎src/query-builder/select-query-builder.ts

+94-7
Original file line numberDiff line numberDiff line change
@@ -53,7 +53,10 @@ import {
5353
import { HavingExpressionFactory, HavingInterface } from './having-interface.js'
5454
import { IdentifierNode } from '../operation-node/identifier-node.js'
5555
import { Explainable, ExplainFormat } from '../util/explainable.js'
56-
import { parseSetOperation } from '../parser/set-operation-parser.js'
56+
import {
57+
SetOperandExpression,
58+
parseSetOperation,
59+
} from '../parser/set-operation-parser.js'
5760
import { AliasedExpression, Expression } from '../expression/expression.js'
5861
import {
5962
ComparisonOperatorExpression,
@@ -1205,8 +1208,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
12051208
* .union(db.selectFrom('pet').select(['id', 'name']))
12061209
* .orderBy('name')
12071210
* ```
1211+
*
1212+
* You can provide a callback to get an expression builder.
1213+
* In the following example, this allows us to wrap the query in parentheses:
1214+
*
1215+
* ```ts
1216+
* db.selectFrom('person')
1217+
* .select(['id', 'first_name as name'])
1218+
* .union((eb) => eb.parens(
1219+
* eb.selectFrom('pet').select(['id', 'name'])
1220+
* ))
1221+
* .orderBy('name')
1222+
* ```
12081223
*/
1209-
union(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1224+
union(
1225+
expression: SetOperandExpression<DB, O>
1226+
): SelectQueryBuilder<DB, TB, O> {
12101227
return new SelectQueryBuilder({
12111228
...this.#props,
12121229
queryNode: SelectQueryNode.cloneWithSetOperation(
@@ -1229,8 +1246,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
12291246
* .unionAll(db.selectFrom('pet').select(['id', 'name']))
12301247
* .orderBy('name')
12311248
* ```
1249+
*
1250+
* You can provide a callback to get an expression builder.
1251+
* In the following example, this allows us to wrap the query in parentheses:
1252+
*
1253+
* ```ts
1254+
* db.selectFrom('person')
1255+
* .select(['id', 'first_name as name'])
1256+
* .unionAll((eb) => eb.parens(
1257+
* eb.selectFrom('pet').select(['id', 'name'])
1258+
* ))
1259+
* .orderBy('name')
1260+
* ```
12321261
*/
1233-
unionAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1262+
unionAll(
1263+
expression: SetOperandExpression<DB, O>
1264+
): SelectQueryBuilder<DB, TB, O> {
12341265
return new SelectQueryBuilder({
12351266
...this.#props,
12361267
queryNode: SelectQueryNode.cloneWithSetOperation(
@@ -1253,8 +1284,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
12531284
* .intersect(db.selectFrom('pet').select(['id', 'name']))
12541285
* .orderBy('name')
12551286
* ```
1287+
*
1288+
* You can provide a callback to get an expression builder.
1289+
* In the following example, this allows us to wrap the query in parentheses:
1290+
*
1291+
* ```ts
1292+
* db.selectFrom('person')
1293+
* .select(['id', 'first_name as name'])
1294+
* .intersect((eb) => eb.parens(
1295+
* eb.selectFrom('pet').select(['id', 'name'])
1296+
* ))
1297+
* .orderBy('name')
1298+
* ```
12561299
*/
1257-
intersect(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1300+
intersect(
1301+
expression: SetOperandExpression<DB, O>
1302+
): SelectQueryBuilder<DB, TB, O> {
12581303
return new SelectQueryBuilder({
12591304
...this.#props,
12601305
queryNode: SelectQueryNode.cloneWithSetOperation(
@@ -1277,8 +1322,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
12771322
* .intersectAll(db.selectFrom('pet').select(['id', 'name']))
12781323
* .orderBy('name')
12791324
* ```
1325+
*
1326+
* You can provide a callback to get an expression builder.
1327+
* In the following example, this allows us to wrap the query in parentheses:
1328+
*
1329+
* ```ts
1330+
* db.selectFrom('person')
1331+
* .select(['id', 'first_name as name'])
1332+
* .intersectAll((eb) => eb.parens(
1333+
* eb.selectFrom('pet').select(['id', 'name'])
1334+
* ))
1335+
* .orderBy('name')
1336+
* ```
12801337
*/
1281-
intersectAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1338+
intersectAll(
1339+
expression: SetOperandExpression<DB, O>
1340+
): SelectQueryBuilder<DB, TB, O> {
12821341
return new SelectQueryBuilder({
12831342
...this.#props,
12841343
queryNode: SelectQueryNode.cloneWithSetOperation(
@@ -1301,8 +1360,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
13011360
* .except(db.selectFrom('pet').select(['id', 'name']))
13021361
* .orderBy('name')
13031362
* ```
1363+
*
1364+
* You can provide a callback to get an expression builder.
1365+
* In the following example, this allows us to wrap the query in parentheses:
1366+
*
1367+
* ```ts
1368+
* db.selectFrom('person')
1369+
* .select(['id', 'first_name as name'])
1370+
* .except((eb) => eb.parens(
1371+
* eb.selectFrom('pet').select(['id', 'name'])
1372+
* ))
1373+
* .orderBy('name')
1374+
* ```
13041375
*/
1305-
except(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1376+
except(
1377+
expression: SetOperandExpression<DB, O>
1378+
): SelectQueryBuilder<DB, TB, O> {
13061379
return new SelectQueryBuilder({
13071380
...this.#props,
13081381
queryNode: SelectQueryNode.cloneWithSetOperation(
@@ -1325,8 +1398,22 @@ export class SelectQueryBuilder<DB, TB extends keyof DB, O>
13251398
* .exceptAll(db.selectFrom('pet').select(['id', 'name']))
13261399
* .orderBy('name')
13271400
* ```
1401+
*
1402+
* You can provide a callback to get an expression builder.
1403+
* In the following example, this allows us to wrap the query in parentheses:
1404+
*
1405+
* ```ts
1406+
* db.selectFrom('person')
1407+
* .select(['id', 'first_name as name'])
1408+
* .exceptAll((eb) => eb.parens(
1409+
* eb.selectFrom('pet').select(['id', 'name'])
1410+
* ))
1411+
* .orderBy('name')
1412+
* ```
13281413
*/
1329-
exceptAll(expression: Expression<O>): SelectQueryBuilder<DB, TB, O> {
1414+
exceptAll(
1415+
expression: SetOperandExpression<DB, O>
1416+
): SelectQueryBuilder<DB, TB, O> {
13301417
return new SelectQueryBuilder({
13311418
...this.#props,
13321419
queryNode: SelectQueryNode.cloneWithSetOperation(

‎src/query-builder/where-interface.ts

+30-3
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,34 @@ export interface WhereInterface<DB, TB extends keyof DB> {
6161
* select * from "person" where "id" in ($1, $2, $3)
6262
* ```
6363
*
64-
* <!-- siteExample("where", "OR where", 30) -->
64+
* <!-- siteExample("where", "Object filter", 30) -->
65+
*
66+
* You can use the `and` function to create a simple equality
67+
* filter using an object
68+
*
69+
* ```ts
70+
* const persons = await db
71+
* .selectFrom('person')
72+
* .selectAll()
73+
* .where((eb) => eb.and({
74+
* first_name: 'Jennifer',
75+
* last_name: eb.ref('first_name')
76+
* }))
77+
* .execute()
78+
* ```
79+
*
80+
* The generated SQL (PostgreSQL):
81+
*
82+
* ```sql
83+
* select *
84+
* from "person"
85+
* where (
86+
* "first_name" = $1
87+
* and "last_name" = "first_name"
88+
* )
89+
* ```
90+
*
91+
* <!-- siteExample("where", "OR where", 40) -->
6592
*
6693
* To combine conditions using `OR`, you can use the expression builder.
6794
* There are two ways to create `OR` expressions. Both are shown in this
@@ -96,7 +123,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
96123
* )
97124
* ```
98125
*
99-
* <!-- siteExample("where", "Conditional where calls", 40) -->
126+
* <!-- siteExample("where", "Conditional where calls", 50) -->
100127
*
101128
* You can add expressions conditionally like this:
102129
*
@@ -191,7 +218,7 @@ export interface WhereInterface<DB, TB extends keyof DB> {
191218
* select * from "person" where "id" in ($1, $2, $3)
192219
* ```
193220
*
194-
* <!-- siteExample("where", "Complex where clause", 50) -->
221+
* <!-- siteExample("where", "Complex where clause", 60) -->
195222
*
196223
* For complex `where` expressions you can pass in a single callback and
197224
* use the `ExpressionBuilder` to build your expression:

‎src/query-compiler/default-query-compiler.ts

+10
Original file line numberDiff line numberDiff line change
@@ -132,6 +132,7 @@ export class DefaultQueryCompiler
132132
protected override visitSelectQuery(node: SelectQueryNode): void {
133133
const wrapInParens =
134134
this.parentNode !== undefined &&
135+
!ParensNode.is(this.parentNode) &&
135136
!InsertQueryNode.is(this.parentNode) &&
136137
!CreateViewNode.is(this.parentNode) &&
137138
!SetOperationNode.is(this.parentNode)
@@ -938,6 +939,15 @@ export class DefaultQueryCompiler
938939
): void {
939940
this.visitNode(node.name)
940941
this.append(' as ')
942+
943+
if (isBoolean(node.materialized)) {
944+
if (!node.materialized) {
945+
this.append('not ')
946+
}
947+
948+
this.append('materialized ')
949+
}
950+
941951
this.visitNode(node.expression)
942952
}
943953

‎src/query-creator.ts

+31-5
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,9 @@ import {
2323
import { QueryExecutor } from './query-executor/query-executor.js'
2424
import {
2525
CommonTableExpression,
26-
parseCommonTableExpression,
2726
QueryCreatorWithCommonTableExpression,
2827
RecursiveCommonTableExpression,
28+
parseCommonTableExpression,
2929
} from './parser/with-parser.js'
3030
import { WithNode } from './operation-node/with-node.js'
3131
import { createQueryId } from './util/query-id.js'
@@ -35,6 +35,7 @@ import { InsertResult } from './query-builder/insert-result.js'
3535
import { DeleteResult } from './query-builder/delete-result.js'
3636
import { UpdateResult } from './query-builder/update-result.js'
3737
import { KyselyPlugin } from './plugin/kysely-plugin.js'
38+
import { CTEBuilderCallback } from './query-builder/cte-builder.js'
3839

3940
export class QueryCreator<DB> {
4041
readonly #props: QueryCreatorProps
@@ -453,12 +454,29 @@ export class QueryCreator<DB> {
453454
* .selectAll()
454455
* .execute()
455456
* ```
457+
*
458+
* The first argument can also be a callback. The callback is passed
459+
* a `CTEBuilder` instance that can be used to configure the CTE:
460+
*
461+
* ```ts
462+
* await db
463+
* .with(
464+
* (cte) => cte('jennifers').materialized(),
465+
* (db) => db
466+
* .selectFrom('person')
467+
* .where('first_name', '=', 'Jennifer')
468+
* .select(['id', 'age'])
469+
* )
470+
* .selectFrom('jennifers')
471+
* .selectAll()
472+
* .execute()
473+
* ```
456474
*/
457475
with<N extends string, E extends CommonTableExpression<DB, N>>(
458-
name: N,
476+
nameOrBuilder: N | CTEBuilderCallback<N>,
459477
expression: E
460478
): QueryCreatorWithCommonTableExpression<DB, N, E> {
461-
const cte = parseCommonTableExpression(name, expression)
479+
const cte = parseCommonTableExpression(nameOrBuilder, expression)
462480

463481
return new QueryCreator({
464482
...this.#props,
@@ -471,13 +489,21 @@ export class QueryCreator<DB> {
471489
/**
472490
* Creates a recursive `with` query (Common Table Expression).
473491
*
492+
* Note that recursiveness is a property of the whole `with` statement.
493+
* You cannot have recursive and non-recursive CTEs in a same `with` statement.
494+
* Therefore the recursiveness is determined by the **first** `with` or
495+
* `withRecusive` call you make.
496+
*
474497
* See the {@link with} method for examples and more documentation.
475498
*/
476499
withRecursive<
477500
N extends string,
478501
E extends RecursiveCommonTableExpression<DB, N>
479-
>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E> {
480-
const cte = parseCommonTableExpression(name, expression)
502+
>(
503+
nameOrBuilder: N | CTEBuilderCallback<N>,
504+
expression: E
505+
): QueryCreatorWithCommonTableExpression<DB, N, E> {
506+
const cte = parseCommonTableExpression(nameOrBuilder, expression)
481507

482508
return new QueryCreator({
483509
...this.#props,

‎test/cloudflare-workers/.dev.vars

Whitespace-only changes.

‎test/cloudflare-workers/api.ts

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
import { Pool } from 'pg'
2+
import { Hono } from 'hono'
3+
import { Generated, Kysely, PostgresDialect, sql } from '../../'
4+
5+
interface Person {
6+
id: Generated<number>
7+
first_name: string
8+
last_name: string | null
9+
}
10+
11+
interface Database {
12+
person: Person
13+
}
14+
15+
const db = new Kysely<Database>({
16+
dialect: new PostgresDialect({
17+
pool: new Pool({
18+
database: 'kysely_test',
19+
host: 'localhost',
20+
user: 'kysely',
21+
port: 5434,
22+
}),
23+
}),
24+
})
25+
26+
const app = new Hono()
27+
28+
app.get('/', async (c) => {
29+
if (
30+
db.selectFrom('person').selectAll().compile().sql !==
31+
'select * from "person"'
32+
) {
33+
throw new Error('Unexpected SQL')
34+
}
35+
36+
const {
37+
rows: [row],
38+
} = await sql`select 1 as ok`.execute(db)
39+
40+
return c.json(row)
41+
})
42+
43+
export default app

‎test/cloudflare-workers/package-lock.json

+3,457
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎test/cloudflare-workers/package.json

+12
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
{
2+
"name": "kysely-cloudflare-workers-test",
3+
"private": true,
4+
"scripts": {
5+
"test": "tsx test.ts"
6+
},
7+
"devDependencies": {
8+
"hono": "^3.2.7",
9+
"tsx": "^3.12.7",
10+
"wrangler": "^3.1.2"
11+
}
12+
}

‎test/cloudflare-workers/test.ts

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
import { unstable_dev } from 'wrangler'
2+
;(async () => {
3+
const worker = await unstable_dev('./api.ts', {
4+
compatibilityDate: '2023-06-28',
5+
experimental: { disableExperimentalWarning: true },
6+
local: true,
7+
// logLevel: 'debug',
8+
nodeCompat: true,
9+
vars: {
10+
NAME: 'cloudflare',
11+
},
12+
})
13+
14+
let exitCode = 0
15+
16+
try {
17+
const response = await worker.fetch('/')
18+
19+
if (!response.ok) {
20+
throw new Error(`Unexpected response: ${response.status}`)
21+
}
22+
23+
console.log('test successful!')
24+
} catch (error) {
25+
exitCode = 1
26+
} finally {
27+
await worker.stop()
28+
process.exit(exitCode)
29+
}
30+
})()

‎test/node/src/expression.test.ts

+16-3
Original file line numberDiff line numberDiff line change
@@ -61,12 +61,19 @@ for (const dialect of DIALECTS) {
6161
// Should not produce double parens
6262
parens(eb('id', '=', 1).or('id', '=', 2)),
6363
eb(parens('id', '+', 1), '>', 10),
64+
// Object and
65+
eb.and({ first_name: 'Jennifer', last_name: 'Aniston' }),
66+
// Object or
67+
eb.or({
68+
first_name: eb.ref('last_name'),
69+
last_name: eb.ref('first_name'),
70+
}),
6471
])
6572
)
6673

6774
testSql(query, dialect, {
6875
postgres: {
69-
sql: 'select "person".* from "person" where ((not "first_name" = $1 or "id" + $2 > $3 or "id" in ($4, $5, $6) or upper("first_name") = $7 or false) and exists (select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id") and true and ("id" = $8 or "id" = $9 or "id" = $10 or "id" = $11) and ("id" = $12 and "first_name" = $13 and "last_name" = $14 and "marital_status" = $15) and ("id" = $16 or "id" = $17) and ("id" + $18) > $19)',
76+
sql: 'select "person".* from "person" where ((not "first_name" = $1 or "id" + $2 > $3 or "id" in ($4, $5, $6) or upper("first_name") = $7 or false) and exists (select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id") and true and ("id" = $8 or "id" = $9 or "id" = $10 or "id" = $11) and ("id" = $12 and "first_name" = $13 and "last_name" = $14 and "marital_status" = $15) and ("id" = $16 or "id" = $17) and ("id" + $18) > $19 and ("first_name" = $20 and "last_name" = $21) and ("first_name" = "last_name" or "last_name" = "first_name"))',
7077
parameters: [
7178
'Jennifer',
7279
1,
@@ -87,10 +94,12 @@ for (const dialect of DIALECTS) {
8794
2,
8895
1,
8996
10,
97+
'Jennifer',
98+
'Aniston',
9099
],
91100
},
92101
mysql: {
93-
sql: 'select `person`.* from `person` where ((not `first_name` = ? or `id` + ? > ? or `id` in (?, ?, ?) or upper(`first_name`) = ? or false) and exists (select `pet`.`id` from `pet` where `pet`.`owner_id` = `person`.`id`) and true and (`id` = ? or `id` = ? or `id` = ? or `id` = ?) and (`id` = ? and `first_name` = ? and `last_name` = ? and `marital_status` = ?) and (`id` = ? or `id` = ?) and (`id` + ?) > ?)',
102+
sql: 'select `person`.* from `person` where ((not `first_name` = ? or `id` + ? > ? or `id` in (?, ?, ?) or upper(`first_name`) = ? or false) and exists (select `pet`.`id` from `pet` where `pet`.`owner_id` = `person`.`id`) and true and (`id` = ? or `id` = ? or `id` = ? or `id` = ?) and (`id` = ? and `first_name` = ? and `last_name` = ? and `marital_status` = ?) and (`id` = ? or `id` = ?) and (`id` + ?) > ? and (`first_name` = ? and `last_name` = ?) and (`first_name` = `last_name` or `last_name` = `first_name`))',
94103
parameters: [
95104
'Jennifer',
96105
1,
@@ -111,10 +120,12 @@ for (const dialect of DIALECTS) {
111120
2,
112121
1,
113122
10,
123+
'Jennifer',
124+
'Aniston',
114125
],
115126
},
116127
sqlite: {
117-
sql: 'select "person".* from "person" where ((not "first_name" = ? or "id" + ? > ? or "id" in (?, ?, ?) or upper("first_name") = ? or false) and exists (select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id") and true and ("id" = ? or "id" = ? or "id" = ? or "id" = ?) and ("id" = ? and "first_name" = ? and "last_name" = ? and "marital_status" = ?) and ("id" = ? or "id" = ?) and ("id" + ?) > ?)',
128+
sql: 'select "person".* from "person" where ((not "first_name" = ? or "id" + ? > ? or "id" in (?, ?, ?) or upper("first_name") = ? or false) and exists (select "pet"."id" from "pet" where "pet"."owner_id" = "person"."id") and true and ("id" = ? or "id" = ? or "id" = ? or "id" = ?) and ("id" = ? and "first_name" = ? and "last_name" = ? and "marital_status" = ?) and ("id" = ? or "id" = ?) and ("id" + ?) > ? and ("first_name" = ? and "last_name" = ?) and ("first_name" = "last_name" or "last_name" = "first_name"))',
118129
parameters: [
119130
'Jennifer',
120131
1,
@@ -135,6 +146,8 @@ for (const dialect of DIALECTS) {
135146
2,
136147
1,
137148
10,
149+
'Jennifer',
150+
'Aniston',
138151
],
139152
},
140153
})

‎test/node/src/set-operation.test.ts

+39
Original file line numberDiff line numberDiff line change
@@ -63,6 +63,45 @@ for (const dialect of DIALECTS) {
6363
])
6464
})
6565

66+
if (dialect === 'postgres' || dialect === 'mysql') {
67+
it('should combine three select queries using union and an expression builder', async () => {
68+
const query = ctx.db
69+
.selectFrom('person')
70+
.select(['id', 'first_name as name'])
71+
.union((eb) =>
72+
eb.parens(
73+
eb
74+
.selectFrom('pet')
75+
.select(['id', 'name'])
76+
.union(eb.selectFrom('toy').select(['id', 'name']))
77+
)
78+
)
79+
.orderBy('name')
80+
81+
testSql(query, dialect, {
82+
postgres: {
83+
sql: 'select "id", "first_name" as "name" from "person" union (select "id", "name" from "pet" union select "id", "name" from "toy") order by "name"',
84+
parameters: [],
85+
},
86+
mysql: {
87+
sql: 'select `id`, `first_name` as `name` from `person` union (select `id`, `name` from `pet` union select `id`, `name` from `toy`) order by `name`',
88+
parameters: [],
89+
},
90+
sqlite: NOT_SUPPORTED,
91+
})
92+
93+
const result = await query.execute()
94+
expect(result).to.containSubset([
95+
{ name: 'Arnold' },
96+
{ name: 'Catto' },
97+
{ name: 'Doggo' },
98+
{ name: 'Hammo' },
99+
{ name: 'Jennifer' },
100+
{ name: 'Sylvester' },
101+
])
102+
})
103+
}
104+
66105
it('should combine two select queries using union all', async () => {
67106
const query = ctx.db
68107
.selectFrom('person')

‎test/node/src/where.test.ts

+107-1
Original file line numberDiff line numberDiff line change
@@ -416,7 +416,7 @@ for (const dialect of DIALECTS) {
416416
])
417417
})
418418

419-
it('two where clauses', async () => {
419+
it('two where expressions', async () => {
420420
const query = ctx.db
421421
.selectFrom('person')
422422
.selectAll()
@@ -486,6 +486,74 @@ for (const dialect of DIALECTS) {
486486
])
487487
})
488488

489+
it('`and where` using the expression builder and chaining', async () => {
490+
const query = ctx.db
491+
.selectFrom('person')
492+
.selectAll()
493+
.where((eb) =>
494+
eb('first_name', '=', 'Jennifer').and(
495+
eb.fn('upper', ['last_name']),
496+
'=',
497+
'ANISTON'
498+
)
499+
)
500+
501+
testSql(query, dialect, {
502+
postgres: {
503+
sql: 'select * from "person" where ("first_name" = $1 and upper("last_name") = $2)',
504+
parameters: ['Jennifer', 'ANISTON'],
505+
},
506+
mysql: {
507+
sql: 'select * from `person` where (`first_name` = ? and upper(`last_name`) = ?)',
508+
parameters: ['Jennifer', 'ANISTON'],
509+
},
510+
sqlite: {
511+
sql: 'select * from "person" where ("first_name" = ? and upper("last_name") = ?)',
512+
parameters: ['Jennifer', 'ANISTON'],
513+
},
514+
})
515+
516+
const persons = await query.execute()
517+
expect(persons).to.have.length(1)
518+
expect(persons).to.containSubset([
519+
{
520+
first_name: 'Jennifer',
521+
last_name: 'Aniston',
522+
gender: 'female',
523+
},
524+
])
525+
})
526+
527+
it('`and where` using the expression builder and a filter object', async () => {
528+
const query = ctx.db
529+
.selectFrom('person')
530+
.selectAll()
531+
.where((eb) =>
532+
eb.and({
533+
first_name: 'Jennifer',
534+
last_name: eb.fn<string>('upper', ['first_name']),
535+
})
536+
)
537+
538+
testSql(query, dialect, {
539+
postgres: {
540+
sql: 'select * from "person" where ("first_name" = $1 and "last_name" = upper("first_name"))',
541+
parameters: ['Jennifer'],
542+
},
543+
mysql: {
544+
sql: 'select * from `person` where (`first_name` = ? and `last_name` = upper(`first_name`))',
545+
parameters: ['Jennifer'],
546+
},
547+
sqlite: {
548+
sql: 'select * from "person" where ("first_name" = ? and "last_name" = upper("first_name"))',
549+
parameters: ['Jennifer'],
550+
},
551+
})
552+
553+
const persons = await query.execute()
554+
expect(persons).to.have.length(0)
555+
})
556+
489557
it('`or where` using the expression builder', async () => {
490558
const query = ctx.db
491559
.selectFrom('person')
@@ -523,6 +591,44 @@ for (const dialect of DIALECTS) {
523591
])
524592
})
525593

594+
it('`or where` using the expression builder and chaining', async () => {
595+
const query = ctx.db
596+
.selectFrom('person')
597+
.selectAll()
598+
.where((eb) =>
599+
eb('first_name', '=', 'Jennifer').or(
600+
eb.fn('upper', ['last_name']),
601+
'=',
602+
'ANISTON'
603+
)
604+
)
605+
606+
testSql(query, dialect, {
607+
postgres: {
608+
sql: 'select * from "person" where ("first_name" = $1 or upper("last_name") = $2)',
609+
parameters: ['Jennifer', 'ANISTON'],
610+
},
611+
mysql: {
612+
sql: 'select * from `person` where (`first_name` = ? or upper(`last_name`) = ?)',
613+
parameters: ['Jennifer', 'ANISTON'],
614+
},
615+
sqlite: {
616+
sql: 'select * from "person" where ("first_name" = ? or upper("last_name") = ?)',
617+
parameters: ['Jennifer', 'ANISTON'],
618+
},
619+
})
620+
621+
const persons = await query.execute()
622+
expect(persons).to.have.length(1)
623+
expect(persons).to.containSubset([
624+
{
625+
first_name: 'Jennifer',
626+
last_name: 'Aniston',
627+
gender: 'female',
628+
},
629+
])
630+
})
631+
526632
it('subquery exists', async () => {
527633
const query = ctx.db
528634
.selectFrom('person')

‎test/node/src/with.test.ts

+54
Original file line numberDiff line numberDiff line change
@@ -178,6 +178,60 @@ for (const dialect of DIALECTS) {
178178
])
179179
})
180180
})
181+
182+
it('should create a CTE with `as materialized`', async () => {
183+
const query = ctx.db
184+
.with(
185+
(cte) => cte('person_name').materialized(),
186+
(qb) => qb.selectFrom('person').select('first_name')
187+
)
188+
.selectFrom('person_name')
189+
.select('person_name.first_name')
190+
.orderBy('first_name')
191+
192+
testSql(query, dialect, {
193+
postgres: {
194+
sql: 'with "person_name" as materialized (select "first_name" from "person") select "person_name"."first_name" from "person_name" order by "first_name"',
195+
parameters: [],
196+
},
197+
mysql: NOT_SUPPORTED,
198+
sqlite: NOT_SUPPORTED,
199+
})
200+
201+
const result = await query.execute()
202+
expect(result).to.eql([
203+
{ first_name: 'Arnold' },
204+
{ first_name: 'Jennifer' },
205+
{ first_name: 'Sylvester' },
206+
])
207+
})
208+
209+
it('should create a CTE with `as not materialized`', async () => {
210+
const query = ctx.db
211+
.with(
212+
(cte) => cte('person_name').notMaterialized(),
213+
(qb) => qb.selectFrom('person').select('first_name')
214+
)
215+
.selectFrom('person_name')
216+
.select('person_name.first_name')
217+
.orderBy('first_name')
218+
219+
testSql(query, dialect, {
220+
postgres: {
221+
sql: 'with "person_name" as not materialized (select "first_name" from "person") select "person_name"."first_name" from "person_name" order by "first_name"',
222+
parameters: [],
223+
},
224+
mysql: NOT_SUPPORTED,
225+
sqlite: NOT_SUPPORTED,
226+
})
227+
228+
const result = await query.execute()
229+
expect(result).to.eql([
230+
{ first_name: 'Arnold' },
231+
{ first_name: 'Jennifer' },
232+
{ first_name: 'Sylvester' },
233+
])
234+
})
181235
}
182236

183237
if (dialect !== 'mysql') {

‎test/typings/shared.d.ts

+2
Original file line numberDiff line numberDiff line change
@@ -69,4 +69,6 @@ export interface PersonMetadata {
6969
}[]
7070
>
7171
schedule: JSONColumnType<{ name: string; time: string }[][][]>
72+
record: JSONColumnType<Record<string, string>>
73+
array: JSONColumnType<Array<string>>
7274
}

‎test/typings/test-d/expression.test-d.ts

+22
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,22 @@ function testExpressionBuilder(eb: ExpressionBuilder<Database, 'person'>) {
8080
])
8181
)
8282

83+
expectAssignable<Expression<SqlBool>>(
84+
eb.and({
85+
'person.age': 10,
86+
first_name: 'Jennifer',
87+
last_name: eb.ref('first_name'),
88+
})
89+
)
90+
91+
expectAssignable<Expression<SqlBool>>(
92+
eb.or({
93+
'person.age': 10,
94+
first_name: 'Jennifer',
95+
last_name: eb.ref('first_name'),
96+
})
97+
)
98+
8399
expectType<
84100
KyselyTypeError<'or() method can only be called on boolean expressions'>
85101
>(eb('age', '+', 1).or('age', '=', 1))
@@ -105,4 +121,10 @@ function testExpressionBuilder(eb: ExpressionBuilder<Database, 'person'>) {
105121

106122
expectError(eb.or([eb.val('not booleanish'), eb.val(true)]))
107123
expectError(eb.or([eb('age', '+', 1), eb.val(true)]))
124+
125+
expectError(eb.and({ unknown_column: 'Jennifer' }))
126+
expectError(eb.and({ age: 'wrong type' }))
127+
128+
expectError(eb.or({ unknown_column: 'Jennifer' }))
129+
expectError(eb.or({ age: 'wrong type' }))
108130
}

‎test/typings/test-d/json-traversal.test-d.ts

+14
Original file line numberDiff line numberDiff line change
@@ -71,6 +71,20 @@ async function testJSONTraversal(db: Kysely<Database>) {
7171

7272
expectType<{ nickname: string | null }>(r8)
7373

74+
const [r9] = await db
75+
.selectFrom('person_metadata')
76+
.select((eb) => eb.ref('record', '->').key('i_dunno_man').as('whatever'))
77+
.execute()
78+
79+
expectType<{ whatever: string | null }>(r9)
80+
81+
const [r10] = await db
82+
.selectFrom('person_metadata')
83+
.select((eb) => eb.ref('array', '->').at(0).as('whenever'))
84+
.execute()
85+
86+
expectType<{ whenever: string | null }>(r10)
87+
7488
// missing operator
7589

7690
expectError(

‎test/typings/test-d/with.test-d.ts

+37
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,27 @@ async function testWith(db: Kysely<Database>) {
6464
}[]
6565
>(r3)
6666

67+
// Using CTE builder.
68+
const r4 = await db
69+
.with(
70+
(cte) => cte('jennifers').materialized(),
71+
(db) =>
72+
db
73+
.selectFrom('person')
74+
.where('first_name', '=', 'Jennifer')
75+
.select(['first_name', 'last_name as ln', 'gender'])
76+
)
77+
.selectFrom('jennifers')
78+
.select(['first_name', 'ln'])
79+
.execute()
80+
81+
expectType<
82+
{
83+
first_name: string
84+
ln: string | null
85+
}[]
86+
>(r4)
87+
6788
// Different columns in expression and CTE name.
6889
expectError(
6990
db
@@ -76,6 +97,22 @@ async function testWith(db: Kysely<Database>) {
7697
.selectFrom('jennifers')
7798
.select(['first_name', 'last_name'])
7899
)
100+
101+
// Unknown CTE name when using the CTE builder.
102+
expectError(
103+
db
104+
.with(
105+
(cte) => cte('jennifers').materialized(),
106+
(db) =>
107+
db
108+
.selectFrom('person')
109+
.where('first_name', '=', 'Jennifer')
110+
.select(['first_name', 'last_name as ln', 'gender'])
111+
)
112+
.selectFrom('lollifers')
113+
.select(['first_name', 'ln'])
114+
.execute()
115+
)
79116
}
80117

81118
async function testManyWith(db: Kysely<Database>) {

0 commit comments

Comments
 (0)
Please sign in to comment.