uql-orm 0.72.1 → 0.73.0

package/dist/sqlite/sqliteDialect.d.ts

@@ -1,6 +1,6 @@
 import { AbstractSqlDialect, type DerivedRelation, type HydrateKind, type RelationRows } from '../dialect/abstractSqlDialect.js';
 import { type JsonAccessMode, type JsonSlot } from '../dialect/jsonSql.js';
-import { type EntityMeta, type FieldOptions, type Query, type QueryContext, type QueryPager, type QueryTextSearchOptions, type QueryWhere, type SqlDialectFeatures, type Type, type VectorDistance, type VectorMetric } from '../type/index.js';
+import { type EntityMeta, type FieldOptions, type Query, type QueryContext, type QueryPager, type QueryTextSearchOptions, type QueryWhere, type SqlDialectFeatures, type VectorDistance, type VectorMetric } from '../type/index.js';
 /** What SQLite and the engines derived from it have. */
 export declare const SQLITE_FEATURES: SqlDialectFeatures;
 export declare class SqliteDialect extends AbstractSqlDialect {
@@ -63,10 +63,10 @@ export declare class SqliteDialect extends AbstractSqlDialect {
     /** A date reads back as SQLite stored it, a number or text, which JSON carries unchanged. */
     protected hydrateKind(field: FieldOptions | undefined): HydrateKind | undefined;
     /**
-     * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
-     * FTS5 virtual table (UQL does not create those; declare it outside your entities).
+     * FTS5 matches the table itself, so this works only where the table *is* an FTS5 virtual table (UQL does
+     * not create those; declare it outside your entities). The whole query is bound, column filter and all.
      */
-    protected appendTextSearch<E>(ctx: QueryContext, entity: Type<E>, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
+    protected appendTextSearch<E>(ctx: QueryContext, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
     /** FTS5's `BM25` of the match, lower for a better one, so negated to rank as every other engine does. */
     protected appendTextScore<E>(ctx: QueryContext, meta: EntityMeta<E>): void;
     protected jsonLength(slot: JsonSlot): string;

package/dist/sqlite/sqliteDialect.js

@@ -6,6 +6,15 @@ import { indexDistance, isVectorIndexType } from '../type/vector.js';
 import { declaredIndexName } from '../util/ddlExpression.util.js';
 import { findVectorIndex, findVectorSort, textSearchFields, vectorCandidates } from '../util/dialect.util.js';
 import { columnFamily, isIntegerColumn } from '../util/field.util.js';
+/**
+ * An FTS5 query over `columns` for what a person typed: each word a quoted string, which FTS5 reads as a
+ * term to match and never as syntax, and every one required, as the other engines read plain words.
+ */
+function ftsQuery(columns, value) {
+    const quote = (text) => `"${text.replaceAll('"', '""')}"`;
+    const words = value.split(/\s+/).filter(Boolean);
+    return `{${columns.map(quote).join(' ')}} : (${words.map(quote).join(' ') || '""'})`;
+}
 /** What SQLite and the engines derived from it have. */
 export const SQLITE_FEATURES = {
     ifNotExists: true,
@@ -146,7 +155,8 @@ export class SqliteDialect extends AbstractSqlDialect {
     carriedFields = {
         numeric: (expr, field) => (isIntegerColumn(field) ? `CAST(${expr} AS TEXT)` : expr),
         blob: (expr) => this.bytesAsText(expr),
-        vector: (expr) => `CASE WHEN typeof(${expr}) = 'blob' THEN ${this.bytesAsText(expr)} ELSE ${expr} END`,
+        // D1 keeps a vector as its text; every other engine here, as float32 bytes.
+        vector: (expr) => (this.features.vectorBytes ? this.bytesAsText(expr) : expr),
     };
     bytesAsText(expr) {
         return `${this.escape(BYTES_PREFIX)} || hex(${expr})`;
@@ -156,13 +166,13 @@ export class SqliteDialect extends AbstractSqlDialect {
         return columnFamily(field?.type) === 'date' ? undefined : super.hydrateKind(field);
     }
     /**
-     * FTS5 matches the table itself rather than its columns, so this only works when the table *is* an
-     * FTS5 virtual table (UQL does not create those; declare it outside your entities).
+     * FTS5 matches the table itself, so this works only where the table *is* an FTS5 virtual table (UQL does
+     * not create those; declare it outside your entities). The whole query is bound, column filter and all.
      */
-    appendTextSearch(ctx, entity, meta, search) {
-        const columns = textSearchFields(meta, search).map((key) => this.escapeId(this.resolveColumnName(key, meta.fields[key])));
-        ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
-        ctx.addValue(search.$value);
+    appendTextSearch(ctx, meta, search) {
+        const columns = textSearchFields(meta, search).map((key) => this.resolveColumnName(key, meta.fields[key]));
+        ctx.append(`${this.escapedTableName(meta)} MATCH `);
+        ctx.addValue(ftsQuery(columns, search.$value));
     }
     /** FTS5's `BM25` of the match, lower for a better one, so negated to rank as every other engine does. */
     appendTextScore(ctx, meta) {

package/dist/type/dialect.d.ts

@@ -1,6 +1,7 @@
 import type { EntityMeta, UpdatePayload } from './entity.js';
 import type { Query, QueryConflictPaths, QueryOptions, QueryPage, QuerySearch, RelationQuery } from './query.js';
 import type { QueryAggMap, QueryAggregate, QueryAggregateOp, QueryGroupMap } from './queryAggregate.js';
+import type { QueryWhere } from './queryWhere.js';
 import type { Type } from './utility.js';
 /**
  * comparison options.
@@ -236,6 +237,16 @@ export interface SqlQueryDialect {
  * a row change turns into a delta.
  */
 export type RelationAggregateOp = QueryAggregateOp;
+/**
+ * One aggregate as every renderer reads it: its op, the field it reads - none counts the rows - and the
+ * rows it reads, where not all of them. A statement's `$select` entry and a relation aggregate are each
+ * this, beside what names the rows they aggregate over.
+ */
+export type AggregateCall<E = object> = {
+    readonly op: QueryAggregateOp;
+    readonly field?: string;
+    readonly where?: QueryWhere<E>;
+};
 /** What a relation aggregate reads: how many rows, or one of the target's columns. */
 export type RelationAggregateProjection = {
     readonly op: '$count';
@@ -244,14 +255,16 @@ export type RelationAggregateProjection = {
     readonly op: Exclude<RelationAggregateOp, '$count'>;
     readonly field: string;
 };
-/** A relation aggregate as a `computed` field holds it: what it reads, off which relation, filtered how. */
-export type RelationAggregateSpec = RelationAggregateProjection & {
+/**
+ * A relation aggregate as a `computed` field holds it: an {@link AggregateCall} over the rows of the
+ * relation it names, capped where it declared a page.
+ */
+export type RelationAggregateSpec = RelationAggregateProjection & Pick<AggregateCall, 'where'> & {
     readonly relation: string;
-    /** Which of the related rows it reads, and the page it caps them to, as the field declared them. */
-    readonly query?: RelationSubqueryQuery;
+    readonly page?: RelationAggregatePage;
 };
-/** The rows a relation subquery reads: which ones, in what order, and the page capping them. */
-export type RelationSubqueryQuery = Pick<RelationQuery, '$where' | '$sort' | '$limit' | '$skip'>;
+/** The page of a relation's rows an aggregate reads, and the order picking them. */
+export type RelationAggregatePage = Pick<RelationQuery, '$sort' | '$limit' | '$skip'>;
 /**
  * Supported SQL dialect identifiers.
  */

package/dist/type/query.d.ts

@@ -130,22 +130,30 @@ export type QuerySortByCount = {
     $count: QuerySortDirection;
 };
 /**
- * Ordering by relevance to the `$text` at the root of `$where`: most relevant first, the one order every
- * engine ranks by (MongoDB's `textScore` sorts no other way).
+ * Ordering by relevance to the `$text` at the root of `$where`, in either direction as any key sorts. The
+ * object form also answers it under the name `$project` gives it, most relevant first unless `$order` says.
  */
 export type QuerySortByText = {
-    $text?: -1 | 'desc';
+    $text?: QuerySortDirection | {
+        readonly $project: string;
+        readonly $order?: QuerySortDirection;
+    };
 };
 /**
- * A sort by fields, JSON paths, a to-one relation's fields, a to-many's `$count`, or a vector distance or
- * `$text` relevance, which `Vector` confines to the queried entity. One mapped type over the key sets: an
- * intersection is checked once per member, which made this the costliest type to check.
+ * A row with the value a `$sort` projects under the name its `$project` gives - a vector's distance, or a
+ * `$text` relevance - which is not inferred: `(await querier.findMany(Post, q)) as WithProjection<Post, 'score'>[]`.
+ */
+export type WithProjection<E, K extends string> = E & Record<K, number>;
+/**
+ * A sort by fields, JSON paths, a to-one relation's fields, a to-many's `$count`, or - where `Root` says it
+ * sorts the queried entity itself, not a relation's rows - a vector distance or a `$text` relevance. One
+ * mapped type over the key sets: an intersection is checked once per member, which made this the costliest.
  */
-export type QuerySortMap<E, Vector extends boolean = true, K extends keyof E = FieldKey<E> | RelationKey<E>> = {
-    [P in K]?: P extends RelationKey<E> ? IsMany<E[P]> extends true ? QuerySortByCount : QuerySortMap<RelationTarget<E[P]>, false> : Vector extends true ? NonNullable<E[P]> extends readonly number[] ? QuerySortValue : QuerySortDirection : QuerySortDirection;
+export type QuerySortMap<E, Root extends boolean = true, K extends keyof E = FieldKey<E> | RelationKey<E>> = {
+    [P in K]?: P extends RelationKey<E> ? IsMany<E[P]> extends true ? QuerySortByCount : QuerySortMap<RelationTarget<E[P]>, false> : Root extends true ? NonNullable<E[P]> extends readonly number[] ? QuerySortValue : QuerySortDirection : QuerySortDirection;
 } & ([JsonFieldPaths<E>] extends [never] ? unknown : {
     [P in JsonFieldPaths<E>]?: QuerySortDirection;
-}) & (Vector extends true ? QuerySortByText : unknown);
+}) & (Root extends true ? QuerySortByText : unknown);
 /**
  * pager options.
  */

package/dist/type/queryWhere.d.ts

@@ -16,8 +16,9 @@ export type QueryTextSearchOptions<E> = {
      */
     $fields?: QuerySelect<E>;
     /**
-     * Postgres text-search configuration (e.g. `'english'`), applied to both the document and the
-     * query. Defaults to the server's `default_text_search_config`. Ignored by other dialects.
+     * The language the search is parsed in (e.g. `'english'`, or `'simple'` for no stemming), else that of
+     * the fulltext index over its fields: the Postgres family's text-search config, MongoDB's `$language`.
+     * MySQL and SQLite parse by their index alone.
      */
     $config?: string;
 };

package/dist/type/vector.d.ts

@@ -23,11 +23,6 @@ export interface QueryVectorSearch extends QueryVectorQuery {
     /** Project the computed distance as a named field in the result. */
     readonly $project?: string;
 }
-/**
- * A row with the distance a `$sort` `$project` names, which is not inferred:
- * `(await querier.findMany(Article, q)) as WithDistance<Article, 'similarity'>[]`.
- */
-export type WithDistance<E, K extends string = '_distance'> = E & Record<K, number>;
 /**
  * How a dialect spells a metric: an operator, or a function taking the metric by name where `metricArg`
  * says so, and `index`, how the dialect's vector index names it where it builds one. One map serves the

package/dist/util/dialect.util.d.ts

@@ -1,5 +1,5 @@
 import type { IndexType } from '../schema/types.js';
-import { type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type FieldUpdateOp, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
+import { type AggregateCall, type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type FieldUpdateOp, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySortDirection, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
 export type CallbackKey = keyof Pick<FieldOptions, 'onInsert' | 'onUpdate'>;
 /** The keys of `payload` a write persists as columns. */
 export declare function filterFieldKeys<E>(meta: EntityMeta<E>, payload: EntityData<E> | UpdatePayload<E>, callbackKey: CallbackKey): FieldKey<E>[];
@@ -90,8 +90,11 @@ export declare function hasVectorNear(where: unknown): boolean;
 export declare function isJsonUpdateOp(value: unknown): value is JsonUpdateOp;
 /** Type guard: checks whether an update payload value is a scalar field's operator. */
 export declare function isFieldUpdateOp(value: unknown): value is FieldUpdateOp;
-/** The one operator a scalar field's update carries, and its operand. */
-export declare function fieldUpdateOf(value: FieldUpdateOp): [keyof FieldUpdateOp, number | bigint];
+/**
+ * The one operator a scalar field's update carries, and its operand. Naming both throws rather than
+ * reading one: their order would change the result, and an untyped payload is how both arrive.
+ */
+export declare function fieldUpdateOf(key: string, value: FieldUpdateOp): [keyof FieldUpdateOp, number | bigint];
 /**
  * The `$where` naming rows by key: a bare value names the one key column (refused on a composite), a
  * composite's key map is a `$where` already, and a list is an `IN` of bare values or an OR of maps.
@@ -118,16 +121,12 @@ export type ParsedGroupEntry<E = object> = {
     readonly alias: string;
     /** The field it reads, behind the to-one relations leading to it: `['transaction', 'orderId']`. */
     readonly path: readonly string[];
-} | {
+} | (AggregateCall<E> & {
     readonly kind: 'fn';
     readonly alias: string;
-    readonly op: QueryAggregateOp;
-    readonly fieldRef: string;
     /** `true` for `$countDistinct`: `COUNT(DISTINCT field)`. */
     readonly distinct: boolean;
-    /** The rows it reads, where not all of the statement's. */
-    readonly where?: QueryWhere<E>;
-};
+});
 /**
  * The `$size` of a relation condition, `{ comments: { $size: { $gte: 2 } } }`, or `undefined` where it
  * filters the target's fields; a mix of the two, `{ $size: 2, name: 'x' }`, is refused.
@@ -192,6 +191,11 @@ export declare function textWeightSteps(weights: readonly number[]): {
 };
 /** The fulltext index over exactly `fields`, in order, which a search of them is served by. */
 export declare function fulltextIndexOver<E>(meta: EntityMeta<E>, fields: readonly string[]): EntityIndexMeta<E> | undefined;
+/** How a `$sort` orders by `$text`: its direction, and the name it answers the relevance under, if any. */
+export declare function textSortOf<E>(sort: QuerySortMap<E> | undefined): {
+    readonly order: QuerySortDirection;
+    readonly project?: string;
+} | undefined;
 /**
  * The search a `$sort` by `$text` ranks by: the one at the root of the same query's `$where`. A nested or
  * negated one has no score to order by, and MongoDB scores only the one `$text` it allows.

package/dist/util/dialect.util.js

@@ -242,8 +242,14 @@ const FIELD_UPDATE_OPS = ['$inc', '$mul'];
 export function isFieldUpdateOp(value) {
     return isRecord(value) && someKey(value, (key) => FIELD_UPDATE_OPS.includes(key));
 }
-/** The one operator a scalar field's update carries, and its operand. */
-export function fieldUpdateOf(value) {
+/**
+ * The one operator a scalar field's update carries, and its operand. Naming both throws rather than
+ * reading one: their order would change the result, and an untyped payload is how both arrive.
+ */
+export function fieldUpdateOf(key, value) {
+    if (value.$inc !== undefined && value.$mul !== undefined) {
+        throw new TypeError(`'${key}' takes one of $inc and $mul`);
+    }
     return value.$inc === undefined ? ['$mul', value.$mul] : ['$inc', value.$inc];
 }
 /**
@@ -379,8 +385,11 @@ export function parseGroupMap(group, select) {
         }
         // `$countDistinct` normalizes to `$count` plus a `distinct` flag.
         const { op, distinct } = resolveAggregateOp(key);
-        const fieldRef = aggregateFieldRef(alias, call[key]);
-        entries.push({ kind: 'fn', alias, op, fieldRef, distinct, ...(hasKeys(where) ? { where } : {}) });
+        const field = aggregateField(alias, call[key]);
+        if (field === undefined && (op !== '$count' || distinct)) {
+            throw new TypeError(`aggregate '${alias}' takes '*' only as a $count`);
+        }
+        entries.push({ kind: 'fn', alias, op, distinct, ...(field && { field }), ...(hasKeys(where) ? { where } : {}) });
     }
     return entries;
 }
@@ -392,9 +401,12 @@ function groupRefPath(alias, ref) {
     }
     return ref[key] === true ? [key] : [key, ...groupRefPath(alias, ref[key])];
 }
-/** The column an aggregate reads: `'*'`, or the one field its `{ field: true }` names. */
-function aggregateFieldRef(alias, arg) {
-    const [field, ...rest] = arg === '*' ? [arg] : namedKeys(arg);
+/** The field an aggregate reads, the one its `{ field: true }` names; none for `'*'`, which counts the rows. */
+function aggregateField(alias, arg) {
+    if (arg === '*') {
+        return undefined;
+    }
+    const [field, ...rest] = namedKeys(arg);
     if (field === undefined || rest.length) {
         throw new TypeError(`aggregate '${alias}' takes one field as { field: true }, or '*': got ${JSON.stringify(arg)}`);
     }
@@ -491,6 +503,14 @@ export function fulltextIndexOver(meta, fields) {
         index.columns.length === fields.length &&
         index.columns.every((entry, at) => entry.column === fields[at]));
 }
+/** How a `$sort` orders by `$text`: its direction, and the name it answers the relevance under, if any. */
+export function textSortOf(sort) {
+    const text = sort?.$text;
+    if (text === undefined) {
+        return undefined;
+    }
+    return isRecord(text) ? { order: text.$order ?? 'desc', project: text.$project } : { order: text };
+}
 /**
  * The search a `$sort` by `$text` ranks by: the one at the root of the same query's `$where`. A nested or
  * negated one has no score to order by, and MongoDB scores only the one `$text` it allows.

package/dist/util/raw.js

@@ -1,6 +1,7 @@
 import { getMeta } from '../entity/metadata/definition.js';
 import { ColumnRef, QueryRaw, RelationAggregate, } from '../type/index.js';
 import { isInlinedExpression } from './field.util.js';
+import { hasKeys } from './object.util.js';
 export function raw(value, ...rest) {
     if (!isTemplateStrings(value)) {
         return new QueryRaw(value);
@@ -49,15 +50,20 @@ export function entityWhere(where) {
  * a member decorator sees no class and so cannot know which the key is; the types keep them apart.
  */
 function memberRef(relation) {
-    const over = (op) => (pick, q) => relationAggregate({ relation, op, field: pick(memberRefs()).key, ...(q && { query: q }) });
+    const over = (op) => (pick, q) => relationAggregate({ relation, op, field: pick(memberRefs()).key, ...rowsOf(q) });
     return Object.assign(columnRef(undefined, relation), {
-        count: (q) => relationAggregate({ relation, op: '$count', ...(q && { query: q }) }),
+        count: (q) => relationAggregate({ relation, op: '$count', ...rowsOf(q) }),
         sum: over('$sum'),
         min: over('$min'),
         max: over('$max'),
         avg: over('$avg'),
     });
 }
+/** The rows an aggregate's declared query reads: its `$where`, and the page the rest of it caps them to. */
+function rowsOf(q) {
+    const { $where, ...page } = q ?? {};
+    return { ...($where && { where: $where }), ...(hasKeys(page) && { page }) };
+}
 /**
  * A relation aggregate as SQL: the dialect writes the same correlated subquery a `$count` reads,
  * correlated to whichever alias the clause naming the field is rendering under.

package/dist/util/wideNumber.d.ts

@@ -7,8 +7,10 @@ import type { RawRow } from '../type/index.js';
  */
 export declare function decodeWideNumber(value: string | bigint): number | string;
 /**
- * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
- * object, and a copy per row cost more than the decode it carried.
+ * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back as
+ * one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried. One argument, so it maps rows as is.
  */
 export declare function decodeBigInts(row: RawRow): RawRow;
+/** {@link decodeBigInts}, keeping the cells `exact` names: what MongoDB reads a `BigInt` field into. */
+export declare function decodeBigIntsExcept(row: RawRow, exact: (key: string) => boolean): RawRow;

package/dist/util/wideNumber.js

@@ -9,14 +9,18 @@ export function decodeWideNumber(value) {
     return Math.abs(decoded) <= Number.MAX_SAFE_INTEGER ? decoded : String(value);
 }
 /**
- * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
- * object, and a copy per row cost more than the decode it carried.
+ * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back as
+ * one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried. One argument, so it maps rows as is.
  */
 export function decodeBigInts(row) {
+    return decodeBigIntsExcept(row, () => false);
+}
+/** {@link decodeBigInts}, keeping the cells `exact` names: what MongoDB reads a `BigInt` field into. */
+export function decodeBigIntsExcept(row, exact) {
     for (const key in row) {
         const value = row[key];
-        if (typeof value === 'bigint') {
+        if (typeof value === 'bigint' && !exact(key)) {
             row[key] = decodeWideNumber(value);
         }
     }

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.72.1",
+  "version": "0.73.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/skills/uql-orm/SKILL.md

@@ -103,6 +103,9 @@ const users = await pool.findMany(User, {
 - `$where` takes a value for equality or an operator map: `$eq`, `$ne`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`,
   `$nin`, `$between`, `$like`, `$ilike`, `$regex`, `$startsWith`, `$endsWith`, `$includes`, `$isNull`,
   `$isNotNull`. `$and`, `$or`, `$not` and `$nor` combine clauses.
+- `$text: { $value }` in `$where` searches text on every engine with full-text search, through the entity's
+  `@Index(..., { type: 'fulltext', config })`, whose columns may carry a `weight`. `$sort: { $text: 'desc' }` ranks by
+  relevance, and `{ $text: { $project: 'score' } }` also returns it, typed with `WithProjection<E, 'score'>`.
 - A result is narrowed to what the query selected and populated: reading an unselected field is a compile error.
   Name that shape with `QueryFindResult<User, 'id' | 'email'>` rather than widening the query.
 - `$populate` loads relations in the same statement. Nothing is lazy: a relation not populated is not there.