turbine-orm 0.34.0 → 0.36.0

package/dist/query/builder.d.ts

@@ -36,7 +36,12 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
     private readonly warnOnUnlimited;
     private readonly utcTimestamps;
     private readonly preparedStatementsEnabled;
-    private readonly sqlCacheEnabled;
+    /**
+     * Whether the SQL template cache is active. Set once in the constructor.
+     * Mutable (not `readonly`) only so {@link withSqlCacheDisabled} can flip it
+     * off around a single synchronous compile (see {@link explain}).
+     */
+    private sqlCacheEnabled;
     private readonly dialect;
     /** Client-level default relation-loading strategy ('join' unless configured). */
     private readonly relationLoadStrategy;
@@ -95,6 +100,28 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * synchronous per call, so this transient is never observed across an await.
      */
     private currentSkip;
+    /**
+     * The bound view of this instance passed to the shared WHERE walk
+     * (`where-compile.ts`). Built once in the constructor so `fingerprintWhere` /
+     * `buildWhereClause` / `collectWhereParams` all drive ONE enumeration + ONE
+     * scalar classifier without widening the class's public surface or allocating
+     * per call. See {@link WhereHost}.
+     */
+    private readonly whereHost;
+    /**
+     * Per-target-table {@link WhereHost} memo for scoped sub-wheres (relation
+     * `EXISTS` filters + relation `with`-clause `where`s). Keyed by table name;
+     * the host depends only on the target table's metadata, so it is shared across
+     * every alias/qualifier for that table. Lazily filled by {@link scopedWhereHost}.
+     */
+    private readonly scopedHostCache;
+    /**
+     * The privacy-preserving view of this instance handed to the extracted WHERE
+     * module (`where.ts`). Built once in the constructor (mirroring the
+     * `whereHost` precedent) so the free functions there reach exactly the
+     * class-resident primitives they need without widening the public surface.
+     */
+    private readonly ctx;
     constructor(pool: pg.Pool, table: string, schema: SchemaMetadata, middlewares?: MiddlewareFn[], options?: QueryInterfaceOptions);
     /** Quote an identifier through the active SQL dialect. */
     private q;
@@ -255,13 +282,17 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      *     write and a follow-up SELECT; the SELECT's rows feed the transform.
      */
     private executeMutation;
-    /**
-     * Build a `SELECT * ... WHERE <predicate>` that re-fetches the row(s) matched
-     * by a write's `where` clause. Used by the `'reselect'` result strategy to
-     * return rows from non-RETURNING engines. Reuses the same parameterized WHERE
-     * builder as reads, so no user value is interpolated.
-     */
-    private buildReselectByWhere;
+    buildCreate(args: CreateArgs<T>): DeferredQuery<T>;
+    buildCreateMany(args: CreateManyArgs<T>): DeferredQuery<T[]>;
+    buildUpdate(args: UpdateArgs<T>): DeferredQuery<T>;
+    buildDelete(args: DeleteArgs<T>): DeferredQuery<T>;
+    buildUpsert(args: UpsertArgs<T>): DeferredQuery<T>;
+    buildUpdateMany(args: UpdateManyArgs<T>): DeferredQuery<{
+        count: number;
+    }>;
+    buildDeleteMany(args: DeleteManyArgs<T>): DeferredQuery<{
+        count: number;
+    }>;
     /**
      * Best-effort extraction of an auto-generated primary key from a write
      * result for `'reselect'` engines (e.g. mysql2's `insertId`). Returns
@@ -290,6 +321,36 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
     private runFindUniqueBatched;
     buildFindUnique<W extends TypedWithClause<R> = {}>(args: FindUniqueArgs<T, R, W, Record<string, boolean> | undefined, Record<string, boolean> | undefined>): DeferredQuery<T | null>;
     findMany<W extends TypedWithClause<R> = {}, S extends Record<string, boolean> | undefined = undefined, O extends Record<string, boolean> | undefined = undefined>(args?: FindManyArgs<T, R, W, S, O>): Promise<QueryResult<T, R, W, S, O>[]>;
+    /**
+     * Return the engine's query plan for a {@link findMany}-shaped query as plain
+     * text lines: a diagnostic surface for inspecting how the database will run a
+     * query (index usage, join strategy, scan type).
+     *
+     * The compiled SELECT is prefixed with the dialect's explain syntax
+     * (Postgres `EXPLAIN`, SQLite `EXPLAIN QUERY PLAN`, MySQL `EXPLAIN
+     * FORMAT=TREE`) and run as a read. The findMany args are compiled with the
+     * SQL template cache disabled, so an explain never reads or writes the shared
+     * cache. Middleware is NOT applied: the returned rows are plan text, not
+     * entity rows. Each result row is flattened to one line by joining its column
+     * values with a single space (Postgres returns one `QUERY PLAN` text column,
+     * SQLite's `EXPLAIN QUERY PLAN` returns four, MySQL's tree format one).
+     *
+     * Only `findMany` shapes are supported (where / orderBy / with / limit /
+     * pagination). Engines whose plan cannot be requested in-band from a compiled
+     * query (SQL Server, whose SHOWPLAN is a session toggle) throw
+     * {@link UnsupportedFeatureError} (E017).
+     *
+     * The plan text itself is engine-owned and NOT covered by semver: its content
+     * and formatting can change with the underlying database version.
+     */
+    explain(args?: FindManyArgs<T, R>): Promise<string[]>;
+    /**
+     * Run `fn` with the SQL template cache forced off, restoring the prior state
+     * afterward. Used by {@link explain}, whose one-off prefixed statement must
+     * neither read nor write the shared cache. `fn` is synchronous, so no query
+     * interleaves between the toggle and its restore.
+     */
+    private withSqlCacheDisabled;
     /**
      * Emit a one-time `console.warn` when {@link findMany} is called without an
      * explicit `limit`/`take` and `warnOnUnlimited` has not been disabled.
@@ -345,385 +406,72 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
     findUniqueOrThrow<W extends TypedWithClause<R> = {}, S extends Record<string, boolean> | undefined = undefined, O extends Record<string, boolean> | undefined = undefined>(args: FindUniqueArgs<T, R, W, S, O>): Promise<QueryResult<T, R, W, S, O>>;
     buildFindUniqueOrThrow<W extends TypedWithClause<R> = {}>(args: FindUniqueArgs<T, R, W, Record<string, boolean> | undefined, Record<string, boolean> | undefined>): DeferredQuery<T>;
     create(args: CreateArgs<T, R>): Promise<T>;
-    buildCreate(args: CreateArgs<T>): DeferredQuery<T>;
-    /**
-     * Build the `'reselect'` plan for {@link buildCreate}: run the INSERT, then
-     * `SELECT * WHERE pk = ?`. Returns `undefined` (skipped) unless the active
-     * dialect's result strategy is `'reselect'`, so the PostgreSQL/RETURNING path
-     * pays nothing. Not yet wired to a real non-RETURNING engine.
-     */
-    private makeCreateReselect;
     createMany(args: CreateManyArgs<T>): Promise<T[]>;
-    buildCreateMany(args: CreateManyArgs<T>): DeferredQuery<T[]>;
     update(args: UpdateArgs<T, R>): Promise<T>;
-    buildUpdate(args: UpdateArgs<T>): DeferredQuery<T>;
     private nestedCreate;
     private nestedUpdate;
     private runInImplicitTx;
     private buildNestedCtx;
     private makeTxProxy;
     delete(args: DeleteArgs<T>): Promise<T>;
-    buildDelete(args: DeleteArgs<T>): DeferredQuery<T>;
     upsert(args: UpsertArgs<T>): Promise<T>;
-    buildUpsert(args: UpsertArgs<T>): DeferredQuery<T>;
     updateMany(args: UpdateManyArgs<T>): Promise<{
         count: number;
     }>;
-    buildUpdateMany(args: UpdateManyArgs<T>): DeferredQuery<{
-        count: number;
-    }>;
     deleteMany(args: DeleteManyArgs<T>): Promise<{
         count: number;
     }>;
-    buildDeleteMany(args: DeleteManyArgs<T>): DeferredQuery<{
-        count: number;
-    }>;
     count(args?: CountArgs<T>): Promise<number>;
     buildCount(args?: CountArgs<T>): DeferredQuery<number>;
     groupBy(args: GroupByArgs<T>): Promise<Record<string, unknown>[]>;
     buildGroupBy(args: GroupByArgs<T>): DeferredQuery<Record<string, unknown>[]>;
-    /**
-     * Compile a groupBy `orderBy` into an ORDER BY body. Unlike findMany ORDER BY
-     * ({@link buildOrderBy}, which validates keys against the table's physical
-     * columns), groupBy ordering targets the columns the RESULT actually
-     * contains: plain by-fields, JSON group-key aliases, and requested aggregates
-     * (`_count` / `_sum` / `_avg` / `_min` / `_max`). Each key re-emits the exact
-     * SELECT expression that produced it (`byOrderExprs` / `aggOrderExprs`),
-     * mirroring how HAVING re-emits aggregate expressions, so no dialect ever has
-     * to accept a SELECT-alias reference in ORDER BY, and any already-bound
-     * JSON-path placeholder is reused verbatim (ORDER BY is the last clause, so
-     * no `$n` renumbering). An aggregate key that was not requested, or an unknown
-     * by-key, throws {@link ValidationError} E003 listing the valid keys.
-     */
-    private buildGroupByOrderBy;
-    /**
-     * Validate a JSON-path target (group key or aggregate target) in groupBy:
-     * the field must resolve to a real json/jsonb column and the path must be a
-     * non-empty array of keys/indexes. Returns the resolved snake_case column.
-     */
-    private resolveJsonPathTarget;
-    /**
-     * Build the `distinctOn` row source for groupBy (PostgreSQL only: other
-     * engines throw {@link UnsupportedFeatureError} E017):
-     *
-     * ```sql
-     * (SELECT DISTINCT ON ("c1") * FROM "table"<WHERE> ORDER BY "c1", <orderBy>) AS "table"
-     * ```
-     *
-     * The wrapper is aliased as the table name so every outer expression (group
-     * keys, aggregates, HAVING, ORDER BY) is byte-identical to the plain path.
-     * `distinctOn.orderBy` is required (it decides which row survives) and
-     * supports plain columns, {@link OrderBySpec} nulls, and JSON-path specs;
-     * JSON paths push their text[] param here, after the WHERE params.
-     */
-    private buildDistinctOnSource;
-    /**
-     * Build the SQL fragments for a {@link HavingClause}.
-     *
-     * Each aggregate expression (`COUNT(*)`, `SUM("col")`, etc.) is constructed
-     * from a **schema-validated, quoted** column identifier — `this.toColumn()`
-     * throws {@link ValidationError} for unknown fields and `this.q()` quotes via
-     * the dialect, so no unvalidated identifier ever reaches the SQL string. Every
-     * comparison value is pushed onto the shared `params` array and referenced by
-     * a `$N` placeholder via {@link buildHavingNumericClauses} — there is no string
-     * interpolation of user values.
-     *
-     * `jsonAggExprs` (from {@link buildGroupBy}) maps `alias:aggKey` to the
-     * exact aggregate expression a JSON-path aggregate emitted in SELECT
-     * (including its already-bound path placeholder), so HAVING on a JSON-path
-     * aggregate alias reuses the same expression instead of resolving the alias
-     * as a column.
-     */
-    private buildHavingClauses;
-    /**
-     * Convert a single having filter into one or more parameterized SQL
-     * comparisons against the given aggregate expression. A bare number is
-     * shorthand for equality. Unknown operator keys throw {@link ValidationError}.
-     */
-    private buildHavingNumericClauses;
-    aggregate(args: AggregateArgs<T>): Promise<AggregateResult<T>>;
     buildAggregate(args: AggregateArgs<T>): DeferredQuery<AggregateResult<T>>;
-    /**
-     * Resolve select/omit options into a list of snake_case column names.
-     * Returns null if neither is provided (meaning all columns).
-     */
+    aggregate(args: AggregateArgs<T>): Promise<AggregateResult<T>>;
     private resolveColumns;
-    /**
-     * Reject any write against a view (H4). Views are introspected with
-     * `isView: true` and are read-only in every engine; a write raises a
-     * {@link ValidationError} (E003) rather than emitting SQL Postgres would
-     * reject (or, worse, silently applying to an updatable view).
-     */
-    private assertWritable;
-    /**
-     * Reject a write whose `data` names a `GENERATED ALWAYS AS (...) STORED`
-     * column (H3). Postgres computes these from other columns and errors if you
-     * try to write them; we fail early with a clear {@link ValidationError} (E003)
-     * instead of surfacing a cryptic driver error. Undefined values are ignored
-     * (they're stripped from the statement anyway).
-     */
-    private assertNoGeneratedColumns;
+    withFingerprint(withClause: WithClause | undefined, table?: string, depth?: number): string;
+    private collectWithParams;
+    private orderByEntryFingerprint;
+    private buildOrderBy;
+    private isRelationOrderByValue;
+    private nullsSuffix;
+    private resolveOrderByColumn;
+    private validateJsonPathOrderBy;
+    private buildJsonPathOrderEntry;
+    private collectRelationPickOrderParams;
+    private collectRelationCountParams;
+    private getCamelDateFields;
+    private makeNestedParser;
+    private buildSelectWithRelations;
     /** Convert camelCase field name to snake_case column name (unquoted, for non-SQL uses) */
     private toColumn;
     /** Convert camelCase field name to a double-quoted SQL identifier */
     private toSqlColumn;
-    /**
-     * Build a single SET clause entry for update/updateMany.
-     *
-     * Supports plain values and atomic operator objects ({ set, increment,
-     * decrement, multiply, divide }). An operator object is detected ONLY when
-     * it has EXACTLY one key that is one of the 5 operator keys — this avoids
-     * misinterpreting JSON column values like `{ set: 'x' }` as operators
-     * (real operator objects always have exactly one key, and a plain JSON
-     * payload that happens to have a single `set` key is extremely unusual).
-     * Multi-key objects are always treated as plain (JSON) values.
-     *
-     * Returns the SQL fragment (e.g., `"view_count" = "view_count" + $3`) and
-     * pushes any required params onto the shared params array so that WHERE
-     * clause numbering continues correctly afterward.
-     */
-    private buildSetClause;
-    /**
-     * Produce a value-invariant fingerprint of a where clause.
-     * Same keys + same operator shapes + same combinator structure => same string.
-     * Different values (e.g. id=1 vs id=999) => identical fingerprint.
-     *
-     * @internal Exposed as package-private for testing via class access.
-     */
     fingerprintWhere(where: Record<string, unknown>): string;
-    /**
-     * Produce a value-invariant fingerprint for array filters while preserving
-     * parameterless boolean operators that change SQL shape.
-     */
-    private fingerprintArrayFilter;
-    /**
-     * Fingerprint a relation filter sub-where for some/every/none.
-     */
-    private fingerprintRelFilter;
-    /**
-     * Walk a where clause and push ONLY values into `params`, in the EXACT same
-     * order that `buildWhereClause` pushes them. Used on cache hit to fill params
-     * without rebuilding SQL.
-     *
-     * @internal Exposed as package-private for testing.
-     */
     collectWhereParams(where: Record<string, unknown>, params: unknown[]): void;
-    /**
-     * Param-collect mirror of {@link buildRelationFilter} for one relation-filter
-     * object (`{ some/every/none/is/isNot }`, already normalized). Pushes, per
-     * present branch and in the canonical order some→none→every→is→isNot, the
-     * branch's sub-where params THEN the target table's global-filter params —
-     * exactly the order buildRelationFilter emits. When no global filter applies
-     * the gf calls are no-ops, so this stays byte-identical to the pre-0.28 path.
-     * Shared by every collect site that mirrors buildRelationFilter
-     * (collectWhereParams, collectRelFilterParams, collectAliasWhereParams).
-     */
-    private collectRelationFilterParams;
-    private collectRelFilterParams;
-    /**
-     * Collect params from operator clauses. Mirrors buildOperatorClauses:
-     * {@link ColumnRef} values compile into the SQL text, so they push NOTHING -
-     * but they re-run the same validation (unknown ref / insensitive mode) so a
-     * warmed cache can never skip a check the build path enforces.
-     */
-    private collectOperatorParams;
-    /**
-     * Collect params from JSON filter. Mirrors buildJsonFilterClauses exactly:
-     * the `path` is bound at most once (its placeholder is shared by every
-     * extraction clause), then equals/contains/hasKey values, then the range
-     * comparison values in {@link JSON_RANGE_OPERATORS} order.
-     */
-    private collectJsonFilterParams;
-    /** Collect params from array filter. Mirrors buildArrayFilterClauses. */
-    private collectArrayFilterParams;
-    /**
-     * Collect params for an orderBy clause. Vector KNN ordering pushes the
-     * `$n::vector` query vector and JSON-path ordering pushes its text[] path;
-     * plain direction ordering is parameterless. Mirrors buildOrderBy's push
-     * order exactly so the cached-SQL param re-collection stays in lockstep.
-     */
-    private collectOrderByParams;
-    /**
-     * Collect params for a vector distance WHERE filter. Mirrors
-     * {@link buildVectorFilterClauses}: the `$n::vector` query vector first, then
-     * the comparison threshold(s).
-     */
-    private collectVectorFilterParams;
-    /**
-     * Produce a fingerprint for a `with` clause tree. Recursion mirrors
-     * buildSelectWithRelations / buildRelationSubquery.
-     *
-     * @internal Exposed as package-private for testing.
-     */
-    withFingerprint(withClause: WithClause | undefined, table?: string, depth?: number): string;
-    /**
-     * Collect params from a `with` clause tree. Mirrors buildSelectWithRelations +
-     * buildRelationSubquery param-push order.
-     */
-    private collectWithParams;
-    /**
-     * Collect params from a single relation subquery. Mirrors buildRelationSubquery.
-     */
-    private collectRelationSubqueryParams;
-    /**
-     * Fingerprint SET clauses for update/updateMany.
-     * Captures key names + operator types (set/increment/etc) but not values.
-     */
-    private fingerprintSet;
-    /**
-     * Collect SET params for update/updateMany. Mirrors buildSetClause param order.
-     */
-    private collectSetParams;
-    /** Build WHERE clause from a where object (supports operators, NULL, OR) */
-    private buildWhere;
-    /**
-     * Resolve the configured global filter for `table`, evaluating a function
-     * filter, honoring the active query's `skipGlobalFilters`. Returns `null` when
-     * no filter applies, the query opted out, or the filter is empty.
-     */
     private resolveGlobalFilter;
-    /**
-     * AND-merge this table's resolved global filter into a user `where`. Either
-     * side may be absent. When no filter applies the user where is returned by
-     * reference, so fingerprints/SQL stay byte-identical to the pre-0.28 path.
-     */
     private mergeGlobalFilter;
-    /**
-     * SQL clause for `targetTable`'s global filter rendered against `alias`
-     * (relation subqueries, `_count`, relation `orderBy`). Pushes its params to
-     * `params`; returns `''` when no filter applies. Mirror:
-     * {@link collectTargetGlobalFilterAlias}.
-     */
-    private targetGlobalFilterAlias;
-    /** Param-collect mirror of {@link targetGlobalFilterAlias}. */
     private collectTargetGlobalFilterAlias;
-    /**
-     * SQL clause for `targetTable`'s global filter rendered against the bare
-     * (unaliased) table name — the form used inside relation-filter `EXISTS`
-     * subqueries. Pushes its params; `''` when none. Mirror:
-     * {@link collectTargetGlobalFilterExists}.
-     */
-    private targetGlobalFilterExists;
-    /** Param-collect mirror of {@link targetGlobalFilterExists}. */
-    private collectTargetGlobalFilterExists;
-    /**
-     * Value-invariant SQL-cache-key segment for the active global-filter
-     * environment. Relation-subquery / relation-filter / `_count` / relation-
-     * `orderBy` global filters are rendered at build time but their SHAPE is not
-     * otherwise in the where/with fingerprint, so this segment guards the cache:
-     * two different filter shapes never collide on one cached SQL text, while two
-     * function-filter results of the SAME shape (differing only in values) share
-     * the entry and bind their own params. Empty (`''`) when no filter applies, so
-     * cache keys stay byte-identical when the feature is unused.
-     */
     private globalFilterCacheSegment;
-    /**
-     * True when the USER-supplied `where` compiles to no predicate (`{}`,
-     * `{ id: undefined }`, `{ OR: [{ a: undefined }] }`, …). This is the exact
-     * signal the empty-`where` guard needs — the compiled emptiness, NOT the
-     * fingerprint (which is non-empty for an all-undefined `OR`/`AND`). It ignores
-     * any configured global filter, so a global filter never lets an unguarded
-     * mass mutation through.
-     */
-    private userPredicateIsEmpty;
-    private assertMutationHasPredicate;
-    /**
-     * Build the inner WHERE expression (without the WHERE keyword).
-     * Returns null if no conditions exist.
-     * Supports: equality, operators, NULL, OR, AND, NOT, relation filters (some/every/none).
-     */
     private buildWhereClause;
-    /**
-     * Build relation filter SQL: WHERE EXISTS / NOT EXISTS subquery
-     * Supports: some (EXISTS), every (NOT EXISTS ... NOT), none (NOT EXISTS)
-     */
-    private buildRelationFilter;
-    /**
-     * Build WHERE clause conditions for a relation filter subquery.
-     * Uses the target table's column mapping to resolve field names.
-     */
-    private buildSubWhereForRelation;
-    /**
-     * Resolve a column's Postgres type from an arbitrary table's metadata
-     * (relation targets, not just `this.table`).
-     */
-    private pgTypeForColumn;
-    /**
-     * The Postgres enum type name for a column, when the schema knows one.
-     *
-     * Introspection stores each column's `udt_name` in `pgTypes` and every
-     * database enum in `schema.enums` (typname → labels); a column whose type
-     * matches an enum key needs an explicit `::"EnumName"` cast on its write
-     * binds — bulk-insert forms like `UNNEST($1::text[])` otherwise type the
-     * value as text and Postgres refuses the implicit text→enum coercion
-     * ("column X is of type Y but expression is of type text").
-     *
-     * Postgres-only by construction: gated on the active dialect being
-     * `postgresql` AND on `schema.enums` having entries (only PG introspection
-     * produces them — `defineSchema` and the other engines leave it empty), so
-     * SQLite/MySQL/MSSQL/PowDB output is byte-identical.
-     */
-    private enumTypeForColumn;
-    /**
-     * `::"EnumName"` cast suffix for a write-bind placeholder on an enum
-     * column; `''` for every other column, so non-enum SQL stays byte-identical.
-     * The type name is an introspected identifier and is quoted via the dialect.
-     */
-    private enumCastSuffix;
-    /**
-     * Equality-fallthrough guard shared by every SQL-build path AND every
-     * cache-hit param-collect path. A plain object literal that matched no known
-     * filter shape on a non-JSON column is almost always a misspelled operator
-     * (`startWith` for `startsWith`); binding it as `col = $1` silently returns
-     * wrong rows. Class instances (Buffer for bytea, Decimal wrappers, ...) are
-     * legitimate bind values and pass through, as do objects on json/jsonb
-     * columns (object equality).
-     */
-    private assertBindableEqualityValue;
-    /**
-     * Build the user-supplied `where` filter of a relation `with` clause against
-     * the relation's table alias. Supports the same scalar surface as the
-     * top-level WHERE builder — equality, IS NULL, operator objects (incl.
-     * `mode: 'insensitive'`), and OR/AND/NOT combinators. Unknown operator
-     * objects throw via {@link assertBindableEqualityValue}.
-     *
-     * Param push order MUST mirror {@link collectAliasWhereParams} exactly, or
-     * cache hits and pipeline batching will desync.
-     */
     private buildAliasWhere;
-    /** Mirrors {@link buildAliasWhere} param-push order for the cache-hit collect path. */
-    private collectAliasWhereParams;
-    /**
-     * Value-invariant, shape-aware fingerprint for a relation `with` clause's
-     * `where` filter. Must distinguish every SQL shape {@link buildAliasWhere}
-     * can emit — equality vs null vs operator sets vs combinators — or two
-     * differently-shaped wheres would share one cached SQL string.
-     */
-    private fingerprintAliasWhere;
-    /**
-     * Validate a `{ col }` column reference against its table and return the
-     * resolved snake_case column name. Shared by the SQL-build path
-     * ({@link buildOperatorClauses}) and the cache-hit param-collect path
-     * (`collectOperatorParams`) so both always throw identically: a warmed
-     * cache can never skip the check.
-     */
-    private resolveColumnRef;
+    private vectorOperator;
+    private pushVectorParam;
+    private normalizeRelationFilter;
+    private isJsonColumnType;
+    private getColumnPgType;
+    private jsonPathParam;
     /**
-     * Compile a `{ col }` reference to its quoted, prefix-matched SQL identifier.
-     * NO param is bound: the referenced column is part of the SQL text (and of
-     * the where fingerprint, see {@link fingerprintOperatorShape}).
+     * Collect params for an orderBy clause. Vector KNN ordering pushes the
+     * `$n::vector` query vector and JSON-path ordering pushes its text[] path;
+     * plain direction ordering is parameterless. Mirrors buildOrderBy's push
+     * order exactly so the cached-SQL param re-collection stays in lockstep.
      */
-    private columnRefSql;
+    private collectOrderByParams;
     /**
-     * Build SQL clauses for a single operator object on a column.
-     * Each operator key becomes its own clause, all ANDed together.
-     *
-     * `equals`/`not`/`gt`/`gte`/`lt`/`lte` also accept a {@link ColumnRef}
-     * (`{ col: 'otherField' }`) which compiles to a column-to-column comparison
-     * against `refCtx`: no param bound, so `collectOperatorParams` mirrors by
-     * pushing nothing and the referenced name lives in the fingerprint.
+     * The {@link WhereHost} for a scoped sub-where over `meta`'s table. Memoized
+     * per table (see {@link scopedHostCache}); the host depends only on the target
+     * metadata, not on the caller's alias/qualifier.
      */
-    private buildOperatorClauses;
     /**
      * Build ORDER BY clause from an object.
      *
@@ -734,187 +482,6 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * findMany path). When `params` is omitted (groupBy / relation path) a vector
      * ordering throws — KNN ordering is only supported at the top level.
      */
-    /**
-     * Value-shape fingerprint for a single orderBy entry, so two queries whose
-     * ORDER BY differs only in nulls placement, vector metric, or relation-count
-     * vs relation-column never collide on one cached SQL string. Captures the
-     * SQL-shaping bits (direction, nulls, metric, relation keys) — never values.
-     */
-    private orderByEntryFingerprint;
-    private buildOrderBy;
-    /**
-     * True when an orderBy value is a relation-ordering object: a plain object
-     * that is neither a vector KNN ordering nor an {@link OrderBySpec}. Its key
-     * in the orderBy clause is a relation name.
-     */
-    private isRelationOrderByValue;
-    /**
-     * Render the ` NULLS FIRST` / ` NULLS LAST` suffix for a column ordering.
-     * Only PostgreSQL and SQLite support the `NULLS FIRST/LAST` grammar — on any
-     * other engine a caller asking for explicit nulls placement gets a clear
-     * {@link UnsupportedFeatureError} (E017) instead of broken SQL.
-     */
-    private nullsSuffix;
-    /**
-     * Resolve an orderBy key to its snake_case column via the table's columnMap
-     * (camelToSnake fallback), throwing the SAME unknown-field E003 the top-level
-     * where path uses. Shared by top-level JSON-path ordering and every nested
-     * relation orderBy path so nested orderBy accepts exactly what top-level
-     * accepts (the 0.30.x bug: nested orderBy skipped the columnMap and rejected
-     * camelCase-named DB columns like "sortOrder").
-     */
-    private resolveOrderByColumn;
-    /**
-     * Validate a {@link JsonPathOrderBy} entry: column must exist AND be
-     * json/jsonb, path must be a non-empty array of keys/indexes: and return
-     * the resolved column. Shared by the SQL-build path
-     * ({@link buildJsonPathOrderEntry}) and the cache-hit param-collect mirrors
-     * so both always throw identically.
-     */
-    private validateJsonPathOrderBy;
-    /**
-     * Compile one {@link JsonPathOrderBy} entry:
-     * `("col" #>> $n::text[])::numeric ASC`: the numeric cast only with
-     * `type: 'numeric'` (default is text comparison), the extraction routed
-     * through the dialect's JSON hook exactly like the JSON where-filters, the
-     * path bound as ONE text[] param (mirrored by the order-param collectors).
-     * `prefix` scopes the column (`''` top-level, `t0.` inside a relation
-     * subquery).
-     */
-    private buildJsonPathOrderEntry;
-    /**
-     * Compile a relation ordering term. For a to-many relation the only allowed
-     * key is `_count`, which becomes a correlated `COUNT(*)` subquery. For a
-     * to-one relation each entry names a target column and becomes a correlated
-     * scalar subquery (supporting {@link OrderBySpec} nulls placement).
-     *
-     * Validation: relation must exist (E005); to-many only allows `_count`, and
-     * to-one only allows real target columns (E003).
-     *
-     * `ctx` generalizes the term beyond the root table: inside a relation
-     * subquery's orderBy the relations live on the TARGET table's metadata and
-     * the correlation parent is the relation's alias, not `this.table`.
-     */
-    private buildRelationOrderBy;
-    /**
-     * Validate a {@link RelationPickOrderBy} entry's scope and shape. Shared by
-     * the SQL-build path ({@link buildRelationPickOrderBy}) and the cache-hit
-     * param-collect mirror ({@link collectRelationPickOrderParams}) so both
-     * always throw identically:
-     *
-     *  - `nested` (inside a relation subquery's orderBy or a pick.orderBy):
-     *    top-level findMany only in this release (E003),
-     *  - manyToMany: not supported (E003 naming the limitation),
-     *  - to-one: order by the target column directly instead (E003),
-     *  - `pick.orderBy` is REQUIRED (deterministic row choice),
-     *  - `by` must be a target column name or a `{ field, path }` JSON-path spec.
-     */
-    private pickOrderNestedError;
-    private validatePickOrderBy;
-    /**
-     * Compile a {@link RelationPickOrderBy} term: a correlated scalar subquery
-     * that picks ONE related row (`ORDER BY <pick.orderBy> LIMIT 1`, optionally
-     * filtered by `pick.where` and the target's global filter) and surfaces one
-     * value from it (a plain target column or a JSON-path extraction) as the
-     * parent ORDER BY key:
-     *
-     * ```sql
-     * (SELECT ord0."data" #>> $1::text[] FROM "versions" ord0
-     *   WHERE ord0."instance_id" = "instances"."id" AND ord0."is_current" = $2
-     *   ORDER BY ord0."created_at" DESC LIMIT 1) ASC NULLS LAST
-     * ```
-     *
-     * Param-push order (mirrored EXACTLY by
-     * {@link collectRelationPickOrderParams}): `by` JSON path (if any) →
-     * target global filter → `pick.where` → `pick.orderBy` JSON paths.
-     */
-    private buildRelationPickOrderBy;
-    /**
-     * Compile the shared inner pieces of a pick-row ordering against `childAlias`
-     * (the table alias the related row is read from): the `by` value expression,
-     * the correlation + target global filter + `pick.where` predicate, and the
-     * `pick.orderBy` clause. Factored out of {@link buildRelationPickOrderBy} so
-     * the subquery and lateral plans build IDENTICAL pieces in the SAME param
-     * push order (`by` JSON path → target global filter → `pick.where` →
-     * `pick.orderBy` JSON paths), which is why the collect mirror
-     * ({@link collectRelationPickOrderParams}) is plan-agnostic.
-     */
-    private compilePickPieces;
-    /**
-     * Param-collect mirror of {@link buildRelationPickOrderBy}: re-runs the same
-     * validation (a warmed cache can never skip it), then pushes in the same
-     * order: `by` JSON path → target global filter → `pick.where` →
-     * `pick.orderBy` JSON paths.
-     */
-    private collectRelationPickOrderParams;
-    /**
-     * Compile the ORDER BY terms of a relation `with` clause against the
-     * relation's table alias. One unified path for every relation shape
-     * (hasMany / manyToMany / belongsTo / hasOne) supporting exactly what the
-     * top-level orderBy accepts at this level:
-     *
-     *  - scalar columns via columnMap resolution (camelToSnake fallback) with
-     *    {@link OrderBySpec} nulls placement,
-     *  - {@link JsonPathOrderBy} entries (path bound as one text[] param),
-     *  - relation ordering on the TARGET's relations (`_count` for to-many, a
-     *    target column for to-one), correlated to the relation alias,
-     *  - vector KNN ordering stays top-level-only (E003, same as before).
-     *
-     * Param pushes (JSON paths, relation-order global filters) MUST be mirrored,
-     * in the same order, by {@link collectRelationOrderParams}.
-     */
-    private buildRelationOrderClause;
-    /**
-     * Param-collect mirror of {@link buildRelationOrderClause}: JSON-path
-     * entries push their path (one text[] param each); relation-order entries
-     * mirror {@link collectOrderByParams}' relation branch (count / to-one
-     * global-filter params); scalar entries push nothing but re-run the same
-     * column validation so a warmed cache can never skip it.
-     */
-    private collectRelationOrderParams;
-    /**
-     * Build a correlated `(SELECT COUNT(*) …)` scalar subquery for a to-many
-     * relation, correlated to `parentRef`. hasMany counts child rows via the FK;
-     * manyToMany counts junction rows via the source key. Shared by the `_count`
-     * `with` key and to-many relation orderBy.
-     *
-     * When `params` is supplied and the target has a global filter, it is
-     * AND-merged so the count only sees surviving rows (a soft-deleted child is
-     * not counted): hasMany filters the counted rows directly; manyToMany adds an
-     * `EXISTS` on the target through the junction (the junction rows themselves
-     * carry no filter). Params are mirrored by {@link collectRelationCountParams}.
-     */
-    private buildRelationCountExpr;
-    /**
-     * `EXISTS (SELECT 1 FROM <target> <talias> WHERE <join> AND <gf>)` restricting
-     * a manyToMany `_count` to targets that survive their global filter. `''` when
-     * the target has no filter. Pushes gf params; mirror:
-     * {@link collectManyToManyTargetGlobalFilter}.
-     */
-    private manyToManyTargetGlobalFilterExists;
-    /** Param-collect mirror of {@link manyToManyTargetGlobalFilterExists}. */
-    private collectManyToManyTargetGlobalFilter;
-    /**
-     * Param-collect mirror of {@link buildRelationCountExpr}'s global-filter
-     * params (hasMany direct filter, or manyToMany EXISTS-on-target). Only pushes
-     * when a filter applies — no-op otherwise.
-     */
-    private collectRelationCountParams;
-    /**
-     * Resolve a {@link VectorMetric} to its pgvector distance operator from a
-     * fixed allow-list, validating the target column is actually a `vector`
-     * column. Throws {@link ValidationError} for an unknown metric or a
-     * non-vector column — a user-supplied string can never become a SQL operator.
-     */
-    private vectorOperator;
-    /**
-     * Validate and bind a query vector as a single `$n::vector` parameter.
-     * Every element must be a finite number (no NaN / Infinity / strings) so a
-     * malformed array can never produce a broken `::vector` literal, and the array
-     * is NEVER string-interpolated into the SQL text. Returns the `$n::vector`
-     * placeholder string.
-     */
-    private pushVectorParam;
     /** Parse a flat row: convert snake_case to camelCase + Date coercion */
     /**
      * Returns the set of camelCase field names for a table's date columns,
@@ -922,304 +489,5 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * memoized per table. Used so nested relation rows (camelCase keys) coerce
      * dates the same way top-level rows do.
      */
-    /**
-     * Prisma-compat: a plain object on a to-one relation key —
-     * `where: { vendor: { name: { contains: 'x' } } }` — is an implicit `is`
-     * filter. Normalize it to `{ is: obj }` so all downstream handling (SQL,
-     * params, fingerprint) sees one canonical shape. To-many relations still
-     * require an explicit `some`/`every`/`none` (a bare object there is
-     * ambiguous and was never valid in Prisma either).
-     */
-    private normalizeRelationFilter;
-    private getCamelDateFields;
     private parseRow;
-    /** Parse a row that may contain JSON nested relation columns */
-    private parseNestedRow;
-    /**
-     * Resolve the emitted column list for a relation, honoring `select` / `omit`.
-     * Shared by {@link buildRelationSubquery} (json order) and
-     * {@link buildRelationShape} (decode key order) so they can never diverge.
-     */
-    private resolveTargetColumns;
-    /**
-     * Render a single relation row's JSON: a keyed object (`'object'`) or a
-     * positional array (`'positional'`). The array drops the keys but keeps the
-     * exact expression order, so {@link RelationShape.keys} maps positions back.
-     */
-    private buildJsonRow;
-    /**
-     * Build the top-level relation shapes for a `with` clause, mirroring
-     * {@link buildSelectWithRelations}: same relation iteration order, same
-     * per-relation column resolution, same nested recursion.
-     */
-    private buildRelationShapes;
-    /**
-     * Recursively describe one relation's positional layout: the camelCase key
-     * order (scalar columns first, then nested relation slots in the same order
-     * {@link buildRelationSubquery} appends them), the nested sub-shapes, and the
-     * cardinality (single object for belongsTo/hasOne, array for the rest).
-     */
-    private buildRelationShape;
-    /**
-     * Build the row parser for a `with` clause. In object mode this is just
-     * {@link parseNestedRow}. In positional mode it decodes each relation's
-     * positional arrays into the object form first (shapes built once, not per
-     * row), then delegates to parseNestedRow for date/snake-camel coercion.
-     */
-    private makeNestedParser;
-    /**
-     * Return a shallow copy of a top-level row with each relation column decoded
-     * from its positional array(s) into the object representation. Only relation
-     * columns are positional — base scalar columns stay object-keyed — so the
-     * result is exactly what the object encoding would have handed parseNestedRow.
-     */
-    private decodePositionalRelations;
-    /**
-     * Decode one relation's positional JSON value. `json_agg` returns the value as
-     * a JSON string at the top level (JSON.parse once); nested relation slots are
-     * already-parsed arrays. A `'many'` value is an array of positional arrays; a
-     * `'one'` value is a single positional array or null.
-     */
-    private decodePositionalValue;
-    /** Map one positional array back to a keyed object using the shape's key order. */
-    private decodePositionalObject;
-    /**
-     * Build a SELECT clause that includes both base columns and nested relation subqueries.
-     *
-     * For each relation specified in the `with` clause, this method generates a correlated
-     * subquery using PostgreSQL's `json_agg(json_build_object(...))` pattern. The result
-     * is a single SQL SELECT clause that resolves the full object tree in one query --
-     * no N+1 problem.
-     *
-     * **How it works:**
-     * 1. Resolves the base columns for the root table (all columns, or a subset via `columnsList`).
-     * 2. Iterates over each key in the `with` clause, looking up the relation definition.
-     * 3. For each relation, delegates to {@link buildRelationSubquery} to generate a
-     *    correlated subquery that returns JSON (array for hasMany, object for belongsTo/hasOne).
-     * 4. Each subquery is aliased as the relation name in the final SELECT.
-     *
-     * **aliasCounter:** A shared `{ n: number }` object is passed through all nesting levels.
-     * Each call to `buildRelationSubquery` increments it to produce unique table aliases
-     * (`t0`, `t1`, `t2`, ...) across arbitrarily deep relation trees, preventing alias
-     * collisions in the generated SQL.
-     *
-     * **Example output:**
-     * ```sql
-     * "users"."id", "users"."name", "users"."email",
-     * (SELECT COALESCE(json_agg(json_build_object('id', t0."id", 'title', t0."title")), '[]'::json)
-     *   FROM "posts" t0 WHERE t0."user_id" = "users"."id") AS "posts"
-     * ```
-     *
-     * @param table - The root table name (e.g. `"users"`).
-     * @param withClause - An object mapping relation names to their include specs
-     *                     (`true` for default inclusion, or `WithOptions` for select/omit/where/orderBy/limit).
-     * @param params - Shared parameter array for parameterized values (`$1`, `$2`, ...).
-     *                 Nested where/limit values are pushed here to prevent SQL injection.
-     * @param columnsList - Optional subset of columns to include in the SELECT. When `null`
-     *                      or omitted, all columns from the table's schema metadata are used.
-     * @param depth - Current nesting depth, passed through to {@link buildRelationSubquery}
-     *                for circular-relation detection. Defaults to `0` at the top level.
-     * @param path - Breadcrumb trail of relation names traversed so far, used in error
-     *               messages when circular or too-deep nesting is detected.
-     * @returns A complete SELECT clause string (without the `SELECT` keyword) containing
-     *          base columns and relation subqueries.
-     */
-    private buildSelectWithRelations;
-    /**
-     * Generate a correlated subquery that returns JSON for a single relation.
-     *
-     * This is the core of Turbine's single-query nested relation strategy. For a given
-     * relation (e.g. `posts` on a `users` query), it produces a self-contained SQL subquery
-     * that PostgreSQL evaluates per parent row, returning either a JSON array (hasMany) or
-     * a single JSON object (belongsTo / hasOne).
-     *
-     * ### Algorithm overview
-     *
-     * 1. **Alias generation:** Allocates a unique alias (`t0`, `t1`, ...) from the shared
-     *    `aliasCounter` so that deeply nested subqueries never collide.
-     *
-     * 2. **Column resolution:** Honors `select` / `omit` options to control which columns
-     *    appear in the output JSON.
-     *
-     * 3. **`json_build_object`:** Builds a JSON object for each row by mapping camelCase
-     *    field names to their column values:
-     *    ```sql
-     *    json_build_object('id', t0."id", 'title', t0."title", 'createdAt', t0."created_at")
-     *    ```
-     *
-     * 4. **`json_agg` wrapping (hasMany):** For one-to-many relations, wraps the
-     *    `json_build_object` call in `json_agg(...)` to aggregate all matching child rows
-     *    into a JSON array. Uses `COALESCE(..., '[]'::json)` so the result is never NULL.
-     *    For belongsTo / hasOne, no aggregation is used -- just the single JSON object
-     *    with `LIMIT 1`.
-     *
-     * 5. **Correlation (WHERE clause):** Links the subquery to the parent row:
-     *    - **hasMany:** `alias.foreignKey = parentRef.referenceKey`
-     *      (e.g. `t0."user_id" = "users"."id"` -- child FK points to parent PK)
-     *    - **belongsTo / hasOne:** `alias.referenceKey = parentRef.foreignKey`
-     *      (e.g. `t0."id" = "posts"."author_id"` -- parent FK points to child PK)
-     *
-     * 6. **Recursion:** If the spec includes a nested `with` clause, this method calls
-     *    itself recursively for each nested relation, passing the current alias as
-     *    `parentRef`. The nested subquery appears as an additional key in the
-     *    `json_build_object` call, wrapped in `COALESCE(..., '[]'::json)`.
-     *    Depth is incremented and capped at 10 to guard against circular relations.
-     *
-     * 7. **LIMIT / ORDER BY wrapping:** For hasMany relations with `limit` or `orderBy`,
-     *    the query is restructured into a two-level form:
-     *    ```sql
-     *    SELECT COALESCE(json_agg(json_build_object(...)), '[]'::json)
-     *    FROM (
-     *      SELECT t0.* FROM "posts" t0
-     *      WHERE t0."user_id" = "users"."id"
-     *      ORDER BY t0."created_at" DESC
-     *      LIMIT $1
-     *    ) t0i
-     *    ```
-     *    This ensures LIMIT and ORDER BY apply to the raw rows *before* `json_agg`
-     *    aggregation. Without the inner subquery, LIMIT would be meaningless because
-     *    `json_agg` produces a single aggregated row.
-     *
-     * 8. **Parameter threading:** All user-supplied values (where filters, limit) are
-     *    pushed to the shared `params` array with `$N` placeholders. No string
-     *    interpolation of user data ever occurs -- all identifiers go through
-     *    `this.q()` and all values are parameterized.
-     *
-     * ### Example output (hasMany with nested relation)
-     * ```sql
-     * SELECT COALESCE(json_agg(json_build_object(
-     *   'id', t0."id",
-     *   'title', t0."title",
-     *   'comments', COALESCE((
-     *     SELECT COALESCE(json_agg(json_build_object('id', t1."id", 'body', t1."body")), '[]'::json)
-     *     FROM "comments" t1 WHERE t1."post_id" = t0."id"
-     *   ), '[]'::json)
-     * )), '[]'::json) FROM "posts" t0 WHERE t0."user_id" = "users"."id"
-     * ```
-     *
-     * @param relDef - The relation definition from schema metadata (contains `to`, `type`,
-     *                 `foreignKey`, `referenceKey`).
-     * @param spec - Either `true` (include with defaults) or a `WithOptions` object that
-     *               can specify `select`, `omit`, `where`, `orderBy`, `limit`, and nested `with`.
-     * @param params - Shared parameter array. User-supplied values are pushed here and
-     *                 referenced as `$1`, `$2`, etc. in the generated SQL.
-     * @param parentRef - The alias (e.g. `"t0"`) or table name (e.g. `"users"`) of the
-     *                    parent query. Used to build the correlated WHERE clause that ties
-     *                    child rows to their parent row.
-     * @param aliasCounter - Shared mutable counter (`{ n: number }`) for generating unique
-     *                       table aliases (`t0`, `t1`, `t2`, ...) across all nesting levels.
-     *                       Each call increments `n` by 1.
-     * @param depth - Current nesting depth (starts at `0`). Incremented on each recursive
-     *                call. If it reaches 10, a {@link CircularRelationError} is thrown.
-     * @param path - Breadcrumb trail of relation/table names traversed so far
-     *               (e.g. `["users", "posts", "comments"]`). Used in the error message
-     *               when circular or too-deep nesting is detected.
-     * @returns A complete SQL subquery string (without surrounding parentheses) that
-     *          evaluates to a JSON array (hasMany) or a JSON object (belongsTo/hasOne).
-     */
-    private buildRelationSubquery;
-    /**
-     * Build the json_agg subquery for a `manyToMany` relation, JOINing the target
-     * table through a junction (join) table.
-     *
-     * Shape (no LIMIT/ORDER):
-     * ```sql
-     * SELECT COALESCE(json_agg(json_build_object(...)), '[]'::json)
-     * FROM <target> <talias>
-     * JOIN <junction> <jalias> ON <jalias>.<targetKey> = <talias>.<targetPK>
-     * WHERE <jalias>.<sourceKey> = <parentRef>.<referenceKey>
-     * ```
-     *
-     * With LIMIT/ORDER, the rows are wrapped in an inner subquery so the LIMIT
-     * applies BEFORE aggregation (identical strategy to hasMany).
-     *
-     * Cardinality is always 'many' → empty-array fallback, never NULL.
-     *
-     * IMPORTANT: every `params.push` here MUST be mirrored, in the same order, in
-     * {@link collectRelationSubqueryParams} or pipeline batching will desync.
-     */
-    private buildManyToManySubquery;
-    /**
-     * Get the Postgres type for a column (e.g. 'jsonb', 'text', '_int4').
-     * Used to detect JSONB/array columns for specialized operators.
-     * Uses pre-computed Map for O(1) lookup instead of linear scan.
-     */
-    /**
-     * Case-insensitive json/jsonb column-type check. Postgres reports lowercase
-     * udt_names, but SQLite/MySQL introspection surfaces the DECLARED type
-     * (e.g. `JSON`), so every JSON-feature gate compares through this predicate
-     * — build and collect sides alike, keeping the SQL-cache lockstep.
-     */
-    private isJsonColumnType;
-    private getColumnPgType;
-    /**
-     * Get the Postgres base element type for an array column.
-     * E.g. '_text' → 'text', '_int4' → 'integer'
-     */
-    private getArrayElementType;
-    /**
-     * Validate and enumerate the range comparisons (`gt`/`gte`/`lt`/`lte`) on a
-     * JSON filter, in the fixed {@link JSON_RANGE_OPERATORS} order. Shared by
-     * the SQL-build path ({@link buildJsonFilterClauses}) and the cache-hit
-     * param-collect path ({@link collectJsonFilterParams}) so both always agree
-     * on which params are pushed — and both throw identically for invalid
-     * shapes, so a warmed cache can never skip validation.
-     */
-    private jsonRangeEntries;
-    /**
-     * Build SQL clauses for JSONB filter operators on a column.
-     * Supports: path, equals, contains, hasKey, gt, gte, lt, lte.
-     *
-     * The `path` param is bound at most once and its placeholder is shared by
-     * every clause that extracts it (equals + range ops), so the param list
-     * stays byte-identical to {@link collectJsonFilterParams}.
-     */
-    private buildJsonFilterClauses;
-    /**
-     * Bind value for a JSON path parameter, encoded per dialect. PostgreSQL's
-     * `#>>` takes a `text[]` (the segments as strings — or `nativeForm` when the
-     * caller has a specific native binding, e.g. JsonFilter's raw path array).
-     * Every other engine's JSON function (`json_extract` / `JSON_EXTRACT` /
-     * `JSON_VALUE`) takes a `'$'`-rooted JSONPath STRING: binding the raw array
-     * would arrive as `'["a"]'` (the driver shims JSON.stringify non-primitive
-     * params) and fail at runtime with the engine's bad-JSON-path error. The
-     * encoded path stays a bound parameter — never spliced into SQL text — so
-     * the build/collect param mirrors stay in lockstep and injection-safe.
-     */
-    private jsonPathParam;
-    /**
-     * Cast an extracted JSON path text value to a numeric type for range
-     * comparison. PostgreSQL uses `(expr)::numeric` (exact — the right way to
-     * compare JSON numbers, and `::float` would lose precision on big ints);
-     * other dialects route through {@link Dialect.castAggregate} (SQLite/MySQL/
-     * SQL Server have no `::` operator) as a float cast.
-     */
-    private castJsonNumeric;
-    /**
-     * Build SQL clauses for Array filter operators on a column.
-     * Supports: has, hasEvery, hasSome, isEmpty.
-     */
-    private buildArrayFilterClauses;
-    /**
-     * Build SQL clauses for a pgvector distance WHERE filter:
-     *
-     *   `"embedding" <-> $1::vector < $2`
-     *
-     * The query vector is bound as a `$n::vector` param (never interpolated), the
-     * metric maps to an operator via a fixed allow-list, and each comparison
-     * threshold (`lt`/`lte`/`gt`/`gte`) is its own bound param. Emits one clause
-     * per supplied comparator (all ANDed). Param push order matches
-     * {@link collectVectorFilterParams}.
-     */
-    private buildVectorFilterClauses;
-    /**
-     * Build SQL clause for full-text search using to_tsvector @@ to_tsquery.
-     * The config name is validated to prevent injection (only alphanumeric + underscore).
-     */
-    private buildTextSearchClause;
-    /**
-     * Get the Postgres array type for a column (used by UNNEST in createMany).
-     * Uses pre-computed Map for O(1) lookup instead of linear scan.
-     */
-    private getColumnArrayType;
 }