Defined in: packages/db/src/query/builder/index.ts:135
TContext extends Context = Context
new BaseQueryBuilder<TContext>(query, resolveCollection?): BaseQueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:138
Partial<QueryIR> = {}
CollectionResolver
BaseQueryBuilder<TContext>
get fn(): object;Defined in: packages/db/src/query/builder/index.ts:923
Functional variants of the query builder These are imperative function that are called for ery row. Warning: that these cannot be optimized by the query compiler, and may prevent some type of optimizations being possible.
q.fn.select((row) => ({
name: row.user.name.toUpperCase(),
age: row.user.age + 1,
}))having(callback): QueryBuilder<TContext>;Filter grouped rows using a function that operates on each aggregated row Warning: This cannot be optimized by the query compiler
(row) => any
A function that receives an aggregated row (with $selected when select() was called) and returns a boolean
QueryBuilder<TContext>
A QueryBuilder with functional having filter applied
// Functional having (not optimized)
query
.from({ posts: postsCollection })
.groupBy(({posts}) => posts.userId)
.select(({posts}) => ({ userId: posts.userId, count: count(posts.id) }))
.fn.having(({ $selected }) => $selected.count > 5)select<TFuncSelectResult>(callback): FnSelectQueryResult<TContext, TFuncSelectResult>;Select fields using a function that operates on each row Warning: This cannot be optimized by the query compiler
TFuncSelectResult
(row) => TFuncSelectResult
A function that receives a row and returns the selected value
FnSelectQueryResult<TContext, TFuncSelectResult>
A QueryBuilder with functional selection applied
// Functional select (not optimized)
query
.from({ users: usersCollection })
.fn.select(row => ({
name: row.users.name.toUpperCase(),
age: row.users.age + 1,
}))Child query builders, query expressions, and helpers such as eq(), toArray(), and materialize() cannot be returned from fn.select(). Use them as fields in select() so the compiler can add them to the query graph.
where(callback): QueryBuilder<TContext>;Filter rows using a function that operates on each row Warning: This cannot be optimized by the query compiler
(row) => any
A function that receives a row and returns a boolean
QueryBuilder<TContext>
A QueryBuilder with functional filtering applied
// Functional where (not optimized)
query
.from({ users: usersCollection })
.fn.where(row => row.users.name.startsWith('A'))_getQuery(): QueryIR;Defined in: packages/db/src/query/builder/index.ts:1015
distinct(): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:856
Specify that the query should return distinct rows. Deduplicates rows based on the selected columns.
QueryBuilder<TContext>
A QueryBuilder with distinct enabled
// Get countries our users are from
query
.from({ users: usersCollection })
.select(({users}) => ({ country: users.country }))
.distinct()findOne(): QueryBuilder<TContext & SingleResult>;Defined in: packages/db/src/query/builder/index.ts:876
Specify that the query should return a single result
QueryBuilder<TContext & SingleResult>
A QueryBuilder that returns the first result
// Get the user matching the query
query
.from({ users: usersCollection })
.where(({users}) => eq(users.id, 1))
.findOne()from<TSource>(source): QueryBuilder<ContextFromSource<TSource>>;Defined in: packages/db/src/query/builder/index.ts:248
Specify the source table or subquery for the query
TSource extends Source
SingleSource<TSource>
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
QueryBuilder<ContextFromSource<TSource>>
A QueryBuilder with the specified source
// Query from a collection
query.from({ users: usersCollection })
// Query from a subquery
const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active)
query.from({ activeUsers })fullJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "full">>;Defined in: packages/db/src/query/builder/index.ts:483
Perform a FULL JOIN with another table or subquery
TSource extends Source
TSource
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
JoinOnCallback<MergeContextForJoinCallback<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends CollectionOptionsIdentity<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends QueryBuilder<TContext> ? ResultValue<TContext> : never }[K] }>>
A function that receives table references and returns the join condition
QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "full">>
A QueryBuilder with the full joined table available
// Full join users with posts
query
.from({ users: usersCollection })
.fullJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))groupBy(callback): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:778
Group rows by one or more columns for aggregation
GroupByCallback<TContext>
A function that receives table references and returns the field(s) to group by
QueryBuilder<TContext>
A QueryBuilder with grouping applied (enables aggregate functions in SELECT and HAVING)
// Group by a single column
query
.from({ posts: postsCollection })
.groupBy(({posts}) => posts.userId)
.select(({posts, count}) => ({
userId: posts.userId,
postCount: count()
}))
// Group by multiple columns
query
.from({ sales: salesCollection })
.groupBy(({sales}) => [sales.region, sales.category])
.select(({sales, sum}) => ({
region: sales.region,
category: sales.category,
totalSales: sum(sales.amount)
}))having(callback): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:577
Filter grouped rows based on aggregate conditions
WhereCallback<TContext>
A function that receives table references and returns an expression
QueryBuilder<TContext>
A QueryBuilder with the having condition applied
// Filter groups by count
query
.from({ posts: postsCollection })
.groupBy(({posts}) => posts.userId)
.having(({posts}) => gt(count(posts.id), 5))
// Filter by average
query
.from({ orders: ordersCollection })
.groupBy(({orders}) => orders.customerId)
.having(({orders}) => gt(avg(orders.total), 100))
// Multiple having calls are ANDed together
query
.from({ orders: ordersCollection })
.groupBy(({orders}) => orders.customerId)
.having(({orders}) => gt(count(orders.id), 5))
.having(({orders}) => gt(avg(orders.total), 100))innerJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "inner">>;Defined in: packages/db/src/query/builder/index.ts:457
Perform an INNER JOIN with another table or subquery
TSource extends Source
TSource
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
JoinOnCallback<MergeContextForJoinCallback<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends CollectionOptionsIdentity<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends QueryBuilder<TContext> ? ResultValue<TContext> : never }[K] }>>
A function that receives table references and returns the join condition
QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "inner">>
A QueryBuilder with the inner joined table available
// Inner join users with posts
query
.from({ users: usersCollection })
.innerJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))join<TSource, TJoinType>(
source,
onCallback,
type): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>;Defined in: packages/db/src/query/builder/index.ts:335
Join another table or subquery to the current query
TSource extends Source
TJoinType extends "inner" | "left" | "right" | "full" = "left"
TSource
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
JoinOnCallback<MergeContextForJoinCallback<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends CollectionOptionsIdentity<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends QueryBuilder<TContext> ? ResultValue<TContext> : never }[K] }>>
A function that receives table references and returns the join condition
TJoinType = ...
The type of join: 'inner', 'left', 'right', or 'full' (defaults to 'left')
QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>>
A QueryBuilder with the joined table available
// Left join users with posts
query
.from({ users: usersCollection })
.join({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))
// Inner join with explicit type
query
.from({ u: usersCollection })
.join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId), 'inner')// Join with a subquery const activeUsers = query.from({ u: usersCollection }).where(({u}) => u.active) query .from({ activeUsers }) .join({ p: postsCollection }, ({u, p}) => eq(u.id, p.userId))
leftJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "left">>;Defined in: packages/db/src/query/builder/index.ts:405
Perform a LEFT JOIN with another table or subquery
TSource extends Source
TSource
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
JoinOnCallback<MergeContextForJoinCallback<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends CollectionOptionsIdentity<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends QueryBuilder<TContext> ? ResultValue<TContext> : never }[K] }>>
A function that receives table references and returns the join condition
QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "left">>
A QueryBuilder with the left joined table available
// Left join users with posts
query
.from({ users: usersCollection })
.leftJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))limit(count): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:811
Limit the number of rows returned by the query orderBy is required for limit
number
Maximum number of rows to return
QueryBuilder<TContext>
A QueryBuilder with the limit applied
// Get top 5 posts by likes
query
.from({ posts: postsCollection })
.orderBy(({posts}) => posts.likes, 'desc')
.limit(5)offset(count): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:835
Skip a number of rows before returning results orderBy is required for offset
number
Number of rows to skip
QueryBuilder<TContext>
A QueryBuilder with the offset applied
// Get second page of results
query
.from({ posts: postsCollection })
.orderBy(({posts}) => posts.createdAt, 'desc')
.offset(page * pageSize)
.limit(pageSize)orderBy(callback, options): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:702
Sort the query results by one or more columns
OrderByCallback<TContext>
A function that receives table references and returns the field to sort by
OrderByDirection | OrderByOptions
QueryBuilder<TContext>
A QueryBuilder with the ordering applied
// Sort by a single column
query
.from({ users: usersCollection })
.orderBy(({users}) => users.name)
// Sort descending
query
.from({ users: usersCollection })
.orderBy(({users}) => users.createdAt, 'desc')
// Multiple sorts (chain orderBy calls)
query
.from({ users: usersCollection })
.orderBy(({users}) => users.lastName)
.orderBy(({users}) => users.firstName)rightJoin<TSource>(source, onCallback): QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "right">>;Defined in: packages/db/src/query/builder/index.ts:431
Perform a RIGHT JOIN with another table or subquery
TSource extends Source
TSource
An object with a single key-value pair where the key is the table alias and the value is a Collection or subquery
JoinOnCallback<MergeContextForJoinCallback<TContext, { [K in string | number | symbol]: { [K in string | number | symbol]: TSource[K] extends CollectionImpl<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends CollectionOptionsIdentity<any, any, any, any, any> ? InferCollectionType<any[any]> : TSource[K] extends QueryBuilder<TContext> ? ResultValue<TContext> : never }[K] }>>
A function that receives table references and returns the join condition
QueryBuilder<MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, "right">>
A QueryBuilder with the right joined table available
// Right join users with posts
query
.from({ users: usersCollection })
.rightJoin({ posts: postsCollection }, ({users, posts}) => eq(users.id, posts.userId))select<TSelectObject>(callback): QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>>;Defined in: packages/db/src/query/builder/index.ts:643
Select specific columns or computed values from the query
TSelectObject extends SelectShape
(refs) => NonScalarSelectObject<TSelectObject>
A function that receives table references and returns an object with selected fields or expressions
QueryBuilder<WithResult<TContext, ResultTypeFromSelect<TSelectObject>>>
A QueryBuilder that returns only the selected fields
// Select specific columns
query
.from({ users: usersCollection })
.select(({users}) => ({
name: users.name,
email: users.email
}))
// Select with computed values
query
.from({ users: usersCollection })
.select(({users}) => ({
fullName: concat(users.firstName, ' ', users.lastName),
ageInMonths: mul(users.age, 12)
}))
// Select with aggregates (requires GROUP BY)
query
.from({ posts: postsCollection })
.groupBy(({posts}) => posts.userId)
.select(({posts, count}) => ({
userId: posts.userId,
postCount: count(posts.id)
}))select<TSelectValue>(callback): QueryBuilder<WithResult<TContext, ResultTypeFromSelectValue<TSelectValue>>>;Defined in: packages/db/src/query/builder/index.ts:648
Select specific columns or computed values from the query
TSelectValue extends ScalarSelectValue
(refs) => TSelectValue
A function that receives table references and returns an object with selected fields or expressions
QueryBuilder<WithResult<TContext, ResultTypeFromSelectValue<TSelectValue>>>
A QueryBuilder that returns only the selected fields
// Select specific columns
query
.from({ users: usersCollection })
.select(({users}) => ({
name: users.name,
email: users.email
}))
// Select with computed values
query
.from({ users: usersCollection })
.select(({users}) => ({
fullName: concat(users.firstName, ' ', users.lastName),
ageInMonths: mul(users.age, 12)
}))
// Select with aggregates (requires GROUP BY)
query
.from({ posts: postsCollection })
.groupBy(({posts}) => posts.userId)
.select(({posts, count}) => ({
userId: posts.userId,
postCount: count(posts.id)
}))unionAll<TSource>(source): QueryBuilder<ContextFromUnionSource<TSource>>;Defined in: packages/db/src/query/builder/index.ts:274
Union multiple independent source streams in one query.
TSource extends Source
TSource
An object with one or more aliases mapped to collections or subqueries
QueryBuilder<ContextFromUnionSource<TSource>>
A QueryBuilder with the unioned sources available
query
.unionAll({ message: messagesCollection, toolCall: toolCallsCollection })
.orderBy(({ message, toolCall }) =>
coalesce(message.timestamp, toolCall.timestamp)
)unionAll<TBranches>(...branches): QueryBuilder<ContextFromUnionBranches<TBranches>>;Defined in: packages/db/src/query/builder/index.ts:277
Union multiple independent source streams in one query.
TBranches extends readonly [QueryBuilder<any>, QueryBuilder<any>]
...TBranches
QueryBuilder<ContextFromUnionBranches<TBranches>>
A QueryBuilder with the unioned sources available
query
.unionAll({ message: messagesCollection, toolCall: toolCallsCollection })
.orderBy(({ message, toolCall }) =>
coalesce(message.timestamp, toolCall.timestamp)
)where(callback): QueryBuilder<TContext>;Defined in: packages/db/src/query/builder/index.ts:522
Filter rows based on a condition
WhereCallback<TContext>
A function that receives table references and returns an expression
QueryBuilder<TContext>
A QueryBuilder with the where condition applied
// Simple condition
query
.from({ users: usersCollection })
.where(({users}) => gt(users.age, 18))
// Multiple conditions
query
.from({ users: usersCollection })
.where(({users}) => and(
gt(users.age, 18),
eq(users.active, true)
))
// Multiple where calls are ANDed together
query
.from({ users: usersCollection })
.where(({users}) => gt(users.age, 18))
.where(({users}) => eq(users.active, true))