diff --git a/CHANGELOG.md b/CHANGELOG.md
index aa2440b37..d35e1e5f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -62,6 +62,7 @@ Each entry that ships in a published release links to the PR that introduced it.
 
 ### Changed
 
+- **Query-operand domains renamed to a `query_<name>` prefix AND moved into the `eql_v3` schema (CIP-3442).** Every scalar query twin introduced by the query-operand surface (above) is now `eql_v3.query_<name>` — `query_integer_eq`, `query_text_ord`, `query_timestamp_ord_ope`, … — and the encrypted-JSONB containment needle follows the same convention: `public.jsonb_query` is now `eql_v3.query_jsonb`. Predicates cast accordingly (`WHERE col = $1::eql_v3.query_integer_eq`; `WHERE doc @> $1::eql_v3.query_jsonb`), the `eql-bindings` `DomainType::sql_domain` strings, `QueryPayload::parse` domain names, and the exported JSON Schema file names (`schema/v3/query_<name>.json`) all carry the new names, and `from_v2_query` / `from_v2_query_typed` target them. This supersedes the `<name>_query` naming in the earlier `[Unreleased]` entries; the old names shipped only in 3.0.0 pre-releases. **Why the prefix:** alphabetical type listings interleaved never-a-column-type query operands with the actual column types (`integer_eq` next to `integer_eq_query`); the shared `query_` prefix sorts every query operand together. **Why the schema move:** query operands are never valid column types, so they don't belong in `public` — the column-type namespace whose survive-schema-drop rationale (dropping EQL-owned schemas must not drop application columns) doesn't apply to them. In `eql_v3` they are versioned with the rest of the public API surface, are uninstalled with it (a column misusing a query domain is dropped by the uninstaller's CASCADE — pinned by the uninstall suite), and casting a query operand requires the same `USAGE ON SCHEMA eql_v3` a caller already needs for the extractors and comparison wrappers. See [U-002](docs/upgrading/v3.0.md#u-002-query-operand-domains-are-eql_v3query_name) in the 3.0 upgrade guide. ([CIP-3442](https://linear.app/cipherstash/issue/CIP-3442))
 - **The `eql_v3` tier's JSON envelope version is now `v: 3` (was `v: 2`).** Every `eql_v3` domain CHECK — the generated scalar families and the hand-written `eql_v3.json` SteVec document domain — now pins `VALUE->>'v' = '3'`, and the canonical payload bindings (`SchemaVersion` in `eql-bindings`, the emitted TypeScript alias, and the JSON Schema `const`) accept exactly `3`, rejecting the legacy `2` at the type boundary. The v3 tier previously carried the v2 wire version for continuity; with the tier now diverging from the legacy wire (the new `op` term), the envelope version matches the schema generation. The legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json` and its validation tests) is unchanged and stays `v: 2`. **Compatibility:** payloads produced for the v3 tier must now carry `v: 3` — a cipherstash-client that emits `v: 2` cannot insert into `eql_v3` domain columns until it is updated to emit the v3 envelope. See [U-001](docs/upgrading/v3.0.md#u-001-eql_v3-payloads-carry-v-3) in the 3.0 upgrade guide. ([#340](https://github.com/cipherstash/encrypt-query-language/pull/340))
 - **Scalar encrypted-domain types are now defined in a Rust catalog, not TOML manifests; the Python codegen toolchain is removed.** Adding a scalar encrypted-domain type (`int4`, `int8`, …) is now one row in `eql-scalars::CATALOG` (`crates/eql-scalars/src/lib.rs`) instead of authoring `tasks/codegen/types/<T>.toml`. `mise run build` regenerates the gitignored SQL surface via `cargo run -p eql-codegen` (Rust, std-only) rather than the Python generator. The catalog row's `Fixture` list is the single source of truth for that type's plaintext fixtures: the SQLx test matrix reads it directly as a compile-time-materialised const (`eql_scalars::INT4_VALUES` / `INT2_VALUES`, `ScalarType::FIXTURE_VALUES`), so there is no longer a generated, committed `tests/sqlx/src/fixtures/<T>_values.rs` — a Rust source of truth no longer round-trips through generated Rust. The shipped SQL is unchanged — `release/*.sql` is byte-identical across the cutover — so there is no change for callers installing EQL; this only affects contributors who extend the scalar domain families. The `python` mise tool, the `pytest`-based `test:codegen` (now `cargo test -p eql-scalars -p eql-codegen`), the per-type `mise run codegen:domain` tasks, and the per-type `tests/sqlx/snapshots/<T>_matrix_tests.txt` baselines (collapsed into one catalog-reconciled `tests/sqlx/snapshots/matrix_tests.txt`) are gone. Why: a single compiler-validated source of truth shared by the generator and the SQLx test harness, and one fewer toolchain in the build/test path — building and testing EQL no longer needs Python (Python remains only for the separate docs-markdown tooling). ([#252](https://github.com/cipherstash/encrypt-query-language/pull/252))
 - **Scalar encrypted-domain types are now defined in a Rust catalog, not TOML manifests; the Python codegen toolchain is removed.** Adding a scalar encrypted-domain type (`integer`, `bigint`, …) is now one row in `eql-scalars::CATALOG` (`crates/eql-scalars/src/lib.rs`) instead of authoring `tasks/codegen/types/<T>.toml`. `mise run build` regenerates the gitignored SQL surface via `cargo run -p eql-codegen` (Rust, std-only) rather than the Python generator. The catalog row's `Fixture` list is the single source of truth for that type's plaintext fixtures: the SQLx test matrix reads it directly as a compile-time-materialised const (`eql_scalars::INT4_VALUES` / `INT2_VALUES`, `ScalarType::FIXTURE_VALUES`), so there is no longer a generated, committed `tests/sqlx/src/fixtures/<T>_values.rs` — a Rust source of truth no longer round-trips through generated Rust. The shipped SQL is unchanged — `release/*.sql` is byte-identical across the cutover — so there is no change for callers installing EQL; this only affects contributors who extend the scalar domain families. The `python` mise tool, the `pytest`-based `test:codegen` (now `cargo test -p eql-scalars -p eql-codegen`), the per-type `mise run codegen:domain` tasks, and the per-type `tests/sqlx/snapshots/<T>_matrix_tests.txt` baselines (collapsed into one catalog-reconciled `tests/sqlx/snapshots/matrix_tests.txt`) are gone. Why: a single compiler-validated source of truth shared by the generator and the SQLx test harness, and one fewer toolchain in the build/test path — building and testing EQL no longer needs Python (Python remains only for the separate docs-markdown tooling). ([#252](https://github.com/cipherstash/encrypt-query-language/pull/252))
diff --git a/CLAUDE.md b/CLAUDE.md
index 9e07cf81f..1fa402d40 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -49,7 +49,7 @@ This is the **Encrypt Query Language (EQL)** - a PostgreSQL extension for search
 ### Directory Structure
 - `src/` - contains only the self-contained `v3` surface (the modular `eql_v2` component directories were removed in 3.0.0)
 - `crates/` - Rust workspace: `eql-domains` (the catalog), `eql-codegen` (SQL/bindings generator), `eql-bindings` (payload bindings), `eql-tests-macros`
-- `src/v3/` - Self-contained `eql_v3` / `eql_v3_internal` surface: `src/v3/schema.sql` (creates both schemas), forked `src/v3/crypto.sql` / `src/v3/common.sql`, hand-written SEM index-term types under `src/v3/sem/` (`hmac_256`, `ore_block_256`) — now created in `eql_v3_internal` — the generated scalar encrypted-domain families under `src/v3/scalars/<T>/` (user-column domains in `public`; extractors **and the supported comparison wrappers** in `eql_v3`; only the blockers and aggregate state functions in `eql_v3_internal`; plus the shared blocker `src/v3/scalars/functions.sql`), and the hand-written encrypted-JSONB (SteVec) surface under `src/v3/jsonb/` (`types.sql`, `functions.sql`, `operators.sql`, `aggregates.sql`, `blockers.sql` — the `public.json` / `public.jsonb_entry` / `public.jsonb_query` domains and CHECK validators live in `public`; typed operators, `jsonb_entry` comparison wrappers, the containment engine (`ste_vec_contains`), and raw-jsonb GIN helpers (`jsonb_array` / `jsonb_contains` / `jsonb_contained_by`) live in `eql_v3`; only the `is_ste_vec_array` helper and aggregate state functions live in `eql_v3_internal`)
+- `src/v3/` - Self-contained `eql_v3` / `eql_v3_internal` surface: `src/v3/schema.sql` (creates both schemas), forked `src/v3/crypto.sql` / `src/v3/common.sql`, hand-written SEM index-term types under `src/v3/sem/` (`hmac_256`, `ore_block_256`) — now created in `eql_v3_internal` — the generated scalar encrypted-domain families under `src/v3/scalars/<T>/` (user-column domains in `public`; extractors **and the supported comparison wrappers** in `eql_v3`; only the blockers and aggregate state functions in `eql_v3_internal`; plus the shared blocker `src/v3/scalars/functions.sql`), and the hand-written encrypted-JSONB (SteVec) surface under `src/v3/jsonb/` (`types.sql`, `functions.sql`, `operators.sql`, `aggregates.sql`, `blockers.sql` — the `public.json` / `public.jsonb_entry` column domains and their CHECK validators live in `public`, while the containment needle `eql_v3.query_jsonb` — a query operand, never a column type — lives in `eql_v3` (CIP-3442); typed operators, `jsonb_entry` comparison wrappers, the containment engine (`ste_vec_contains`), and raw-jsonb GIN helpers (`jsonb_array` / `jsonb_contains` / `jsonb_contained_by`) live in `eql_v3`; only the `is_ste_vec_array` helper and aggregate state functions live in `eql_v3_internal`)
 - `tasks/` - mise task scripts
 - `tests/sqlx/` - Rust/SQLx test framework (PostgreSQL 14-17 support)
 - `release/` - Generated SQL installation files
@@ -63,7 +63,7 @@ This is the **Encrypt Query Language (EQL)** - a PostgreSQL extension for search
 
 ### Encrypted-Domain Types
 
-`src/v3/scalars/` holds the generated **encrypted-domain type families** — jsonb-backed PostgreSQL domains in the **`public` schema**, one domain per operator/index capability (`public.<T>` storage-only, `public.<T>_eq`, `public.<T>_ord`). The domains are `public.integer`, `public.integer_eq`, `public.integer_ord`, `public.integer_ord_ore`; their extractors (`eql_v3.eq_term`, `eql_v3.ord_term`), aggregates (`eql_v3.min`/`max`), **and the supported comparison wrappers** (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`) all live in **`eql_v3`** — the wrappers are public so every operator has a callable function equivalent (Supabase/PostgREST). Only the **blockers** (for unsupported operators — they just raise), the **aggregate state functions**, and the SEM index-term types the extractors/wrappers return and construct (`eql_v3_internal.hmac_256`, `eql_v3_internal.ore_block_256`) live in **`eql_v3_internal`** — hand-written under `src/v3/sem/`, schema-qualified via the codegen's `INTERNAL_SCHEMA` constant for the generated surface (the codegen's `SCHEMA` constant qualifies the public wrappers; the `operator_entry` renderer picks the backing function's schema by whether the operator is supported) — so the whole v3 surface (both schemas together) is self-contained (no `eql_v2.<symbol>` appears anywhere in v3 SQL; CI gates this via `mise run test:self_contained_v3` and the self-contained `release/cipherstash-encrypt.sql` installer). `public.integer` (PR #239, supersedes #225) is the reference scalar implementation; the catalog now generates a full surface for `integer`, `smallint`, `bigint`, `date`, `timestamp`, `numeric`, `text`, `boolean`, `real`, and `double`, all following this materializer pattern. `jsonb` is a `CATALOG` family too, but a permanently **hand-written**, not generated, one: its three domains (`public.json` document, `public.jsonb_entry`, `public.jsonb_query`) carry `Shape::SteVecDocument` / `SteVecEntry` / `SteVecQuery` (the `Shape` enum in `crates/eql-domains/src/lib.rs`) instead of `Shape::Scalar`, and their SQL lives under `src/v3/jsonb/` rather than `src/v3/scalars/<T>/` — `eql-codegen` renders SQL only for `scalar_families()` (the `Shape::Scalar` rows), so the fixed-envelope ordered-scalar materializer described below never touches `jsonb`. This is a deliberate, permanent split, not a gap awaiting a future generator.
+`src/v3/scalars/` holds the generated **encrypted-domain type families** — jsonb-backed PostgreSQL domains in the **`public` schema**, one domain per operator/index capability (`public.<T>` storage-only, `public.<T>_eq`, `public.<T>_ord`), plus an `eql_v3.query_<T>_<cap>` **query-operand twin** per term-bearing domain (index-terms-only, no ciphertext `c`; in `eql_v3`, not `public`, because a query operand is never a column type — CIP-3442). The domains are `public.integer`, `public.integer_eq`, `public.integer_ord`, `public.integer_ord_ore`; their extractors (`eql_v3.eq_term`, `eql_v3.ord_term`), aggregates (`eql_v3.min`/`max`), **and the supported comparison wrappers** (`eq`/`neq`/`lt`/`lte`/`gt`/`gte`/`contains`/`contained_by`) all live in **`eql_v3`** — the wrappers are public so every operator has a callable function equivalent (Supabase/PostgREST). Only the **blockers** (for unsupported operators — they just raise), the **aggregate state functions**, and the SEM index-term types the extractors/wrappers return and construct (`eql_v3_internal.hmac_256`, `eql_v3_internal.ore_block_256`) live in **`eql_v3_internal`** — hand-written under `src/v3/sem/`, schema-qualified via the codegen's `INTERNAL_SCHEMA` constant for the generated surface (the codegen's `SCHEMA` constant qualifies the public wrappers; the `operator_entry` renderer picks the backing function's schema by whether the operator is supported) — so the whole v3 surface (both schemas together) is self-contained (no `eql_v2.<symbol>` appears anywhere in v3 SQL; CI gates this via `mise run test:self_contained_v3` and the self-contained `release/cipherstash-encrypt.sql` installer). `public.integer` (PR #239, supersedes #225) is the reference scalar implementation; the catalog now generates a full surface for `integer`, `smallint`, `bigint`, `date`, `timestamp`, `numeric`, `text`, `boolean`, `real`, and `double`, all following this materializer pattern. `jsonb` is a `CATALOG` family too, but a permanently **hand-written**, not generated, one: its three domains (`public.json` document, `public.jsonb_entry`, `eql_v3.query_jsonb`) carry `Shape::SteVecDocument` / `SteVecEntry` / `SteVecQuery` (the `Shape` enum in `crates/eql-domains/src/lib.rs`) instead of `Shape::Scalar`, and their SQL lives under `src/v3/jsonb/` rather than `src/v3/scalars/<T>/` — `eql-codegen` renders SQL only for `scalar_families()` (the `Shape::Scalar` rows), so the fixed-envelope ordered-scalar materializer described below never touches `jsonb`. This is a deliberate, permanent split, not a gap awaiting a future generator.
 
 Adding a scalar encrypted-domain type is one row in the Rust catalog `eql-domains::CATALOG` (`crates/eql-domains/src/lib.rs`): a `DomainFamily` giving the type `name` (e.g. `bigint`), its `ScalarKind` (the `kind` field), the `Domain`s mapping each generated (bare) domain name to its fixed index `Term`s (`eq => [Hm]`, `ord`/`ord_ore => [Ore]`), and the `Fixture` value list. Term capabilities are fixed in the `Term` enum's `impl` methods (with unit tests): `Hm` provides equality, and `Ore` provides equality plus ordering. There is no TOML manifest and no Python — the catalog is the source of truth, validated by the compiler (an undefined term or unknown scalar is a compile error) plus catalog `#[test]`s. `mise run build` runs `cargo run -p eql-codegen`, which regenerates the scalar SQL surface into `src/v3/scalars/<T>/` from `CATALOG` at the start of every build; that surface includes supported comparison wrappers plus blockers for native `jsonb` operators that would otherwise be reachable through domain fallback. `cargo run -p eql-codegen` regenerates every type at once (the same call `mise run build` uses; there is no per-type codegen task). The generated `*_types.sql` / `*_functions.sql` / `*_operators.sql` / `*_aggregates.sql` files are **committed in place** under `src/v3/scalars/<T>/` and drift-gated by `mise run codegen:parity` (regenerate in place + `git diff` + untracked check — the same regenerate-and-diff pattern `types:check` uses for the committed bindings). They are still machine-generated: change the catalog and rebuild, never hand-edit (CI fails on drift). The per-type plaintext fixture lists the SQLx matrix consumes are **not** a generated file — they are materialised from each `CATALOG` row at compile time as `eql_domains::INT4_VALUES` / `INT2_VALUES` (the `int_values!` macro) and read directly by `ScalarType::FIXTURE_VALUES`; a Rust source of truth no longer round-trips through a committed generated `.rs`. Generated SQL carries a `-- AUTOMATICALLY GENERATED FILE` header (the project-wide marker `docs:validate` greps on); change the catalog and rebuild, never hand-edit. Hand-written SQL beyond the fixed surface goes in `src/v3/scalars/<T>/<T>_extensions.sql` with no auto-generated header and explicit `-- REQUIRE:` edges — that file IS committed. `jsonb` (see above) never enters this pipeline: every consumer here (`generate_all`, `list-types`, the SQLx matrix) iterates `eql_domains::scalar_families()`, which excludes any non-`Shape::Scalar` row, so `jsonb` is invisible to the materializer and the matrix by construction, not by a per-type exception.
 
diff --git a/SUPABASE.md b/SUPABASE.md
index f3b3ce951..8a0f7ce21 100644
--- a/SUPABASE.md
+++ b/SUPABASE.md
@@ -181,7 +181,7 @@ the `eql_v3.jsonb_path_*` helper functions, all without operator classes:
 
 ```sql
 -- Document containment (GIN-indexable on Supabase)
-SELECT * FROM orders WHERE data_encrypted @> $1::public.jsonb_query;
+SELECT * FROM orders WHERE data_encrypted @> $1::eql_v3.query_jsonb;
 
 -- Field access (selector is the deterministic selector hash, typed as text)
 SELECT data_encrypted -> '<selector>'::text FROM orders;
diff --git a/crates/eql-bindings/CHANGELOG.md b/crates/eql-bindings/CHANGELOG.md
index 5d17f845e..6c96e809a 100644
--- a/crates/eql-bindings/CHANGELOG.md
+++ b/crates/eql-bindings/CHANGELOG.md
@@ -12,19 +12,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Scalar query-operand bindings (CIP-3432).** Every term-bearing scalar
   domain now has a generated query twin — `IntegerEqQuery`, `IntegerOrdOpeQuery`,
   `TextSearchQuery`, … — the **enveloped term-only** operand `{v, i, <terms>}`
-  (envelope minus the ciphertext `c`) for its `public.<name>_query` query
+  (envelope minus the ciphertext `c`) for its `eql_v3.query_<name>` query
   domain, with matching TypeScript bindings (`bindings/v3/*Query.ts`) and JSON
-  Schemas (`schema/v3/*_query.json`). Storage-only domains (no operators) get no
-  twin. `QueryPayload` is now catalog-generated — a variant per query twin plus
-  the SteVec containment needle — superseding the hand-written single-variant
-  enum. A new `all_query()` inventory exposes the query twins separately from
-  `all()` (which stays the stored + SteVec conversion-target inventory).
+  Schemas (`schema/v3/query_<name>.json`). Storage-only domains (no operators)
+  get no twin. `QueryPayload` is now catalog-generated — a variant per query
+  twin plus the SteVec containment needle — superseding the hand-written
+  single-variant enum. A new `all_query()` inventory exposes the query twins
+  separately from `all()` (which stays the stored + SteVec conversion-target
+  inventory).
 
 ### Changed
 
+- **Query-operand domain names switched to the `query_<name>` prefix, homed
+  in the `eql_v3` schema (CIP-3442).** The SQL domain names carried by the
+  query twins — in `DomainType::sql_domain`, the names `QueryPayload::parse`
+  accepts, and the exported JSON Schema file names — are now `query_<name>` /
+  `eql_v3.query_<name>` (e.g. `query_integer_eq`), and the SteVec containment
+  needle is `eql_v3.query_jsonb` (was `public.jsonb_query`).
+  `DomainType::domain` now strips whichever schema qualifies `sql_domain`
+  (`public.` for column domains, `eql_v3.` for query operands) instead of
+  assuming `public.`. Matches the renamed/relocated SQL surface — query
+  operands are never column types, so they leave the `public` column-type
+  namespace; supersedes the `public.<name>_query` naming shipped only in
+  3.0.0 pre-releases.
 - **`from_v2_query` / `from_v2_query_typed` now convert scalar query targets.**
   A term-bearing scalar target hoists the v2 payload's required terms into the
-  `{v: 3, i, <terms>}` operand for its `<name>_query` domain (dropping the
+  `{v: 3, i, <terms>}` operand for its `query_<name>` domain (dropping the
   stored `c`/`k`; `bf` reinterpreted to signed `smallint[]`), validated through
   the generated `QueryPayload`. Storage-only scalar targets still return
   `UnsupportedQueryTarget`. Previously every scalar query target failed closed.
diff --git a/crates/eql-bindings/bindings/v3/BigintEqQuery.ts b/crates/eql-bindings/bindings/v3/BigintEqQuery.ts
index bdf9c2268..7166ab6c8 100644
--- a/crates/eql-bindings/bindings/v3/BigintEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/BigintEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.bigint_eq_query` — equality domain query operand.
+ * `eql_v3.query_bigint_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/BigintOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/BigintOrdOpeQuery.ts
index 4de2db413..7c01b2c77 100644
--- a/crates/eql-bindings/bindings/v3/BigintOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/BigintOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.bigint_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_bigint_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/BigintOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/BigintOrdOreQuery.ts
index 35e548217..28b2fc2a7 100644
--- a/crates/eql-bindings/bindings/v3/BigintOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/BigintOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.bigint_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_bigint_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/BigintOrdQuery.ts b/crates/eql-bindings/bindings/v3/BigintOrdQuery.ts
index 27a7a7096..219b6f2dd 100644
--- a/crates/eql-bindings/bindings/v3/BigintOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/BigintOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.bigint_ord_query` — ordering domain query operand.
+ * `eql_v3.query_bigint_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DateEqQuery.ts b/crates/eql-bindings/bindings/v3/DateEqQuery.ts
index 335e2fb96..39b987447 100644
--- a/crates/eql-bindings/bindings/v3/DateEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DateEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.date_eq_query` — equality domain query operand.
+ * `eql_v3.query_date_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DateOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/DateOrdOpeQuery.ts
index 298bf2b7b..396687d7b 100644
--- a/crates/eql-bindings/bindings/v3/DateOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DateOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.date_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_date_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DateOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/DateOrdOreQuery.ts
index 2717bf235..726326377 100644
--- a/crates/eql-bindings/bindings/v3/DateOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DateOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.date_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_date_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DateOrdQuery.ts b/crates/eql-bindings/bindings/v3/DateOrdQuery.ts
index 632fbdfb0..bf3bfa66b 100644
--- a/crates/eql-bindings/bindings/v3/DateOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DateOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.date_ord_query` — ordering domain query operand.
+ * `eql_v3.query_date_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DoubleEqQuery.ts b/crates/eql-bindings/bindings/v3/DoubleEqQuery.ts
index c4c906e4c..3ec5ce8e7 100644
--- a/crates/eql-bindings/bindings/v3/DoubleEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DoubleEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.double_eq_query` — equality domain query operand.
+ * `eql_v3.query_double_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DoubleOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/DoubleOrdOpeQuery.ts
index 3e128a99d..7aab5ae6e 100644
--- a/crates/eql-bindings/bindings/v3/DoubleOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DoubleOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.double_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_double_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DoubleOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/DoubleOrdOreQuery.ts
index 7f686a036..937c44c41 100644
--- a/crates/eql-bindings/bindings/v3/DoubleOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DoubleOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.double_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_double_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/DoubleOrdQuery.ts b/crates/eql-bindings/bindings/v3/DoubleOrdQuery.ts
index 972799ff9..9b35d87d3 100644
--- a/crates/eql-bindings/bindings/v3/DoubleOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/DoubleOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.double_ord_query` — ordering domain query operand.
+ * `eql_v3.query_double_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/IntegerEqQuery.ts b/crates/eql-bindings/bindings/v3/IntegerEqQuery.ts
index 2fe9d70a6..c63844234 100644
--- a/crates/eql-bindings/bindings/v3/IntegerEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/IntegerEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.integer_eq_query` — equality domain query operand.
+ * `eql_v3.query_integer_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/IntegerOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/IntegerOrdOpeQuery.ts
index fba5a5269..a04709d0b 100644
--- a/crates/eql-bindings/bindings/v3/IntegerOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/IntegerOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.integer_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_integer_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/IntegerOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/IntegerOrdOreQuery.ts
index 5ad3c0414..e7c4c9e0b 100644
--- a/crates/eql-bindings/bindings/v3/IntegerOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/IntegerOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.integer_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_integer_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/IntegerOrdQuery.ts b/crates/eql-bindings/bindings/v3/IntegerOrdQuery.ts
index 855461e5c..27952f861 100644
--- a/crates/eql-bindings/bindings/v3/IntegerOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/IntegerOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.integer_ord_query` — ordering domain query operand.
+ * `eql_v3.query_integer_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/NumericEqQuery.ts b/crates/eql-bindings/bindings/v3/NumericEqQuery.ts
index 006d35c59..aa4cd6883 100644
--- a/crates/eql-bindings/bindings/v3/NumericEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/NumericEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.numeric_eq_query` — equality domain query operand.
+ * `eql_v3.query_numeric_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/NumericOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/NumericOrdOpeQuery.ts
index 0b69f372e..f6f2fd8ca 100644
--- a/crates/eql-bindings/bindings/v3/NumericOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/NumericOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.numeric_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_numeric_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/NumericOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/NumericOrdOreQuery.ts
index 42f0c138a..1b3c39a82 100644
--- a/crates/eql-bindings/bindings/v3/NumericOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/NumericOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.numeric_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_numeric_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/NumericOrdQuery.ts b/crates/eql-bindings/bindings/v3/NumericOrdQuery.ts
index ee8dcb744..f2c7a2fc8 100644
--- a/crates/eql-bindings/bindings/v3/NumericOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/NumericOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.numeric_ord_query` — ordering domain query operand.
+ * `eql_v3.query_numeric_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/RealEqQuery.ts b/crates/eql-bindings/bindings/v3/RealEqQuery.ts
index 938ebd35e..7eb74e86b 100644
--- a/crates/eql-bindings/bindings/v3/RealEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/RealEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.real_eq_query` — equality domain query operand.
+ * `eql_v3.query_real_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/RealOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/RealOrdOpeQuery.ts
index 2b7554584..d815c3cea 100644
--- a/crates/eql-bindings/bindings/v3/RealOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/RealOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.real_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_real_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/RealOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/RealOrdOreQuery.ts
index 626ab64cc..08d72e5c6 100644
--- a/crates/eql-bindings/bindings/v3/RealOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/RealOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.real_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_real_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/RealOrdQuery.ts b/crates/eql-bindings/bindings/v3/RealOrdQuery.ts
index 3932d80f3..9867c5af4 100644
--- a/crates/eql-bindings/bindings/v3/RealOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/RealOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.real_ord_query` — ordering domain query operand.
+ * `eql_v3.query_real_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/SmallintEqQuery.ts b/crates/eql-bindings/bindings/v3/SmallintEqQuery.ts
index ab9f0f460..a7909d960 100644
--- a/crates/eql-bindings/bindings/v3/SmallintEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/SmallintEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.smallint_eq_query` — equality domain query operand.
+ * `eql_v3.query_smallint_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/SmallintOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/SmallintOrdOpeQuery.ts
index 95ebc6a6d..5924a30f4 100644
--- a/crates/eql-bindings/bindings/v3/SmallintOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/SmallintOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.smallint_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_smallint_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/SmallintOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/SmallintOrdOreQuery.ts
index fc9aad722..78e4f38d9 100644
--- a/crates/eql-bindings/bindings/v3/SmallintOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/SmallintOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.smallint_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_smallint_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/SmallintOrdQuery.ts b/crates/eql-bindings/bindings/v3/SmallintOrdQuery.ts
index 79196471f..7eabe8d72 100644
--- a/crates/eql-bindings/bindings/v3/SmallintOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/SmallintOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.smallint_ord_query` — ordering domain query operand.
+ * `eql_v3.query_smallint_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/SteVecQuery.ts b/crates/eql-bindings/bindings/v3/SteVecQuery.ts
index 7d4d64a8d..eb1cab954 100644
--- a/crates/eql-bindings/bindings/v3/SteVecQuery.ts
+++ b/crates/eql-bindings/bindings/v3/SteVecQuery.ts
@@ -2,6 +2,6 @@
 import type { SteVecQueryEntry } from "./SteVecQueryEntry";
 
 /**
- * `public.jsonb_query` — a containment needle (`{sv:[query-entry]}`). Strict.
+ * `eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict.
  */
 export type SteVecQuery = { sv: Array<SteVecQueryEntry>, };
diff --git a/crates/eql-bindings/bindings/v3/TextEqQuery.ts b/crates/eql-bindings/bindings/v3/TextEqQuery.ts
index 80bc5726a..00bfdb41e 100644
--- a/crates/eql-bindings/bindings/v3/TextEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_eq_query` — equality domain query operand.
+ * `eql_v3.query_text_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TextMatchQuery.ts b/crates/eql-bindings/bindings/v3/TextMatchQuery.ts
index 5b2186427..4e525ab6c 100644
--- a/crates/eql-bindings/bindings/v3/TextMatchQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextMatchQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_match_query` — match domain query operand.
+ * `eql_v3.query_text_match` — match domain query operand.
  *
  * Operators: `@>` `<@`. Required keys: `v` `i` `bf`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TextOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/TextOrdOpeQuery.ts
index f56e48854..ae7e69259 100644
--- a/crates/eql-bindings/bindings/v3/TextOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextOrdOpeQuery.ts
@@ -5,7 +5,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_text_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TextOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/TextOrdOreQuery.ts
index 39714e018..00290b7cc 100644
--- a/crates/eql-bindings/bindings/v3/TextOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextOrdOreQuery.ts
@@ -5,7 +5,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_text_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TextOrdQuery.ts b/crates/eql-bindings/bindings/v3/TextOrdQuery.ts
index bffe6d452..4fc033acb 100644
--- a/crates/eql-bindings/bindings/v3/TextOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextOrdQuery.ts
@@ -5,7 +5,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_ord_query` — ordering domain query operand.
+ * `eql_v3.query_text_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TextSearchQuery.ts b/crates/eql-bindings/bindings/v3/TextSearchQuery.ts
index 95f880203..7a2f6c822 100644
--- a/crates/eql-bindings/bindings/v3/TextSearchQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TextSearchQuery.ts
@@ -6,7 +6,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.text_search_query` — search domain query operand.
+ * `eql_v3.query_text_search` — search domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TimestampEqQuery.ts b/crates/eql-bindings/bindings/v3/TimestampEqQuery.ts
index 9957cfadc..afc2e9820 100644
--- a/crates/eql-bindings/bindings/v3/TimestampEqQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TimestampEqQuery.ts
@@ -4,7 +4,7 @@ import type { Identifier } from "./Identifier";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.timestamp_eq_query` — equality domain query operand.
+ * `eql_v3.query_timestamp_eq` — equality domain query operand.
  *
  * Operators: `=` `<>`. Required keys: `v` `i` `hm`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TimestampOrdOpeQuery.ts b/crates/eql-bindings/bindings/v3/TimestampOrdOpeQuery.ts
index 3aa566c09..d35251ae3 100644
--- a/crates/eql-bindings/bindings/v3/TimestampOrdOpeQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TimestampOrdOpeQuery.ts
@@ -4,7 +4,7 @@ import type { OpeCllw } from "./OpeCllw";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.timestamp_ord_ope_query` — ordering domain query operand.
+ * `eql_v3.query_timestamp_ord_ope` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TimestampOrdOreQuery.ts b/crates/eql-bindings/bindings/v3/TimestampOrdOreQuery.ts
index dde9a9651..c5979fdbc 100644
--- a/crates/eql-bindings/bindings/v3/TimestampOrdOreQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TimestampOrdOreQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.timestamp_ord_ore_query` — ordering domain query operand.
+ * `eql_v3.query_timestamp_ord_ore` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/bindings/v3/TimestampOrdQuery.ts b/crates/eql-bindings/bindings/v3/TimestampOrdQuery.ts
index 40a87a216..65c9ab5d5 100644
--- a/crates/eql-bindings/bindings/v3/TimestampOrdQuery.ts
+++ b/crates/eql-bindings/bindings/v3/TimestampOrdQuery.ts
@@ -4,7 +4,7 @@ import type { OreBlock256 } from "./OreBlock256";
 import type { SchemaVersion } from "./SchemaVersion";
 
 /**
- * `public.timestamp_ord_query` — ordering domain query operand.
+ * `eql_v3.query_timestamp_ord` — ordering domain query operand.
  *
  * Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
  */
diff --git a/crates/eql-bindings/schema/v3/bigint_eq_query.json b/crates/eql-bindings/schema/v3/query_bigint_eq.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/bigint_eq_query.json
rename to crates/eql-bindings/schema/v3/query_bigint_eq.json
index 9288fdc32..1836bf657 100644
--- a/crates/eql-bindings/schema/v3/bigint_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_bigint_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/bigint_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_bigint_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.bigint_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_bigint_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/bigint_ord_query.json b/crates/eql-bindings/schema/v3/query_bigint_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/bigint_ord_query.json
rename to crates/eql-bindings/schema/v3/query_bigint_ord.json
index 98c4bd655..027c55b16 100644
--- a/crates/eql-bindings/schema/v3/bigint_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_bigint_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/bigint_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_bigint_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.bigint_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_bigint_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/bigint_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_bigint_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/bigint_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_bigint_ord_ope.json
index 38dc59f27..e1f7de0ed 100644
--- a/crates/eql-bindings/schema/v3/bigint_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_bigint_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/bigint_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_bigint_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.bigint_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_bigint_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/bigint_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_bigint_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/bigint_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_bigint_ord_ore.json
index 74b2a1927..eed10008b 100644
--- a/crates/eql-bindings/schema/v3/bigint_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_bigint_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/bigint_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_bigint_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.bigint_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_bigint_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/date_eq_query.json b/crates/eql-bindings/schema/v3/query_date_eq.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/date_eq_query.json
rename to crates/eql-bindings/schema/v3/query_date_eq.json
index ab1ca29f8..984858364 100644
--- a/crates/eql-bindings/schema/v3/date_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_date_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/date_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_date_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.date_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_date_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/date_ord_query.json b/crates/eql-bindings/schema/v3/query_date_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/date_ord_query.json
rename to crates/eql-bindings/schema/v3/query_date_ord.json
index d38dd1e3c..a958a401c 100644
--- a/crates/eql-bindings/schema/v3/date_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_date_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/date_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_date_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.date_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_date_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/date_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_date_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/date_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_date_ord_ope.json
index 59906195c..92e8e960f 100644
--- a/crates/eql-bindings/schema/v3/date_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_date_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/date_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_date_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.date_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_date_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/date_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_date_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/date_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_date_ord_ore.json
index f7d0cc7fb..cc68f5d67 100644
--- a/crates/eql-bindings/schema/v3/date_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_date_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/date_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_date_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.date_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_date_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/double_eq_query.json b/crates/eql-bindings/schema/v3/query_double_eq.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/double_eq_query.json
rename to crates/eql-bindings/schema/v3/query_double_eq.json
index 85fee1c0c..7aee106cd 100644
--- a/crates/eql-bindings/schema/v3/double_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_double_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/double_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_double_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.double_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_double_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/double_ord_query.json b/crates/eql-bindings/schema/v3/query_double_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/double_ord_query.json
rename to crates/eql-bindings/schema/v3/query_double_ord.json
index c2d4d88e4..73f779672 100644
--- a/crates/eql-bindings/schema/v3/double_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_double_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/double_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_double_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.double_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_double_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/double_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_double_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/double_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_double_ord_ope.json
index d4fca8bff..2e47c813d 100644
--- a/crates/eql-bindings/schema/v3/double_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_double_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/double_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_double_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.double_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_double_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/double_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_double_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/double_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_double_ord_ore.json
index a02376bb4..8d62e570d 100644
--- a/crates/eql-bindings/schema/v3/double_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_double_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/double_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_double_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.double_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_double_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/integer_eq_query.json b/crates/eql-bindings/schema/v3/query_integer_eq.json
similarity index 90%
rename from crates/eql-bindings/schema/v3/integer_eq_query.json
rename to crates/eql-bindings/schema/v3/query_integer_eq.json
index 9083fdcc5..d83ab492d 100644
--- a/crates/eql-bindings/schema/v3/integer_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_integer_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/integer_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_integer_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.integer_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_integer_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/integer_ord_query.json b/crates/eql-bindings/schema/v3/query_integer_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/integer_ord_query.json
rename to crates/eql-bindings/schema/v3/query_integer_ord.json
index f42a34899..01861ace6 100644
--- a/crates/eql-bindings/schema/v3/integer_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_integer_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/integer_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_integer_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.integer_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_integer_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/integer_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_integer_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/integer_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_integer_ord_ope.json
index 8e72ca611..07df17da1 100644
--- a/crates/eql-bindings/schema/v3/integer_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_integer_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/integer_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_integer_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.integer_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_integer_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/integer_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_integer_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/integer_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_integer_ord_ore.json
index 0f7e43152..039a9076e 100644
--- a/crates/eql-bindings/schema/v3/integer_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_integer_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/integer_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_integer_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.integer_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_integer_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/jsonb_query.json b/crates/eql-bindings/schema/v3/query_jsonb.json
similarity index 94%
rename from crates/eql-bindings/schema/v3/jsonb_query.json
rename to crates/eql-bindings/schema/v3/query_jsonb.json
index d33e4fe83..f08f6b7bf 100644
--- a/crates/eql-bindings/schema/v3/jsonb_query.json
+++ b/crates/eql-bindings/schema/v3/query_jsonb.json
@@ -49,10 +49,10 @@
       "type": "object"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/jsonb_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_jsonb.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.jsonb_query` — a containment needle (`{sv:[query-entry]}`). Strict.",
+  "description": "`eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict.",
   "properties": {
     "sv": {
       "items": {
diff --git a/crates/eql-bindings/schema/v3/numeric_eq_query.json b/crates/eql-bindings/schema/v3/query_numeric_eq.json
similarity index 90%
rename from crates/eql-bindings/schema/v3/numeric_eq_query.json
rename to crates/eql-bindings/schema/v3/query_numeric_eq.json
index 535d7425d..199d48472 100644
--- a/crates/eql-bindings/schema/v3/numeric_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_numeric_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/numeric_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_numeric_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.numeric_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_numeric_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/numeric_ord_query.json b/crates/eql-bindings/schema/v3/query_numeric_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/numeric_ord_query.json
rename to crates/eql-bindings/schema/v3/query_numeric_ord.json
index 71ae7d757..3e826a01d 100644
--- a/crates/eql-bindings/schema/v3/numeric_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_numeric_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/numeric_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_numeric_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.numeric_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_numeric_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/numeric_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_numeric_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/numeric_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_numeric_ord_ope.json
index 15525ad8c..93edbc906 100644
--- a/crates/eql-bindings/schema/v3/numeric_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_numeric_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/numeric_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_numeric_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.numeric_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_numeric_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/numeric_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_numeric_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/numeric_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_numeric_ord_ore.json
index 3b8f12209..9ee42bbbd 100644
--- a/crates/eql-bindings/schema/v3/numeric_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_numeric_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/numeric_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_numeric_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.numeric_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_numeric_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/real_eq_query.json b/crates/eql-bindings/schema/v3/query_real_eq.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/real_eq_query.json
rename to crates/eql-bindings/schema/v3/query_real_eq.json
index 3f5176f4f..50a2e5b03 100644
--- a/crates/eql-bindings/schema/v3/real_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_real_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/real_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_real_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.real_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_real_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/real_ord_query.json b/crates/eql-bindings/schema/v3/query_real_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/real_ord_query.json
rename to crates/eql-bindings/schema/v3/query_real_ord.json
index ec12f83d6..5e1aa53ac 100644
--- a/crates/eql-bindings/schema/v3/real_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_real_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/real_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_real_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.real_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_real_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/real_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_real_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/real_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_real_ord_ope.json
index 429604ae8..38a5a337a 100644
--- a/crates/eql-bindings/schema/v3/real_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_real_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/real_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_real_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.real_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_real_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/real_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_real_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/real_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_real_ord_ore.json
index eb1b73816..7f062dda9 100644
--- a/crates/eql-bindings/schema/v3/real_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_real_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/real_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_real_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.real_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_real_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/smallint_eq_query.json b/crates/eql-bindings/schema/v3/query_smallint_eq.json
similarity index 90%
rename from crates/eql-bindings/schema/v3/smallint_eq_query.json
rename to crates/eql-bindings/schema/v3/query_smallint_eq.json
index d05d8d080..77fe5e24c 100644
--- a/crates/eql-bindings/schema/v3/smallint_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_smallint_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/smallint_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_smallint_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.smallint_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_smallint_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/smallint_ord_query.json b/crates/eql-bindings/schema/v3/query_smallint_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/smallint_ord_query.json
rename to crates/eql-bindings/schema/v3/query_smallint_ord.json
index 475e08bd7..2302c2c55 100644
--- a/crates/eql-bindings/schema/v3/smallint_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_smallint_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/smallint_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_smallint_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.smallint_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_smallint_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/smallint_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_smallint_ord_ope.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/smallint_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_smallint_ord_ope.json
index 9778bfff2..aaef17d03 100644
--- a/crates/eql-bindings/schema/v3/smallint_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_smallint_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/smallint_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_smallint_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.smallint_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_smallint_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/smallint_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_smallint_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/smallint_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_smallint_ord_ore.json
index c29e09753..b3e2cd7aa 100644
--- a/crates/eql-bindings/schema/v3/smallint_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_smallint_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/smallint_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_smallint_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.smallint_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_smallint_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/text_eq_query.json b/crates/eql-bindings/schema/v3/query_text_eq.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/text_eq_query.json
rename to crates/eql-bindings/schema/v3/query_text_eq.json
index 833281305..b0ec58ca3 100644
--- a/crates/eql-bindings/schema/v3/text_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_text_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/text_match_query.json b/crates/eql-bindings/schema/v3/query_text_match.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/text_match_query.json
rename to crates/eql-bindings/schema/v3/query_text_match.json
index 476bd52da..d7a781677 100644
--- a/crates/eql-bindings/schema/v3/text_match_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_match.json
@@ -35,10 +35,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_match_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_match.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_match_query` — match domain query operand.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `bf`.",
+  "description": "`eql_v3.query_text_match` — match domain query operand.\n\nOperators: `@>` `<@`. Required keys: `v` `i` `bf`.",
   "properties": {
     "bf": {
       "$ref": "#/$defs/BloomFilter"
diff --git a/crates/eql-bindings/schema/v3/text_ord_query.json b/crates/eql-bindings/schema/v3/query_text_ord.json
similarity index 93%
rename from crates/eql-bindings/schema/v3/text_ord_query.json
rename to crates/eql-bindings/schema/v3/query_text_ord.json
index 79fd6c436..6e8412be3 100644
--- a/crates/eql-bindings/schema/v3/text_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_ord.json
@@ -36,10 +36,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.",
+  "description": "`eql_v3.query_text_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/text_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_text_ord_ope.json
similarity index 93%
rename from crates/eql-bindings/schema/v3/text_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_text_ord_ope.json
index d3758fea8..21a2d4621 100644
--- a/crates/eql-bindings/schema/v3/text_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_ord_ope.json
@@ -33,10 +33,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `op`.",
+  "description": "`eql_v3.query_text_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `op`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/text_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_text_ord_ore.json
similarity index 93%
rename from crates/eql-bindings/schema/v3/text_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_text_ord_ore.json
index cdd266373..850d4623c 100644
--- a/crates/eql-bindings/schema/v3/text_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_ord_ore.json
@@ -36,10 +36,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.",
+  "description": "`eql_v3.query_text_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/text_search_query.json b/crates/eql-bindings/schema/v3/query_text_search.json
similarity index 94%
rename from crates/eql-bindings/schema/v3/text_search_query.json
rename to crates/eql-bindings/schema/v3/query_text_search.json
index b19db9d53..909eafc67 100644
--- a/crates/eql-bindings/schema/v3/text_search_query.json
+++ b/crates/eql-bindings/schema/v3/query_text_search.json
@@ -46,10 +46,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/text_search_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_text_search.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.text_search_query` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.",
+  "description": "`eql_v3.query_text_search` — search domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.",
   "properties": {
     "bf": {
       "$ref": "#/$defs/BloomFilter"
diff --git a/crates/eql-bindings/schema/v3/timestamp_eq_query.json b/crates/eql-bindings/schema/v3/query_timestamp_eq.json
similarity index 90%
rename from crates/eql-bindings/schema/v3/timestamp_eq_query.json
rename to crates/eql-bindings/schema/v3/query_timestamp_eq.json
index a49427932..f3e7ca3e0 100644
--- a/crates/eql-bindings/schema/v3/timestamp_eq_query.json
+++ b/crates/eql-bindings/schema/v3/query_timestamp_eq.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/timestamp_eq_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_timestamp_eq.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.timestamp_eq_query` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
+  "description": "`eql_v3.query_timestamp_eq` — equality domain query operand.\n\nOperators: `=` `<>`. Required keys: `v` `i` `hm`.",
   "properties": {
     "hm": {
       "$ref": "#/$defs/Hmac256"
diff --git a/crates/eql-bindings/schema/v3/timestamp_ord_query.json b/crates/eql-bindings/schema/v3/query_timestamp_ord.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/timestamp_ord_query.json
rename to crates/eql-bindings/schema/v3/query_timestamp_ord.json
index 2dfdc5279..5a6af8ac4 100644
--- a/crates/eql-bindings/schema/v3/timestamp_ord_query.json
+++ b/crates/eql-bindings/schema/v3/query_timestamp_ord.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/timestamp_ord_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_timestamp_ord.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.timestamp_ord_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_timestamp_ord` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/timestamp_ord_ope_query.json b/crates/eql-bindings/schema/v3/query_timestamp_ord_ope.json
similarity index 91%
rename from crates/eql-bindings/schema/v3/timestamp_ord_ope_query.json
rename to crates/eql-bindings/schema/v3/query_timestamp_ord_ope.json
index 02ef7beb5..dc2bf8aae 100644
--- a/crates/eql-bindings/schema/v3/timestamp_ord_ope_query.json
+++ b/crates/eql-bindings/schema/v3/query_timestamp_ord_ope.json
@@ -29,10 +29,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/timestamp_ord_ope_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_timestamp_ord_ope.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.timestamp_ord_ope_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
+  "description": "`eql_v3.query_timestamp_ord_ope` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/schema/v3/timestamp_ord_ore_query.json b/crates/eql-bindings/schema/v3/query_timestamp_ord_ore.json
similarity index 92%
rename from crates/eql-bindings/schema/v3/timestamp_ord_ore_query.json
rename to crates/eql-bindings/schema/v3/query_timestamp_ord_ore.json
index 6f9700b32..4322bd7fc 100644
--- a/crates/eql-bindings/schema/v3/timestamp_ord_ore_query.json
+++ b/crates/eql-bindings/schema/v3/query_timestamp_ord_ore.json
@@ -32,10 +32,10 @@
       "type": "integer"
     }
   },
-  "$id": "https://schemas.cipherstash.com/eql/v3/timestamp_ord_ore_query.json",
+  "$id": "https://schemas.cipherstash.com/eql/v3/query_timestamp_ord_ore.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "additionalProperties": false,
-  "description": "`public.timestamp_ord_ore_query` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
+  "description": "`eql_v3.query_timestamp_ord_ore` — ordering domain query operand.\n\nOperators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.",
   "properties": {
     "i": {
       "$ref": "#/$defs/Identifier"
diff --git a/crates/eql-bindings/src/from_v2/error.rs b/crates/eql-bindings/src/from_v2/error.rs
index 0b976deae..e9013d68d 100644
--- a/crates/eql-bindings/src/from_v2/error.rs
+++ b/crates/eql-bindings/src/from_v2/error.rs
@@ -24,7 +24,7 @@ pub enum FromV2Error {
     },
     /// [`TargetDomain::parse`](super::TargetDomain::parse) did not find the
     /// name in the catalog-generated inventory (or it names a SteVec shape —
-    /// `jsonb_entry` / `jsonb_query` — that is not a conversion target).
+    /// `jsonb_entry` / `query_jsonb` — that is not a conversion target).
     UnknownDomain {
         /// The name that failed to resolve.
         name: String,
@@ -35,7 +35,7 @@ pub enum FromV2Error {
     /// is [`FromV2Error::AmbiguousTerm`]) with `entry` locating the offender.
     MissingTerm {
         /// The (unqualified) target domain name, e.g. `text_eq`, or the
-        /// SteVec shape (`json` / `jsonb_query`) for per-entry terms.
+        /// SteVec shape (`json` / `query_jsonb`) for per-entry terms.
         domain: String,
         /// The missing wire key (`hm`/`ob`/`bf`/`op`, or `hm|oc` for entries).
         key: String,
diff --git a/crates/eql-bindings/src/from_v2/mod.rs b/crates/eql-bindings/src/from_v2/mod.rs
index 9f099d8c6..977c1e732 100644
--- a/crates/eql-bindings/src/from_v2/mod.rs
+++ b/crates/eql-bindings/src/from_v2/mod.rs
@@ -66,7 +66,7 @@
 //! `eql_v3.to_ste_vec_query` does (stray `a` markers and `c` ciphertexts are
 //! stripped). A term-bearing scalar target hoists the target's required terms
 //! into the enveloped term-only operand `{v: 3, i, <terms>}` for its
-//! `<name>_query` domain — the query counterpart of the stored conversion,
+//! `query_<name>` domain — the query counterpart of the stored conversion,
 //! dropping `c`/`k` (CIP-3432). A STORAGE-ONLY scalar target (no terms, no
 //! operators) has no query operand and returns
 //! [`FromV2Error::UnsupportedQueryTarget`].
@@ -173,7 +173,7 @@ fn convert(v2: &Value, target: TargetDomain) -> Result<Value, FromV2Error> {
 ///
 /// A term-bearing [`TargetDomain::Scalar`]: the target's required terms are
 /// hoisted into the enveloped term-only operand `{v: 3, i, <terms>}` for its
-/// `<name>_query` domain, dropping `c`/`k` (`bf` reinterpreted to signed
+/// `query_<name>` domain, dropping `c`/`k` (`bf` reinterpreted to signed
 /// `smallint[]`). A storage-only scalar target has no operators and returns
 /// [`FromV2Error::UnsupportedQueryTarget`].
 ///
@@ -183,7 +183,7 @@ fn convert(v2: &Value, target: TargetDomain) -> Result<Value, FromV2Error> {
 pub fn from_v2_query(v2: &Value, target: TargetDomain) -> Result<Value, FromV2Error> {
     let out = convert_query(v2, target)?;
     // Validate through the generated QueryPayload strict parser (the query-side
-    // counterpart of validate_as), keyed on the target's `<name>_query` domain.
+    // counterpart of validate_as), keyed on the target's `query_<name>` domain.
     parse_query(&query_domain_name(target), &out)?;
     Ok(out)
 }
@@ -202,7 +202,7 @@ pub fn from_v2_query(v2: &Value, target: TargetDomain) -> Result<Value, FromV2Er
 ///
 /// Storage-only scalar targets fail with
 /// [`FromV2Error::UnsupportedQueryTarget`] exactly like [`from_v2_query`];
-/// term-bearing scalars yield the matching `<name>_query` [`QueryPayload`]
+/// term-bearing scalars yield the matching `query_<name>` [`QueryPayload`]
 /// variant.
 pub fn from_v2_query_typed(v2: &Value, target: TargetDomain) -> Result<QueryPayload, FromV2Error> {
     let out = convert_query(v2, target)?;
@@ -210,12 +210,13 @@ pub fn from_v2_query_typed(v2: &Value, target: TargetDomain) -> Result<QueryPayl
 }
 
 /// The unqualified query-operand domain a target converts into: the scalar
-/// twin `<name>_query`, or `jsonb_query` for the SteVec needle. (Replaces the
-/// old single `QUERY_DOMAIN` constant now that scalar query shapes exist.)
+/// twin `query_<name>`, or `query_jsonb` for the hand-written SteVec needle —
+/// both on the query-operand PREFIX convention (CIP-3442). (Replaces the old
+/// single `QUERY_DOMAIN` constant now that scalar query shapes exist.)
 fn query_domain_name(target: TargetDomain) -> String {
     match target {
-        TargetDomain::Json => "jsonb_query".to_string(),
-        TargetDomain::Scalar(t) => format!("{}_query", t.domain()),
+        TargetDomain::Json => "query_jsonb".to_string(),
+        TargetDomain::Scalar(t) => format!("query_{}", t.domain()),
     }
 }
 
@@ -243,7 +244,7 @@ fn convert_query(v2: &Value, target: TargetDomain) -> Result<Value, FromV2Error>
 }
 
 /// v2 scalar query payload → v3 enveloped term-only operand `{v: 3, i,
-/// <terms>}` for `target`'s `<name>_query` domain. Hoists exactly the target's
+/// <terms>}` for `target`'s `query_<name>` domain. Hoists exactly the target's
 /// required terms out of the v2 payload (a query operand may omit the v2
 /// envelope), dropping `c`/`k` — the query counterpart of [`convert_scalar`]
 /// (which keeps `c`). A STORAGE-ONLY target (no terms, no operators) has no
@@ -335,7 +336,7 @@ fn validate_as(domain: &str, value: &Value) -> Result<(), FromV2Error> {
         .find(|d| d.domain() == domain)
         .unwrap_or_else(|| {
             // `domain` always came from the same inventory via
-            // `TargetDomain::parse` (or is the literal "json"/"jsonb_query").
+            // `TargetDomain::parse` (or is the literal "json"/"query_jsonb").
             unreachable!("domain {domain} resolved by parse must be in the inventory")
         });
     entry.parse_value(value).map_err(FromV2Error::Invalid)
@@ -483,7 +484,7 @@ impl EntryShape {
     fn domain(self) -> &'static str {
         match self {
             Self::Document => "json",
-            Self::Query => "jsonb_query",
+            Self::Query => "query_jsonb",
         }
     }
 }
diff --git a/crates/eql-bindings/src/from_v2/target.rs b/crates/eql-bindings/src/from_v2/target.rs
index 2e08d181d..e77e1de23 100644
--- a/crates/eql-bindings/src/from_v2/target.rs
+++ b/crates/eql-bindings/src/from_v2/target.rs
@@ -50,7 +50,7 @@ impl TargetDomain {
     /// Shape-aware: scalar domains resolve to [`TargetDomain::Scalar`] with
     /// their catalog term keys; the SteVec document domain `json` resolves to
     /// [`TargetDomain::Json`]; the remaining SteVec shapes (`jsonb_entry`,
-    /// `jsonb_query`) are inventory members but not conversion targets, so
+    /// `query_jsonb`) are inventory members but not conversion targets, so
     /// they — like any unknown name — return
     /// [`FromV2Error::UnknownDomain`].
     pub fn parse(name: &str) -> Result<Self, FromV2Error> {
diff --git a/crates/eql-bindings/src/v3/bigint.rs b/crates/eql-bindings/src/v3/bigint.rs
index 9951b2186..dff8c373c 100644
--- a/crates/eql-bindings/src/v3/bigint.rs
+++ b/crates/eql-bindings/src/v3/bigint.rs
@@ -165,7 +165,7 @@ impl DomainType for BigintOrdOpe {
         schema_for!(BigintOrdOpe)
     }
 }
-/// `public.bigint_eq_query` — equality domain query operand.
+/// `eql_v3.query_bigint_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct BigintEqQuery {
 }
 impl DomainType for BigintEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.bigint_eq_query"
+        "eql_v3.query_bigint_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for BigintEqQuery {
         schema_for!(BigintEqQuery)
     }
 }
-/// `public.bigint_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_bigint_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct BigintOrdOreQuery {
 }
 impl DomainType for BigintOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.bigint_ord_ore_query"
+        "eql_v3.query_bigint_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for BigintOrdOreQuery {
         schema_for!(BigintOrdOreQuery)
     }
 }
-/// `public.bigint_ord_query` — ordering domain query operand.
+/// `eql_v3.query_bigint_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct BigintOrdQuery {
 }
 impl DomainType for BigintOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.bigint_ord_query"
+        "eql_v3.query_bigint_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for BigintOrdQuery {
         schema_for!(BigintOrdQuery)
     }
 }
-/// `public.bigint_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_bigint_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct BigintOrdOpeQuery {
 }
 impl DomainType for BigintOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.bigint_ord_ope_query"
+        "eql_v3.query_bigint_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/date.rs b/crates/eql-bindings/src/v3/date.rs
index 198c7de22..2e4b8b7b8 100644
--- a/crates/eql-bindings/src/v3/date.rs
+++ b/crates/eql-bindings/src/v3/date.rs
@@ -165,7 +165,7 @@ impl DomainType for DateOrdOpe {
         schema_for!(DateOrdOpe)
     }
 }
-/// `public.date_eq_query` — equality domain query operand.
+/// `eql_v3.query_date_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct DateEqQuery {
 }
 impl DomainType for DateEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.date_eq_query"
+        "eql_v3.query_date_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for DateEqQuery {
         schema_for!(DateEqQuery)
     }
 }
-/// `public.date_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_date_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct DateOrdOreQuery {
 }
 impl DomainType for DateOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.date_ord_ore_query"
+        "eql_v3.query_date_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for DateOrdOreQuery {
         schema_for!(DateOrdOreQuery)
     }
 }
-/// `public.date_ord_query` — ordering domain query operand.
+/// `eql_v3.query_date_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct DateOrdQuery {
 }
 impl DomainType for DateOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.date_ord_query"
+        "eql_v3.query_date_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for DateOrdQuery {
         schema_for!(DateOrdQuery)
     }
 }
-/// `public.date_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_date_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct DateOrdOpeQuery {
 }
 impl DomainType for DateOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.date_ord_ope_query"
+        "eql_v3.query_date_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/domain_type.rs b/crates/eql-bindings/src/v3/domain_type.rs
index 351329bb8..c2cf64fa3 100644
--- a/crates/eql-bindings/src/v3/domain_type.rs
+++ b/crates/eql-bindings/src/v3/domain_type.rs
@@ -9,7 +9,10 @@ use std::marker::PhantomData;
 use schemars::{schema_for, JsonSchema, Schema};
 use serde::Deserialize;
 
-/// The PostgreSQL schema every user-column domain in this module inhabits.
+/// The PostgreSQL schema every user-COLUMN domain in this module inhabits.
+/// The `query_<name>` operand twins are NOT column types and live in `eql_v3`
+/// instead (CIP-3442) — dropping the EQL-owned schema can never drop an
+/// application column, and a query operand is never an application column.
 pub const SQL_SCHEMA: &str = "public";
 
 /// Base URL for the canonical `$id` of every published v3 JSON Schema.
@@ -41,12 +44,14 @@ pub trait DomainType {
     fn sql_domain(&self) -> &'static str;
 
     /// Unqualified SQL domain name (e.g. `"integer_eq"`) — [`Self::sql_domain`]
-    /// minus the schema qualifier; matches `eql-domains`
+    /// minus the schema qualifier (`public.` for column domains, `eql_v3.` for
+    /// the query-operand twins); matches `eql-domains`
     /// `DomainFamily::domain_name`.
     fn domain(&self) -> &'static str {
         self.sql_domain()
-            .strip_prefix("public.")
-            .expect("sql_domain must be qualified with the public schema")
+            .split_once('.')
+            .expect("sql_domain must be schema-qualified")
+            .1
     }
 
     /// Canonical `$id` for this domain's published JSON Schema —
diff --git a/crates/eql-bindings/src/v3/double.rs b/crates/eql-bindings/src/v3/double.rs
index 93f050df8..b3a92522a 100644
--- a/crates/eql-bindings/src/v3/double.rs
+++ b/crates/eql-bindings/src/v3/double.rs
@@ -165,7 +165,7 @@ impl DomainType for DoubleOrdOpe {
         schema_for!(DoubleOrdOpe)
     }
 }
-/// `public.double_eq_query` — equality domain query operand.
+/// `eql_v3.query_double_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct DoubleEqQuery {
 }
 impl DomainType for DoubleEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.double_eq_query"
+        "eql_v3.query_double_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for DoubleEqQuery {
         schema_for!(DoubleEqQuery)
     }
 }
-/// `public.double_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_double_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct DoubleOrdOreQuery {
 }
 impl DomainType for DoubleOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.double_ord_ore_query"
+        "eql_v3.query_double_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for DoubleOrdOreQuery {
         schema_for!(DoubleOrdOreQuery)
     }
 }
-/// `public.double_ord_query` — ordering domain query operand.
+/// `eql_v3.query_double_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct DoubleOrdQuery {
 }
 impl DomainType for DoubleOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.double_ord_query"
+        "eql_v3.query_double_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for DoubleOrdQuery {
         schema_for!(DoubleOrdQuery)
     }
 }
-/// `public.double_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_double_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct DoubleOrdOpeQuery {
 }
 impl DomainType for DoubleOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.double_ord_ope_query"
+        "eql_v3.query_double_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/integer.rs b/crates/eql-bindings/src/v3/integer.rs
index 631b57da6..cd16e1484 100644
--- a/crates/eql-bindings/src/v3/integer.rs
+++ b/crates/eql-bindings/src/v3/integer.rs
@@ -165,7 +165,7 @@ impl DomainType for IntegerOrdOpe {
         schema_for!(IntegerOrdOpe)
     }
 }
-/// `public.integer_eq_query` — equality domain query operand.
+/// `eql_v3.query_integer_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct IntegerEqQuery {
 }
 impl DomainType for IntegerEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.integer_eq_query"
+        "eql_v3.query_integer_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for IntegerEqQuery {
         schema_for!(IntegerEqQuery)
     }
 }
-/// `public.integer_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_integer_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct IntegerOrdOreQuery {
 }
 impl DomainType for IntegerOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.integer_ord_ore_query"
+        "eql_v3.query_integer_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for IntegerOrdOreQuery {
         schema_for!(IntegerOrdOreQuery)
     }
 }
-/// `public.integer_ord_query` — ordering domain query operand.
+/// `eql_v3.query_integer_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct IntegerOrdQuery {
 }
 impl DomainType for IntegerOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.integer_ord_query"
+        "eql_v3.query_integer_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for IntegerOrdQuery {
         schema_for!(IntegerOrdQuery)
     }
 }
-/// `public.integer_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_integer_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct IntegerOrdOpeQuery {
 }
 impl DomainType for IntegerOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.integer_ord_ope_query"
+        "eql_v3.query_integer_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/inventory.rs b/crates/eql-bindings/src/v3/inventory.rs
index 1a08dba09..f35a3c889 100644
--- a/crates/eql-bindings/src/v3/inventory.rs
+++ b/crates/eql-bindings/src/v3/inventory.rs
@@ -61,7 +61,7 @@ pub fn all() -> Vec<Box<dyn DomainType>> {
         Box::new(PhantomData::<super::jsonb::SteVecQuery>),
     ]
 }
-/// Every v3 QUERY-operand twin (`public.<name>_query`, the enveloped
+/// Every v3 QUERY-operand twin (`eql_v3.query_<name>`, the enveloped
 /// term-only operand), in `eql-domains::CATALOG` order — generated.
 /// Separate from [`all`] so query domains never resolve as stored
 /// conversion targets; used by the JSON Schema export and query
diff --git a/crates/eql-bindings/src/v3/jsonb.rs b/crates/eql-bindings/src/v3/jsonb.rs
index 7f22c4cab..2f44f841d 100644
--- a/crates/eql-bindings/src/v3/jsonb.rs
+++ b/crates/eql-bindings/src/v3/jsonb.rs
@@ -105,7 +105,7 @@ pub struct SteVecEntry {
     pub term: SteVecTerm,
 }
 
-/// `public.jsonb_query` — a containment needle (`{sv:[query-entry]}`). Strict.
+/// `eql_v3.query_jsonb` — a containment needle (`{sv:[query-entry]}`). Strict.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
 #[ts(export, export_to = "v3/")]
 #[serde(deny_unknown_fields)]
@@ -157,4 +157,4 @@ macro_rules! ste_vec_domain_type {
 
 ste_vec_domain_type!(SteVecDocument, "public.json");
 ste_vec_domain_type!(SteVecEntry, "public.jsonb_entry");
-ste_vec_domain_type!(SteVecQuery, "public.jsonb_query");
+ste_vec_domain_type!(SteVecQuery, "eql_v3.query_jsonb");
diff --git a/crates/eql-bindings/src/v3/numeric.rs b/crates/eql-bindings/src/v3/numeric.rs
index 044a9c8ef..790ef8cac 100644
--- a/crates/eql-bindings/src/v3/numeric.rs
+++ b/crates/eql-bindings/src/v3/numeric.rs
@@ -165,7 +165,7 @@ impl DomainType for NumericOrdOpe {
         schema_for!(NumericOrdOpe)
     }
 }
-/// `public.numeric_eq_query` — equality domain query operand.
+/// `eql_v3.query_numeric_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct NumericEqQuery {
 }
 impl DomainType for NumericEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.numeric_eq_query"
+        "eql_v3.query_numeric_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for NumericEqQuery {
         schema_for!(NumericEqQuery)
     }
 }
-/// `public.numeric_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_numeric_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct NumericOrdOreQuery {
 }
 impl DomainType for NumericOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.numeric_ord_ore_query"
+        "eql_v3.query_numeric_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for NumericOrdOreQuery {
         schema_for!(NumericOrdOreQuery)
     }
 }
-/// `public.numeric_ord_query` — ordering domain query operand.
+/// `eql_v3.query_numeric_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct NumericOrdQuery {
 }
 impl DomainType for NumericOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.numeric_ord_query"
+        "eql_v3.query_numeric_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for NumericOrdQuery {
         schema_for!(NumericOrdQuery)
     }
 }
-/// `public.numeric_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_numeric_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct NumericOrdOpeQuery {
 }
 impl DomainType for NumericOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.numeric_ord_ope_query"
+        "eql_v3.query_numeric_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/query_payload.rs b/crates/eql-bindings/src/v3/query_payload.rs
index f66f8e29e..1c4a003cf 100644
--- a/crates/eql-bindings/src/v3/query_payload.rs
+++ b/crates/eql-bindings/src/v3/query_payload.rs
@@ -3,9 +3,9 @@
 use super::domain_type::DomainType;
 use serde::{Deserialize, Serialize};
 /// Every v3 QUERY-operand shape in one type: one variant per term-bearing
-/// scalar query twin (`public.<name>_query`, the enveloped term-only
+/// scalar query twin (`eql_v3.query_<name>`, the enveloped term-only
 /// operand — `{v, i, <terms>}`, no `c`) plus the SteVec containment
-/// needle (`public.jsonb_query`). Generated from the catalog, so it
+/// needle (`eql_v3.query_jsonb`). Generated from the catalog, so it
 /// cannot drift when the catalog grows.
 ///
 /// Serialization is exactly the inner struct's (`#[serde(untagged)]`
@@ -17,90 +17,90 @@ use serde::{Deserialize, Serialize};
 #[derive(Clone, Debug, PartialEq, Serialize)]
 #[serde(untagged)]
 pub enum QueryPayload {
-    /// The `public.integer_eq_query` query operand.
+    /// The `eql_v3.query_integer_eq` query operand.
     IntegerEqQuery(super::integer::IntegerEqQuery),
-    /// The `public.integer_ord_ore_query` query operand.
+    /// The `eql_v3.query_integer_ord_ore` query operand.
     IntegerOrdOreQuery(super::integer::IntegerOrdOreQuery),
-    /// The `public.integer_ord_query` query operand.
+    /// The `eql_v3.query_integer_ord` query operand.
     IntegerOrdQuery(super::integer::IntegerOrdQuery),
-    /// The `public.integer_ord_ope_query` query operand.
+    /// The `eql_v3.query_integer_ord_ope` query operand.
     IntegerOrdOpeQuery(super::integer::IntegerOrdOpeQuery),
-    /// The `public.smallint_eq_query` query operand.
+    /// The `eql_v3.query_smallint_eq` query operand.
     SmallintEqQuery(super::smallint::SmallintEqQuery),
-    /// The `public.smallint_ord_ore_query` query operand.
+    /// The `eql_v3.query_smallint_ord_ore` query operand.
     SmallintOrdOreQuery(super::smallint::SmallintOrdOreQuery),
-    /// The `public.smallint_ord_query` query operand.
+    /// The `eql_v3.query_smallint_ord` query operand.
     SmallintOrdQuery(super::smallint::SmallintOrdQuery),
-    /// The `public.smallint_ord_ope_query` query operand.
+    /// The `eql_v3.query_smallint_ord_ope` query operand.
     SmallintOrdOpeQuery(super::smallint::SmallintOrdOpeQuery),
-    /// The `public.bigint_eq_query` query operand.
+    /// The `eql_v3.query_bigint_eq` query operand.
     BigintEqQuery(super::bigint::BigintEqQuery),
-    /// The `public.bigint_ord_ore_query` query operand.
+    /// The `eql_v3.query_bigint_ord_ore` query operand.
     BigintOrdOreQuery(super::bigint::BigintOrdOreQuery),
-    /// The `public.bigint_ord_query` query operand.
+    /// The `eql_v3.query_bigint_ord` query operand.
     BigintOrdQuery(super::bigint::BigintOrdQuery),
-    /// The `public.bigint_ord_ope_query` query operand.
+    /// The `eql_v3.query_bigint_ord_ope` query operand.
     BigintOrdOpeQuery(super::bigint::BigintOrdOpeQuery),
-    /// The `public.date_eq_query` query operand.
+    /// The `eql_v3.query_date_eq` query operand.
     DateEqQuery(super::date::DateEqQuery),
-    /// The `public.date_ord_ore_query` query operand.
+    /// The `eql_v3.query_date_ord_ore` query operand.
     DateOrdOreQuery(super::date::DateOrdOreQuery),
-    /// The `public.date_ord_query` query operand.
+    /// The `eql_v3.query_date_ord` query operand.
     DateOrdQuery(super::date::DateOrdQuery),
-    /// The `public.date_ord_ope_query` query operand.
+    /// The `eql_v3.query_date_ord_ope` query operand.
     DateOrdOpeQuery(super::date::DateOrdOpeQuery),
-    /// The `public.timestamp_eq_query` query operand.
+    /// The `eql_v3.query_timestamp_eq` query operand.
     TimestampEqQuery(super::timestamp::TimestampEqQuery),
-    /// The `public.timestamp_ord_ore_query` query operand.
+    /// The `eql_v3.query_timestamp_ord_ore` query operand.
     TimestampOrdOreQuery(super::timestamp::TimestampOrdOreQuery),
-    /// The `public.timestamp_ord_query` query operand.
+    /// The `eql_v3.query_timestamp_ord` query operand.
     TimestampOrdQuery(super::timestamp::TimestampOrdQuery),
-    /// The `public.timestamp_ord_ope_query` query operand.
+    /// The `eql_v3.query_timestamp_ord_ope` query operand.
     TimestampOrdOpeQuery(super::timestamp::TimestampOrdOpeQuery),
-    /// The `public.numeric_eq_query` query operand.
+    /// The `eql_v3.query_numeric_eq` query operand.
     NumericEqQuery(super::numeric::NumericEqQuery),
-    /// The `public.numeric_ord_ore_query` query operand.
+    /// The `eql_v3.query_numeric_ord_ore` query operand.
     NumericOrdOreQuery(super::numeric::NumericOrdOreQuery),
-    /// The `public.numeric_ord_query` query operand.
+    /// The `eql_v3.query_numeric_ord` query operand.
     NumericOrdQuery(super::numeric::NumericOrdQuery),
-    /// The `public.numeric_ord_ope_query` query operand.
+    /// The `eql_v3.query_numeric_ord_ope` query operand.
     NumericOrdOpeQuery(super::numeric::NumericOrdOpeQuery),
-    /// The `public.text_eq_query` query operand.
+    /// The `eql_v3.query_text_eq` query operand.
     TextEqQuery(super::text::TextEqQuery),
-    /// The `public.text_match_query` query operand.
+    /// The `eql_v3.query_text_match` query operand.
     TextMatchQuery(super::text::TextMatchQuery),
-    /// The `public.text_ord_ore_query` query operand.
+    /// The `eql_v3.query_text_ord_ore` query operand.
     TextOrdOreQuery(super::text::TextOrdOreQuery),
-    /// The `public.text_ord_query` query operand.
+    /// The `eql_v3.query_text_ord` query operand.
     TextOrdQuery(super::text::TextOrdQuery),
-    /// The `public.text_ord_ope_query` query operand.
+    /// The `eql_v3.query_text_ord_ope` query operand.
     TextOrdOpeQuery(super::text::TextOrdOpeQuery),
-    /// The `public.text_search_query` query operand.
+    /// The `eql_v3.query_text_search` query operand.
     TextSearchQuery(super::text::TextSearchQuery),
-    /// The `public.real_eq_query` query operand.
+    /// The `eql_v3.query_real_eq` query operand.
     RealEqQuery(super::real::RealEqQuery),
-    /// The `public.real_ord_ore_query` query operand.
+    /// The `eql_v3.query_real_ord_ore` query operand.
     RealOrdOreQuery(super::real::RealOrdOreQuery),
-    /// The `public.real_ord_query` query operand.
+    /// The `eql_v3.query_real_ord` query operand.
     RealOrdQuery(super::real::RealOrdQuery),
-    /// The `public.real_ord_ope_query` query operand.
+    /// The `eql_v3.query_real_ord_ope` query operand.
     RealOrdOpeQuery(super::real::RealOrdOpeQuery),
-    /// The `public.double_eq_query` query operand.
+    /// The `eql_v3.query_double_eq` query operand.
     DoubleEqQuery(super::double::DoubleEqQuery),
-    /// The `public.double_ord_ore_query` query operand.
+    /// The `eql_v3.query_double_ord_ore` query operand.
     DoubleOrdOreQuery(super::double::DoubleOrdOreQuery),
-    /// The `public.double_ord_query` query operand.
+    /// The `eql_v3.query_double_ord` query operand.
     DoubleOrdQuery(super::double::DoubleOrdQuery),
-    /// The `public.double_ord_ope_query` query operand.
+    /// The `eql_v3.query_double_ord_ope` query operand.
     DoubleOrdOpeQuery(super::double::DoubleOrdOpeQuery),
-    /// The `public.jsonb_query` query operand.
+    /// The `eql_v3.query_jsonb` query operand.
     SteVec(super::jsonb::SteVecQuery),
 }
 impl QueryPayload {
     /// Strictly parse `value` as `domain`'s query payload, KEEPING the
     /// parsed value — the query-side counterpart of
     /// [`super::DomainPayload::parse`]. `domain` is the unqualified name
-    /// (`"integer_eq_query"`, `"jsonb_query"`, …). `None` when `domain`
+    /// (`"query_integer_eq"`, `"query_jsonb"`, …). `None` when `domain`
     /// is not a query-operand domain; `Some(Err)` when the strict parse
     /// fails (`deny_unknown_fields` rejects a stray `c`).
     pub fn parse(
@@ -108,130 +108,130 @@ impl QueryPayload {
         value: &serde_json::Value,
     ) -> Option<Result<Self, serde_json::Error>> {
         match domain {
-            "integer_eq_query" => {
+            "query_integer_eq" => {
                 Some(super::integer::IntegerEqQuery::deserialize(value).map(Self::IntegerEqQuery))
             }
-            "integer_ord_ore_query" => Some(
+            "query_integer_ord_ore" => Some(
                 super::integer::IntegerOrdOreQuery::deserialize(value)
                     .map(Self::IntegerOrdOreQuery),
             ),
-            "integer_ord_query" => {
+            "query_integer_ord" => {
                 Some(super::integer::IntegerOrdQuery::deserialize(value).map(Self::IntegerOrdQuery))
             }
-            "integer_ord_ope_query" => Some(
+            "query_integer_ord_ope" => Some(
                 super::integer::IntegerOrdOpeQuery::deserialize(value)
                     .map(Self::IntegerOrdOpeQuery),
             ),
-            "smallint_eq_query" => Some(
+            "query_smallint_eq" => Some(
                 super::smallint::SmallintEqQuery::deserialize(value).map(Self::SmallintEqQuery),
             ),
-            "smallint_ord_ore_query" => Some(
+            "query_smallint_ord_ore" => Some(
                 super::smallint::SmallintOrdOreQuery::deserialize(value)
                     .map(Self::SmallintOrdOreQuery),
             ),
-            "smallint_ord_query" => Some(
+            "query_smallint_ord" => Some(
                 super::smallint::SmallintOrdQuery::deserialize(value).map(Self::SmallintOrdQuery),
             ),
-            "smallint_ord_ope_query" => Some(
+            "query_smallint_ord_ope" => Some(
                 super::smallint::SmallintOrdOpeQuery::deserialize(value)
                     .map(Self::SmallintOrdOpeQuery),
             ),
-            "bigint_eq_query" => {
+            "query_bigint_eq" => {
                 Some(super::bigint::BigintEqQuery::deserialize(value).map(Self::BigintEqQuery))
             }
-            "bigint_ord_ore_query" => Some(
+            "query_bigint_ord_ore" => Some(
                 super::bigint::BigintOrdOreQuery::deserialize(value).map(Self::BigintOrdOreQuery),
             ),
-            "bigint_ord_query" => {
+            "query_bigint_ord" => {
                 Some(super::bigint::BigintOrdQuery::deserialize(value).map(Self::BigintOrdQuery))
             }
-            "bigint_ord_ope_query" => Some(
+            "query_bigint_ord_ope" => Some(
                 super::bigint::BigintOrdOpeQuery::deserialize(value).map(Self::BigintOrdOpeQuery),
             ),
-            "date_eq_query" => {
+            "query_date_eq" => {
                 Some(super::date::DateEqQuery::deserialize(value).map(Self::DateEqQuery))
             }
-            "date_ord_ore_query" => {
+            "query_date_ord_ore" => {
                 Some(super::date::DateOrdOreQuery::deserialize(value).map(Self::DateOrdOreQuery))
             }
-            "date_ord_query" => {
+            "query_date_ord" => {
                 Some(super::date::DateOrdQuery::deserialize(value).map(Self::DateOrdQuery))
             }
-            "date_ord_ope_query" => {
+            "query_date_ord_ope" => {
                 Some(super::date::DateOrdOpeQuery::deserialize(value).map(Self::DateOrdOpeQuery))
             }
-            "timestamp_eq_query" => Some(
+            "query_timestamp_eq" => Some(
                 super::timestamp::TimestampEqQuery::deserialize(value).map(Self::TimestampEqQuery),
             ),
-            "timestamp_ord_ore_query" => Some(
+            "query_timestamp_ord_ore" => Some(
                 super::timestamp::TimestampOrdOreQuery::deserialize(value)
                     .map(Self::TimestampOrdOreQuery),
             ),
-            "timestamp_ord_query" => Some(
+            "query_timestamp_ord" => Some(
                 super::timestamp::TimestampOrdQuery::deserialize(value)
                     .map(Self::TimestampOrdQuery),
             ),
-            "timestamp_ord_ope_query" => Some(
+            "query_timestamp_ord_ope" => Some(
                 super::timestamp::TimestampOrdOpeQuery::deserialize(value)
                     .map(Self::TimestampOrdOpeQuery),
             ),
-            "numeric_eq_query" => {
+            "query_numeric_eq" => {
                 Some(super::numeric::NumericEqQuery::deserialize(value).map(Self::NumericEqQuery))
             }
-            "numeric_ord_ore_query" => Some(
+            "query_numeric_ord_ore" => Some(
                 super::numeric::NumericOrdOreQuery::deserialize(value)
                     .map(Self::NumericOrdOreQuery),
             ),
-            "numeric_ord_query" => {
+            "query_numeric_ord" => {
                 Some(super::numeric::NumericOrdQuery::deserialize(value).map(Self::NumericOrdQuery))
             }
-            "numeric_ord_ope_query" => Some(
+            "query_numeric_ord_ope" => Some(
                 super::numeric::NumericOrdOpeQuery::deserialize(value)
                     .map(Self::NumericOrdOpeQuery),
             ),
-            "text_eq_query" => {
+            "query_text_eq" => {
                 Some(super::text::TextEqQuery::deserialize(value).map(Self::TextEqQuery))
             }
-            "text_match_query" => {
+            "query_text_match" => {
                 Some(super::text::TextMatchQuery::deserialize(value).map(Self::TextMatchQuery))
             }
-            "text_ord_ore_query" => {
+            "query_text_ord_ore" => {
                 Some(super::text::TextOrdOreQuery::deserialize(value).map(Self::TextOrdOreQuery))
             }
-            "text_ord_query" => {
+            "query_text_ord" => {
                 Some(super::text::TextOrdQuery::deserialize(value).map(Self::TextOrdQuery))
             }
-            "text_ord_ope_query" => {
+            "query_text_ord_ope" => {
                 Some(super::text::TextOrdOpeQuery::deserialize(value).map(Self::TextOrdOpeQuery))
             }
-            "text_search_query" => {
+            "query_text_search" => {
                 Some(super::text::TextSearchQuery::deserialize(value).map(Self::TextSearchQuery))
             }
-            "real_eq_query" => {
+            "query_real_eq" => {
                 Some(super::real::RealEqQuery::deserialize(value).map(Self::RealEqQuery))
             }
-            "real_ord_ore_query" => {
+            "query_real_ord_ore" => {
                 Some(super::real::RealOrdOreQuery::deserialize(value).map(Self::RealOrdOreQuery))
             }
-            "real_ord_query" => {
+            "query_real_ord" => {
                 Some(super::real::RealOrdQuery::deserialize(value).map(Self::RealOrdQuery))
             }
-            "real_ord_ope_query" => {
+            "query_real_ord_ope" => {
                 Some(super::real::RealOrdOpeQuery::deserialize(value).map(Self::RealOrdOpeQuery))
             }
-            "double_eq_query" => {
+            "query_double_eq" => {
                 Some(super::double::DoubleEqQuery::deserialize(value).map(Self::DoubleEqQuery))
             }
-            "double_ord_ore_query" => Some(
+            "query_double_ord_ore" => Some(
                 super::double::DoubleOrdOreQuery::deserialize(value).map(Self::DoubleOrdOreQuery),
             ),
-            "double_ord_query" => {
+            "query_double_ord" => {
                 Some(super::double::DoubleOrdQuery::deserialize(value).map(Self::DoubleOrdQuery))
             }
-            "double_ord_ope_query" => Some(
+            "query_double_ord_ope" => Some(
                 super::double::DoubleOrdOpeQuery::deserialize(value).map(Self::DoubleOrdOpeQuery),
             ),
-            "jsonb_query" => Some(super::jsonb::SteVecQuery::deserialize(value).map(Self::SteVec)),
+            "query_jsonb" => Some(super::jsonb::SteVecQuery::deserialize(value).map(Self::SteVec)),
             _ => None,
         }
     }
@@ -279,11 +279,11 @@ impl QueryPayload {
             Self::SteVec(payload) => payload,
         }
     }
-    /// Fully-qualified SQL domain name, e.g. `"public.integer_eq_query"`.
+    /// Fully-qualified SQL domain name, e.g. `"eql_v3.query_integer_eq"`.
     pub fn sql_domain(&self) -> &'static str {
         self.as_domain_type().sql_domain()
     }
-    /// Unqualified SQL domain name, e.g. `"integer_eq_query"` — the name
+    /// Unqualified SQL domain name, e.g. `"query_integer_eq"` — the name
     /// [`QueryPayload::parse`] accepts.
     pub fn domain(&self) -> &'static str {
         self.as_domain_type().domain()
diff --git a/crates/eql-bindings/src/v3/real.rs b/crates/eql-bindings/src/v3/real.rs
index 5337a014a..31201219d 100644
--- a/crates/eql-bindings/src/v3/real.rs
+++ b/crates/eql-bindings/src/v3/real.rs
@@ -165,7 +165,7 @@ impl DomainType for RealOrdOpe {
         schema_for!(RealOrdOpe)
     }
 }
-/// `public.real_eq_query` — equality domain query operand.
+/// `eql_v3.query_real_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct RealEqQuery {
 }
 impl DomainType for RealEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.real_eq_query"
+        "eql_v3.query_real_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for RealEqQuery {
         schema_for!(RealEqQuery)
     }
 }
-/// `public.real_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_real_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct RealOrdOreQuery {
 }
 impl DomainType for RealOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.real_ord_ore_query"
+        "eql_v3.query_real_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for RealOrdOreQuery {
         schema_for!(RealOrdOreQuery)
     }
 }
-/// `public.real_ord_query` — ordering domain query operand.
+/// `eql_v3.query_real_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct RealOrdQuery {
 }
 impl DomainType for RealOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.real_ord_query"
+        "eql_v3.query_real_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for RealOrdQuery {
         schema_for!(RealOrdQuery)
     }
 }
-/// `public.real_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_real_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct RealOrdOpeQuery {
 }
 impl DomainType for RealOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.real_ord_ope_query"
+        "eql_v3.query_real_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/smallint.rs b/crates/eql-bindings/src/v3/smallint.rs
index a16891098..bb1a78881 100644
--- a/crates/eql-bindings/src/v3/smallint.rs
+++ b/crates/eql-bindings/src/v3/smallint.rs
@@ -165,7 +165,7 @@ impl DomainType for SmallintOrdOpe {
         schema_for!(SmallintOrdOpe)
     }
 }
-/// `public.smallint_eq_query` — equality domain query operand.
+/// `eql_v3.query_smallint_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct SmallintEqQuery {
 }
 impl DomainType for SmallintEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.smallint_eq_query"
+        "eql_v3.query_smallint_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for SmallintEqQuery {
         schema_for!(SmallintEqQuery)
     }
 }
-/// `public.smallint_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_smallint_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct SmallintOrdOreQuery {
 }
 impl DomainType for SmallintOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.smallint_ord_ore_query"
+        "eql_v3.query_smallint_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for SmallintOrdOreQuery {
         schema_for!(SmallintOrdOreQuery)
     }
 }
-/// `public.smallint_ord_query` — ordering domain query operand.
+/// `eql_v3.query_smallint_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct SmallintOrdQuery {
 }
 impl DomainType for SmallintOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.smallint_ord_query"
+        "eql_v3.query_smallint_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for SmallintOrdQuery {
         schema_for!(SmallintOrdQuery)
     }
 }
-/// `public.smallint_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_smallint_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct SmallintOrdOpeQuery {
 }
 impl DomainType for SmallintOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.smallint_ord_ope_query"
+        "eql_v3.query_smallint_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/text.rs b/crates/eql-bindings/src/v3/text.rs
index 698870acb..e777b5d0a 100644
--- a/crates/eql-bindings/src/v3/text.rs
+++ b/crates/eql-bindings/src/v3/text.rs
@@ -234,7 +234,7 @@ impl DomainType for TextSearch {
         schema_for!(TextSearch)
     }
 }
-/// `public.text_eq_query` — equality domain query operand.
+/// `eql_v3.query_text_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -247,7 +247,7 @@ pub struct TextEqQuery {
 }
 impl DomainType for TextEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_eq_query"
+        "eql_v3.query_text_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -265,7 +265,7 @@ impl DomainType for TextEqQuery {
         schema_for!(TextEqQuery)
     }
 }
-/// `public.text_match_query` — match domain query operand.
+/// `eql_v3.query_text_match` — match domain query operand.
 ///
 /// Operators: `@>` `<@`. Required keys: `v` `i` `bf`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -278,7 +278,7 @@ pub struct TextMatchQuery {
 }
 impl DomainType for TextMatchQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_match_query"
+        "eql_v3.query_text_match"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -296,7 +296,7 @@ impl DomainType for TextMatchQuery {
         schema_for!(TextMatchQuery)
     }
 }
-/// `public.text_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_text_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -310,7 +310,7 @@ pub struct TextOrdOreQuery {
 }
 impl DomainType for TextOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_ord_ore_query"
+        "eql_v3.query_text_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -328,7 +328,7 @@ impl DomainType for TextOrdOreQuery {
         schema_for!(TextOrdOreQuery)
     }
 }
-/// `public.text_ord_query` — ordering domain query operand.
+/// `eql_v3.query_text_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -342,7 +342,7 @@ pub struct TextOrdQuery {
 }
 impl DomainType for TextOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_ord_query"
+        "eql_v3.query_text_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -360,7 +360,7 @@ impl DomainType for TextOrdQuery {
         schema_for!(TextOrdQuery)
     }
 }
-/// `public.text_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_text_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `hm` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -374,7 +374,7 @@ pub struct TextOrdOpeQuery {
 }
 impl DomainType for TextOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_ord_ope_query"
+        "eql_v3.query_text_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -392,7 +392,7 @@ impl DomainType for TextOrdOpeQuery {
         schema_for!(TextOrdOpeQuery)
     }
 }
-/// `public.text_search_query` — search domain query operand.
+/// `eql_v3.query_text_search` — search domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=` `@>` `<@`. Required keys: `v` `i` `hm` `ob` `bf`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -407,7 +407,7 @@ pub struct TextSearchQuery {
 }
 impl DomainType for TextSearchQuery {
     fn sql_domain_static() -> &'static str {
-        "public.text_search_query"
+        "eql_v3.query_text_search"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/src/v3/timestamp.rs b/crates/eql-bindings/src/v3/timestamp.rs
index 8972bf494..5a5b3ce4c 100644
--- a/crates/eql-bindings/src/v3/timestamp.rs
+++ b/crates/eql-bindings/src/v3/timestamp.rs
@@ -165,7 +165,7 @@ impl DomainType for TimestampOrdOpe {
         schema_for!(TimestampOrdOpe)
     }
 }
-/// `public.timestamp_eq_query` — equality domain query operand.
+/// `eql_v3.query_timestamp_eq` — equality domain query operand.
 ///
 /// Operators: `=` `<>`. Required keys: `v` `i` `hm`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -178,7 +178,7 @@ pub struct TimestampEqQuery {
 }
 impl DomainType for TimestampEqQuery {
     fn sql_domain_static() -> &'static str {
-        "public.timestamp_eq_query"
+        "eql_v3.query_timestamp_eq"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -196,7 +196,7 @@ impl DomainType for TimestampEqQuery {
         schema_for!(TimestampEqQuery)
     }
 }
-/// `public.timestamp_ord_ore_query` — ordering domain query operand.
+/// `eql_v3.query_timestamp_ord_ore` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -209,7 +209,7 @@ pub struct TimestampOrdOreQuery {
 }
 impl DomainType for TimestampOrdOreQuery {
     fn sql_domain_static() -> &'static str {
-        "public.timestamp_ord_ore_query"
+        "eql_v3.query_timestamp_ord_ore"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -227,7 +227,7 @@ impl DomainType for TimestampOrdOreQuery {
         schema_for!(TimestampOrdOreQuery)
     }
 }
-/// `public.timestamp_ord_query` — ordering domain query operand.
+/// `eql_v3.query_timestamp_ord` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `ob`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -240,7 +240,7 @@ pub struct TimestampOrdQuery {
 }
 impl DomainType for TimestampOrdQuery {
     fn sql_domain_static() -> &'static str {
-        "public.timestamp_ord_query"
+        "eql_v3.query_timestamp_ord"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
@@ -258,7 +258,7 @@ impl DomainType for TimestampOrdQuery {
         schema_for!(TimestampOrdQuery)
     }
 }
-/// `public.timestamp_ord_ope_query` — ordering domain query operand.
+/// `eql_v3.query_timestamp_ord_ope` — ordering domain query operand.
 ///
 /// Operators: `=` `<>` `<` `<=` `>` `>=`. Required keys: `v` `i` `op`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, TS, JsonSchema)]
@@ -271,7 +271,7 @@ pub struct TimestampOrdOpeQuery {
 }
 impl DomainType for TimestampOrdOpeQuery {
     fn sql_domain_static() -> &'static str {
-        "public.timestamp_ord_ope_query"
+        "eql_v3.query_timestamp_ord_ope"
     }
     fn sql_domain(&self) -> &'static str {
         Self::sql_domain_static()
diff --git a/crates/eql-bindings/tests/catalog_parity.rs b/crates/eql-bindings/tests/catalog_parity.rs
index 17f4b4089..5e2d91bc8 100644
--- a/crates/eql-bindings/tests/catalog_parity.rs
+++ b/crates/eql-bindings/tests/catalog_parity.rs
@@ -155,8 +155,8 @@ fn parse_value_validates_through_the_inventory() {
         "sv": [ { "s": "sel", "c": "ct", "hm": "deadbeef" } ]
     });
     assert!(entry("json").parse_value(&doc).is_ok());
-    assert!(entry("jsonb_query").parse_value(&doc).is_err());
-    assert!(entry("jsonb_query")
+    assert!(entry("query_jsonb").parse_value(&doc).is_err());
+    assert!(entry("query_jsonb")
         .parse_value(&json!({ "sv": [ { "s": "sel", "hm": "deadbeef" } ] }))
         .is_ok());
 }
@@ -264,7 +264,7 @@ fn schemas_are_strict() {
 ///   every real payload — the SQL CHECK is laxer and only mandates `v`/`i`/`sv`,
 ///   but the binding models the real wire, which always carries `k`)
 /// - `public.jsonb_entry` requires `s` `c` + exactly one of `hm` XOR `oc`
-/// - `public.jsonb_query`  requires `sv`; each element `s` + `hm` XOR `oc`, no `c`
+/// - `eql_v3.query_jsonb`  requires `sv`; each element `s` + `hm` XOR `oc`, no `c`
 #[test]
 fn jsonb_schema_required_keys_match_the_sql_check_contract() {
     let entries = v3::all();
@@ -326,24 +326,24 @@ fn jsonb_schema_required_keys_match_the_sql_check_contract() {
 
     // Query: {sv}. The element (SteVecQueryEntry) requires `s` + hm XOR oc and
     // carries NO ciphertext `c` — the "queries never carry ciphertext" rule.
-    let query = schema_of("jsonb_query");
+    let query = schema_of("query_jsonb");
     assert_eq!(
-        required(&query, "/required", "jsonb_query"),
+        required(&query, "/required", "query_jsonb"),
         set(&["sv"]),
-        "public.jsonb_query required keys must be sv"
+        "eql_v3.query_jsonb required keys must be sv"
     );
     let elem_required = required(
         &query,
         "/$defs/SteVecQueryEntry/required",
-        "jsonb_query element",
+        "query_jsonb element",
     );
     assert!(
         elem_required.contains("s"),
-        "jsonb_query element must require a selector s, got {elem_required:?}"
+        "query_jsonb element must require a selector s, got {elem_required:?}"
     );
     assert!(
         !elem_required.contains("c"),
-        "jsonb_query element must NOT require a ciphertext c \
+        "query_jsonb element must NOT require a ciphertext c \
          (is_valid_ste_vec_query_payload forbids it), got {elem_required:?}"
     );
     // Same arm-wise check as jsonb_entry: the query element's hm XOR oc union must
@@ -351,16 +351,16 @@ fn jsonb_schema_required_keys_match_the_sql_check_contract() {
     let query_alts = query
         .pointer("/$defs/SteVecQueryEntry/anyOf")
         .and_then(|v| v.as_array())
-        .expect("jsonb_query element schema must carry an anyOf term union");
+        .expect("query_jsonb element schema must carry an anyOf term union");
     let query_alt_required: Vec<BTreeSet<String>> = query_alts
         .iter()
-        .map(|alt| required(alt, "/required", "jsonb_query element anyOf"))
+        .map(|alt| required(alt, "/required", "query_jsonb element anyOf"))
         .collect();
     assert!(
         query_alt_required.len() == 2
             && query_alt_required.contains(&set(&["hm"]))
             && query_alt_required.contains(&set(&["oc"])),
-        "public.jsonb_query element anyOf must offer exactly the hm-only and \
+        "eql_v3.query_jsonb element anyOf must offer exactly the hm-only and \
          oc-only term alternatives (each arm a singleton), got {query_alt_required:?}"
     );
 }
diff --git a/crates/eql-bindings/tests/domain_payload.rs b/crates/eql-bindings/tests/domain_payload.rs
index b8363f08e..3eb82680f 100644
--- a/crates/eql-bindings/tests/domain_payload.rs
+++ b/crates/eql-bindings/tests/domain_payload.rs
@@ -209,7 +209,7 @@ fn parse_constructs_every_stored_payload_domain() {
             } else if stored {
                 from_v2(&v2_ct_full(), target(&name)).unwrap()
             } else {
-                // jsonb_entry / jsonb_query: inventory members but not stored
+                // jsonb_entry / query_jsonb: inventory members but not stored
                 // payloads — no DomainPayload variant, parse returns None.
                 assert!(
                     DomainPayload::parse(&name, &json!({})).is_none(),
@@ -234,7 +234,7 @@ fn parse_returns_none_for_unknown_domains() {
         "",
         "jsonb",
         "jsonb_entry",
-        "jsonb_query",
+        "query_jsonb",
     ] {
         assert!(
             DomainPayload::parse(name, &json!({})).is_none(),
diff --git a/crates/eql-bindings/tests/from_v2.rs b/crates/eql-bindings/tests/from_v2.rs
index 42a316b2f..8605c517d 100644
--- a/crates/eql-bindings/tests/from_v2.rs
+++ b/crates/eql-bindings/tests/from_v2.rs
@@ -417,12 +417,12 @@ fn ste_vec_query_entry_term_errors_match_document_rules() {
         from_v2_query(&both, TargetDomain::Json).unwrap_err(),
         FromV2Error::AmbiguousTerm { entry: 0 }
     ));
-    // The query path names ITS shape (jsonb_query, not json) and locates the
+    // The query path names ITS shape (query_jsonb, not json) and locates the
     // entry.
     let neither = json!({ "sv": [ { "s": SELECTOR, "hm": HEX }, { "s": SELECTOR } ] });
     match from_v2_query(&neither, TargetDomain::Json).unwrap_err() {
         FromV2Error::MissingTerm { domain, key, entry } => {
-            assert_eq!(domain, "jsonb_query");
+            assert_eq!(domain, "query_jsonb");
             assert_eq!(key, "hm|oc");
             assert_eq!(entry, Some(1));
         }
diff --git a/crates/eql-bindings/tests/query_payload.rs b/crates/eql-bindings/tests/query_payload.rs
index 14b4d259b..39ed85842 100644
--- a/crates/eql-bindings/tests/query_payload.rs
+++ b/crates/eql-bindings/tests/query_payload.rs
@@ -8,7 +8,7 @@
 //! wire) — plus failure parity: both entry points reject the same inputs with
 //! the same errors, including [`FromV2Error::UnsupportedQueryTarget`] for
 //! STORAGE-ONLY scalar targets (term-bearing scalars now hoist to their
-//! `<name>_query` operand — CIP-3432).
+//! `query_<name>` operand — CIP-3432, prefix naming CIP-3442).
 
 use eql_bindings::from_v2::{from_v2_query, from_v2_query_typed, FromV2Error, TargetDomain};
 use eql_bindings::v3::{DomainType, QueryPayload};
@@ -67,12 +67,12 @@ fn typed_needle_yields_the_ste_vec_variant() {
         ]
     });
     let typed = assert_serialization_pin(&v2);
-    assert_eq!(typed.domain(), "jsonb_query");
-    assert_eq!(typed.sql_domain(), "public.jsonb_query");
+    assert_eq!(typed.domain(), "query_jsonb");
+    assert_eq!(typed.sql_domain(), "eql_v3.query_jsonb");
     match &typed {
         QueryPayload::SteVec(q) => {
             assert_eq!(q.sv.len(), 2, "entry order/count preserved");
-            assert_eq!(q.sql_domain(), "public.jsonb_query");
+            assert_eq!(q.sql_domain(), "eql_v3.query_jsonb");
         }
         other => panic!("a jsonb target must yield the SteVec needle, got {other:?}"),
     }
@@ -122,7 +122,7 @@ fn v2_scalar_query(term_keys: &[&str]) -> Value {
 fn scalar_query_hoist_and_storage_only_unsupported() {
     // CIP-3432: a term-bearing scalar target hoists the v2 payload's required
     // terms into the enveloped term-only operand `{v:3, i, <terms>}` for its
-    // `<name>_query` domain (dropping `c`/`k`); a storage-only scalar target
+    // `query_<name>` domain (dropping `c`/`k`); a storage-only scalar target
     // (no operators) still fails closed with UnsupportedQueryTarget. Exhaustive
     // over the catalog, both entry points, with the typed==untyped pin.
     for family in eql_domains::scalar_families() {
@@ -165,8 +165,8 @@ fn scalar_query_hoist_and_storage_only_unsupported() {
 
             let typed =
                 from_v2_query_typed(&v2, t).unwrap_or_else(|e| panic!("{name} typed hoist: {e:?}"));
-            assert_eq!(typed.domain(), format!("{name}_query"), "{name} domain");
-            assert_eq!(typed.sql_domain(), format!("public.{name}_query"));
+            assert_eq!(typed.domain(), format!("query_{name}"), "{name} domain");
+            assert_eq!(typed.sql_domain(), format!("eql_v3.query_{name}"));
             assert_eq!(
                 serde_json::to_value(&typed).unwrap(),
                 out,
@@ -186,7 +186,7 @@ fn typed_entry_term_errors_match_from_v2_query() {
     let neither = json!({ "sv": [ { "s": SELECTOR, "hm": HEX }, { "s": SELECTOR } ] });
     match from_v2_query_typed(&neither, TargetDomain::Json).unwrap_err() {
         FromV2Error::MissingTerm { domain, key, entry } => {
-            assert_eq!(domain, "jsonb_query");
+            assert_eq!(domain, "query_jsonb");
             assert_eq!(key, "hm|oc");
             assert_eq!(entry, Some(1));
         }
@@ -224,10 +224,10 @@ fn typed_rejects_the_same_envelopes_as_from_v2_query() {
 #[test]
 fn parse_constructs_the_needle_from_its_domain_name() {
     let needle = json!({ "sv": [ { "s": SELECTOR, "hm": HEX } ] });
-    let parsed = QueryPayload::parse("jsonb_query", &needle)
-        .expect("jsonb_query must be a QueryPayload domain")
+    let parsed = QueryPayload::parse("query_jsonb", &needle)
+        .expect("query_jsonb must be a QueryPayload domain")
         .expect("strict parse must succeed");
-    assert_eq!(parsed.domain(), "jsonb_query");
+    assert_eq!(parsed.domain(), "query_jsonb");
     assert_eq!(serde_json::to_value(&parsed).unwrap(), needle);
 }
 
@@ -237,7 +237,7 @@ fn parse_is_strict_exactly_like_the_binding_struct() {
     // fails, exactly as the untyped path's validate_as does.
     let stray = json!({ "sv": [ { "s": SELECTOR, "hm": HEX } ], "extra": 1 });
     assert!(
-        QueryPayload::parse("jsonb_query", &stray).unwrap().is_err(),
+        QueryPayload::parse("query_jsonb", &stray).unwrap().is_err(),
         "deny_unknown_fields must reject a stray root key"
     );
 }
@@ -250,7 +250,7 @@ fn parse_returns_none_for_non_query_domains() {
         "json",
         "jsonb_entry",
         "integer_eq",
-        "public.jsonb_query",
+        "eql_v3.query_jsonb",
         "",
     ] {
         assert!(
diff --git a/crates/eql-bindings/tests/v3_conformance.rs b/crates/eql-bindings/tests/v3_conformance.rs
index 3a60294aa..7665e5c0e 100644
--- a/crates/eql-bindings/tests/v3_conformance.rs
+++ b/crates/eql-bindings/tests/v3_conformance.rs
@@ -472,7 +472,7 @@ fn stevec_query_round_trips() {
     let wire = json!({ "sv": [ { "s": "sel", "hm": "deadbeef" } ] });
     let parsed: SteVecQuery = serde_json::from_value(wire.clone()).unwrap();
     assert_eq!(serde_json::to_value(&parsed).unwrap(), wire);
-    assert_eq!(SteVecQuery::sql_domain_static(), "public.jsonb_query");
+    assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_jsonb");
     // Unknown top-level key rejected (SteVecQuery has no flatten field).
     assert!(serde_json::from_value::<SteVecQuery>(json!({ "sv": [], "bogus": 1 })).is_err());
     // NOTE: a query ELEMENT carrying `c` is NOT rejected here — SteVecQueryEntry
@@ -516,7 +516,7 @@ fn stevec_document_and_query_schemas_are_strict() {
     assert_eq!(sq.pointer("/additionalProperties"), Some(&json!(false)));
     // SteVecDocument/Query domain names.
     assert_eq!(SteVecDocument::sql_domain_static(), "public.json");
-    assert_eq!(SteVecQuery::sql_domain_static(), "public.jsonb_query");
+    assert_eq!(SteVecQuery::sql_domain_static(), "eql_v3.query_jsonb");
 }
 
 #[test]
diff --git a/crates/eql-codegen/src/bindings.rs b/crates/eql-codegen/src/bindings.rs
index b9426699c..2d4d3f568 100644
--- a/crates/eql-codegen/src/bindings.rs
+++ b/crates/eql-codegen/src/bindings.rs
@@ -191,20 +191,22 @@ fn render_struct(family: &DomainFamily, domain: &Domain) -> TokenStream {
 
 /// One query-operand payload struct + its `DomainType` impl for a capability
 /// domain: the storage struct MINUS the `c` ciphertext. A query operand carries
-/// only index terms (no stored ciphertext), so its `public.<name>_query` domain
+/// only index terms (no stored ciphertext), so its `eql_v3.query_<name>` domain
 /// admits exactly `{v, i, <terms>}` — `deny_unknown_fields` makes a stray `c`
-/// (or any storage key) a parse error, mirroring the SQL `<name>_query` domain
+/// (or any storage key) a parse error, mirroring the SQL `query_<name>` domain
 /// CHECK (CIP-3432). Emitted only for term-bearing domains: a storage-only
 /// domain has no operators, so no query operand.
 fn render_query_struct(family: &DomainFamily, domain: &Domain) -> TokenStream {
-    let full = domain.full_name(family.name);
+    let query_name = domain.query_name(family.name);
     let ident = format_ident!("{}Query", domain.struct_ident(family.name));
-    let sql_domain = format!("public.{full}_query");
+    // Query operands live in the public-API schema, NOT `public`: they are
+    // never valid column types (CIP-3442).
+    let sql_domain = format!("eql_v3.{query_name}");
 
     // Query doc: same capability label + operator union as storage, but the
     // required-key list drops `c` (query operands omit the ciphertext).
     let summary = format!(
-        " `public.{full}_query` — {} query operand.",
+        " `eql_v3.{query_name}` — {} query operand.",
         capability_label(domain.name)
     );
     let ops = Term::operators_for_terms(domain.terms);
@@ -382,7 +384,7 @@ pub fn render_inventory_rs() -> String {
             ]
         }
 
-        /// Every v3 QUERY-operand twin (`public.<name>_query`, the enveloped
+        /// Every v3 QUERY-operand twin (`eql_v3.query_<name>`, the enveloped
         /// term-only operand), in `eql-domains::CATALOG` order — generated.
         /// Separate from [`all`] so query domains never resolve as stored
         /// conversion targets; used by the JSON Schema export and query
@@ -517,8 +519,8 @@ pub fn render_payload_rs() -> String {
 }
 
 /// The catalog's QUERY-operand domains, in a stable order: a query twin for
-/// every term-bearing scalar domain (`public.<name>_query`), then the SteVec
-/// containment needle (`public.jsonb_query`). Exactly the shapes the generated
+/// every term-bearing scalar domain (`eql_v3.query_<name>`), then the SteVec
+/// containment needle (`eql_v3.query_jsonb`). Exactly the shapes the generated
 /// `QueryPayload` spans and `from_v2_query` can target. Returned as
 /// `(module, variant ident, struct ident, unqualified query-domain name)`; the
 /// SteVec needle keeps the `SteVec` variant name the `from_v2` query path
@@ -531,12 +533,7 @@ fn query_payload_domains() -> Vec<(String, String, String, String)> {
                 .filter(|d| !d.terms.is_empty())
                 .map(move |d| {
                     let q = format!("{}Query", d.struct_ident(f.name));
-                    (
-                        f.name.to_string(),
-                        q.clone(),
-                        q,
-                        format!("{}_query", d.full_name(f.name)),
-                    )
+                    (f.name.to_string(), q.clone(), q, d.query_name(f.name))
                 })
         })
         .collect();
@@ -544,15 +541,15 @@ fn query_payload_domains() -> Vec<(String, String, String, String)> {
         "jsonb".into(),
         "SteVec".into(),
         "SteVecQuery".into(),
-        "jsonb_query".into(),
+        "query_jsonb".into(),
     ));
     out
 }
 
 /// Render the generated `crates/eql-bindings/src/v3/query_payload.rs`: the
 /// `QueryPayload` enum spanning every QUERY-operand domain — a variant per
-/// term-bearing scalar query twin (`public.<name>_query`) plus the SteVec
-/// containment needle (`public.jsonb_query`) — with its
+/// term-bearing scalar query twin (`eql_v3.query_<name>`) plus the SteVec
+/// containment needle (`eql_v3.query_jsonb`) — with its
 /// construct-from-known-domain `parse` constructor.
 ///
 /// Generated for the same reason as [`render_payload_rs`]'s `DomainPayload`:
@@ -569,7 +566,8 @@ pub fn render_query_payload_rs() -> String {
         let m = format_ident!("{module}");
         let v = format_ident!("{variant}");
         let s = format_ident!("{strukt}");
-        let doc = format!(" The `public.{key}` query operand.");
+        // Every query-operand domain lives in eql_v3 (CIP-3442).
+        let doc = format!(" The `eql_v3.{key}` query operand.");
         variants.extend(quote! {
             #[doc = #doc]
             #v(super::#m::#s),
@@ -595,9 +593,9 @@ pub fn render_query_payload_rs() -> String {
         use super::domain_type::DomainType;
 
         /// Every v3 QUERY-operand shape in one type: one variant per term-bearing
-        /// scalar query twin (`public.<name>_query`, the enveloped term-only
+        /// scalar query twin (`eql_v3.query_<name>`, the enveloped term-only
         /// operand — `{v, i, <terms>}`, no `c`) plus the SteVec containment
-        /// needle (`public.jsonb_query`). Generated from the catalog, so it
+        /// needle (`eql_v3.query_jsonb`). Generated from the catalog, so it
         /// cannot drift when the catalog grows.
         ///
         /// Serialization is exactly the inner struct's (`#[serde(untagged)]`
@@ -616,7 +614,7 @@ pub fn render_query_payload_rs() -> String {
             /// Strictly parse `value` as `domain`'s query payload, KEEPING the
             /// parsed value — the query-side counterpart of
             /// [`super::DomainPayload::parse`]. `domain` is the unqualified name
-            /// (`"integer_eq_query"`, `"jsonb_query"`, …). `None` when `domain`
+            /// (`"query_integer_eq"`, `"query_jsonb"`, …). `None` when `domain`
             /// is not a query-operand domain; `Some(Err)` when the strict parse
             /// fails (`deny_unknown_fields` rejects a stray `c`).
             pub fn parse(
@@ -636,12 +634,12 @@ pub fn render_query_payload_rs() -> String {
                 }
             }
 
-            /// Fully-qualified SQL domain name, e.g. `"public.integer_eq_query"`.
+            /// Fully-qualified SQL domain name, e.g. `"eql_v3.query_integer_eq"`.
             pub fn sql_domain(&self) -> &'static str {
                 self.as_domain_type().sql_domain()
             }
 
-            /// Unqualified SQL domain name, e.g. `"integer_eq_query"` — the name
+            /// Unqualified SQL domain name, e.g. `"query_integer_eq"` — the name
             /// [`QueryPayload::parse`] accepts.
             pub fn domain(&self) -> &'static str {
                 self.as_domain_type().domain()
@@ -782,8 +780,9 @@ mod tests {
     #[test]
     fn query_twins_drop_c_and_name_query_domains() {
         // CIP-3432: every term-bearing capability domain gets a `<Name>Query`
-        // twin = the storage struct minus `c`, on the `public.<name>_query`
-        // domain. Storage-only domains (no operators) get no twin.
+        // twin = the storage struct minus `c`, on the `eql_v3.query_<name>`
+        // domain (prefix naming — CIP-3442). Storage-only domains (no
+        // operators) get no twin.
         let out = render_family_bindings(family("integer"));
         for s in [
             "struct IntegerEqQuery ",
@@ -801,10 +800,10 @@ mod tests {
         assert_eq!(field_idents(&out, "IntegerEqQuery"), ["v", "i", "hm"]);
         assert_eq!(field_idents(&out, "IntegerOrdQuery"), ["v", "i", "ob"]);
         assert_eq!(field_idents(&out, "IntegerOrdOpeQuery"), ["v", "i", "op"]);
-        assert!(out.contains("\"public.integer_eq_query\""));
+        assert!(out.contains("\"eql_v3.query_integer_eq\""));
         assert!(out.contains("impl DomainType for IntegerEqQuery"));
         assert!(out.contains("schema_for!(IntegerEqQuery)"));
-        assert!(out.contains("`public.integer_eq_query` — equality domain query operand."));
+        assert!(out.contains("`eql_v3.query_integer_eq` — equality domain query operand."));
         // Query twin term keys mirror the storage domain's.
         assert!(out.contains(r#"&["op"]"#));
 
@@ -815,7 +814,7 @@ mod tests {
             field_idents(&text, "TextSearchQuery"),
             ["v", "i", "hm", "ob", "bf"]
         );
-        assert!(text.contains("`public.text_match_query` — match domain query operand."));
+        assert!(text.contains("`eql_v3.query_text_match` — match domain query operand."));
     }
 
     #[test]
@@ -1001,8 +1000,8 @@ mod tests {
     #[test]
     fn query_payload_enum_spans_query_twins_and_stevec_needle() {
         // CIP-3432: QueryPayload is now generated — one variant per term-bearing
-        // scalar query twin (`<name>_query`) plus the SteVec needle
-        // (`jsonb_query`), in query_payload_domains() order (scalars, then
+        // scalar query twin (`query_<name>`) plus the SteVec needle
+        // (`query_jsonb`), in query_payload_domains() order (scalars, then
         // SteVec). Serialize-only + untagged + no export derives, like
         // DomainPayload.
         let out = render_query_payload_rs();
@@ -1024,9 +1023,9 @@ mod tests {
         assert_eq!(variants.len(), term_bearing + 1);
 
         // parse arms keyed on the unqualified query-domain names.
-        assert!(out.contains(r#""integer_eq_query" =>"#));
+        assert!(out.contains(r#""query_integer_eq" =>"#));
         assert!(out.contains("IntegerEqQuery::deserialize(value).map(Self::IntegerEqQuery)"));
-        assert!(out.contains(r#""jsonb_query" =>"#));
+        assert!(out.contains(r#""query_jsonb" =>"#));
         assert!(out.contains("SteVecQuery::deserialize(value).map(Self::SteVec)"));
         assert!(out.contains("_ => None,"));
 
diff --git a/crates/eql-codegen/src/context.rs b/crates/eql-codegen/src/context.rs
index 493d1f320..816dd1130 100644
--- a/crates/eql-codegen/src/context.rs
+++ b/crates/eql-codegen/src/context.rs
@@ -157,12 +157,12 @@ pub fn domain_block(family_name: &str, domain: &Domain) -> DomainBlock {
     }
 }
 
-/// The query-operand twin block for a term-bearing domain: `public.<name>_query`,
+/// The query-operand twin block for a term-bearing domain: `public.query_<name>`,
 /// keys = envelope-minus-`c` (`v`/`i`) + the domain's terms, with `c` FORBIDDEN
 /// (a query operand carries no ciphertext — CIP-3432). Same non-empty-array term
 /// rule as the storage block.
 pub fn query_domain_block(family_name: &str, domain: &Domain) -> DomainBlock {
-    let name = format!("{}_query", domain.full_name(family_name));
+    let name = domain.query_name(family_name);
 
     // Envelope minus the ciphertext `c`, then the domain's terms.
     let mut keys: Vec<String> = ENVELOPE_KEYS
@@ -352,6 +352,16 @@ pub fn domain_name(name: &str) -> String {
     format!("public.{name}")
 }
 
+/// The schema-qualified name of a QUERY-OPERAND domain, e.g.
+/// `eql_v3.query_integer_eq`. Query twins live in the public-API `SCHEMA`
+/// (not `public`) — they are never valid column types, so the
+/// application-columns-survive-schema-drop rationale behind `domain_name`
+/// does not apply, and keeping them out of `public` keeps the column-type
+/// namespace to actual column types (CIP-3442).
+pub fn query_domain_name(name: &str) -> String {
+    format!("{SCHEMA}.{name}")
+}
+
 /// The extractor-call SQL for one operand, casting jsonb to the domain first.
 /// Port of `_extract_arg`. `dom` is the schema-qualified domain name.
 pub fn extract_arg(arg_type: &str, extractor: &str, dom: &str, arg: &str) -> String {
diff --git a/crates/eql-codegen/src/dump.rs b/crates/eql-codegen/src/dump.rs
index fb6248d33..1164b6c28 100644
--- a/crates/eql-codegen/src/dump.rs
+++ b/crates/eql-codegen/src/dump.rs
@@ -14,7 +14,7 @@ use serde::Serialize;
 pub struct CatalogDump {
     pub types: Vec<TypeEntry>,
     /// The `jsonb` (SteVec) family — `public.json` / `public.jsonb_entry` /
-    /// `public.jsonb_query`. Their SQL is hand-written under `src/v3/jsonb/`; the
+    /// `eql_v3.query_jsonb`. Their SQL is hand-written under `src/v3/jsonb/`; the
     /// catalog owns only their inventory (scalar-only consumers ignore this field).
     pub stevec: Vec<SteVecEntry>,
 }
@@ -64,12 +64,12 @@ pub struct TermInfo {
 #[derive(Serialize)]
 pub struct SteVecEntry {
     /// The bare domain name (resolved under the `public` schema, like a scalar's
-    /// `integer_eq`): `json` / `jsonb_entry` / `jsonb_query`.
+    /// `integer_eq`): `json` / `jsonb_entry` / `query_jsonb`.
     pub full_name: String,
     /// The catalog domain name: `json` / `entry` / `query`.
     pub name: &'static str,
     /// Index terms for this SteVec domain. Non-empty only for `jsonb_entry`
-    /// (the sv element type); the `json` container and `jsonb_query` domains
+    /// (the sv element type); the `json` container and `query_jsonb` domains
     /// carry no term extractors — see `stevec_terms`.
     pub terms: Vec<TermInfo>,
 }
@@ -95,7 +95,7 @@ fn term_infos(terms: &[Term]) -> Vec<TermInfo> {
 ///
 /// Terms live on `jsonb_entry` — the sv *element* type — ONLY: `eql_v3.eq_term`
 /// reads `coalesce(hm, oc)` for `=`/`<>`, and `eql_v3.ore_cllw` reads `oc` for
-/// `<`/`<=`/`>`/`>=`. The `json` container and `jsonb_query` domains carry no
+/// `<`/`<=`/`>`/`>=`. The `json` container and `query_jsonb` domains carry no
 /// term extractors (their surface is containment `@>`/`<@` and path navigation),
 /// so they return no terms. Keyed on the catalog domain name (`json`/`entry`/
 /// `query`).
@@ -220,7 +220,7 @@ mod tests {
     fn stevec_jsonb_family_is_dumped() {
         let dump = dump_catalog();
         let names: Vec<&str> = dump.stevec.iter().map(|e| e.full_name.as_str()).collect();
-        assert_eq!(names, ["json", "jsonb_entry", "jsonb_query"]);
+        assert_eq!(names, ["json", "jsonb_entry", "query_jsonb"]);
 
         let by_name = |n: &str| {
             dump.stevec
@@ -238,10 +238,10 @@ mod tests {
             .collect();
         assert_eq!(entry_extractors, ["eq_term", "ore_cllw"]);
 
-        // The `json` container and `jsonb_query` domains carry no term
+        // The `json` container and `query_jsonb` domains carry no term
         // extractors — their surface is containment (@>, <@) and path nav.
         assert!(by_name("json").terms.is_empty());
-        assert!(by_name("jsonb_query").terms.is_empty());
+        assert!(by_name("query_jsonb").terms.is_empty());
     }
 
     /// Pins the hand-re-derived `suffix` wire field — the one channel with no
@@ -288,7 +288,7 @@ mod tests {
         // `list-types` / `dump-catalog` output the scalar-matrix tooling consumes)
         // must NOT surface the SteVec `jsonb` family: it has no `scalars::jsonb::*`
         // matrix and no generated SQL surface, even though two of its three
-        // domain names (`public.jsonb_entry` / `public.jsonb_query`) now follow
+        // domain names (`public.jsonb_entry` / `eql_v3.query_jsonb`) now follow
         // the family+suffix string convention — the payload shape is still not
         // flat. This pins the exclusion directly at the codegen surface rather
         // than relying only on the transitive `scalar_families()` guard in
diff --git a/crates/eql-codegen/src/generate.rs b/crates/eql-codegen/src/generate.rs
index 6951a3594..a943dccae 100644
--- a/crates/eql-codegen/src/generate.rs
+++ b/crates/eql-codegen/src/generate.rs
@@ -56,7 +56,7 @@ pub fn render_types_file(spec: &DomainFamily) -> String {
         .expect("render types.sql")
 }
 
-/// Body for <T>_query_types.sql: a `public.<name>_query` operand domain per
+/// Body for query_<T>_types.sql: a `public.query_<name>` operand domain per
 /// TERM-BEARING domain — the index-terms-only twin (no `c`) whose operators
 /// consume a query operand (CIP-3432). Storage-only domains have no operators,
 /// so no query twin.
@@ -189,14 +189,14 @@ pub fn render_operators_file(family_name: &str, domain: &Domain) -> String {
         .expect("render operators.sql")
 }
 
-/// REQUIRE path for a family's _query_types.sql.
+/// REQUIRE path for a family's query_<T>_types.sql.
 fn query_types_path(family_name: &str) -> String {
-    scalar_path(family_name, &format!("{family_name}_query_types.sql"))
+    scalar_path(family_name, &format!("query_{family_name}_types.sql"))
 }
 
-/// Body for a term-bearing domain's <name>_query_functions.sql (CIP-3432): the
+/// Body for a term-bearing domain's query_<name>_functions.sql (CIP-3432): the
 /// query-operand extractor OVERLOADS (the same extractors, on
-/// `public.<name>_query`) plus the comparison WRAPPERS binding the storage
+/// `eql_v3.query_<name>`) plus the comparison WRAPPERS binding the storage
 /// domain to its query twin — for the domain's SUPPORTED operators only, in
 /// both directions. Reuses the same `functions.sql` template as the storage
 /// surface; a query operand carries the same terms, so each wrapper compares
@@ -204,12 +204,13 @@ fn query_types_path(family_name: &str) -> String {
 pub fn render_query_functions_file(family_name: &str, domain: &Domain) -> String {
     use crate::consts::sql_str;
     use crate::context::{
-        domain_name, environment, extractor_entry, wrapper_entry, FunctionsContext,
+        domain_name, environment, extractor_entry, query_domain_name, wrapper_entry,
+        FunctionsContext,
     };
     let name = domain.full_name(family_name);
-    let query_name = format!("{name}_query");
+    let query_name = domain.query_name(family_name);
     let storage_dom = domain_name(&name);
-    let query_dom = domain_name(&query_name);
+    let query_dom = query_domain_name(&query_name);
     let supported = Term::operators_for_terms(domain.terms);
 
     let mut entries = Vec::new();
@@ -271,16 +272,18 @@ pub fn render_query_functions_file(family_name: &str, domain: &Domain) -> String
         .expect("render query functions.sql")
 }
 
-/// Body for a term-bearing domain's <name>_query_operators.sql (CIP-3432): a
-/// `CREATE OPERATOR` binding `(storage_domain, <name>_query)` for every
-/// supported operator, plus its `(<name>_query, storage_domain)` commutator, so
-/// `col <op> $1::public.<name>_query` resolves to the query wrapper.
+/// Body for a term-bearing domain's query_<name>_operators.sql (CIP-3432): a
+/// `CREATE OPERATOR` binding `(storage_domain, query_<name>)` for every
+/// supported operator, plus its `(query_<name>, storage_domain)` commutator, so
+/// `col <op> $1::eql_v3.query_<name>` resolves to the query wrapper.
 pub fn render_query_operators_file(family_name: &str, domain: &Domain) -> String {
-    use crate::context::{domain_name, environment, operator_entry, OperatorsContext};
+    use crate::context::{
+        domain_name, environment, operator_entry, query_domain_name, OperatorsContext,
+    };
     let name = domain.full_name(family_name);
-    let query_name = format!("{name}_query");
+    let query_name = domain.query_name(family_name);
     let storage_dom = domain_name(&name);
-    let query_dom = domain_name(&query_name);
+    let query_dom = query_domain_name(&query_name);
     let supported = Term::operators_for_terms(domain.terms);
 
     let mut operators = Vec::new();
@@ -362,7 +365,7 @@ pub fn render_type(spec: &DomainFamily, out_dir: &Path) -> Vec<(PathBuf, String)
     // least one term-bearing domain (storage-only families have no query surface).
     if spec.domains.iter().any(|d| !d.terms.is_empty()) {
         rendered.push((
-            out_dir.join(format!("{family_name}_query_types.sql")),
+            out_dir.join(format!("query_{family_name}_types.sql")),
             render_query_types_file(spec),
         ));
     }
@@ -377,15 +380,16 @@ pub fn render_type(spec: &DomainFamily, out_dir: &Path) -> Vec<(PathBuf, String)
             render_operators_file(family_name, d),
         ));
         // Query-operand surface (CIP-3432): extractor overloads + wrappers +
-        // operators binding the storage domain to its `<name>_query` twin. Only
+        // operators binding the storage domain to its `query_<name>` twin. Only
         // term-bearing domains have a query twin (storage-only = no operators).
         if !d.terms.is_empty() {
+            let query_name = d.query_name(family_name);
             rendered.push((
-                out_dir.join(format!("{name}_query_functions.sql")),
+                out_dir.join(format!("{query_name}_functions.sql")),
                 render_query_functions_file(family_name, d),
             ));
             rendered.push((
-                out_dir.join(format!("{name}_query_operators.sql")),
+                out_dir.join(format!("{query_name}_operators.sql")),
                 render_query_operators_file(family_name, d),
             ));
         }
@@ -559,7 +563,7 @@ mod tests {
             .collect();
         assert!(names.contains(&"integer_types.sql".to_string()));
         // Query-operand twin domains (term-only, no `c`) for the family.
-        assert!(names.contains(&"integer_query_types.sql".to_string()));
+        assert!(names.contains(&"query_integer_types.sql".to_string()));
         for dom in [
             "integer",
             "integer_eq",
@@ -578,10 +582,10 @@ mod tests {
             "integer_ord",
             "integer_ord_ope",
         ] {
-            assert!(names.contains(&format!("{dom}_query_functions.sql")));
-            assert!(names.contains(&format!("{dom}_query_operators.sql")));
+            assert!(names.contains(&format!("query_{dom}_functions.sql")));
+            assert!(names.contains(&format!("query_{dom}_operators.sql")));
         }
-        assert!(!names.contains(&"integer_query_functions.sql".to_string()));
+        assert!(!names.contains(&"query_integer_functions.sql".to_string()));
         assert!(!names.contains(&"integer_aggregates.sql".to_string()));
         assert!(!names.contains(&"integer_eq_aggregates.sql".to_string()));
         assert!(names.contains(&"integer_ord_ore_aggregates.sql".to_string()));
diff --git a/crates/eql-codegen/templates/query_types.sql.j2 b/crates/eql-codegen/templates/query_types.sql.j2
index 3a4d1725d..2dee7bf01 100644
--- a/crates/eql-codegen/templates/query_types.sql.j2
+++ b/crates/eql-codegen/templates/query_types.sql.j2
@@ -1,22 +1,26 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/{{ family_name }}/{{ family_name }}_query_types.sql
+--! @file v3/scalars/{{ family_name }}/query_{{ family_name }}_types.sql
 --! @brief Query-operand domains for {{ family_name }} (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.{{ family_name }}_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `{{ schema }}` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::{{ schema }}.query_{{ family_name }}_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
 {%- for d in domains %}
-  --! @brief Query-operand domain public.{{ d.name }} (term-only; no `c`).
+  --! @brief Query-operand domain {{ schema }}.{{ d.name }} (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = '{{ d.typname }}' AND typnamespace = 'public'::regnamespace
+    WHERE typname = '{{ d.typname }}' AND typnamespace = '{{ schema }}'::regnamespace
   ) THEN
-    CREATE DOMAIN public.{{ d.name }} AS jsonb
+    CREATE DOMAIN {{ schema }}.{{ d.name }} AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         {%- for k in d.keys %}
@@ -33,7 +37,7 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.{{ d.name }} IS '{{ d.comment }}';
+  COMMENT ON DOMAIN {{ schema }}.{{ d.name }} IS '{{ d.comment }}';
 {% endfor -%}
 END
 $$;
diff --git a/crates/eql-domains/src/lib.rs b/crates/eql-domains/src/lib.rs
index b89ad08ca..8a711db85 100644
--- a/crates/eql-domains/src/lib.rs
+++ b/crates/eql-domains/src/lib.rs
@@ -135,7 +135,7 @@ pub enum Shape {
     Scalar,
     /// A `jsonb` family payload: `public.json` (`{v, i, sv: [entry]}`),
     /// `public.jsonb_entry` (`{s, c, a?, #[flatten] SteVecTerm}`), or
-    /// `public.jsonb_query` (`{sv: [query-entry]}`). The three differ in
+    /// `public.query_jsonb` (`{sv: [query-entry]}`). The three differ in
     /// payload body but share the non-flat-scalar shape, so a single variant
     /// covers them; `Domain.name` (`"json"`/`"entry"`/`"query"`) already
     /// disambiguates which one a given domain is (see `Domain::full_name` /
@@ -435,7 +435,7 @@ const JSONB_DOMAINS: &[Domain] = &[
 
 /// `jsonb` — the encrypted-JSONB (SteVec) family: `public.json` (document, the
 /// one explicit-name exception — see `JSONB_DOMAINS`), `public.jsonb_entry`
-/// (one sv element), `public.jsonb_query` (containment needle). The Rust
+/// (one sv element), `public.query_jsonb` (containment needle). The Rust
 /// struct *bodies* are hand-written (`crates/eql-bindings/src/v3/jsonb.rs`,
 /// not derivable from the catalog); `Domain::rust_struct_name` derives their
 /// *identifiers* (`SteVecDocument`/`SteVecEntry`/`SteVecQuery`) from
diff --git a/crates/eql-domains/src/spec.rs b/crates/eql-domains/src/spec.rs
index bb7fe8a0e..4de3d5b30 100644
--- a/crates/eql-domains/src/spec.rs
+++ b/crates/eql-domains/src/spec.rs
@@ -11,16 +11,25 @@ impl Domain {
     /// the `_` join — codegen builds every domain name through this, so the
     /// "domain name starts with the family name" rule is structural.
     ///
-    /// One documented exception: the `jsonb` family's document domain
-    /// (`public.json`, `Domain.name == "json"`) predates the catalog and
-    /// doesn't follow the family+suffix convention (`family_name` is
-    /// `"jsonb"`, not `"json"`), so its `name` is returned verbatim instead of
-    /// being joined. Every other domain — scalar or the other two SteVec
-    /// shapes — uses the join.
+    /// Two documented exceptions, both on the `jsonb` family:
+    ///
+    /// - the document domain (`public.json`, `Domain.name == "json"`) predates
+    ///   the catalog and doesn't follow the family+suffix convention
+    ///   (`family_name` is `"jsonb"`, not `"json"`), so its `name` is returned
+    ///   verbatim instead of being joined;
+    /// - the containment needle (`Domain.name == "query"`) follows the
+    ///   query-operand PREFIX convention (CIP-3442): `query_jsonb`, matching
+    ///   the scalar `query_<name>` twins so every query-operand type sorts
+    ///   apart from the column domains in alphabetical type listings.
+    ///
+    /// Every other domain — scalar or the SteVec entry — uses the join.
     pub fn full_name(&self, family_name: &str) -> String {
         if matches!(self.shape, crate::Shape::SteVec) && self.name == "json" {
             return self.name.to_string();
         }
+        if matches!(self.shape, crate::Shape::SteVec) && self.name == "query" {
+            return format!("query_{family_name}");
+        }
         if self.name.is_empty() {
             family_name.to_string()
         } else {
@@ -28,6 +37,18 @@ impl Domain {
         }
     }
 
+    /// The full (unqualified) name of this domain's query-operand twin under
+    /// `family_name`: the `query_` PREFIX joined to [`Self::full_name`]
+    /// (`"query_integer_eq"`). The **single** site that owns the query-twin
+    /// naming convention — codegen (SQL + bindings) builds every query-domain
+    /// name through this. A prefix (not the earlier `_query` suffix) so query
+    /// operands sort together, apart from the column domains they twin, in
+    /// alphabetical type listings such as Supabase Studio's type picker
+    /// (CIP-3442).
+    pub fn query_name(&self, family_name: &str) -> String {
+        format!("query_{}", self.full_name(family_name))
+    }
+
     /// The PascalCase Rust/TS struct identifier for this domain under
     /// `family_name`: the [`Self::full_name`] snake_case name mangled to
     /// PascalCase (`"integer_ord_ore"` -> `"IntegerOrdOre"`, storage `""` ->
@@ -159,6 +180,24 @@ mod tests {
         assert_eq!(eq.struct_ident("double"), "DoubleEq");
     }
 
+    #[test]
+    fn query_name_prefixes_the_full_name() {
+        // `query_` is a PREFIX so query twins sort apart from the column
+        // domains in alphabetical type listings (Supabase Studio — CIP-3442).
+        let eq = Domain {
+            name: "eq",
+            terms: &[Term::Hm],
+            shape: Shape::Scalar,
+        };
+        assert_eq!(eq.query_name("integer"), "query_integer_eq");
+        let ord_ore = Domain {
+            name: "ord_ore",
+            terms: &[Term::Ore],
+            shape: Shape::Scalar,
+        };
+        assert_eq!(ord_ore.query_name("timestamp"), "query_timestamp_ord_ore");
+    }
+
     #[test]
     fn scalar_families_exclude_non_scalar_families_after_jsonb_flip() {
         use crate::{scalar_families, CATALOG, JSONB};
@@ -171,16 +210,18 @@ mod tests {
     }
 
     #[test]
-    fn jsonb_domain_names_follow_the_family_suffix_convention() {
-        // Entry/query carry the same family+suffix naming as every scalar
-        // family. The document is the one documented exception — its
-        // established name `json` doesn't match the family name `jsonb`, so
-        // `full_name` returns it verbatim rather than concatenating. Real SQL
-        // names: public.json, public.jsonb_entry, public.jsonb_query.
+    fn jsonb_domain_names_follow_the_documented_conventions() {
+        // The entry carries the family+suffix naming every scalar family uses.
+        // The document is one documented exception — its established name
+        // `json` doesn't match the family name `jsonb`, so `full_name` returns
+        // it verbatim rather than concatenating. The containment needle is the
+        // other — it follows the query-operand PREFIX convention (CIP-3442),
+        // like the scalar `query_<name>` twins. Real SQL names: public.json,
+        // public.jsonb_entry, public.query_jsonb.
         use crate::JSONB;
         assert_eq!(JSONB.domain_name(&JSONB.domains[0]), "json");
         assert_eq!(JSONB.domain_name(&JSONB.domains[1]), "jsonb_entry");
-        assert_eq!(JSONB.domain_name(&JSONB.domains[2]), "jsonb_query");
+        assert_eq!(JSONB.domain_name(&JSONB.domains[2]), "query_jsonb");
     }
 
     #[test]
diff --git a/crates/eql-domains/src/tests.rs b/crates/eql-domains/src/tests.rs
index fe99c7882..01752802f 100644
--- a/crates/eql-domains/src/tests.rs
+++ b/crates/eql-domains/src/tests.rs
@@ -1244,6 +1244,14 @@ mod invariant_tests {
                 if s.name == "jsonb" && d.name == "json" {
                     continue;
                 }
+                // The jsonb containment needle follows the query-operand
+                // PREFIX convention (CIP-3442) instead: `query_<family>`,
+                // matching the scalar `query_<name>` twins — see
+                // `Domain::full_name`.
+                if s.name == "jsonb" && d.name == "query" {
+                    assert_eq!(s.domain_name(d), format!("query_{}", s.name));
+                    continue;
+                }
                 let name = s.domain_name(d);
                 assert!(
                     name == s.name || name.starts_with(&format!("{}_", s.name)),
diff --git a/docs/reference/catalog-driven-architecture.md b/docs/reference/catalog-driven-architecture.md
index 2af1100f9..749af1924 100644
--- a/docs/reference/catalog-driven-architecture.md
+++ b/docs/reference/catalog-driven-architecture.md
@@ -190,7 +190,7 @@ flowchart LR
 | `boolean` | Bool | storage-only (2-value cardinality leak → no searchable index) |
 
 **`jsonb` sits outside this classification.** It carries three domains — `public.json`
-(document), `public.jsonb_entry` (one `sv` leaf), `public.jsonb_query` (containment
+(document), `public.jsonb_entry` (one `sv` leaf), `eql_v3.query_jsonb` (containment
 needle) — each tagged `Shape::SteVec` rather than `Shape::Scalar`, with an empty flat
 `terms` list: capability lives *structurally* inside the payload (per-`sv`-leaf `hm`
 XOR `oc`), not as a family-level `Term` set. `Domain.name` (`"json"`/`"entry"`/`"query"`)
diff --git a/docs/reference/database-indexes.md b/docs/reference/database-indexes.md
index 1baa0e3ca..abe0d4068 100644
--- a/docs/reference/database-indexes.md
+++ b/docs/reference/database-indexes.md
@@ -181,11 +181,11 @@ CREATE INDEX orders_data_gin
   ON orders USING gin (eql_v3.to_ste_vec_query(data_encrypted)::jsonb jsonb_path_ops);
 ANALYZE orders;
 
-SELECT * FROM orders WHERE data_encrypted @> $1::public.jsonb_query;
+SELECT * FROM orders WHERE data_encrypted @> $1::eql_v3.query_jsonb;
 -- Bitmap Index Scan on orders_data_gin
 ```
 
-The needle must be typed — `$1::public.jsonb_query`, another `public.json`, or an `public.jsonb_entry`. A bare untyped literal falls through to native `jsonb @>`.
+The needle must be typed — `$1::eql_v3.query_jsonb`, another `public.json`, or an `public.jsonb_entry`. A bare untyped literal falls through to native `jsonb @>`.
 
 ### GIN vs B-tree / hash
 
diff --git a/docs/reference/json-support.md b/docs/reference/json-support.md
index 2f1b9e6d7..0bf217c57 100644
--- a/docs/reference/json-support.md
+++ b/docs/reference/json-support.md
@@ -43,7 +43,7 @@ Always give the operand a known type:
 ```sql
 -- ✅ correct — typed operand resolves to the eql_v3 operator
 WHERE doc -> 'email'::text = $1
-WHERE doc @> $1::public.jsonb_query
+WHERE doc @> $1::eql_v3.query_jsonb
 WHERE doc -> $1            -- a text parameter (the CipherStash Proxy interface)
 
 -- ⚠ wrong — bare untyped literal resolves to native jsonb -> text, returns NULL
@@ -56,11 +56,11 @@ This is **intrinsic to the domain type-kind**, not a bug: the only way to remove
 
 ### Containment queries (`@>`, `<@`)
 
-`@>` tests whether the encrypted document contains a structure; `<@` is the reverse. The needle must be **typed** — another `public.json`, an `public.jsonb_query`, or an `public.jsonb_entry`:
+`@>` tests whether the encrypted document contains a structure; `<@` is the reverse. The needle must be **typed** — another `public.json`, an `eql_v3.query_jsonb`, or an `public.jsonb_entry`:
 
 ```sql
 SELECT * FROM examples
-WHERE encrypted_json @> $1::public.jsonb_query;
+WHERE encrypted_json @> $1::eql_v3.query_jsonb;
 ```
 
 This is the encrypted equivalent of the plaintext `jsonb_column @> '{"top":{"nested":["a"]}}'`.
@@ -72,7 +72,7 @@ CREATE INDEX examples_json_gin
   ON examples USING gin (eql_v3.to_ste_vec_query(encrypted_json)::jsonb jsonb_path_ops);
 ANALYZE examples;
 
-SELECT * FROM examples WHERE encrypted_json @> $1::public.jsonb_query;
+SELECT * FROM examples WHERE encrypted_json @> $1::eql_v3.query_jsonb;
 ```
 
 See [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment) for the full setup.
@@ -145,7 +145,7 @@ GROUP BY eql_v3.eq_term(encrypted_json -> 'color_selector'::text);
 
 - **`eql_v3.ste_vec(val jsonb) RETURNS jsonb[]`** — extracts the ste_vec index array from an encrypted payload.
 - **`eql_v3.ste_vec_contains(a public.json, b public.json) RETURNS boolean`** — true if all ste_vec terms in `b` exist in `a`; backs the `@>` operator.
-- **`eql_v3.to_ste_vec_query(val public.json) RETURNS public.jsonb_query`** — the GIN-indexable query shape `@>` inlines to.
+- **`eql_v3.to_ste_vec_query(val public.json) RETURNS eql_v3.query_jsonb`** — the GIN-indexable query shape `@>` inlines to.
 - **`eql_v3.meta_data(val jsonb)`**, **`eql_v3.ciphertext(val jsonb)`**, **`eql_v3.selector(val jsonb)` / `(entry public.jsonb_entry)`** — envelope / ciphertext / selector accessors.
 
 ### Path query functions
@@ -197,7 +197,7 @@ Structured Encryption (ste_vec) makes a JSONB document searchable by:
 
 ```sql
 -- Find records where account.email = "alice@example.com"
-WHERE encrypted_data @> $1::public.jsonb_query;
+WHERE encrypted_data @> $1::eql_v3.query_jsonb;
 ```
 
 Encryption and selector generation are handled by CipherStash Proxy or CipherStash Stack, not by EQL directly.
diff --git a/docs/reference/permissions.md b/docs/reference/permissions.md
index 23c9d0ee8..88ca3128b 100644
--- a/docs/reference/permissions.md
+++ b/docs/reference/permissions.md
@@ -60,6 +60,7 @@ needs `USAGE` on it anyway. The exact requirement is path-dependent:
 | jsonb containment read (`@>` `<@` / `ste_vec_contains`) | ✅ | — | — |
 | Cast/write raw JSON → `public.json` | ✅ | ✅ | — |
 | Cast/write raw JSON → a scalar domain (`public.integer`…) | ✅ | — | — |
+| Cast a query operand → `eql_v3.query_<name>` / `eql_v3.query_jsonb` | ✅ | — | — |
 
 Why the internal grant is needed even though you only call public objects:
 
@@ -73,7 +74,7 @@ Why the internal grant is needed even though you only call public objects:
 - The **ORE comparison** behind ordering and `MIN`/`MAX` calls pgcrypto
   `encrypt()`, which the installer places in the `extensions` schema — hence the
   `USAGE` there.
-- **Casting raw jsonb to `public.json` or `public.jsonb_query`** fires a
+- **Casting raw jsonb to `public.json` or `eql_v3.query_jsonb`** fires a
   domain `CHECK` that calls an `eql_v3_internal.is_valid_*` validator. (Scalar
   domain CHECKs — and, since issue #354, the `public.jsonb_entry` CHECK — are
   pure structural jsonb tests, so casting to those domains needs no internal
diff --git a/docs/reference/sql-support.md b/docs/reference/sql-support.md
index 044f7d164..a48d03572 100644
--- a/docs/reference/sql-support.md
+++ b/docs/reference/sql-support.md
@@ -136,7 +136,7 @@ The search capabilities available on a value extracted via `->` or `eql_v3.jsonb
 
 | SQL form                         | Resolves to                                        | Returns / notes |
 | -------------------------------- | -------------------------------------------------- | --------------- |
-| `doc @> needle` / `needle <@ doc` | `eql_v3."@>"` / `eql_v3."<@"`                      | document containment; GIN-indexable via `eql_v3.to_ste_vec_query(doc)::jsonb` — see [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment). `needle` must be typed (`$1::public.jsonb_query`, another `public.json`, or an `public.jsonb_entry`). |
+| `doc @> needle` / `needle <@ doc` | `eql_v3."@>"` / `eql_v3."<@"`                      | document containment; GIN-indexable via `eql_v3.to_ste_vec_query(doc)::jsonb` — see [GIN Indexes for JSONB Containment](./database-indexes.md#gin-indexes-for-jsonb-containment). `needle` must be typed (`$1::eql_v3.query_jsonb`, another `public.json`, or an `public.jsonb_entry`). |
 | `doc -> 'sel'::text` / `doc -> N` | `eql_v3."->"`                                     | field / 0-based array-element access; returns `public.jsonb_entry`. |
 | `doc ->> 'sel'::text`            | `eql_v3."->>"`                                     | the matching entry serialized as `text` (ciphertext JSON, **not** decrypted plaintext). |
 | extracted-leaf `=` `<>`          | `eql_v3.eq_term(public.jsonb_entry)`             | equality on a value extracted via `->` (e.g. `doc -> 'sel'::text = $1`). |
@@ -145,7 +145,7 @@ The search capabilities available on a value extracted via `->` or `eql_v3.jsonb
 | `eql_v3.jsonb_path_query(doc, sel)` | path query                                      | set-returning; yields encrypted entries. Also `jsonb_path_query_first`, `jsonb_path_exists`. |
 | `eql_v3.jsonb_array_length/elements/elements_text(doc)` | array helpers                  | length / set-returning elements / element text. |
 
-> **Typed operands (important).** The selector / needle operand must carry a **known type** — a typed parameter (`$1`, which the Proxy supplies) or an explicit cast (`doc -> 'sel'::text`, `$1::public.jsonb_query`). A bare untyped literal (`doc -> 'sel'`) resolves to the **native `jsonb` operator** (PostgreSQL reduces the `public.json` domain to its `jsonb` base type for an unknown-typed RHS) and silently returns native jsonb semantics instead of the encrypted operator.
+> **Typed operands (important).** The selector / needle operand must carry a **known type** — a typed parameter (`$1`, which the Proxy supplies) or an explicit cast (`doc -> 'sel'::text`, `$1::eql_v3.query_jsonb`). A bare untyped literal (`doc -> 'sel'`) resolves to the **native `jsonb` operator** (PostgreSQL reduces the `public.json` domain to its `jsonb` base type for an unknown-typed RHS) and silently returns native jsonb semantics instead of the encrypted operator.
 
 ### Blocked JSONB operators
 
diff --git a/docs/tutorials/proxy-configuration.md b/docs/tutorials/proxy-configuration.md
index 58003918e..7b4ddd9a8 100644
--- a/docs/tutorials/proxy-configuration.md
+++ b/docs/tutorials/proxy-configuration.md
@@ -102,7 +102,7 @@ SELECT * FROM users WHERE encrypted_name @> $1::public.text_match;
 **Encrypted JSON** (`public.json`) — containment and field access; see [EQL with JSON and JSONB](../reference/json-support.md):
 
 ```sql
-SELECT * FROM users WHERE encrypted_profile @> $1::public.jsonb_query;
+SELECT * FROM users WHERE encrypted_profile @> $1::eql_v3.query_jsonb;
 SELECT encrypted_profile -> 'email_selector'::text FROM users;
 ```
 
@@ -118,7 +118,7 @@ SELECT encrypted_profile -> 'email_selector'::text FROM users;
 
 ## Troubleshooting
 
-**Operator resolves to native `jsonb` / returns `NULL` instead of searching.** The query operand was an untyped literal, so PostgreSQL flattened the `eql_v3` domain to `jsonb`. Type the operand (`$1::public.text_eq`, `$1::public.jsonb_query`) — the Proxy does this automatically.
+**Operator resolves to native `jsonb` / returns `NULL` instead of searching.** The query operand was an untyped literal, so PostgreSQL flattened the `eql_v3` domain to `jsonb`. Type the operand (`$1::public.text_eq`, `$1::eql_v3.query_jsonb`) — the Proxy does this automatically.
 
 **`=` returns no rows.** The column's values do not carry an `hm` equality term. Confirm the client is configured to emit the right term for the column's variant (step 2), and that data was written through the Proxy after configuring it.
 
diff --git a/docs/upgrading/v3.0.md b/docs/upgrading/v3.0.md
index 6fefc1f2f..7772cf6cb 100644
--- a/docs/upgrading/v3.0.md
+++ b/docs/upgrading/v3.0.md
@@ -8,12 +8,14 @@ release is prepared.
 ## TL;DR
 
 1. **The `eql_v3` JSON envelope version is now `v: 3`** ([U-001](#u-001-eql_v3-payloads-carry-v-3)). Every `eql_v3` domain `CHECK` pins `VALUE->>'v' = '3'`, and the published payload bindings (Rust / TypeScript / JSON Schema) accept exactly `3`. Payloads carrying the legacy `v: 2` are rejected on insert or cast.
+2. **Query-operand domains are `eql_v3.query_<name>`** ([U-002](#u-002-query-operand-domains-are-eql_v3query_name)). Renamed from the `_query` suffix to a `query_` prefix AND moved from `public` into the `eql_v3` schema: `public.integer_eq_query` → `eql_v3.query_integer_eq`, and the encrypted-JSONB containment needle `public.jsonb_query` → `eql_v3.query_jsonb`. Only affects 3.0.0 pre-release adopters — the old names never shipped in a final release.
 
 ## Compatibility
 
 | Component | Status |
 | --- | --- |
-| `eql_v3` schema name, domain names, operator names | **Unchanged.** |
+| `eql_v3` schema name, column-domain names, operator names | **Unchanged.** |
+| Query-operand domains (`public.<name>_query`, `public.jsonb_query` — 3.0.0 pre-releases only) | **Changed.** Now `eql_v3.query_<name>` / `eql_v3.query_jsonb` — see U-002. |
 | `eql_v3` payload envelope version (`v`) | **Changed.** `2` → `3`. Re-encryption / re-emission with a v3-envelope client required — see U-001. |
 | `eql_v3` payload term keys (`hm` / `ob` / `bf`, new `op`) | **Unchanged** (additive `op`). |
 | Legacy `eql_v2` wire documentation (`docs/reference/schema/eql-payload-v2.*.schema.json`) | **Unchanged.** Stays `v: 2`. |
@@ -50,3 +52,63 @@ SELECT '{"v":2,"i":{},"c":"x","hm":"aa"}'::jsonb::public.text_eq;
 -- Must succeed:
 SELECT '{"v":3,"i":{},"c":"x","hm":"aa"}'::jsonb::public.text_eq;
 ```
+
+### U-002: Query-operand domains are `eql_v3.query_<name>`
+
+**What changed.** The query-operand domains — the index-terms-only twins a
+client casts query parameters to — changed identity in two coordinated ways
+relative to the 3.0.0 pre-releases:
+
+1. **Named with a `query_` PREFIX** instead of the `_query` suffix:
+   `query_integer_eq`, `query_text_ord`, …, and `query_jsonb` for the
+   encrypted-JSONB containment needle (was `jsonb_query`).
+2. **Moved from `public` into the `eql_v3` schema**: `eql_v3.query_integer_eq`,
+   `eql_v3.query_jsonb`, ….
+
+The old names never shipped in a final release. The column-type domains
+(`public.integer_eq`, `public.json`, `public.jsonb_entry`, …) are unchanged —
+they stay in `public` so dropping EQL-owned schemas can never drop an
+application column.
+
+**Why.** A query operand is never a valid column type, so it doesn't belong in
+the column-type namespace: in `public` the operands interleaved with the
+actual column types in alphabetical type listings (most visibly Supabase
+Studio's Table Builder type picker), and the survive-schema-drop rationale for
+`public` placement doesn't apply to a type no application column should use.
+In `eql_v3` the operands are versioned and uninstalled with the rest of the
+public API surface, and the `query_` prefix keeps them sorted together
+wherever they are listed.
+
+**Who is affected.** Only adopters of the 3.0.0 pre-releases. Any SQL casting
+to a pre-release query domain (`WHERE col = $1::public.integer_eq_query`,
+`WHERE doc @> $1::public.jsonb_query`), and any client resolving the
+`eql-bindings` query domains by name (`QueryPayload::parse("integer_eq_query", …)`,
+the `schema/v3/*_query.json` JSON Schema files).
+
+**What to do.**
+
+- Rename the casts: `$1::eql_v3.query_integer_eq`, `$1::eql_v3.query_jsonb`.
+- Update `eql-bindings` to the matching release (the
+  `DomainType::sql_domain` strings, `QueryPayload::parse` names, and JSON
+  Schema file names follow the new convention).
+- Grants: casting to an `eql_v3` domain requires `USAGE ON SCHEMA eql_v3` —
+  the same grant a querying role already needs for the extractors and
+  comparison wrappers (see `docs/reference/permissions.md`), so no new grant
+  is expected in practice.
+- Audit for misuse: if any table column was declared with a pre-release
+  query-operand type, move it to the matching storage domain — from 3.0.0 the
+  uninstaller's `DROP SCHEMA eql_v3 CASCADE` drops query-operand-typed
+  columns with the schema.
+- GIN containment indexes built over `eql_v3.to_ste_vec_query(col)` are
+  unaffected — the function name is unchanged; only the domain type moved.
+
+**Verification.**
+
+```sql
+-- Must succeed (the relocated operand domains exist):
+SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::eql_v3.query_text_eq;
+SELECT '{"sv":[{"s":"aa","hm":"bb"}]}'::jsonb::eql_v3.query_jsonb;
+-- Must fail with "type does not exist" (the pre-release names are gone):
+SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::public.text_eq_query;
+SELECT '{"v":3,"i":{},"hm":"aa"}'::jsonb::public.query_text_eq;
+```
diff --git a/src/v3/jsonb/operators.sql b/src/v3/jsonb/operators.sql
index 7e511a68b..fa7ec9319 100644
--- a/src/v3/jsonb/operators.sql
+++ b/src/v3/jsonb/operators.sql
@@ -144,15 +144,15 @@ CREATE OPERATOR @>(
   RIGHTARG=public.json
 );
 
---! @brief @> contains operator with an jsonb_query needle.
+--! @brief @> contains operator with an query_jsonb needle.
 --!
 --! Inlines to native `jsonb @>` over `eql_v3.to_ste_vec_query(a)::jsonb`, so a
 --! functional GIN index on the same expression engages.
 --!
 --! @param a public.json Container.
---! @param b public.jsonb_query Query payload.
+--! @param b eql_v3.query_jsonb Query payload.
 --! @return boolean True if a contains b.
-CREATE FUNCTION eql_v3."@>"(a public.json, b public.jsonb_query)
+CREATE FUNCTION eql_v3."@>"(a public.json, b eql_v3.query_jsonb)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -162,7 +162,7 @@ $$;
 CREATE OPERATOR @>(
   FUNCTION=eql_v3."@>",
   LEFTARG=public.json,
-  RIGHTARG=public.jsonb_query
+  RIGHTARG=eql_v3.query_jsonb
 );
 
 --! @brief @> contains operator with a single jsonb_entry needle.
@@ -219,11 +219,11 @@ CREATE OPERATOR <@(
   RIGHTARG=public.json
 );
 
---! @brief <@ contained-by operator with an jsonb_query LHS.
---! @param a public.jsonb_query Query payload.
+--! @brief <@ contained-by operator with an query_jsonb LHS.
+--! @param a eql_v3.query_jsonb Query payload.
 --! @param b public.json Container.
 --! @return boolean True if b contains a.
-CREATE FUNCTION eql_v3."<@"(a public.jsonb_query, b public.json)
+CREATE FUNCTION eql_v3."<@"(a eql_v3.query_jsonb, b public.json)
 RETURNS boolean
 LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE
 AS $$
@@ -232,7 +232,7 @@ $$;
 
 CREATE OPERATOR <@(
   FUNCTION=eql_v3."<@",
-  LEFTARG=public.jsonb_query,
+  LEFTARG=eql_v3.query_jsonb,
   RIGHTARG=public.json
 );
 
diff --git a/src/v3/jsonb/types.sql b/src/v3/jsonb/types.sql
index e1200a540..89b822981 100644
--- a/src/v3/jsonb/types.sql
+++ b/src/v3/jsonb/types.sql
@@ -8,7 +8,7 @@
 --! blockers.sql can attach):
 --!   - public.json     — storage/root: an EQL envelope object ({i, v, ...}).
 --!   - public.jsonb_entry — a single sv element (returned by `->`).
---!   - public.jsonb_query  — a containment needle (sv elements, no ciphertext).
+--!   - eql_v3.query_jsonb  — a containment needle (sv elements, no ciphertext).
 
 --! @brief Validate a single SteVec entry payload.
 --! @internal
@@ -39,7 +39,7 @@ $$;
 --!         string `s`, no ciphertext, and exactly one string term (`hm` XOR
 --!         `oc`).
 --! @note plpgsql, not LANGUAGE sql (issues #353/#354): the only caller is the
---!   public.jsonb_query domain CHECK, where a SQL function can never be
+--!   eql_v3.query_jsonb domain CHECK, where a SQL function can never be
 --!   inlined (and the CHECK itself cannot absorb this body — it needs a
 --!   subquery over the sv elements, which CHECK constraints forbid). plpgsql
 --!   caches its plan across calls instead of paying the per-call SQL-function
@@ -188,7 +188,7 @@ $$;
 --! `jsonb @>`.
 --!
 --! @note Construct from inline JSON via the DOMAIN cast:
---!       `'{"sv":[{"s":"<sel>","hm":"<hm>"}]}'::public.jsonb_query`.
+--!       `'{"sv":[{"s":"<sel>","hm":"<hm>"}]}'::eql_v3.query_jsonb`.
 --! @see eql_v3.to_ste_vec_query
 --!
 --! @internal
@@ -199,25 +199,25 @@ $$;
 --! plan; substantially cheaper per call than a non-inlined LANGUAGE sql
 --! function — the same finding as issue #353), since this cast sits on the
 --! per-query hot path of every containment scenario
---! (`$1::jsonb::public.jsonb_query`).
+--! (`$1::jsonb::eql_v3.query_jsonb`).
 --! @endinternal
 DO $$
 BEGIN
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'jsonb_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_jsonb' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.jsonb_query AS jsonb
+    CREATE DOMAIN eql_v3.query_jsonb AS jsonb
       CHECK (
         public.eql_v3_is_valid_ste_vec_query_payload(VALUE)
       );
   END IF;
 
-  COMMENT ON DOMAIN public.jsonb_query IS 'EQL JSONB query operand (containment)';
+  COMMENT ON DOMAIN eql_v3.query_jsonb IS 'EQL JSONB query operand (containment)';
 END
 $$;
 
---! @brief Convert a public.json to a jsonb_query needle.
+--! @brief Convert a public.json to a query_jsonb needle.
 --!
 --! Normalises each sv element down to the matching-relevant fields: `s` plus
 --! exactly one of `hm` / `oc`. Other fields (`c`, `a`, `i`/`v`, anything else)
@@ -226,10 +226,10 @@ $$;
 --!   `GIN (eql_v3.to_ste_vec_query(col)::jsonb jsonb_path_ops)`.
 --!
 --! @param e public.json Source encrypted payload
---! @return public.jsonb_query Query-shaped needle, sv elements normalised.
---! @see public.jsonb_query
+--! @return eql_v3.query_jsonb Query-shaped needle, sv elements normalised.
+--! @see eql_v3.query_jsonb
 CREATE FUNCTION eql_v3.to_ste_vec_query(e public.json)
-  RETURNS public.jsonb_query
+  RETURNS eql_v3.query_jsonb
   LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$
   SELECT jsonb_build_object(
@@ -247,9 +247,9 @@ AS $$
        FROM jsonb_array_elements(e::jsonb -> 'sv') AS elem),
       '[]'::jsonb
     )
-  )::public.jsonb_query
+  )::eql_v3.query_jsonb
 $$;
 
-CREATE CAST (public.json AS public.jsonb_query)
+CREATE CAST (public.json AS eql_v3.query_jsonb)
   WITH FUNCTION eql_v3.to_ste_vec_query
   AS ASSIGNMENT;
diff --git a/src/v3/scalars/bigint/bigint_eq_query_functions.sql b/src/v3/scalars/bigint/query_bigint_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/bigint/bigint_eq_query_functions.sql
rename to src/v3/scalars/bigint/query_bigint_eq_functions.sql
index 592d291e0..c6673878a 100644
--- a/src/v3/scalars/bigint/bigint_eq_query_functions.sql
+++ b/src/v3/scalars/bigint/query_bigint_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
 -- REQUIRE: src/v3/scalars/bigint/bigint_eq_functions.sql
 
---! @file encrypted_domain/bigint/bigint_eq_query_functions.sql
---! @brief Functions for public.bigint_eq_query.
+--! @file encrypted_domain/bigint/query_bigint_eq_functions.sql
+--! @brief Functions for eql_v3.query_bigint_eq.
 
---! @brief Index extractor for public.bigint_eq_query.
---! @param a public.bigint_eq_query
+--! @brief Index extractor for eql_v3.query_bigint_eq.
+--! @param a eql_v3.query_bigint_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.bigint_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_bigint_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.bigint_eq_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_eq.
 --! @param a public.bigint_eq
---! @param b public.bigint_eq_query
+--! @param b eql_v3.query_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b public.bigint_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.bigint_eq, b eql_v3.query_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_eq_query.
---! @param a public.bigint_eq_query
+--! @brief Operator wrapper for eql_v3.query_bigint_eq.
+--! @param a eql_v3.query_bigint_eq
 --! @param b public.bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_eq_query, b public.bigint_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_eq, b public.bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_eq_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_eq.
 --! @param a public.bigint_eq
---! @param b public.bigint_eq_query
+--! @param b eql_v3.query_bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b public.bigint_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.bigint_eq, b eql_v3.query_bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_eq_query.
---! @param a public.bigint_eq_query
+--! @brief Operator wrapper for eql_v3.query_bigint_eq.
+--! @param a eql_v3.query_bigint_eq
 --! @param b public.bigint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_eq_query, b public.bigint_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_eq, b public.bigint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/double/double_eq_query_operators.sql b/src/v3/scalars/bigint/query_bigint_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/double/double_eq_query_operators.sql
rename to src/v3/scalars/bigint/query_bigint_eq_operators.sql
index 33c205ba8..9b0268c4f 100644
--- a/src/v3/scalars/double/double_eq_query_operators.sql
+++ b/src/v3/scalars/bigint/query_bigint_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
--- REQUIRE: src/v3/scalars/double/double_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_eq_functions.sql
 
---! @file encrypted_domain/double/double_eq_query_operators.sql
---! @brief Operators for public.double_eq_query.
+--! @file encrypted_domain/bigint/query_bigint_eq_operators.sql
+--! @brief Operators for eql_v3.query_bigint_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query,
+  LEFTARG = public.bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq,
+  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.bigint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_eq, RIGHTARG = public.double_eq_query,
+  LEFTARG = public.bigint_eq, RIGHTARG = eql_v3.query_bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_eq_query, RIGHTARG = public.double_eq,
+  LEFTARG = eql_v3.query_bigint_eq, RIGHTARG = public.bigint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/bigint/bigint_ord_query_functions.sql b/src/v3/scalars/bigint/query_bigint_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/bigint/bigint_ord_query_functions.sql
rename to src/v3/scalars/bigint/query_bigint_ord_functions.sql
index 0f3a31b56..a2796ba1c 100644
--- a/src/v3/scalars/bigint/bigint_ord_query_functions.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_query_functions.sql
---! @brief Functions for public.bigint_ord_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_functions.sql
+--! @brief Functions for eql_v3.query_bigint_ord.
 
---! @brief Index extractor for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Index extractor for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
 --! @param a public.bigint_ord
---! @param b public.bigint_ord_query
+--! @param b eql_v3.query_bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b public.bigint_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.bigint_ord, b eql_v3.query_bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_query.
---! @param a public.bigint_ord_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord.
+--! @param a eql_v3.query_bigint_ord
 --! @param b public.bigint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord_query, b public.bigint_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord, b public.bigint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/bigint/bigint_ord_ope_query_functions.sql b/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/bigint/bigint_ord_ope_query_functions.sql
rename to src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
index bfcd81f0c..9d7e00a36 100644
--- a/src/v3/scalars/bigint/bigint_ord_ope_query_functions.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_ope_query_functions.sql
---! @brief Functions for public.bigint_ord_ope_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_bigint_ord_ope.
 
---! @brief Index extractor for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Index extractor for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_bigint_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
 --! @param a public.bigint_ord_ope
---! @param b public.bigint_ord_ope_query
+--! @param b eql_v3.query_bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ope_query.
---! @param a public.bigint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ope.
+--! @param a eql_v3.query_bigint_ord_ope
 --! @param b public.bigint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/bigint/bigint_ord_ope_query_operators.sql b/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/bigint/bigint_ord_ope_query_operators.sql
rename to src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
index b0cd809eb..40681965c 100644
--- a/src/v3/scalars/bigint/bigint_ord_ope_query_operators.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ope_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_ope_query_operators.sql
---! @brief Operators for public.bigint_ord_ope_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_bigint_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord_ope, RIGHTARG = public.bigint_ord_ope_query,
+  LEFTARG = public.bigint_ord_ope, RIGHTARG = eql_v3.query_bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord_ope_query, RIGHTARG = public.bigint_ord_ope,
+  LEFTARG = eql_v3.query_bigint_ord_ope, RIGHTARG = public.bigint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/double/double_ord_query_operators.sql b/src/v3/scalars/bigint/query_bigint_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/double/double_ord_query_operators.sql
rename to src/v3/scalars/bigint/query_bigint_ord_operators.sql
index ebf23083d..cd11a78dc 100644
--- a/src/v3/scalars/double/double_ord_query_operators.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
--- REQUIRE: src/v3/scalars/double/double_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_functions.sql
 
---! @file encrypted_domain/double/double_ord_query_operators.sql
---! @brief Operators for public.double_ord_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_operators.sql
+--! @brief Operators for eql_v3.query_bigint_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord, RIGHTARG = public.double_ord_query,
+  LEFTARG = public.bigint_ord, RIGHTARG = eql_v3.query_bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord_query, RIGHTARG = public.double_ord,
+  LEFTARG = eql_v3.query_bigint_ord, RIGHTARG = public.bigint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/bigint/bigint_ord_ore_query_functions.sql b/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/bigint/bigint_ord_ore_query_functions.sql
rename to src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
index 98ab4bc62..f12a75b35 100644
--- a/src/v3/scalars/bigint/bigint_ord_ore_query_functions.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
 -- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_ore_query_functions.sql
---! @brief Functions for public.bigint_ord_ore_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_bigint_ord_ore.
 
---! @brief Index extractor for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Index extractor for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_bigint_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
 --! @param a public.bigint_ord_ore
---! @param b public.bigint_ord_ore_query
+--! @param b eql_v3.query_bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.bigint_ord_ore_query.
---! @param a public.bigint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_bigint_ord_ore.
+--! @param a eql_v3.query_bigint_ord_ore
 --! @param b public.bigint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/bigint/bigint_ord_ore_query_operators.sql b/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/bigint/bigint_ord_ore_query_operators.sql
rename to src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
index ad938b635..84358a8c8 100644
--- a/src/v3/scalars/bigint/bigint_ord_ore_query_operators.sql
+++ b/src/v3/scalars/bigint/query_bigint_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_types.sql
+-- REQUIRE: src/v3/scalars/bigint/query_bigint_ord_ore_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_ore_query_operators.sql
---! @brief Operators for public.bigint_ord_ore_query.
+--! @file encrypted_domain/bigint/query_bigint_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_bigint_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord_ore, RIGHTARG = public.bigint_ord_ore_query,
+  LEFTARG = public.bigint_ord_ore, RIGHTARG = eql_v3.query_bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord_ore_query, RIGHTARG = public.bigint_ord_ore,
+  LEFTARG = eql_v3.query_bigint_ord_ore, RIGHTARG = public.bigint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/bigint/bigint_query_types.sql b/src/v3/scalars/bigint/query_bigint_types.sql
similarity index 52%
rename from src/v3/scalars/bigint/bigint_query_types.sql
rename to src/v3/scalars/bigint/query_bigint_types.sql
index 6a5221e2e..e4570d506 100644
--- a/src/v3/scalars/bigint/bigint_query_types.sql
+++ b/src/v3/scalars/bigint/query_bigint_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/bigint/bigint_query_types.sql
+--! @file v3/scalars/bigint/query_bigint_types.sql
 --! @brief Query-operand domains for bigint (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.bigint_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_bigint_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.bigint_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_bigint_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'bigint_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_bigint_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.bigint_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_bigint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.bigint_eq_query IS 'EQL bigint query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_bigint_eq IS 'EQL bigint query operand (equality)';
 
-  --! @brief Query-operand domain public.bigint_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_bigint_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'bigint_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_bigint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.bigint_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_bigint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.bigint_ord_ore_query IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ore IS 'EQL bigint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.bigint_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_bigint_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'bigint_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_bigint_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.bigint_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_bigint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.bigint_ord_query IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_bigint_ord IS 'EQL bigint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.bigint_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_bigint_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'bigint_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_bigint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.bigint_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_bigint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.bigint_ord_ope_query IS 'EQL bigint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_bigint_ord_ope IS 'EQL bigint query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/date/date_eq_query_functions.sql b/src/v3/scalars/date/query_date_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/date/date_eq_query_functions.sql
rename to src/v3/scalars/date/query_date_eq_functions.sql
index fd852e89a..88f557f69 100644
--- a/src/v3/scalars/date/date_eq_query_functions.sql
+++ b/src/v3/scalars/date/query_date_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
 -- REQUIRE: src/v3/scalars/date/date_eq_functions.sql
 
---! @file encrypted_domain/date/date_eq_query_functions.sql
---! @brief Functions for public.date_eq_query.
+--! @file encrypted_domain/date/query_date_eq_functions.sql
+--! @brief Functions for eql_v3.query_date_eq.
 
---! @brief Index extractor for public.date_eq_query.
---! @param a public.date_eq_query
+--! @brief Index extractor for eql_v3.query_date_eq.
+--! @param a eql_v3.query_date_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.date_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_date_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.date_eq_query.
+--! @brief Operator wrapper for eql_v3.query_date_eq.
 --! @param a public.date_eq
---! @param b public.date_eq_query
+--! @param b eql_v3.query_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_eq, b public.date_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.date_eq, b eql_v3.query_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.date_eq_query.
---! @param a public.date_eq_query
+--! @brief Operator wrapper for eql_v3.query_date_eq.
+--! @param a eql_v3.query_date_eq
 --! @param b public.date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_eq_query, b public.date_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_eq, b public.date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.date_eq_query.
+--! @brief Operator wrapper for eql_v3.query_date_eq.
 --! @param a public.date_eq
---! @param b public.date_eq_query
+--! @param b eql_v3.query_date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_eq, b public.date_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.date_eq, b eql_v3.query_date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.date_eq_query.
---! @param a public.date_eq_query
+--! @brief Operator wrapper for eql_v3.query_date_eq.
+--! @param a eql_v3.query_date_eq
 --! @param b public.date_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_eq_query, b public.date_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_eq, b public.date_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/text/text_eq_query_operators.sql b/src/v3/scalars/date/query_date_eq_operators.sql
similarity index 53%
rename from src/v3/scalars/text/text_eq_query_operators.sql
rename to src/v3/scalars/date/query_date_eq_operators.sql
index 7fd1b6b6c..b816f1cee 100644
--- a/src/v3/scalars/text/text_eq_query_operators.sql
+++ b/src/v3/scalars/date/query_date_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_eq_functions.sql
 
---! @file encrypted_domain/text/text_eq_query_operators.sql
---! @brief Operators for public.text_eq_query.
+--! @file encrypted_domain/date/query_date_eq_operators.sql
+--! @brief Operators for eql_v3.query_date_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query,
+  LEFTARG = public.date_eq, RIGHTARG = eql_v3.query_date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq,
+  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.date_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_eq, RIGHTARG = public.text_eq_query,
+  LEFTARG = public.date_eq, RIGHTARG = eql_v3.query_date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_eq_query, RIGHTARG = public.text_eq,
+  LEFTARG = eql_v3.query_date_eq, RIGHTARG = public.date_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/date/date_ord_query_functions.sql b/src/v3/scalars/date/query_date_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/date/date_ord_query_functions.sql
rename to src/v3/scalars/date/query_date_ord_functions.sql
index 5802622d2..c3990ccda 100644
--- a/src/v3/scalars/date/date_ord_query_functions.sql
+++ b/src/v3/scalars/date/query_date_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
 -- REQUIRE: src/v3/scalars/date/date_ord_functions.sql
 
---! @file encrypted_domain/date/date_ord_query_functions.sql
---! @brief Functions for public.date_ord_query.
+--! @file encrypted_domain/date/query_date_ord_functions.sql
+--! @brief Functions for eql_v3.query_date_ord.
 
---! @brief Index extractor for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Index extractor for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.date_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord.
 --! @param a public.date_ord
---! @param b public.date_ord_query
+--! @param b eql_v3.query_date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord, b public.date_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.date_ord, b eql_v3.query_date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_query.
---! @param a public.date_ord_query
+--! @brief Operator wrapper for eql_v3.query_date_ord.
+--! @param a eql_v3.query_date_ord
 --! @param b public.date_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord_query, b public.date_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord, b public.date_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/date/date_ord_ope_query_functions.sql b/src/v3/scalars/date/query_date_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/date/date_ord_ope_query_functions.sql
rename to src/v3/scalars/date/query_date_ord_ope_functions.sql
index 458e5adc5..f2f631fae 100644
--- a/src/v3/scalars/date/date_ord_ope_query_functions.sql
+++ b/src/v3/scalars/date/query_date_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
 -- REQUIRE: src/v3/scalars/date/date_ord_ope_functions.sql
 
---! @file encrypted_domain/date/date_ord_ope_query_functions.sql
---! @brief Functions for public.date_ord_ope_query.
+--! @file encrypted_domain/date/query_date_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_date_ord_ope.
 
---! @brief Index extractor for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Index extractor for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_date_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
 --! @param a public.date_ord_ope
---! @param b public.date_ord_ope_query
+--! @param b eql_v3.query_date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ope_query.
---! @param a public.date_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ope.
+--! @param a eql_v3.query_date_ord_ope
 --! @param b public.date_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord_ope_query, b public.date_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/date/date_ord_ope_query_operators.sql b/src/v3/scalars/date/query_date_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/date/date_ord_ope_query_operators.sql
rename to src/v3/scalars/date/query_date_ord_ope_operators.sql
index 12648c7ba..5da774020 100644
--- a/src/v3/scalars/date/date_ord_ope_query_operators.sql
+++ b/src/v3/scalars/date/query_date_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
--- REQUIRE: src/v3/scalars/date/date_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_ord_ope_functions.sql
 
---! @file encrypted_domain/date/date_ord_ope_query_operators.sql
---! @brief Operators for public.date_ord_ope_query.
+--! @file encrypted_domain/date/query_date_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_date_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord_ope, RIGHTARG = public.date_ord_ope_query,
+  LEFTARG = public.date_ord_ope, RIGHTARG = eql_v3.query_date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord_ope_query, RIGHTARG = public.date_ord_ope,
+  LEFTARG = eql_v3.query_date_ord_ope, RIGHTARG = public.date_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/text/text_ord_query_operators.sql b/src/v3/scalars/date/query_date_ord_operators.sql
similarity index 61%
rename from src/v3/scalars/text/text_ord_query_operators.sql
rename to src/v3/scalars/date/query_date_ord_operators.sql
index 5cd8721ed..f55618fe4 100644
--- a/src/v3/scalars/text/text_ord_query_operators.sql
+++ b/src/v3/scalars/date/query_date_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_ord_functions.sql
 
---! @file encrypted_domain/text/text_ord_query_operators.sql
---! @brief Operators for public.text_ord_query.
+--! @file encrypted_domain/date/query_date_ord_operators.sql
+--! @brief Operators for eql_v3.query_date_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord, RIGHTARG = public.text_ord_query,
+  LEFTARG = public.date_ord, RIGHTARG = eql_v3.query_date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord_query, RIGHTARG = public.text_ord,
+  LEFTARG = eql_v3.query_date_ord, RIGHTARG = public.date_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/date/date_ord_ore_query_functions.sql b/src/v3/scalars/date/query_date_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/date/date_ord_ore_query_functions.sql
rename to src/v3/scalars/date/query_date_ord_ore_functions.sql
index 30557d02c..e89d554c8 100644
--- a/src/v3/scalars/date/date_ord_ore_query_functions.sql
+++ b/src/v3/scalars/date/query_date_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
 -- REQUIRE: src/v3/scalars/date/date_ord_ore_functions.sql
 
---! @file encrypted_domain/date/date_ord_ore_query_functions.sql
---! @brief Functions for public.date_ord_ore_query.
+--! @file encrypted_domain/date/query_date_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_date_ord_ore.
 
---! @brief Index extractor for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Index extractor for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_date_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
 --! @param a public.date_ord_ore
---! @param b public.date_ord_ore_query
+--! @param b eql_v3.query_date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.date_ord_ore_query.
---! @param a public.date_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_date_ord_ore.
+--! @param a eql_v3.query_date_ord_ore
 --! @param b public.date_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.date_ord_ore_query, b public.date_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/real/real_ord_ore_query_operators.sql b/src/v3/scalars/date/query_date_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/real/real_ord_ore_query_operators.sql
rename to src/v3/scalars/date/query_date_ord_ore_operators.sql
index 16c10fa38..0bc871590 100644
--- a/src/v3/scalars/real/real_ord_ore_query_operators.sql
+++ b/src/v3/scalars/date/query_date_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
--- REQUIRE: src/v3/scalars/real/real_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/date/query_date_types.sql
+-- REQUIRE: src/v3/scalars/date/query_date_ord_ore_functions.sql
 
---! @file encrypted_domain/real/real_ord_ore_query_operators.sql
---! @brief Operators for public.real_ord_ore_query.
+--! @file encrypted_domain/date/query_date_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_date_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord_ore, RIGHTARG = public.real_ord_ore_query,
+  LEFTARG = public.date_ord_ore, RIGHTARG = eql_v3.query_date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord_ore_query, RIGHTARG = public.real_ord_ore,
+  LEFTARG = eql_v3.query_date_ord_ore, RIGHTARG = public.date_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/date/date_query_types.sql b/src/v3/scalars/date/query_date_types.sql
similarity index 52%
rename from src/v3/scalars/date/date_query_types.sql
rename to src/v3/scalars/date/query_date_types.sql
index 1f163444a..6ba8c8f44 100644
--- a/src/v3/scalars/date/date_query_types.sql
+++ b/src/v3/scalars/date/query_date_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/date/date_query_types.sql
+--! @file v3/scalars/date/query_date_types.sql
 --! @brief Query-operand domains for date (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.date_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_date_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.date_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_date_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'date_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_date_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.date_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_date_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.date_eq_query IS 'EQL date query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_date_eq IS 'EQL date query operand (equality)';
 
-  --! @brief Query-operand domain public.date_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_date_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'date_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_date_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.date_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_date_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.date_ord_ore_query IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_date_ord_ore IS 'EQL date query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.date_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_date_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'date_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_date_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.date_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_date_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.date_ord_query IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_date_ord IS 'EQL date query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.date_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_date_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'date_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_date_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.date_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_date_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.date_ord_ope_query IS 'EQL date query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_date_ord_ope IS 'EQL date query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/double/double_eq_query_functions.sql b/src/v3/scalars/double/query_double_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/double/double_eq_query_functions.sql
rename to src/v3/scalars/double/query_double_eq_functions.sql
index a73af71db..f0c6aa0c8 100644
--- a/src/v3/scalars/double/double_eq_query_functions.sql
+++ b/src/v3/scalars/double/query_double_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
 -- REQUIRE: src/v3/scalars/double/double_eq_functions.sql
 
---! @file encrypted_domain/double/double_eq_query_functions.sql
---! @brief Functions for public.double_eq_query.
+--! @file encrypted_domain/double/query_double_eq_functions.sql
+--! @brief Functions for eql_v3.query_double_eq.
 
---! @brief Index extractor for public.double_eq_query.
---! @param a public.double_eq_query
+--! @brief Index extractor for eql_v3.query_double_eq.
+--! @param a eql_v3.query_double_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.double_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_double_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.double_eq_query.
+--! @brief Operator wrapper for eql_v3.query_double_eq.
 --! @param a public.double_eq
---! @param b public.double_eq_query
+--! @param b eql_v3.query_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_eq, b public.double_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.double_eq, b eql_v3.query_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.double_eq_query.
---! @param a public.double_eq_query
+--! @brief Operator wrapper for eql_v3.query_double_eq.
+--! @param a eql_v3.query_double_eq
 --! @param b public.double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_eq_query, b public.double_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_eq, b public.double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.double_eq_query.
+--! @brief Operator wrapper for eql_v3.query_double_eq.
 --! @param a public.double_eq
---! @param b public.double_eq_query
+--! @param b eql_v3.query_double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_eq, b public.double_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.double_eq, b eql_v3.query_double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.double_eq_query.
---! @param a public.double_eq_query
+--! @brief Operator wrapper for eql_v3.query_double_eq.
+--! @param a eql_v3.query_double_eq
 --! @param b public.double_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_eq_query, b public.double_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_eq, b public.double_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/bigint/bigint_eq_query_operators.sql b/src/v3/scalars/double/query_double_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/bigint/bigint_eq_query_operators.sql
rename to src/v3/scalars/double/query_double_eq_operators.sql
index 2b2e482da..a2d581cbe 100644
--- a/src/v3/scalars/bigint/bigint_eq_query_operators.sql
+++ b/src/v3/scalars/double/query_double_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_eq_functions.sql
 
---! @file encrypted_domain/bigint/bigint_eq_query_operators.sql
---! @brief Operators for public.bigint_eq_query.
+--! @file encrypted_domain/double/query_double_eq_operators.sql
+--! @brief Operators for eql_v3.query_double_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query,
+  LEFTARG = public.double_eq, RIGHTARG = eql_v3.query_double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq,
+  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.double_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_eq, RIGHTARG = public.bigint_eq_query,
+  LEFTARG = public.double_eq, RIGHTARG = eql_v3.query_double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_eq_query, RIGHTARG = public.bigint_eq,
+  LEFTARG = eql_v3.query_double_eq, RIGHTARG = public.double_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/double/double_ord_query_functions.sql b/src/v3/scalars/double/query_double_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/double/double_ord_query_functions.sql
rename to src/v3/scalars/double/query_double_ord_functions.sql
index 8096cb985..276a6bd24 100644
--- a/src/v3/scalars/double/double_ord_query_functions.sql
+++ b/src/v3/scalars/double/query_double_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
 -- REQUIRE: src/v3/scalars/double/double_ord_functions.sql
 
---! @file encrypted_domain/double/double_ord_query_functions.sql
---! @brief Functions for public.double_ord_query.
+--! @file encrypted_domain/double/query_double_ord_functions.sql
+--! @brief Functions for eql_v3.query_double_ord.
 
---! @brief Index extractor for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Index extractor for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.double_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord.
 --! @param a public.double_ord
---! @param b public.double_ord_query
+--! @param b eql_v3.query_double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord, b public.double_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.double_ord, b eql_v3.query_double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_query.
---! @param a public.double_ord_query
+--! @brief Operator wrapper for eql_v3.query_double_ord.
+--! @param a eql_v3.query_double_ord
 --! @param b public.double_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord_query, b public.double_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord, b public.double_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/double/double_ord_ope_query_functions.sql b/src/v3/scalars/double/query_double_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/double/double_ord_ope_query_functions.sql
rename to src/v3/scalars/double/query_double_ord_ope_functions.sql
index 6474a7d77..01e431dd6 100644
--- a/src/v3/scalars/double/double_ord_ope_query_functions.sql
+++ b/src/v3/scalars/double/query_double_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
 -- REQUIRE: src/v3/scalars/double/double_ord_ope_functions.sql
 
---! @file encrypted_domain/double/double_ord_ope_query_functions.sql
---! @brief Functions for public.double_ord_ope_query.
+--! @file encrypted_domain/double/query_double_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_double_ord_ope.
 
---! @brief Index extractor for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Index extractor for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_double_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
 --! @param a public.double_ord_ope
---! @param b public.double_ord_ope_query
+--! @param b eql_v3.query_double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ope_query.
---! @param a public.double_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ope.
+--! @param a eql_v3.query_double_ord_ope
 --! @param b public.double_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord_ope_query, b public.double_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/double/double_ord_ope_query_operators.sql b/src/v3/scalars/double/query_double_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/double/double_ord_ope_query_operators.sql
rename to src/v3/scalars/double/query_double_ord_ope_operators.sql
index 73c7adb31..ce292ca0d 100644
--- a/src/v3/scalars/double/double_ord_ope_query_operators.sql
+++ b/src/v3/scalars/double/query_double_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
--- REQUIRE: src/v3/scalars/double/double_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_ord_ope_functions.sql
 
---! @file encrypted_domain/double/double_ord_ope_query_operators.sql
---! @brief Operators for public.double_ord_ope_query.
+--! @file encrypted_domain/double/query_double_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_double_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord_ope, RIGHTARG = public.double_ord_ope_query,
+  LEFTARG = public.double_ord_ope, RIGHTARG = eql_v3.query_double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord_ope_query, RIGHTARG = public.double_ord_ope,
+  LEFTARG = eql_v3.query_double_ord_ope, RIGHTARG = public.double_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/bigint/bigint_ord_query_operators.sql b/src/v3/scalars/double/query_double_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/bigint/bigint_ord_query_operators.sql
rename to src/v3/scalars/double/query_double_ord_operators.sql
index eb9e0a3a5..8f1aa007b 100644
--- a/src/v3/scalars/bigint/bigint_ord_query_operators.sql
+++ b/src/v3/scalars/double/query_double_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_query_types.sql
--- REQUIRE: src/v3/scalars/bigint/bigint_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_ord_functions.sql
 
---! @file encrypted_domain/bigint/bigint_ord_query_operators.sql
---! @brief Operators for public.bigint_ord_query.
+--! @file encrypted_domain/double/query_double_ord_operators.sql
+--! @brief Operators for eql_v3.query_double_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord, RIGHTARG = public.bigint_ord_query,
+  LEFTARG = public.double_ord, RIGHTARG = eql_v3.query_double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.bigint_ord_query, RIGHTARG = public.bigint_ord,
+  LEFTARG = eql_v3.query_double_ord, RIGHTARG = public.double_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/double/double_ord_ore_query_functions.sql b/src/v3/scalars/double/query_double_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/double/double_ord_ore_query_functions.sql
rename to src/v3/scalars/double/query_double_ord_ore_functions.sql
index 372d0d0b8..07a345400 100644
--- a/src/v3/scalars/double/double_ord_ore_query_functions.sql
+++ b/src/v3/scalars/double/query_double_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
 -- REQUIRE: src/v3/scalars/double/double_ord_ore_functions.sql
 
---! @file encrypted_domain/double/double_ord_ore_query_functions.sql
---! @brief Functions for public.double_ord_ore_query.
+--! @file encrypted_domain/double/query_double_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_double_ord_ore.
 
---! @brief Index extractor for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Index extractor for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_double_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
 --! @param a public.double_ord_ore
---! @param b public.double_ord_ore_query
+--! @param b eql_v3.query_double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.double_ord_ore_query.
---! @param a public.double_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_double_ord_ore.
+--! @param a eql_v3.query_double_ord_ore
 --! @param b public.double_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.double_ord_ore_query, b public.double_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/double/double_ord_ore_query_operators.sql b/src/v3/scalars/double/query_double_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/double/double_ord_ore_query_operators.sql
rename to src/v3/scalars/double/query_double_ord_ore_operators.sql
index 3fcf71a85..abcb7a04e 100644
--- a/src/v3/scalars/double/double_ord_ore_query_operators.sql
+++ b/src/v3/scalars/double/query_double_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/double/double_query_types.sql
--- REQUIRE: src/v3/scalars/double/double_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/double/query_double_types.sql
+-- REQUIRE: src/v3/scalars/double/query_double_ord_ore_functions.sql
 
---! @file encrypted_domain/double/double_ord_ore_query_operators.sql
---! @brief Operators for public.double_ord_ore_query.
+--! @file encrypted_domain/double/query_double_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_double_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord_ore, RIGHTARG = public.double_ord_ore_query,
+  LEFTARG = public.double_ord_ore, RIGHTARG = eql_v3.query_double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.double_ord_ore_query, RIGHTARG = public.double_ord_ore,
+  LEFTARG = eql_v3.query_double_ord_ore, RIGHTARG = public.double_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/double/double_query_types.sql b/src/v3/scalars/double/query_double_types.sql
similarity index 52%
rename from src/v3/scalars/double/double_query_types.sql
rename to src/v3/scalars/double/query_double_types.sql
index 57ec15ef6..fa2ba08a7 100644
--- a/src/v3/scalars/double/double_query_types.sql
+++ b/src/v3/scalars/double/query_double_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/double/double_query_types.sql
+--! @file v3/scalars/double/query_double_types.sql
 --! @brief Query-operand domains for double (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.double_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_double_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.double_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_double_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'double_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_double_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.double_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_double_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.double_eq_query IS 'EQL double query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_double_eq IS 'EQL double query operand (equality)';
 
-  --! @brief Query-operand domain public.double_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_double_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'double_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_double_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.double_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_double_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.double_ord_ore_query IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_double_ord_ore IS 'EQL double query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.double_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_double_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'double_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_double_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.double_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_double_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.double_ord_query IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_double_ord IS 'EQL double query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.double_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_double_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'double_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_double_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.double_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_double_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.double_ord_ope_query IS 'EQL double query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_double_ord_ope IS 'EQL double query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/integer/integer_eq_query_functions.sql b/src/v3/scalars/integer/query_integer_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/integer/integer_eq_query_functions.sql
rename to src/v3/scalars/integer/query_integer_eq_functions.sql
index b6443c1ba..aaf29c15d 100644
--- a/src/v3/scalars/integer/integer_eq_query_functions.sql
+++ b/src/v3/scalars/integer/query_integer_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
 -- REQUIRE: src/v3/scalars/integer/integer_eq_functions.sql
 
---! @file encrypted_domain/integer/integer_eq_query_functions.sql
---! @brief Functions for public.integer_eq_query.
+--! @file encrypted_domain/integer/query_integer_eq_functions.sql
+--! @brief Functions for eql_v3.query_integer_eq.
 
---! @brief Index extractor for public.integer_eq_query.
---! @param a public.integer_eq_query
+--! @brief Index extractor for eql_v3.query_integer_eq.
+--! @param a eql_v3.query_integer_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.integer_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_integer_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.integer_eq_query.
+--! @brief Operator wrapper for eql_v3.query_integer_eq.
 --! @param a public.integer_eq
---! @param b public.integer_eq_query
+--! @param b eql_v3.query_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_eq, b public.integer_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.integer_eq, b eql_v3.query_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.integer_eq_query.
---! @param a public.integer_eq_query
+--! @brief Operator wrapper for eql_v3.query_integer_eq.
+--! @param a eql_v3.query_integer_eq
 --! @param b public.integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_eq_query, b public.integer_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_eq, b public.integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.integer_eq_query.
+--! @brief Operator wrapper for eql_v3.query_integer_eq.
 --! @param a public.integer_eq
---! @param b public.integer_eq_query
+--! @param b eql_v3.query_integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_eq, b public.integer_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.integer_eq, b eql_v3.query_integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.integer_eq_query.
---! @param a public.integer_eq_query
+--! @brief Operator wrapper for eql_v3.query_integer_eq.
+--! @param a eql_v3.query_integer_eq
 --! @param b public.integer_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_eq_query, b public.integer_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_eq, b public.integer_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/numeric/numeric_eq_query_operators.sql b/src/v3/scalars/integer/query_integer_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/numeric/numeric_eq_query_operators.sql
rename to src/v3/scalars/integer/query_integer_eq_operators.sql
index c0a27401b..b85365b19 100644
--- a/src/v3/scalars/numeric/numeric_eq_query_operators.sql
+++ b/src/v3/scalars/integer/query_integer_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_eq_functions.sql
 
---! @file encrypted_domain/numeric/numeric_eq_query_operators.sql
---! @brief Operators for public.numeric_eq_query.
+--! @file encrypted_domain/integer/query_integer_eq_operators.sql
+--! @brief Operators for eql_v3.query_integer_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query,
+  LEFTARG = public.integer_eq, RIGHTARG = eql_v3.query_integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq,
+  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.integer_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_eq, RIGHTARG = public.numeric_eq_query,
+  LEFTARG = public.integer_eq, RIGHTARG = eql_v3.query_integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_eq_query, RIGHTARG = public.numeric_eq,
+  LEFTARG = eql_v3.query_integer_eq, RIGHTARG = public.integer_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/integer/integer_ord_query_functions.sql b/src/v3/scalars/integer/query_integer_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/integer/integer_ord_query_functions.sql
rename to src/v3/scalars/integer/query_integer_ord_functions.sql
index 1aa56ca0a..8f75fcd04 100644
--- a/src/v3/scalars/integer/integer_ord_query_functions.sql
+++ b/src/v3/scalars/integer/query_integer_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
 -- REQUIRE: src/v3/scalars/integer/integer_ord_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_query_functions.sql
---! @brief Functions for public.integer_ord_query.
+--! @file encrypted_domain/integer/query_integer_ord_functions.sql
+--! @brief Functions for eql_v3.query_integer_ord.
 
---! @brief Index extractor for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Index extractor for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
 --! @param a public.integer_ord
---! @param b public.integer_ord_query
+--! @param b eql_v3.query_integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord, b public.integer_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.integer_ord, b eql_v3.query_integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_query.
---! @param a public.integer_ord_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord.
+--! @param a eql_v3.query_integer_ord
 --! @param b public.integer_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord_query, b public.integer_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord, b public.integer_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/integer/integer_ord_ope_query_functions.sql b/src/v3/scalars/integer/query_integer_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/integer/integer_ord_ope_query_functions.sql
rename to src/v3/scalars/integer/query_integer_ord_ope_functions.sql
index 292ccce18..59e5a97ca 100644
--- a/src/v3/scalars/integer/integer_ord_ope_query_functions.sql
+++ b/src/v3/scalars/integer/query_integer_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ope_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_ope_query_functions.sql
---! @brief Functions for public.integer_ord_ope_query.
+--! @file encrypted_domain/integer/query_integer_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_integer_ord_ope.
 
---! @brief Index extractor for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Index extractor for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_integer_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
 --! @param a public.integer_ord_ope
---! @param b public.integer_ord_ope_query
+--! @param b eql_v3.query_integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ope_query.
---! @param a public.integer_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ope.
+--! @param a eql_v3.query_integer_ord_ope
 --! @param b public.integer_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord_ope_query, b public.integer_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/integer/integer_ord_ope_query_operators.sql b/src/v3/scalars/integer/query_integer_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/integer/integer_ord_ope_query_operators.sql
rename to src/v3/scalars/integer/query_integer_ord_ope_operators.sql
index 083420371..1e6ca6c70 100644
--- a/src/v3/scalars/integer/integer_ord_ope_query_operators.sql
+++ b/src/v3/scalars/integer/query_integer_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
--- REQUIRE: src/v3/scalars/integer/integer_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_ord_ope_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_ope_query_operators.sql
---! @brief Operators for public.integer_ord_ope_query.
+--! @file encrypted_domain/integer/query_integer_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_integer_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord_ope, RIGHTARG = public.integer_ord_ope_query,
+  LEFTARG = public.integer_ord_ope, RIGHTARG = eql_v3.query_integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord_ope_query, RIGHTARG = public.integer_ord_ope,
+  LEFTARG = eql_v3.query_integer_ord_ope, RIGHTARG = public.integer_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/numeric/numeric_ord_query_operators.sql b/src/v3/scalars/integer/query_integer_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/numeric/numeric_ord_query_operators.sql
rename to src/v3/scalars/integer/query_integer_ord_operators.sql
index e16290705..040676bcc 100644
--- a/src/v3/scalars/numeric/numeric_ord_query_operators.sql
+++ b/src/v3/scalars/integer/query_integer_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_ord_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_query_operators.sql
---! @brief Operators for public.numeric_ord_query.
+--! @file encrypted_domain/integer/query_integer_ord_operators.sql
+--! @brief Operators for eql_v3.query_integer_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord, RIGHTARG = public.numeric_ord_query,
+  LEFTARG = public.integer_ord, RIGHTARG = eql_v3.query_integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord_query, RIGHTARG = public.numeric_ord,
+  LEFTARG = eql_v3.query_integer_ord, RIGHTARG = public.integer_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/integer/integer_ord_ore_query_functions.sql b/src/v3/scalars/integer/query_integer_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/integer/integer_ord_ore_query_functions.sql
rename to src/v3/scalars/integer/query_integer_ord_ore_functions.sql
index 288a77dea..d9a388cae 100644
--- a/src/v3/scalars/integer/integer_ord_ore_query_functions.sql
+++ b/src/v3/scalars/integer/query_integer_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
 -- REQUIRE: src/v3/scalars/integer/integer_ord_ore_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_ore_query_functions.sql
---! @brief Functions for public.integer_ord_ore_query.
+--! @file encrypted_domain/integer/query_integer_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_integer_ord_ore.
 
---! @brief Index extractor for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Index extractor for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_integer_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
 --! @param a public.integer_ord_ore
---! @param b public.integer_ord_ore_query
+--! @param b eql_v3.query_integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.integer_ord_ore_query.
---! @param a public.integer_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_integer_ord_ore.
+--! @param a eql_v3.query_integer_ord_ore
 --! @param b public.integer_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.integer_ord_ore_query, b public.integer_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/integer/integer_ord_ore_query_operators.sql b/src/v3/scalars/integer/query_integer_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/integer/integer_ord_ore_query_operators.sql
rename to src/v3/scalars/integer/query_integer_ord_ore_operators.sql
index 1646eb223..4190c3f82 100644
--- a/src/v3/scalars/integer/integer_ord_ore_query_operators.sql
+++ b/src/v3/scalars/integer/query_integer_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
--- REQUIRE: src/v3/scalars/integer/integer_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_types.sql
+-- REQUIRE: src/v3/scalars/integer/query_integer_ord_ore_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_ore_query_operators.sql
---! @brief Operators for public.integer_ord_ore_query.
+--! @file encrypted_domain/integer/query_integer_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_integer_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord_ore, RIGHTARG = public.integer_ord_ore_query,
+  LEFTARG = public.integer_ord_ore, RIGHTARG = eql_v3.query_integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord_ore_query, RIGHTARG = public.integer_ord_ore,
+  LEFTARG = eql_v3.query_integer_ord_ore, RIGHTARG = public.integer_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/integer/integer_query_types.sql b/src/v3/scalars/integer/query_integer_types.sql
similarity index 52%
rename from src/v3/scalars/integer/integer_query_types.sql
rename to src/v3/scalars/integer/query_integer_types.sql
index baaffea4a..a736fc2ad 100644
--- a/src/v3/scalars/integer/integer_query_types.sql
+++ b/src/v3/scalars/integer/query_integer_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/integer/integer_query_types.sql
+--! @file v3/scalars/integer/query_integer_types.sql
 --! @brief Query-operand domains for integer (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.integer_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_integer_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.integer_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_integer_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'integer_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_integer_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.integer_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_integer_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.integer_eq_query IS 'EQL integer query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_integer_eq IS 'EQL integer query operand (equality)';
 
-  --! @brief Query-operand domain public.integer_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_integer_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'integer_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_integer_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.integer_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_integer_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.integer_ord_ore_query IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_integer_ord_ore IS 'EQL integer query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.integer_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_integer_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'integer_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_integer_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.integer_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_integer_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.integer_ord_query IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_integer_ord IS 'EQL integer query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.integer_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_integer_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'integer_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_integer_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.integer_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_integer_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.integer_ord_ope_query IS 'EQL integer query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_integer_ord_ope IS 'EQL integer query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/numeric/numeric_eq_query_functions.sql b/src/v3/scalars/numeric/query_numeric_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/numeric/numeric_eq_query_functions.sql
rename to src/v3/scalars/numeric/query_numeric_eq_functions.sql
index a94e23f3d..870c43157 100644
--- a/src/v3/scalars/numeric/numeric_eq_query_functions.sql
+++ b/src/v3/scalars/numeric/query_numeric_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
 -- REQUIRE: src/v3/scalars/numeric/numeric_eq_functions.sql
 
---! @file encrypted_domain/numeric/numeric_eq_query_functions.sql
---! @brief Functions for public.numeric_eq_query.
+--! @file encrypted_domain/numeric/query_numeric_eq_functions.sql
+--! @brief Functions for eql_v3.query_numeric_eq.
 
---! @brief Index extractor for public.numeric_eq_query.
---! @param a public.numeric_eq_query
+--! @brief Index extractor for eql_v3.query_numeric_eq.
+--! @param a eql_v3.query_numeric_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.numeric_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_numeric_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.numeric_eq_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_eq.
 --! @param a public.numeric_eq
---! @param b public.numeric_eq_query
+--! @param b eql_v3.query_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b public.numeric_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.numeric_eq, b eql_v3.query_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_eq_query.
---! @param a public.numeric_eq_query
+--! @brief Operator wrapper for eql_v3.query_numeric_eq.
+--! @param a eql_v3.query_numeric_eq
 --! @param b public.numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_eq_query, b public.numeric_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_eq, b public.numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_eq_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_eq.
 --! @param a public.numeric_eq
---! @param b public.numeric_eq_query
+--! @param b eql_v3.query_numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b public.numeric_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.numeric_eq, b eql_v3.query_numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_eq_query.
---! @param a public.numeric_eq_query
+--! @brief Operator wrapper for eql_v3.query_numeric_eq.
+--! @param a eql_v3.query_numeric_eq
 --! @param b public.numeric_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_eq_query, b public.numeric_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_eq, b public.numeric_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/integer/integer_eq_query_operators.sql b/src/v3/scalars/numeric/query_numeric_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/integer/integer_eq_query_operators.sql
rename to src/v3/scalars/numeric/query_numeric_eq_operators.sql
index e2bdc0aa9..6d2b56196 100644
--- a/src/v3/scalars/integer/integer_eq_query_operators.sql
+++ b/src/v3/scalars/numeric/query_numeric_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
--- REQUIRE: src/v3/scalars/integer/integer_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_eq_functions.sql
 
---! @file encrypted_domain/integer/integer_eq_query_operators.sql
---! @brief Operators for public.integer_eq_query.
+--! @file encrypted_domain/numeric/query_numeric_eq_operators.sql
+--! @brief Operators for eql_v3.query_numeric_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query,
+  LEFTARG = public.numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq,
+  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.numeric_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_eq, RIGHTARG = public.integer_eq_query,
+  LEFTARG = public.numeric_eq, RIGHTARG = eql_v3.query_numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_eq_query, RIGHTARG = public.integer_eq,
+  LEFTARG = eql_v3.query_numeric_eq, RIGHTARG = public.numeric_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/numeric/numeric_ord_query_functions.sql b/src/v3/scalars/numeric/query_numeric_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/numeric/numeric_ord_query_functions.sql
rename to src/v3/scalars/numeric/query_numeric_ord_functions.sql
index f88fd2cf4..7b81fd20e 100644
--- a/src/v3/scalars/numeric/numeric_ord_query_functions.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_query_functions.sql
---! @brief Functions for public.numeric_ord_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_functions.sql
+--! @brief Functions for eql_v3.query_numeric_ord.
 
---! @brief Index extractor for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Index extractor for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
 --! @param a public.numeric_ord
---! @param b public.numeric_ord_query
+--! @param b eql_v3.query_numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b public.numeric_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.numeric_ord, b eql_v3.query_numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_query.
---! @param a public.numeric_ord_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord.
+--! @param a eql_v3.query_numeric_ord
 --! @param b public.numeric_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord_query, b public.numeric_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord, b public.numeric_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/numeric/numeric_ord_ope_query_functions.sql b/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/numeric/numeric_ord_ope_query_functions.sql
rename to src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
index 51ee095ce..d903cd346 100644
--- a/src/v3/scalars/numeric/numeric_ord_ope_query_functions.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_ope_query_functions.sql
---! @brief Functions for public.numeric_ord_ope_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_numeric_ord_ope.
 
---! @brief Index extractor for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Index extractor for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_numeric_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
 --! @param a public.numeric_ord_ope
---! @param b public.numeric_ord_ope_query
+--! @param b eql_v3.query_numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ope_query.
---! @param a public.numeric_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ope.
+--! @param a eql_v3.query_numeric_ord_ope
 --! @param b public.numeric_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/numeric/numeric_ord_ope_query_operators.sql b/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/numeric/numeric_ord_ope_query_operators.sql
rename to src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
index bf609f805..6550de6d6 100644
--- a/src/v3/scalars/numeric/numeric_ord_ope_query_operators.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ope_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_ope_query_operators.sql
---! @brief Operators for public.numeric_ord_ope_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_numeric_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord_ope, RIGHTARG = public.numeric_ord_ope_query,
+  LEFTARG = public.numeric_ord_ope, RIGHTARG = eql_v3.query_numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord_ope_query, RIGHTARG = public.numeric_ord_ope,
+  LEFTARG = eql_v3.query_numeric_ord_ope, RIGHTARG = public.numeric_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/integer/integer_ord_query_operators.sql b/src/v3/scalars/numeric/query_numeric_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/integer/integer_ord_query_operators.sql
rename to src/v3/scalars/numeric/query_numeric_ord_operators.sql
index b3d7888d5..eea11a3bc 100644
--- a/src/v3/scalars/integer/integer_ord_query_operators.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/integer/integer_query_types.sql
--- REQUIRE: src/v3/scalars/integer/integer_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_functions.sql
 
---! @file encrypted_domain/integer/integer_ord_query_operators.sql
---! @brief Operators for public.integer_ord_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_operators.sql
+--! @brief Operators for eql_v3.query_numeric_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord, RIGHTARG = public.integer_ord_query,
+  LEFTARG = public.numeric_ord, RIGHTARG = eql_v3.query_numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.integer_ord_query, RIGHTARG = public.integer_ord,
+  LEFTARG = eql_v3.query_numeric_ord, RIGHTARG = public.numeric_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/numeric/numeric_ord_ore_query_functions.sql b/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/numeric/numeric_ord_ore_query_functions.sql
rename to src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
index d317895d8..74c45e922 100644
--- a/src/v3/scalars/numeric/numeric_ord_ore_query_functions.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
 -- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_ore_query_functions.sql
---! @brief Functions for public.numeric_ord_ore_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_numeric_ord_ore.
 
---! @brief Index extractor for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Index extractor for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_numeric_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
 --! @param a public.numeric_ord_ore
---! @param b public.numeric_ord_ore_query
+--! @param b eql_v3.query_numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.numeric_ord_ore_query.
---! @param a public.numeric_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_numeric_ord_ore.
+--! @param a eql_v3.query_numeric_ord_ore
 --! @param b public.numeric_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/numeric/numeric_ord_ore_query_operators.sql b/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/numeric/numeric_ord_ore_query_operators.sql
rename to src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
index aef45def1..cbb36b565 100644
--- a/src/v3/scalars/numeric/numeric_ord_ore_query_operators.sql
+++ b/src/v3/scalars/numeric/query_numeric_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_query_types.sql
--- REQUIRE: src/v3/scalars/numeric/numeric_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_types.sql
+-- REQUIRE: src/v3/scalars/numeric/query_numeric_ord_ore_functions.sql
 
---! @file encrypted_domain/numeric/numeric_ord_ore_query_operators.sql
---! @brief Operators for public.numeric_ord_ore_query.
+--! @file encrypted_domain/numeric/query_numeric_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_numeric_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord_ore, RIGHTARG = public.numeric_ord_ore_query,
+  LEFTARG = public.numeric_ord_ore, RIGHTARG = eql_v3.query_numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.numeric_ord_ore_query, RIGHTARG = public.numeric_ord_ore,
+  LEFTARG = eql_v3.query_numeric_ord_ore, RIGHTARG = public.numeric_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/numeric/numeric_query_types.sql b/src/v3/scalars/numeric/query_numeric_types.sql
similarity index 52%
rename from src/v3/scalars/numeric/numeric_query_types.sql
rename to src/v3/scalars/numeric/query_numeric_types.sql
index 846db569f..33c650f53 100644
--- a/src/v3/scalars/numeric/numeric_query_types.sql
+++ b/src/v3/scalars/numeric/query_numeric_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/numeric/numeric_query_types.sql
+--! @file v3/scalars/numeric/query_numeric_types.sql
 --! @brief Query-operand domains for numeric (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.numeric_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_numeric_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.numeric_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_numeric_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'numeric_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_numeric_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.numeric_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_numeric_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.numeric_eq_query IS 'EQL numeric query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_numeric_eq IS 'EQL numeric query operand (equality)';
 
-  --! @brief Query-operand domain public.numeric_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_numeric_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'numeric_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_numeric_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.numeric_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_numeric_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.numeric_ord_ore_query IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ore IS 'EQL numeric query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.numeric_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_numeric_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'numeric_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_numeric_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.numeric_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_numeric_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.numeric_ord_query IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_numeric_ord IS 'EQL numeric query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.numeric_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_numeric_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'numeric_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_numeric_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.numeric_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_numeric_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.numeric_ord_ope_query IS 'EQL numeric query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_numeric_ord_ope IS 'EQL numeric query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/real/real_eq_query_functions.sql b/src/v3/scalars/real/query_real_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/real/real_eq_query_functions.sql
rename to src/v3/scalars/real/query_real_eq_functions.sql
index 2413a984b..167d00f02 100644
--- a/src/v3/scalars/real/real_eq_query_functions.sql
+++ b/src/v3/scalars/real/query_real_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
 -- REQUIRE: src/v3/scalars/real/real_eq_functions.sql
 
---! @file encrypted_domain/real/real_eq_query_functions.sql
---! @brief Functions for public.real_eq_query.
+--! @file encrypted_domain/real/query_real_eq_functions.sql
+--! @brief Functions for eql_v3.query_real_eq.
 
---! @brief Index extractor for public.real_eq_query.
---! @param a public.real_eq_query
+--! @brief Index extractor for eql_v3.query_real_eq.
+--! @param a eql_v3.query_real_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.real_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_real_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.real_eq_query.
+--! @brief Operator wrapper for eql_v3.query_real_eq.
 --! @param a public.real_eq
---! @param b public.real_eq_query
+--! @param b eql_v3.query_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_eq, b public.real_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.real_eq, b eql_v3.query_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.real_eq_query.
---! @param a public.real_eq_query
+--! @brief Operator wrapper for eql_v3.query_real_eq.
+--! @param a eql_v3.query_real_eq
 --! @param b public.real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_eq_query, b public.real_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_eq, b public.real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.real_eq_query.
+--! @brief Operator wrapper for eql_v3.query_real_eq.
 --! @param a public.real_eq
---! @param b public.real_eq_query
+--! @param b eql_v3.query_real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_eq, b public.real_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.real_eq, b eql_v3.query_real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.real_eq_query.
---! @param a public.real_eq_query
+--! @brief Operator wrapper for eql_v3.query_real_eq.
+--! @param a eql_v3.query_real_eq
 --! @param b public.real_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_eq_query, b public.real_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_eq, b public.real_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/real/real_eq_query_operators.sql b/src/v3/scalars/real/query_real_eq_operators.sql
similarity index 53%
rename from src/v3/scalars/real/real_eq_query_operators.sql
rename to src/v3/scalars/real/query_real_eq_operators.sql
index 51dadf82f..a15a7f8f5 100644
--- a/src/v3/scalars/real/real_eq_query_operators.sql
+++ b/src/v3/scalars/real/query_real_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
--- REQUIRE: src/v3/scalars/real/real_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_eq_functions.sql
 
---! @file encrypted_domain/real/real_eq_query_operators.sql
---! @brief Operators for public.real_eq_query.
+--! @file encrypted_domain/real/query_real_eq_operators.sql
+--! @brief Operators for eql_v3.query_real_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query,
+  LEFTARG = public.real_eq, RIGHTARG = eql_v3.query_real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq,
+  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.real_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_eq, RIGHTARG = public.real_eq_query,
+  LEFTARG = public.real_eq, RIGHTARG = eql_v3.query_real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_eq_query, RIGHTARG = public.real_eq,
+  LEFTARG = eql_v3.query_real_eq, RIGHTARG = public.real_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/real/real_ord_query_functions.sql b/src/v3/scalars/real/query_real_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/real/real_ord_query_functions.sql
rename to src/v3/scalars/real/query_real_ord_functions.sql
index b1dc852dc..f68239223 100644
--- a/src/v3/scalars/real/real_ord_query_functions.sql
+++ b/src/v3/scalars/real/query_real_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
 -- REQUIRE: src/v3/scalars/real/real_ord_functions.sql
 
---! @file encrypted_domain/real/real_ord_query_functions.sql
---! @brief Functions for public.real_ord_query.
+--! @file encrypted_domain/real/query_real_ord_functions.sql
+--! @brief Functions for eql_v3.query_real_ord.
 
---! @brief Index extractor for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Index extractor for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.real_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord.
 --! @param a public.real_ord
---! @param b public.real_ord_query
+--! @param b eql_v3.query_real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord, b public.real_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.real_ord, b eql_v3.query_real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_query.
---! @param a public.real_ord_query
+--! @brief Operator wrapper for eql_v3.query_real_ord.
+--! @param a eql_v3.query_real_ord
 --! @param b public.real_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord_query, b public.real_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord, b public.real_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/real/real_ord_ope_query_functions.sql b/src/v3/scalars/real/query_real_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/real/real_ord_ope_query_functions.sql
rename to src/v3/scalars/real/query_real_ord_ope_functions.sql
index b26b34d82..3a1e87fb8 100644
--- a/src/v3/scalars/real/real_ord_ope_query_functions.sql
+++ b/src/v3/scalars/real/query_real_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
 -- REQUIRE: src/v3/scalars/real/real_ord_ope_functions.sql
 
---! @file encrypted_domain/real/real_ord_ope_query_functions.sql
---! @brief Functions for public.real_ord_ope_query.
+--! @file encrypted_domain/real/query_real_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_real_ord_ope.
 
---! @brief Index extractor for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Index extractor for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_real_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
 --! @param a public.real_ord_ope
---! @param b public.real_ord_ope_query
+--! @param b eql_v3.query_real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ope_query.
---! @param a public.real_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ope.
+--! @param a eql_v3.query_real_ord_ope
 --! @param b public.real_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord_ope_query, b public.real_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/real/real_ord_ope_query_operators.sql b/src/v3/scalars/real/query_real_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/real/real_ord_ope_query_operators.sql
rename to src/v3/scalars/real/query_real_ord_ope_operators.sql
index 2df12e8f2..7d4c92f34 100644
--- a/src/v3/scalars/real/real_ord_ope_query_operators.sql
+++ b/src/v3/scalars/real/query_real_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
--- REQUIRE: src/v3/scalars/real/real_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_ord_ope_functions.sql
 
---! @file encrypted_domain/real/real_ord_ope_query_operators.sql
---! @brief Operators for public.real_ord_ope_query.
+--! @file encrypted_domain/real/query_real_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_real_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord_ope, RIGHTARG = public.real_ord_ope_query,
+  LEFTARG = public.real_ord_ope, RIGHTARG = eql_v3.query_real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord_ope_query, RIGHTARG = public.real_ord_ope,
+  LEFTARG = eql_v3.query_real_ord_ope, RIGHTARG = public.real_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/real/real_ord_query_operators.sql b/src/v3/scalars/real/query_real_ord_operators.sql
similarity index 61%
rename from src/v3/scalars/real/real_ord_query_operators.sql
rename to src/v3/scalars/real/query_real_ord_operators.sql
index c8e1230c4..3611558bc 100644
--- a/src/v3/scalars/real/real_ord_query_operators.sql
+++ b/src/v3/scalars/real/query_real_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
--- REQUIRE: src/v3/scalars/real/real_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_ord_functions.sql
 
---! @file encrypted_domain/real/real_ord_query_operators.sql
---! @brief Operators for public.real_ord_query.
+--! @file encrypted_domain/real/query_real_ord_operators.sql
+--! @brief Operators for eql_v3.query_real_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord, RIGHTARG = public.real_ord_query,
+  LEFTARG = public.real_ord, RIGHTARG = eql_v3.query_real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.real_ord_query, RIGHTARG = public.real_ord,
+  LEFTARG = eql_v3.query_real_ord, RIGHTARG = public.real_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/real/real_ord_ore_query_functions.sql b/src/v3/scalars/real/query_real_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/real/real_ord_ore_query_functions.sql
rename to src/v3/scalars/real/query_real_ord_ore_functions.sql
index 3ca14a58e..a84edd3dd 100644
--- a/src/v3/scalars/real/real_ord_ore_query_functions.sql
+++ b/src/v3/scalars/real/query_real_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/real/real_query_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
 -- REQUIRE: src/v3/scalars/real/real_ord_ore_functions.sql
 
---! @file encrypted_domain/real/real_ord_ore_query_functions.sql
---! @brief Functions for public.real_ord_ore_query.
+--! @file encrypted_domain/real/query_real_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_real_ord_ore.
 
---! @brief Index extractor for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Index extractor for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_real_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
 --! @param a public.real_ord_ore
---! @param b public.real_ord_ore_query
+--! @param b eql_v3.query_real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.real_ord_ore_query.
---! @param a public.real_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_real_ord_ore.
+--! @param a eql_v3.query_real_ord_ore
 --! @param b public.real_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.real_ord_ore_query, b public.real_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/date/date_ord_ore_query_operators.sql b/src/v3/scalars/real/query_real_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/date/date_ord_ore_query_operators.sql
rename to src/v3/scalars/real/query_real_ord_ore_operators.sql
index 57a711730..3e76d82d0 100644
--- a/src/v3/scalars/date/date_ord_ore_query_operators.sql
+++ b/src/v3/scalars/real/query_real_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
--- REQUIRE: src/v3/scalars/date/date_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/real/query_real_types.sql
+-- REQUIRE: src/v3/scalars/real/query_real_ord_ore_functions.sql
 
---! @file encrypted_domain/date/date_ord_ore_query_operators.sql
---! @brief Operators for public.date_ord_ore_query.
+--! @file encrypted_domain/real/query_real_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_real_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord_ore, RIGHTARG = public.date_ord_ore_query,
+  LEFTARG = public.real_ord_ore, RIGHTARG = eql_v3.query_real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord_ore_query, RIGHTARG = public.date_ord_ore,
+  LEFTARG = eql_v3.query_real_ord_ore, RIGHTARG = public.real_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/real/real_query_types.sql b/src/v3/scalars/real/query_real_types.sql
similarity index 52%
rename from src/v3/scalars/real/real_query_types.sql
rename to src/v3/scalars/real/query_real_types.sql
index e328ae225..00d94d19c 100644
--- a/src/v3/scalars/real/real_query_types.sql
+++ b/src/v3/scalars/real/query_real_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/real/real_query_types.sql
+--! @file v3/scalars/real/query_real_types.sql
 --! @brief Query-operand domains for real (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.real_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_real_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.real_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_real_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'real_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_real_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.real_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_real_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.real_eq_query IS 'EQL real query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_real_eq IS 'EQL real query operand (equality)';
 
-  --! @brief Query-operand domain public.real_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_real_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'real_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_real_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.real_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_real_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.real_ord_ore_query IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_real_ord_ore IS 'EQL real query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.real_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_real_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'real_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_real_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.real_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_real_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.real_ord_query IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_real_ord IS 'EQL real query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.real_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_real_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'real_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_real_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.real_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_real_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.real_ord_ope_query IS 'EQL real query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_real_ord_ope IS 'EQL real query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/smallint/smallint_eq_query_functions.sql b/src/v3/scalars/smallint/query_smallint_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/smallint/smallint_eq_query_functions.sql
rename to src/v3/scalars/smallint/query_smallint_eq_functions.sql
index 609f8ad8a..68193eb45 100644
--- a/src/v3/scalars/smallint/smallint_eq_query_functions.sql
+++ b/src/v3/scalars/smallint/query_smallint_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
 -- REQUIRE: src/v3/scalars/smallint/smallint_eq_functions.sql
 
---! @file encrypted_domain/smallint/smallint_eq_query_functions.sql
---! @brief Functions for public.smallint_eq_query.
+--! @file encrypted_domain/smallint/query_smallint_eq_functions.sql
+--! @brief Functions for eql_v3.query_smallint_eq.
 
---! @brief Index extractor for public.smallint_eq_query.
---! @param a public.smallint_eq_query
+--! @brief Index extractor for eql_v3.query_smallint_eq.
+--! @param a eql_v3.query_smallint_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.smallint_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_smallint_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.smallint_eq_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_eq.
 --! @param a public.smallint_eq
---! @param b public.smallint_eq_query
+--! @param b eql_v3.query_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b public.smallint_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.smallint_eq, b eql_v3.query_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_eq_query.
---! @param a public.smallint_eq_query
+--! @brief Operator wrapper for eql_v3.query_smallint_eq.
+--! @param a eql_v3.query_smallint_eq
 --! @param b public.smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_eq_query, b public.smallint_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_eq, b public.smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_eq_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_eq.
 --! @param a public.smallint_eq
---! @param b public.smallint_eq_query
+--! @param b eql_v3.query_smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b public.smallint_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.smallint_eq, b eql_v3.query_smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_eq_query.
---! @param a public.smallint_eq_query
+--! @brief Operator wrapper for eql_v3.query_smallint_eq.
+--! @param a eql_v3.query_smallint_eq
 --! @param b public.smallint_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_eq_query, b public.smallint_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_eq, b public.smallint_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/smallint/smallint_eq_query_operators.sql b/src/v3/scalars/smallint/query_smallint_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/smallint/smallint_eq_query_operators.sql
rename to src/v3/scalars/smallint/query_smallint_eq_operators.sql
index c2324c77e..aa88ee81d 100644
--- a/src/v3/scalars/smallint/smallint_eq_query_operators.sql
+++ b/src/v3/scalars/smallint/query_smallint_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_eq_functions.sql
 
---! @file encrypted_domain/smallint/smallint_eq_query_operators.sql
---! @brief Operators for public.smallint_eq_query.
+--! @file encrypted_domain/smallint/query_smallint_eq_operators.sql
+--! @brief Operators for eql_v3.query_smallint_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query,
+  LEFTARG = public.smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq,
+  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.smallint_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_eq, RIGHTARG = public.smallint_eq_query,
+  LEFTARG = public.smallint_eq, RIGHTARG = eql_v3.query_smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_eq_query, RIGHTARG = public.smallint_eq,
+  LEFTARG = eql_v3.query_smallint_eq, RIGHTARG = public.smallint_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/smallint/smallint_ord_query_functions.sql b/src/v3/scalars/smallint/query_smallint_ord_functions.sql
similarity index 50%
rename from src/v3/scalars/smallint/smallint_ord_query_functions.sql
rename to src/v3/scalars/smallint/query_smallint_ord_functions.sql
index 22593c6be..35a6f4797 100644
--- a/src/v3/scalars/smallint/smallint_ord_query_functions.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_query_functions.sql
---! @brief Functions for public.smallint_ord_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_functions.sql
+--! @brief Functions for eql_v3.query_smallint_ord.
 
---! @brief Index extractor for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Index extractor for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
 --! @param a public.smallint_ord
---! @param b public.smallint_ord_query
+--! @param b eql_v3.query_smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b public.smallint_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.smallint_ord, b eql_v3.query_smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_query.
---! @param a public.smallint_ord_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord.
+--! @param a eql_v3.query_smallint_ord
 --! @param b public.smallint_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord_query, b public.smallint_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord, b public.smallint_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/smallint/smallint_ord_ope_query_functions.sql b/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/smallint/smallint_ord_ope_query_functions.sql
rename to src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
index 0d023bb8d..d668ec404 100644
--- a/src/v3/scalars/smallint/smallint_ord_ope_query_functions.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_ope_query_functions.sql
---! @brief Functions for public.smallint_ord_ope_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_smallint_ord_ope.
 
---! @brief Index extractor for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Index extractor for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_smallint_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
 --! @param a public.smallint_ord_ope
---! @param b public.smallint_ord_ope_query
+--! @param b eql_v3.query_smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ope_query.
---! @param a public.smallint_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ope.
+--! @param a eql_v3.query_smallint_ord_ope
 --! @param b public.smallint_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/smallint/smallint_ord_ope_query_operators.sql b/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/smallint/smallint_ord_ope_query_operators.sql
rename to src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
index 1fd9a7081..94fd2e460 100644
--- a/src/v3/scalars/smallint/smallint_ord_ope_query_operators.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ope_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_ope_query_operators.sql
---! @brief Operators for public.smallint_ord_ope_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_smallint_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord_ope, RIGHTARG = public.smallint_ord_ope_query,
+  LEFTARG = public.smallint_ord_ope, RIGHTARG = eql_v3.query_smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord_ope_query, RIGHTARG = public.smallint_ord_ope,
+  LEFTARG = eql_v3.query_smallint_ord_ope, RIGHTARG = public.smallint_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/smallint/smallint_ord_query_operators.sql b/src/v3/scalars/smallint/query_smallint_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/smallint/smallint_ord_query_operators.sql
rename to src/v3/scalars/smallint/query_smallint_ord_operators.sql
index 3f3844135..7cf266447 100644
--- a/src/v3/scalars/smallint/smallint_ord_query_operators.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_query_operators.sql
---! @brief Operators for public.smallint_ord_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_operators.sql
+--! @brief Operators for eql_v3.query_smallint_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord, RIGHTARG = public.smallint_ord_query,
+  LEFTARG = public.smallint_ord, RIGHTARG = eql_v3.query_smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord_query, RIGHTARG = public.smallint_ord,
+  LEFTARG = eql_v3.query_smallint_ord, RIGHTARG = public.smallint_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/smallint/smallint_ord_ore_query_functions.sql b/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/smallint/smallint_ord_ore_query_functions.sql
rename to src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
index 5d30b06dc..4c057d78d 100644
--- a/src/v3/scalars/smallint/smallint_ord_ore_query_functions.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
 -- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_ore_query_functions.sql
---! @brief Functions for public.smallint_ord_ore_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_smallint_ord_ore.
 
---! @brief Index extractor for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Index extractor for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_smallint_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
 --! @param a public.smallint_ord_ore
---! @param b public.smallint_ord_ore_query
+--! @param b eql_v3.query_smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.smallint_ord_ore_query.
---! @param a public.smallint_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_smallint_ord_ore.
+--! @param a eql_v3.query_smallint_ord_ore
 --! @param b public.smallint_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/smallint/smallint_ord_ore_query_operators.sql b/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/smallint/smallint_ord_ore_query_operators.sql
rename to src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
index 4536a5a26..04c6b6018 100644
--- a/src/v3/scalars/smallint/smallint_ord_ore_query_operators.sql
+++ b/src/v3/scalars/smallint/query_smallint_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_query_types.sql
--- REQUIRE: src/v3/scalars/smallint/smallint_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_types.sql
+-- REQUIRE: src/v3/scalars/smallint/query_smallint_ord_ore_functions.sql
 
---! @file encrypted_domain/smallint/smallint_ord_ore_query_operators.sql
---! @brief Operators for public.smallint_ord_ore_query.
+--! @file encrypted_domain/smallint/query_smallint_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_smallint_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord_ore, RIGHTARG = public.smallint_ord_ore_query,
+  LEFTARG = public.smallint_ord_ore, RIGHTARG = eql_v3.query_smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.smallint_ord_ore_query, RIGHTARG = public.smallint_ord_ore,
+  LEFTARG = eql_v3.query_smallint_ord_ore, RIGHTARG = public.smallint_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/smallint/smallint_query_types.sql b/src/v3/scalars/smallint/query_smallint_types.sql
similarity index 52%
rename from src/v3/scalars/smallint/smallint_query_types.sql
rename to src/v3/scalars/smallint/query_smallint_types.sql
index 6a8623e43..2cae4cdd7 100644
--- a/src/v3/scalars/smallint/smallint_query_types.sql
+++ b/src/v3/scalars/smallint/query_smallint_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/smallint/smallint_query_types.sql
+--! @file v3/scalars/smallint/query_smallint_types.sql
 --! @brief Query-operand domains for smallint (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.smallint_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_smallint_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.smallint_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_smallint_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'smallint_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_smallint_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.smallint_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_smallint_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.smallint_eq_query IS 'EQL smallint query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_smallint_eq IS 'EQL smallint query operand (equality)';
 
-  --! @brief Query-operand domain public.smallint_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_smallint_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'smallint_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_smallint_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.smallint_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_smallint_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.smallint_ord_ore_query IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ore IS 'EQL smallint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.smallint_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_smallint_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'smallint_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_smallint_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.smallint_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_smallint_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.smallint_ord_query IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_smallint_ord IS 'EQL smallint query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.smallint_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_smallint_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'smallint_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_smallint_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.smallint_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_smallint_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.smallint_ord_ope_query IS 'EQL smallint query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_smallint_ord_ope IS 'EQL smallint query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/text/text_eq_query_functions.sql b/src/v3/scalars/text/query_text_eq_functions.sql
similarity index 50%
rename from src/v3/scalars/text/text_eq_query_functions.sql
rename to src/v3/scalars/text/query_text_eq_functions.sql
index 783a32ab1..7ffc6aced 100644
--- a/src/v3/scalars/text/text_eq_query_functions.sql
+++ b/src/v3/scalars/text/query_text_eq_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_eq_functions.sql
 
---! @file encrypted_domain/text/text_eq_query_functions.sql
---! @brief Functions for public.text_eq_query.
+--! @file encrypted_domain/text/query_text_eq_functions.sql
+--! @brief Functions for eql_v3.query_text_eq.
 
---! @brief Index extractor for public.text_eq_query.
---! @param a public.text_eq_query
+--! @brief Index extractor for eql_v3.query_text_eq.
+--! @param a eql_v3.query_text_eq
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.text_eq_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_eq)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_eq_query.
+--! @brief Operator wrapper for eql_v3.query_text_eq.
 --! @param a public.text_eq
---! @param b public.text_eq_query
+--! @param b eql_v3.query_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_eq, b public.text_eq_query)
+CREATE FUNCTION eql_v3.eq(a public.text_eq, b eql_v3.query_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_eq_query.
---! @param a public.text_eq_query
+--! @brief Operator wrapper for eql_v3.query_text_eq.
+--! @param a eql_v3.query_text_eq
 --! @param b public.text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_eq_query, b public.text_eq)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_eq, b public.text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_eq_query.
+--! @brief Operator wrapper for eql_v3.query_text_eq.
 --! @param a public.text_eq
---! @param b public.text_eq_query
+--! @param b eql_v3.query_text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_eq, b public.text_eq_query)
+CREATE FUNCTION eql_v3.neq(a public.text_eq, b eql_v3.query_text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_eq_query.
---! @param a public.text_eq_query
+--! @brief Operator wrapper for eql_v3.query_text_eq.
+--! @param a eql_v3.query_text_eq
 --! @param b public.text_eq
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_eq_query, b public.text_eq)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_eq, b public.text_eq)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/date/date_eq_query_operators.sql b/src/v3/scalars/text/query_text_eq_operators.sql
similarity index 53%
rename from src/v3/scalars/date/date_eq_query_operators.sql
rename to src/v3/scalars/text/query_text_eq_operators.sql
index 00a07f230..ada949cff 100644
--- a/src/v3/scalars/date/date_eq_query_operators.sql
+++ b/src/v3/scalars/text/query_text_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
--- REQUIRE: src/v3/scalars/date/date_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_eq_functions.sql
 
---! @file encrypted_domain/date/date_eq_query_operators.sql
---! @brief Operators for public.date_eq_query.
+--! @file encrypted_domain/text/query_text_eq_operators.sql
+--! @brief Operators for eql_v3.query_text_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query,
+  LEFTARG = public.text_eq, RIGHTARG = eql_v3.query_text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq,
+  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.text_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_eq, RIGHTARG = public.date_eq_query,
+  LEFTARG = public.text_eq, RIGHTARG = eql_v3.query_text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_eq_query, RIGHTARG = public.date_eq,
+  LEFTARG = eql_v3.query_text_eq, RIGHTARG = public.text_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/text/text_match_query_functions.sql b/src/v3/scalars/text/query_text_match_functions.sql
similarity index 51%
rename from src/v3/scalars/text/text_match_query_functions.sql
rename to src/v3/scalars/text/query_text_match_functions.sql
index c94726fd6..fc3f9a060 100644
--- a/src/v3/scalars/text/text_match_query_functions.sql
+++ b/src/v3/scalars/text/query_text_match_functions.sql
@@ -1,47 +1,47 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_match_functions.sql
 
---! @file encrypted_domain/text/text_match_query_functions.sql
---! @brief Functions for public.text_match_query.
+--! @file encrypted_domain/text/query_text_match_functions.sql
+--! @brief Functions for eql_v3.query_text_match.
 
---! @brief Index extractor for public.text_match_query.
---! @param a public.text_match_query
+--! @brief Index extractor for eql_v3.query_text_match.
+--! @param a eql_v3.query_text_match
 --! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a public.text_match_query)
+CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_match)
 RETURNS eql_v3_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_match_query.
+--! @brief Operator wrapper for eql_v3.query_text_match.
 --! @param a public.text_match
---! @param b public.text_match_query
+--! @param b eql_v3.query_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.contains(a public.text_match, b public.text_match_query)
+CREATE FUNCTION eql_v3.contains(a public.text_match, b eql_v3.query_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_match_query.
---! @param a public.text_match_query
+--! @brief Operator wrapper for eql_v3.query_text_match.
+--! @param a eql_v3.query_text_match
 --! @param b public.text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.contains(a public.text_match_query, b public.text_match)
+CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_match, b public.text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_match_query.
+--! @brief Operator wrapper for eql_v3.query_text_match.
 --! @param a public.text_match
---! @param b public.text_match_query
+--! @param b eql_v3.query_text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.contained_by(a public.text_match, b public.text_match_query)
+CREATE FUNCTION eql_v3.contained_by(a public.text_match, b eql_v3.query_text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_match_query.
---! @param a public.text_match_query
+--! @brief Operator wrapper for eql_v3.query_text_match.
+--! @param a eql_v3.query_text_match
 --! @param b public.text_match
 --! @return boolean
-CREATE FUNCTION eql_v3.contained_by(a public.text_match_query, b public.text_match)
+CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_match, b public.text_match)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;
diff --git a/src/v3/scalars/text/text_match_query_operators.sql b/src/v3/scalars/text/query_text_match_operators.sql
similarity index 51%
rename from src/v3/scalars/text/text_match_query_operators.sql
rename to src/v3/scalars/text/query_text_match_operators.sql
index 713df68ea..3d4fcc2c6 100644
--- a/src/v3/scalars/text/text_match_query_operators.sql
+++ b/src/v3/scalars/text/query_text_match_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_match_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_match_functions.sql
 
---! @file encrypted_domain/text/text_match_query_operators.sql
---! @brief Operators for public.text_match_query.
+--! @file encrypted_domain/text/query_text_match_operators.sql
+--! @brief Operators for eql_v3.query_text_match.
 
 CREATE OPERATOR @> (
   FUNCTION = eql_v3.contains,
-  LEFTARG = public.text_match, RIGHTARG = public.text_match_query,
+  LEFTARG = public.text_match, RIGHTARG = eql_v3.query_text_match,
   COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @> (
   FUNCTION = eql_v3.contains,
-  LEFTARG = public.text_match_query, RIGHTARG = public.text_match,
+  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.text_match,
   COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR <@ (
   FUNCTION = eql_v3.contained_by,
-  LEFTARG = public.text_match, RIGHTARG = public.text_match_query,
+  LEFTARG = public.text_match, RIGHTARG = eql_v3.query_text_match,
   COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR <@ (
   FUNCTION = eql_v3.contained_by,
-  LEFTARG = public.text_match_query, RIGHTARG = public.text_match,
+  LEFTARG = eql_v3.query_text_match, RIGHTARG = public.text_match,
   COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel
 );
diff --git a/src/v3/scalars/text/text_ord_query_functions.sql b/src/v3/scalars/text/query_text_ord_functions.sql
similarity index 51%
rename from src/v3/scalars/text/text_ord_query_functions.sql
rename to src/v3/scalars/text/query_text_ord_functions.sql
index abb9b0c56..c2f209a0e 100644
--- a/src/v3/scalars/text/text_ord_query_functions.sql
+++ b/src/v3/scalars/text/query_text_ord_functions.sql
@@ -1,119 +1,119 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_ord_functions.sql
 
---! @file encrypted_domain/text/text_ord_query_functions.sql
---! @brief Functions for public.text_ord_query.
+--! @file encrypted_domain/text/query_text_ord_functions.sql
+--! @brief Functions for eql_v3.query_text_ord.
 
---! @brief Index extractor for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Index extractor for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.text_ord_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Index extractor for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.text_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord.
 --! @param a public.text_ord
---! @param b public.text_ord_query
+--! @param b eql_v3.query_text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord, b public.text_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.text_ord, b eql_v3.query_text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_query.
---! @param a public.text_ord_query
+--! @brief Operator wrapper for eql_v3.query_text_ord.
+--! @param a eql_v3.query_text_ord
 --! @param b public.text_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord_query, b public.text_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord, b public.text_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/text/text_ord_ope_query_functions.sql b/src/v3/scalars/text/query_text_ord_ope_functions.sql
similarity index 51%
rename from src/v3/scalars/text/text_ord_ope_query_functions.sql
rename to src/v3/scalars/text/query_text_ord_ope_functions.sql
index 0cb386234..df5c46164 100644
--- a/src/v3/scalars/text/text_ord_ope_query_functions.sql
+++ b/src/v3/scalars/text/query_text_ord_ope_functions.sql
@@ -1,119 +1,119 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_ord_ope_functions.sql
 
---! @file encrypted_domain/text/text_ord_ope_query_functions.sql
---! @brief Functions for public.text_ord_ope_query.
+--! @file encrypted_domain/text/query_text_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_text_ord_ope.
 
---! @brief Index extractor for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Index extractor for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ope)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Index extractor for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_text_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
 --! @param a public.text_ord_ope
---! @param b public.text_ord_ope_query
+--! @param b eql_v3.query_text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ope_query.
---! @param a public.text_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ope.
+--! @param a eql_v3.query_text_ord_ope
 --! @param b public.text_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord_ope_query, b public.text_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/text/text_ord_ope_query_operators.sql b/src/v3/scalars/text/query_text_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/text/text_ord_ope_query_operators.sql
rename to src/v3/scalars/text/query_text_ord_ope_operators.sql
index 7fe4bcf70..a28be3f10 100644
--- a/src/v3/scalars/text/text_ord_ope_query_operators.sql
+++ b/src/v3/scalars/text/query_text_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_ord_ope_functions.sql
 
---! @file encrypted_domain/text/text_ord_ope_query_operators.sql
---! @brief Operators for public.text_ord_ope_query.
+--! @file encrypted_domain/text/query_text_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_text_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord_ope, RIGHTARG = public.text_ord_ope_query,
+  LEFTARG = public.text_ord_ope, RIGHTARG = eql_v3.query_text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord_ope_query, RIGHTARG = public.text_ord_ope,
+  LEFTARG = eql_v3.query_text_ord_ope, RIGHTARG = public.text_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/date/date_ord_query_operators.sql b/src/v3/scalars/text/query_text_ord_operators.sql
similarity index 61%
rename from src/v3/scalars/date/date_ord_query_operators.sql
rename to src/v3/scalars/text/query_text_ord_operators.sql
index 83f9aa950..e71c0b886 100644
--- a/src/v3/scalars/date/date_ord_query_operators.sql
+++ b/src/v3/scalars/text/query_text_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/date/date_query_types.sql
--- REQUIRE: src/v3/scalars/date/date_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_ord_functions.sql
 
---! @file encrypted_domain/date/date_ord_query_operators.sql
---! @brief Operators for public.date_ord_query.
+--! @file encrypted_domain/text/query_text_ord_operators.sql
+--! @brief Operators for eql_v3.query_text_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord, RIGHTARG = public.date_ord_query,
+  LEFTARG = public.text_ord, RIGHTARG = eql_v3.query_text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.date_ord_query, RIGHTARG = public.date_ord,
+  LEFTARG = eql_v3.query_text_ord, RIGHTARG = public.text_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/text/text_ord_ore_query_functions.sql b/src/v3/scalars/text/query_text_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/text/text_ord_ore_query_functions.sql
rename to src/v3/scalars/text/query_text_ord_ore_functions.sql
index 483056931..c69dc11cf 100644
--- a/src/v3/scalars/text/text_ord_ore_query_functions.sql
+++ b/src/v3/scalars/text/query_text_ord_ore_functions.sql
@@ -1,119 +1,119 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_ord_ore_functions.sql
 
---! @file encrypted_domain/text/text_ord_ore_query_functions.sql
---! @brief Functions for public.text_ord_ore_query.
+--! @file encrypted_domain/text/query_text_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_text_ord_ore.
 
---! @brief Index extractor for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Index extractor for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_ord_ore)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Index extractor for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
 --! @param a public.text_ord_ore
---! @param b public.text_ord_ore_query
+--! @param b eql_v3.query_text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_ord_ore_query.
---! @param a public.text_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_text_ord_ore.
+--! @param a eql_v3.query_text_ord_ore
 --! @param b public.text_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_ord_ore_query, b public.text_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/text/text_ord_ore_query_operators.sql b/src/v3/scalars/text/query_text_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/text/text_ord_ore_query_operators.sql
rename to src/v3/scalars/text/query_text_ord_ore_operators.sql
index 0cce1e386..e75150fd2 100644
--- a/src/v3/scalars/text/text_ord_ore_query_operators.sql
+++ b/src/v3/scalars/text/query_text_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_ord_ore_functions.sql
 
---! @file encrypted_domain/text/text_ord_ore_query_operators.sql
---! @brief Operators for public.text_ord_ore_query.
+--! @file encrypted_domain/text/query_text_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_text_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord_ore, RIGHTARG = public.text_ord_ore_query,
+  LEFTARG = public.text_ord_ore, RIGHTARG = eql_v3.query_text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_ord_ore_query, RIGHTARG = public.text_ord_ore,
+  LEFTARG = eql_v3.query_text_ord_ore, RIGHTARG = public.text_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/text/text_search_query_functions.sql b/src/v3/scalars/text/query_text_search_functions.sql
similarity index 51%
rename from src/v3/scalars/text/text_search_query_functions.sql
rename to src/v3/scalars/text/query_text_search_functions.sql
index d6830b778..56255c179 100644
--- a/src/v3/scalars/text/text_search_query_functions.sql
+++ b/src/v3/scalars/text/query_text_search_functions.sql
@@ -1,159 +1,159 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
 -- REQUIRE: src/v3/scalars/text/text_search_functions.sql
 
---! @file encrypted_domain/text/text_search_query_functions.sql
---! @brief Functions for public.text_search_query.
+--! @file encrypted_domain/text/query_text_search_functions.sql
+--! @brief Functions for eql_v3.query_text_search.
 
---! @brief Index extractor for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Index extractor for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.text_search_query)
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_text_search)
 RETURNS eql_v3_internal.hmac_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
 
---! @brief Index extractor for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Index extractor for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.text_search_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_text_search)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Index extractor for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Index extractor for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @return eql_v3_internal.bloom_filter
-CREATE FUNCTION eql_v3.match_term(a public.text_search_query)
+CREATE FUNCTION eql_v3.match_term(a eql_v3.query_text_search)
 RETURNS eql_v3_internal.bloom_filter
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.bloom_filter(a::jsonb) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.eq(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.neq(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.lt(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.lte(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.gt(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.gte(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.contains(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.contains(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.contains(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.contains(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) @> eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
+--! @brief Operator wrapper for eql_v3.query_text_search.
 --! @param a public.text_search
---! @param b public.text_search_query
+--! @param b eql_v3.query_text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.contained_by(a public.text_search, b public.text_search_query)
+CREATE FUNCTION eql_v3.contained_by(a public.text_search, b eql_v3.query_text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;
 
---! @brief Operator wrapper for public.text_search_query.
---! @param a public.text_search_query
+--! @brief Operator wrapper for eql_v3.query_text_search.
+--! @param a eql_v3.query_text_search
 --! @param b public.text_search
 --! @return boolean
-CREATE FUNCTION eql_v3.contained_by(a public.text_search_query, b public.text_search)
+CREATE FUNCTION eql_v3.contained_by(a eql_v3.query_text_search, b public.text_search)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.match_term(a) <@ eql_v3.match_term(b) $$;
diff --git a/src/v3/scalars/text/text_search_query_operators.sql b/src/v3/scalars/text/query_text_search_operators.sql
similarity index 61%
rename from src/v3/scalars/text/text_search_query_operators.sql
rename to src/v3/scalars/text/query_text_search_operators.sql
index 47e58fbff..42baa00ac 100644
--- a/src/v3/scalars/text/text_search_query_operators.sql
+++ b/src/v3/scalars/text/query_text_search_operators.sql
@@ -1,103 +1,103 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/text/text_query_types.sql
--- REQUIRE: src/v3/scalars/text/text_search_query_functions.sql
+-- REQUIRE: src/v3/scalars/text/query_text_types.sql
+-- REQUIRE: src/v3/scalars/text/query_text_search_functions.sql
 
---! @file encrypted_domain/text/text_search_query_operators.sql
---! @brief Operators for public.text_search_query.
+--! @file encrypted_domain/text/query_text_search_operators.sql
+--! @brief Operators for eql_v3.query_text_search.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR @> (
   FUNCTION = eql_v3.contains,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR @> (
   FUNCTION = eql_v3.contains,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = <@, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR <@ (
   FUNCTION = eql_v3.contained_by,
-  LEFTARG = public.text_search, RIGHTARG = public.text_search_query,
+  LEFTARG = public.text_search, RIGHTARG = eql_v3.query_text_search,
   COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel
 );
 
 CREATE OPERATOR <@ (
   FUNCTION = eql_v3.contained_by,
-  LEFTARG = public.text_search_query, RIGHTARG = public.text_search,
+  LEFTARG = eql_v3.query_text_search, RIGHTARG = public.text_search,
   COMMUTATOR = @>, RESTRICT = contsel, JOIN = contjoinsel
 );
diff --git a/src/v3/scalars/text/text_query_types.sql b/src/v3/scalars/text/query_text_types.sql
similarity index 55%
rename from src/v3/scalars/text/text_query_types.sql
rename to src/v3/scalars/text/query_text_types.sql
index 8552e9268..4356326ae 100644
--- a/src/v3/scalars/text/text_query_types.sql
+++ b/src/v3/scalars/text/query_text_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/text/text_query_types.sql
+--! @file v3/scalars/text/query_text_types.sql
 --! @brief Query-operand domains for text (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.text_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_text_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.text_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_eq_query IS 'EQL text query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_text_eq IS 'EQL text query operand (equality)';
 
-  --! @brief Query-operand domain public.text_match_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_match (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_match_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_match' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_match_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_match AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -44,14 +48,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_match_query IS 'EQL text query operand (containment)';
+  COMMENT ON DOMAIN eql_v3.query_text_match IS 'EQL text query operand (containment)';
 
-  --! @brief Query-operand domain public.text_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -65,14 +69,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_ord_ore_query IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_text_ord_ore IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.text_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -86,14 +90,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_ord_query IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_text_ord IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.text_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -105,14 +109,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_ord_ope_query IS 'EQL text query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_text_ord_ope IS 'EQL text query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.text_search_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_text_search (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'text_search_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_text_search' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.text_search_query AS jsonb
+    CREATE DOMAIN eql_v3.query_text_search AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -127,6 +131,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.text_search_query IS 'EQL text query operand (equality, ordering, containment)';
+  COMMENT ON DOMAIN eql_v3.query_text_search IS 'EQL text query operand (equality, ordering, containment)';
 END
 $$;
diff --git a/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql b/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
new file mode 100644
index 000000000..cae7ce21e
--- /dev/null
+++ b/src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
@@ -0,0 +1,47 @@
+-- AUTOMATICALLY GENERATED FILE.
+-- REQUIRE: src/v3/schema.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql
+
+--! @file encrypted_domain/timestamp/query_timestamp_eq_functions.sql
+--! @brief Functions for eql_v3.query_timestamp_eq.
+
+--! @brief Index extractor for eql_v3.query_timestamp_eq.
+--! @param a eql_v3.query_timestamp_eq
+--! @return eql_v3_internal.hmac_256
+CREATE FUNCTION eql_v3.eq_term(a eql_v3.query_timestamp_eq)
+RETURNS eql_v3_internal.hmac_256
+LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
+
+--! @brief Operator wrapper for eql_v3.query_timestamp_eq.
+--! @param a public.timestamp_eq
+--! @param b eql_v3.query_timestamp_eq
+--! @return boolean
+CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b eql_v3.query_timestamp_eq)
+RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+
+--! @brief Operator wrapper for eql_v3.query_timestamp_eq.
+--! @param a eql_v3.query_timestamp_eq
+--! @param b public.timestamp_eq
+--! @return boolean
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_eq, b public.timestamp_eq)
+RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
+
+--! @brief Operator wrapper for eql_v3.query_timestamp_eq.
+--! @param a public.timestamp_eq
+--! @param b eql_v3.query_timestamp_eq
+--! @return boolean
+CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b eql_v3.query_timestamp_eq)
+RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
+
+--! @brief Operator wrapper for eql_v3.query_timestamp_eq.
+--! @param a eql_v3.query_timestamp_eq
+--! @param b public.timestamp_eq
+--! @return boolean
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_eq, b public.timestamp_eq)
+RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/src/v3/scalars/timestamp/timestamp_eq_query_operators.sql b/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
similarity index 52%
rename from src/v3/scalars/timestamp/timestamp_eq_query_operators.sql
rename to src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
index 5623510e9..602ac5e38 100644
--- a/src/v3/scalars/timestamp/timestamp_eq_query_operators.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_eq_operators.sql
@@ -1,31 +1,31 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_query_functions.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_eq_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_eq_query_operators.sql
---! @brief Operators for public.timestamp_eq_query.
+--! @file encrypted_domain/timestamp/query_timestamp_eq_operators.sql
+--! @brief Operators for eql_v3.query_timestamp_eq.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query,
+  LEFTARG = public.timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq,
+  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.timestamp_eq,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_eq, RIGHTARG = public.timestamp_eq_query,
+  LEFTARG = public.timestamp_eq, RIGHTARG = eql_v3.query_timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_eq_query, RIGHTARG = public.timestamp_eq,
+  LEFTARG = eql_v3.query_timestamp_eq, RIGHTARG = public.timestamp_eq,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
diff --git a/src/v3/scalars/timestamp/timestamp_ord_query_functions.sql b/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
similarity index 50%
rename from src/v3/scalars/timestamp/timestamp_ord_query_functions.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
index 2fcc5a43e..2232de244 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_query_functions.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_query_functions.sql
---! @brief Functions for public.timestamp_ord_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_functions.sql
+--! @brief Functions for eql_v3.query_timestamp_ord.
 
---! @brief Index extractor for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Index extractor for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.eq(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.neq(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.lt(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.lte(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.gt(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
 --! @param a public.timestamp_ord
---! @param b public.timestamp_ord_query
+--! @param b eql_v3.query_timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord_query)
+CREATE FUNCTION eql_v3.gte(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_query.
---! @param a public.timestamp_ord_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord.
+--! @param a eql_v3.query_timestamp_ord
 --! @param b public.timestamp_ord
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_query, b public.timestamp_ord)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/timestamp/timestamp_ord_ope_query_functions.sql b/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
similarity index 50%
rename from src/v3/scalars/timestamp/timestamp_ord_ope_query_functions.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
index d66933c6d..7a0e884b8 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_ope_query_functions.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_ope_query_functions.sql
---! @brief Functions for public.timestamp_ord_ope_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_functions.sql
+--! @brief Functions for eql_v3.query_timestamp_ord_ope.
 
---! @brief Index extractor for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Index extractor for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @return eql_v3_internal.ope_cllw
-CREATE FUNCTION eql_v3.ord_ope_term(a public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.ord_ope_term(a eql_v3.query_timestamp_ord_ope)
 RETURNS eql_v3_internal.ope_cllw
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ope_cllw(a::jsonb) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) = eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <> eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) < eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) <= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) > eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
 --! @param a public.timestamp_ord_ope
---! @param b public.timestamp_ord_ope_query
+--! @param b eql_v3.query_timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
+CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ope_query.
---! @param a public.timestamp_ord_ope_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ope.
+--! @param a eql_v3.query_timestamp_ord_ope
 --! @param b public.timestamp_ord_ope
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_ope_term(a) >= eql_v3.ord_ope_term(b) $$;
diff --git a/src/v3/scalars/timestamp/timestamp_ord_ope_query_operators.sql b/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
similarity index 60%
rename from src/v3/scalars/timestamp/timestamp_ord_ope_query_operators.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
index b84577166..f145fc2f9 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_ope_query_operators.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_ope_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ope_query_functions.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ope_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_ope_query_operators.sql
---! @brief Operators for public.timestamp_ord_ope_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_ope_operators.sql
+--! @brief Operators for eql_v3.query_timestamp_ord_ope.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope_query,
+  LEFTARG = public.timestamp_ord_ope, RIGHTARG = eql_v3.query_timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord_ope_query, RIGHTARG = public.timestamp_ord_ope,
+  LEFTARG = eql_v3.query_timestamp_ord_ope, RIGHTARG = public.timestamp_ord_ope,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/timestamp/timestamp_ord_query_operators.sql b/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
similarity index 60%
rename from src/v3/scalars/timestamp/timestamp_ord_query_operators.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
index 0e12faaa0..bf23dc146 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_query_operators.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_query_functions.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_query_operators.sql
---! @brief Operators for public.timestamp_ord_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_operators.sql
+--! @brief Operators for eql_v3.query_timestamp_ord.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord, RIGHTARG = public.timestamp_ord_query,
+  LEFTARG = public.timestamp_ord, RIGHTARG = eql_v3.query_timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord_query, RIGHTARG = public.timestamp_ord,
+  LEFTARG = eql_v3.query_timestamp_ord, RIGHTARG = public.timestamp_ord,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/timestamp/timestamp_ord_ore_query_functions.sql b/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
similarity index 50%
rename from src/v3/scalars/timestamp/timestamp_ord_ore_query_functions.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
index d43610831..db1cc47d3 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_ore_query_functions.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
@@ -1,111 +1,111 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
 -- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_ore_query_functions.sql
---! @brief Functions for public.timestamp_ord_ore_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_functions.sql
+--! @brief Functions for eql_v3.query_timestamp_ord_ore.
 
---! @brief Index extractor for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Index extractor for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @return eql_v3_internal.ore_block_256
-CREATE FUNCTION eql_v3.ord_term(a public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.ord_term(a eql_v3.query_timestamp_ord_ore)
 RETURNS eql_v3_internal.ore_block_256
 LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3_internal.ore_block_256(a::jsonb) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) = eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <> eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) < eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.lte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) <= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) > eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
 --! @param a public.timestamp_ord_ore
---! @param b public.timestamp_ord_ore_query
+--! @param b eql_v3.query_timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
+CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
 
---! @brief Operator wrapper for public.timestamp_ord_ore_query.
---! @param a public.timestamp_ord_ore_query
+--! @brief Operator wrapper for eql_v3.query_timestamp_ord_ore.
+--! @param a eql_v3.query_timestamp_ord_ore
 --! @param b public.timestamp_ord_ore
 --! @return boolean
-CREATE FUNCTION eql_v3.gte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
+CREATE FUNCTION eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
 AS $$ SELECT eql_v3.ord_term(a) >= eql_v3.ord_term(b) $$;
diff --git a/src/v3/scalars/timestamp/timestamp_ord_ore_query_operators.sql b/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
similarity index 60%
rename from src/v3/scalars/timestamp/timestamp_ord_ore_query_operators.sql
rename to src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
index 3596318ef..5a7f28542 100644
--- a/src/v3/scalars/timestamp/timestamp_ord_ore_query_operators.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_ord_ore_operators.sql
@@ -1,79 +1,79 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_ord_ore_query_functions.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_types.sql
+-- REQUIRE: src/v3/scalars/timestamp/query_timestamp_ord_ore_functions.sql
 
---! @file encrypted_domain/timestamp/timestamp_ord_ore_query_operators.sql
---! @brief Operators for public.timestamp_ord_ore_query.
+--! @file encrypted_domain/timestamp/query_timestamp_ord_ore_operators.sql
+--! @brief Operators for eql_v3.query_timestamp_ord_ore.
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR = (
   FUNCTION = eql_v3.eq,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = =, NEGATOR = <>, RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR <> (
   FUNCTION = eql_v3.neq,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = <>, NEGATOR = =, RESTRICT = neqsel, JOIN = neqjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR < (
   FUNCTION = eql_v3.lt,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = >, NEGATOR = >=, RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR <= (
   FUNCTION = eql_v3.lte,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = >=, NEGATOR = >, RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR > (
   FUNCTION = eql_v3.gt,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = <, NEGATOR = <=, RESTRICT = scalargtsel, JOIN = scalargtjoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore_query,
+  LEFTARG = public.timestamp_ord_ore, RIGHTARG = eql_v3.query_timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR >= (
   FUNCTION = eql_v3.gte,
-  LEFTARG = public.timestamp_ord_ore_query, RIGHTARG = public.timestamp_ord_ore,
+  LEFTARG = eql_v3.query_timestamp_ord_ore, RIGHTARG = public.timestamp_ord_ore,
   COMMUTATOR = <=, NEGATOR = <, RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
diff --git a/src/v3/scalars/timestamp/timestamp_query_types.sql b/src/v3/scalars/timestamp/query_timestamp_types.sql
similarity index 52%
rename from src/v3/scalars/timestamp/timestamp_query_types.sql
rename to src/v3/scalars/timestamp/query_timestamp_types.sql
index 0ed26a7eb..11ac5d65f 100644
--- a/src/v3/scalars/timestamp/timestamp_query_types.sql
+++ b/src/v3/scalars/timestamp/query_timestamp_types.sql
@@ -1,21 +1,25 @@
 -- AUTOMATICALLY GENERATED FILE.
 -- REQUIRE: src/v3/schema.sql
 
---! @file v3/scalars/timestamp/timestamp_query_types.sql
+--! @file v3/scalars/timestamp/query_timestamp_types.sql
 --! @brief Query-operand domains for timestamp (index-terms-only, no ciphertext).
---! @note Cast a query operand explicitly to its `_query` domain in a predicate
---!       (e.g. `WHERE col = $1::public.timestamp_eq_query`). A bare,
---!       uncast literal RHS is ambiguous between the `_query` and `jsonb`
+--! @note Query-operand domains live in `eql_v3` (not `public`): they are
+--!       never valid column types, so they don't belong in the column-type
+--!       namespace, and dropping the EQL-owned schema can never drop an
+--!       application column.
+--! @note Cast a query operand explicitly to its `query_` domain in a predicate
+--!       (e.g. `WHERE col = $1::eql_v3.query_timestamp_eq`). A bare,
+--!       uncast literal RHS is ambiguous between the `query_` and `jsonb`
 --!       operator overloads and will not resolve.
 
 DO $$
 BEGIN
-  --! @brief Query-operand domain public.timestamp_eq_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_timestamp_eq (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'timestamp_eq_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_timestamp_eq' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.timestamp_eq_query AS jsonb
+    CREATE DOMAIN eql_v3.query_timestamp_eq AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -26,14 +30,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.timestamp_eq_query IS 'EQL timestamp query operand (equality)';
+  COMMENT ON DOMAIN eql_v3.query_timestamp_eq IS 'EQL timestamp query operand (equality)';
 
-  --! @brief Query-operand domain public.timestamp_ord_ore_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ore (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'timestamp_ord_ore_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_timestamp_ord_ore' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.timestamp_ord_ore_query AS jsonb
+    CREATE DOMAIN eql_v3.query_timestamp_ord_ore AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -46,14 +50,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.timestamp_ord_ore_query IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ore IS 'EQL timestamp query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.timestamp_ord_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_timestamp_ord (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'timestamp_ord_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_timestamp_ord' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.timestamp_ord_query AS jsonb
+    CREATE DOMAIN eql_v3.query_timestamp_ord AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -66,14 +70,14 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.timestamp_ord_query IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_timestamp_ord IS 'EQL timestamp query operand (equality, ordering)';
 
-  --! @brief Query-operand domain public.timestamp_ord_ope_query (term-only; no `c`).
+  --! @brief Query-operand domain eql_v3.query_timestamp_ord_ope (term-only; no `c`).
   IF NOT EXISTS (
     SELECT 1 FROM pg_type
-    WHERE typname = 'timestamp_ord_ope_query' AND typnamespace = 'public'::regnamespace
+    WHERE typname = 'query_timestamp_ord_ope' AND typnamespace = 'eql_v3'::regnamespace
   ) THEN
-    CREATE DOMAIN public.timestamp_ord_ope_query AS jsonb
+    CREATE DOMAIN eql_v3.query_timestamp_ord_ope AS jsonb
       CHECK (
         jsonb_typeof(VALUE) = 'object'
         AND VALUE ? 'v'
@@ -84,6 +88,6 @@ BEGIN
       );
   END IF;
 
-  COMMENT ON DOMAIN public.timestamp_ord_ope_query IS 'EQL timestamp query operand (equality, ordering)';
+  COMMENT ON DOMAIN eql_v3.query_timestamp_ord_ope IS 'EQL timestamp query operand (equality, ordering)';
 END
 $$;
diff --git a/src/v3/scalars/timestamp/timestamp_eq_query_functions.sql b/src/v3/scalars/timestamp/timestamp_eq_query_functions.sql
deleted file mode 100644
index 1c0c2af22..000000000
--- a/src/v3/scalars/timestamp/timestamp_eq_query_functions.sql
+++ /dev/null
@@ -1,47 +0,0 @@
--- AUTOMATICALLY GENERATED FILE.
--- REQUIRE: src/v3/schema.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_query_types.sql
--- REQUIRE: src/v3/scalars/timestamp/timestamp_eq_functions.sql
-
---! @file encrypted_domain/timestamp/timestamp_eq_query_functions.sql
---! @brief Functions for public.timestamp_eq_query.
-
---! @brief Index extractor for public.timestamp_eq_query.
---! @param a public.timestamp_eq_query
---! @return eql_v3_internal.hmac_256
-CREATE FUNCTION eql_v3.eq_term(a public.timestamp_eq_query)
-RETURNS eql_v3_internal.hmac_256
-LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3_internal.hmac_256(a::jsonb) $$;
-
---! @brief Operator wrapper for public.timestamp_eq_query.
---! @param a public.timestamp_eq
---! @param b public.timestamp_eq_query
---! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq_query)
-RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
-
---! @brief Operator wrapper for public.timestamp_eq_query.
---! @param a public.timestamp_eq_query
---! @param b public.timestamp_eq
---! @return boolean
-CREATE FUNCTION eql_v3.eq(a public.timestamp_eq_query, b public.timestamp_eq)
-RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) = eql_v3.eq_term(b) $$;
-
---! @brief Operator wrapper for public.timestamp_eq_query.
---! @param a public.timestamp_eq
---! @param b public.timestamp_eq_query
---! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq_query)
-RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
-
---! @brief Operator wrapper for public.timestamp_eq_query.
---! @param a public.timestamp_eq_query
---! @param b public.timestamp_eq
---! @return boolean
-CREATE FUNCTION eql_v3.neq(a public.timestamp_eq_query, b public.timestamp_eq)
-RETURNS boolean LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
-AS $$ SELECT eql_v3.eq_term(a) <> eql_v3.eq_term(b) $$;
diff --git a/tasks/docs/generate/test_xml_to_json.py b/tasks/docs/generate/test_xml_to_json.py
index 52930da2a..fe3e8e940 100755
--- a/tasks/docs/generate/test_xml_to_json.py
+++ b/tasks/docs/generate/test_xml_to_json.py
@@ -41,7 +41,7 @@
       {"key": "hm", "extractor": "eq_term", "ctor": "hmac_256"},
       {"key": "oc", "extractor": "ore_cllw", "ctor": "ore_cllw"}
     ] },
-    { "full_name": "jsonb_query", "name": "query", "terms": [] }
+    { "full_name": "query_jsonb", "name": "query", "terms": [] }
   ]
 }"""
 
@@ -124,9 +124,9 @@ def test_load_domains():
     assert by_name["public.text_search"]["capabilities"] == ["equality", "order", "match"]
     # SteVec (jsonb) domains come from the `stevec` section. Term extractors are
     # hardcoded on `jsonb_entry` (the sv element type) ONLY — hm -> eq_term,
-    # oc -> ore_cllw; the `json` container and `jsonb_query` carry none.
+    # oc -> ore_cllw; the `json` container and `query_jsonb` carry none.
     assert by_name["public.json"]["termFunctions"] == []
-    assert by_name["public.jsonb_query"]["termFunctions"] == []
+    assert by_name["eql_v3.query_jsonb"]["termFunctions"] == []
     assert by_name["public.jsonb_entry"]["capabilities"] == ["json"]
     assert by_name["public.jsonb_entry"]["shape"] == "stevec"
     assert by_name["public.jsonb_entry"]["termFunctions"] == ["eql_v3.eq_term", "eql_v3.ore_cllw"]
diff --git a/tasks/docs/generate/xml-to-json.py b/tasks/docs/generate/xml-to-json.py
index 2d2f2ff3d..54d1af282 100755
--- a/tasks/docs/generate/xml-to-json.py
+++ b/tasks/docs/generate/xml-to-json.py
@@ -115,11 +115,14 @@ def load_domains(catalog_path: Path) -> list:
                 "termFunctions": _term_functions(dom.get("terms", [])),
             })
 
-    # SteVec (jsonb) family: hand-written SQL, catalog inventory only. Like the
-    # scalar domains these live in `public`; the extractor functions are eql_v3.
+    # SteVec (jsonb) family: hand-written SQL, catalog inventory only. The
+    # column-type domains (`json`, `jsonb_entry`) live in `public`; the
+    # containment needle (`query_jsonb`) is a query operand, never a column
+    # type, and lives in `eql_v3` (CIP-3442). Extractor functions are eql_v3.
     for entry in catalog.get("stevec", []):
+        schema = "eql_v3" if entry["full_name"].startswith("query_") else "public"
         domains.append({
-            "name": f"public.{entry['full_name']}",
+            "name": f"{schema}.{entry['full_name']}",
             "type": "jsonb",
             "variant": "",
             "base": "jsonb",
diff --git a/tasks/test/clean_install_v3.sh b/tasks/test/clean_install_v3.sh
index 497f813f7..c896c4eb3 100755
--- a/tasks/test/clean_install_v3.sh
+++ b/tasks/test/clean_install_v3.sh
@@ -77,9 +77,9 @@ INSERT INTO v3_json_smoke VALUES
 SELECT (e -> 'sel'::text)::jsonb ->> 'hm' FROM v3_json_smoke WHERE id = 1;
 SELECT e ->> 'sel'::text FROM v3_json_smoke WHERE id = 1;
 SELECT count(*) FROM v3_json_smoke
-WHERE e @> '{"sv":[{"s":"sel","hm":"00"}]}'::public.jsonb_query;
+WHERE e @> '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_jsonb;
 SELECT count(*) FROM v3_json_smoke
-WHERE '{"sv":[{"s":"sel","hm":"00"}]}'::public.jsonb_query <@ e;
+WHERE '{"sv":[{"s":"sel","hm":"00"}]}'::eql_v3.query_jsonb <@ e;
 
 -- Documented GIN expression installs cleanly in a v3-only database.
 CREATE INDEX v3_json_smoke_gin
diff --git a/tasks/test/splinter.sh b/tasks/test/splinter.sh
index f14461980..e87e1cd1c 100755
--- a/tasks/test/splinter.sh
+++ b/tasks/test/splinter.sh
@@ -94,7 +94,7 @@ function_search_path_mutable	eql_v3_internal	ore_cllw_gte	function	Inner compara
 function_search_path_mutable	eql_v3	ord_ope_term	function	CLLW-OPE order term extractor for the public *_ord_ope domains: returns eql_v3_internal.ope_cllw, a domain over bytea that inherits the native bytea comparison operators and DEFAULT btree opclass. Used inside the inlinable comparison wrappers and as the functional-index expression USING btree (eql_v3.ord_ope_term(col)); must inline so the whole chain folds to native bytea comparisons the index can match. One overload per *_ord_ope domain.
 function_search_path_mutable	eql_v3_internal	ope_cllw	function	CLLW-OPE extractor for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) constructor used inside eql_v3.ord_ope_term, hex-decoding `op` to the bytea-backed eql_v3_internal.ope_cllw domain. The domain inherits bytea's native comparison operators and btree opclass, so the WHOLE comparison chain (wrapper -> ord_ope_term -> this) is inlinable SQL and the functional btree index on eql_v3.ord_ope_term(col) engages structurally — the hmac_256 pattern. Carries the `eql-inline-critical` COMMENT marker (bare jsonb arg escapes the structural domain-arg skip).
 # Encrypted-JSONB document surface (src/v3/jsonb): the hand-written public.json /
-# jsonb_entry / jsonb_query domains and their selector/extractor/operator
+# jsonb_entry / query_jsonb domains and their selector/extractor/operator
 # functions. Inlinable for functional-index matching; left unpinned by
 # tasks/pin_search_path_v3.sql via either
 # the structural jsonb-domain-arg skip or the documented `eql-inline-critical`
@@ -109,7 +109,7 @@ function_search_path_mutable	eql_v3	has_ore_cllw	function	ORE-CLLW presence chec
 function_search_path_mutable	eql_v3_internal	ore_cllw	function	ORE-CLLW constructor for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) constructor. Takes bare jsonb, not a jsonb-backed domain, so it is left unpinned via the explicit inline-critical OID clause in pin_search_path_v3.sql (mirrors eql_v3_internal.hmac_256/bloom_filter) rather than the structural skip. Distinct from the eql_v3.ore_cllw(jsonb_entry) extractor overload, which stays public.
 function_search_path_mutable	eql_v3_internal	has_ore_cllw	function	ORE-CLLW presence check for the eql_v3 SEM fork (now in eql_v3_internal): inlinable SQL (jsonb) counterpart to eql_v3_internal.ore_cllw. Same inline-critical OID rationale. Distinct from the eql_v3.has_ore_cllw(jsonb_entry) overload, which stays public.
 function_search_path_mutable	eql_v3	selector	function	STE-vec entry selector extractor: typed (public.jsonb_entry) overload, inlinable so `eql_v3.selector(col -> 'sel')` folds into the calling query. Structural domain-arg skip. The (jsonb) overload is plpgsql with a pinned search_path and does not surface.
-function_search_path_mutable	eql_v3	to_ste_vec_query	function	Encrypted-JSONB query-document constructor (CAST WITH FUNCTION for public.jsonb_query): inlinable SQL over a public.json domain arg, structural domain-arg skip. Builds the ste_vec query value the @>/<@ wrappers compare against; must inline to fold into the calling query.
+function_search_path_mutable	eql_v3	to_ste_vec_query	function	Encrypted-JSONB query-document constructor (CAST WITH FUNCTION for eql_v3.query_jsonb): inlinable SQL over a public.json domain arg, structural domain-arg skip. Builds the ste_vec query value the @>/<@ wrappers compare against; must inline to fold into the calling query.
 function_search_path_mutable	eql_v3	jsonb_array	function	ste_vec deterministic-field array extractor on the eql_v3 encrypted-JSONB surface: public inlinable SQL (raw jsonb arg) behind the documented functional GIN index expression eql_v3.jsonb_array(col). Takes bare jsonb, so it carries the documented `eql-inline-critical` COMMENT marker that pin_search_path_v3.sql honours rather than the structural skip.
 function_search_path_mutable	eql_v3	jsonb_contains	function	Public GIN-inlining containment helper (function-form of @> over raw jsonb): unfolds to eql_v3.jsonb_array(a) @> eql_v3.jsonb_array(b). Carries the `eql-inline-critical` COMMENT marker.
 function_search_path_mutable	eql_v3	jsonb_contained_by	function	Public GIN-inlining reverse-containment helper (function-form of <@ over raw jsonb): same as eql_v3.jsonb_contains.
diff --git a/tests/sqlx/snapshots/eql_v3_public_surface.txt b/tests/sqlx/snapshots/eql_v3_public_surface.txt
index 0fb88f423..6773adb2d 100644
--- a/tests/sqlx/snapshots/eql_v3_public_surface.txt
+++ b/tests/sqlx/snapshots/eql_v3_public_surface.txt
@@ -56,38 +56,75 @@ aggregate eql_v3.min(public.text_search)
 aggregate eql_v3.min(public.timestamp_ord)
 aggregate eql_v3.min(public.timestamp_ord_ope)
 aggregate eql_v3.min(public.timestamp_ord_ore)
-cast public."json" -> public.jsonb_query
+cast public."json" -> eql_v3.query_jsonb
 function eql_v3.->(e public."json", selector integer)
 function eql_v3.->(e public."json", selector text)
 function eql_v3.->>(e public."json", selector integer)
 function eql_v3.->>(e public."json", selector text)
+function eql_v3.<@(a eql_v3.query_jsonb, b public."json")
 function eql_v3.<@(a public."json", b public."json")
 function eql_v3.<@(a public.jsonb_entry, b public."json")
-function eql_v3.<@(a public.jsonb_query, b public."json")
+function eql_v3.@>(a public."json", b eql_v3.query_jsonb)
 function eql_v3.@>(a public."json", b public."json")
 function eql_v3.@>(a public."json", b public.jsonb_entry)
-function eql_v3.@>(a public."json", b public.jsonb_query)
 function eql_v3.ciphertext(val jsonb)
+function eql_v3.contained_by(a eql_v3.query_text_match, b public.text_match)
+function eql_v3.contained_by(a eql_v3.query_text_search, b public.text_search)
 function eql_v3.contained_by(a jsonb, b public.text_match)
 function eql_v3.contained_by(a jsonb, b public.text_search)
+function eql_v3.contained_by(a public.text_match, b eql_v3.query_text_match)
 function eql_v3.contained_by(a public.text_match, b jsonb)
 function eql_v3.contained_by(a public.text_match, b public.text_match)
-function eql_v3.contained_by(a public.text_match, b public.text_match_query)
-function eql_v3.contained_by(a public.text_match_query, b public.text_match)
+function eql_v3.contained_by(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.contained_by(a public.text_search, b jsonb)
 function eql_v3.contained_by(a public.text_search, b public.text_search)
-function eql_v3.contained_by(a public.text_search, b public.text_search_query)
-function eql_v3.contained_by(a public.text_search_query, b public.text_search)
+function eql_v3.contains(a eql_v3.query_text_match, b public.text_match)
+function eql_v3.contains(a eql_v3.query_text_search, b public.text_search)
 function eql_v3.contains(a jsonb, b public.text_match)
 function eql_v3.contains(a jsonb, b public.text_search)
+function eql_v3.contains(a public.text_match, b eql_v3.query_text_match)
 function eql_v3.contains(a public.text_match, b jsonb)
 function eql_v3.contains(a public.text_match, b public.text_match)
-function eql_v3.contains(a public.text_match, b public.text_match_query)
-function eql_v3.contains(a public.text_match_query, b public.text_match)
+function eql_v3.contains(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.contains(a public.text_search, b jsonb)
 function eql_v3.contains(a public.text_search, b public.text_search)
-function eql_v3.contains(a public.text_search, b public.text_search_query)
-function eql_v3.contains(a public.text_search_query, b public.text_search)
+function eql_v3.eq(a eql_v3.query_bigint_eq, b public.bigint_eq)
+function eql_v3.eq(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.eq(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.eq(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.eq(a eql_v3.query_date_eq, b public.date_eq)
+function eql_v3.eq(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.eq(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.eq(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.eq(a eql_v3.query_double_eq, b public.double_eq)
+function eql_v3.eq(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.eq(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.eq(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.eq(a eql_v3.query_integer_eq, b public.integer_eq)
+function eql_v3.eq(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.eq(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.eq(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.eq(a eql_v3.query_numeric_eq, b public.numeric_eq)
+function eql_v3.eq(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.eq(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.eq(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.eq(a eql_v3.query_real_eq, b public.real_eq)
+function eql_v3.eq(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.eq(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.eq(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.eq(a eql_v3.query_smallint_eq, b public.smallint_eq)
+function eql_v3.eq(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.eq(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.eq(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.eq(a eql_v3.query_text_eq, b public.text_eq)
+function eql_v3.eq(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.eq(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.eq(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.eq(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.eq(a eql_v3.query_timestamp_eq, b public.timestamp_eq)
+function eql_v3.eq(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.eq(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.eq(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.eq(a jsonb, b public.bigint_eq)
 function eql_v3.eq(a jsonb, b public.bigint_ord)
 function eql_v3.eq(a jsonb, b public.bigint_ord_ope)
@@ -125,182 +162,173 @@ function eql_v3.eq(a jsonb, b public.timestamp_eq)
 function eql_v3.eq(a jsonb, b public.timestamp_ord)
 function eql_v3.eq(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.eq(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.eq(a public.bigint_eq, b eql_v3.query_bigint_eq)
 function eql_v3.eq(a public.bigint_eq, b jsonb)
 function eql_v3.eq(a public.bigint_eq, b public.bigint_eq)
-function eql_v3.eq(a public.bigint_eq, b public.bigint_eq_query)
-function eql_v3.eq(a public.bigint_eq_query, b public.bigint_eq)
+function eql_v3.eq(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.eq(a public.bigint_ord, b jsonb)
 function eql_v3.eq(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.eq(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.eq(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.eq(a public.bigint_ord_ope, b jsonb)
 function eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.eq(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.eq(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.eq(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.eq(a public.bigint_ord_ore, b jsonb)
 function eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.eq(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.eq(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.eq(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.eq(a public.date_eq, b eql_v3.query_date_eq)
 function eql_v3.eq(a public.date_eq, b jsonb)
 function eql_v3.eq(a public.date_eq, b public.date_eq)
-function eql_v3.eq(a public.date_eq, b public.date_eq_query)
-function eql_v3.eq(a public.date_eq_query, b public.date_eq)
+function eql_v3.eq(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.eq(a public.date_ord, b jsonb)
 function eql_v3.eq(a public.date_ord, b public.date_ord)
-function eql_v3.eq(a public.date_ord, b public.date_ord_query)
+function eql_v3.eq(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.eq(a public.date_ord_ope, b jsonb)
 function eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.eq(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.eq(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.eq(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.eq(a public.date_ord_ore, b jsonb)
 function eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.eq(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.eq(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.eq(a public.date_ord_query, b public.date_ord)
+function eql_v3.eq(a public.double_eq, b eql_v3.query_double_eq)
 function eql_v3.eq(a public.double_eq, b jsonb)
 function eql_v3.eq(a public.double_eq, b public.double_eq)
-function eql_v3.eq(a public.double_eq, b public.double_eq_query)
-function eql_v3.eq(a public.double_eq_query, b public.double_eq)
+function eql_v3.eq(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.eq(a public.double_ord, b jsonb)
 function eql_v3.eq(a public.double_ord, b public.double_ord)
-function eql_v3.eq(a public.double_ord, b public.double_ord_query)
+function eql_v3.eq(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.eq(a public.double_ord_ope, b jsonb)
 function eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.eq(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.eq(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.eq(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.eq(a public.double_ord_ore, b jsonb)
 function eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.eq(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.eq(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.eq(a public.double_ord_query, b public.double_ord)
+function eql_v3.eq(a public.integer_eq, b eql_v3.query_integer_eq)
 function eql_v3.eq(a public.integer_eq, b jsonb)
 function eql_v3.eq(a public.integer_eq, b public.integer_eq)
-function eql_v3.eq(a public.integer_eq, b public.integer_eq_query)
-function eql_v3.eq(a public.integer_eq_query, b public.integer_eq)
+function eql_v3.eq(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.eq(a public.integer_ord, b jsonb)
 function eql_v3.eq(a public.integer_ord, b public.integer_ord)
-function eql_v3.eq(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.eq(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.eq(a public.integer_ord_ope, b jsonb)
 function eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.eq(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.eq(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.eq(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.eq(a public.integer_ord_ore, b jsonb)
 function eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.eq(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.eq(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.eq(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.eq(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.eq(a public.numeric_eq, b eql_v3.query_numeric_eq)
 function eql_v3.eq(a public.numeric_eq, b jsonb)
 function eql_v3.eq(a public.numeric_eq, b public.numeric_eq)
-function eql_v3.eq(a public.numeric_eq, b public.numeric_eq_query)
-function eql_v3.eq(a public.numeric_eq_query, b public.numeric_eq)
+function eql_v3.eq(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.eq(a public.numeric_ord, b jsonb)
 function eql_v3.eq(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.eq(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.eq(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.eq(a public.numeric_ord_ope, b jsonb)
 function eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.eq(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.eq(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.eq(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.eq(a public.numeric_ord_ore, b jsonb)
 function eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.eq(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.eq(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.eq(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.eq(a public.real_eq, b eql_v3.query_real_eq)
 function eql_v3.eq(a public.real_eq, b jsonb)
 function eql_v3.eq(a public.real_eq, b public.real_eq)
-function eql_v3.eq(a public.real_eq, b public.real_eq_query)
-function eql_v3.eq(a public.real_eq_query, b public.real_eq)
+function eql_v3.eq(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.eq(a public.real_ord, b jsonb)
 function eql_v3.eq(a public.real_ord, b public.real_ord)
-function eql_v3.eq(a public.real_ord, b public.real_ord_query)
+function eql_v3.eq(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.eq(a public.real_ord_ope, b jsonb)
 function eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.eq(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.eq(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.eq(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.eq(a public.real_ord_ore, b jsonb)
 function eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.eq(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.eq(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.eq(a public.real_ord_query, b public.real_ord)
+function eql_v3.eq(a public.smallint_eq, b eql_v3.query_smallint_eq)
 function eql_v3.eq(a public.smallint_eq, b jsonb)
 function eql_v3.eq(a public.smallint_eq, b public.smallint_eq)
-function eql_v3.eq(a public.smallint_eq, b public.smallint_eq_query)
-function eql_v3.eq(a public.smallint_eq_query, b public.smallint_eq)
+function eql_v3.eq(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.eq(a public.smallint_ord, b jsonb)
 function eql_v3.eq(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.eq(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.eq(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.eq(a public.smallint_ord_ope, b jsonb)
 function eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.eq(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.eq(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.eq(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.eq(a public.smallint_ord_ore, b jsonb)
 function eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.eq(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.eq(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.eq(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.eq(a public.text_eq, b eql_v3.query_text_eq)
 function eql_v3.eq(a public.text_eq, b jsonb)
 function eql_v3.eq(a public.text_eq, b public.text_eq)
-function eql_v3.eq(a public.text_eq, b public.text_eq_query)
-function eql_v3.eq(a public.text_eq_query, b public.text_eq)
+function eql_v3.eq(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.eq(a public.text_ord, b jsonb)
 function eql_v3.eq(a public.text_ord, b public.text_ord)
-function eql_v3.eq(a public.text_ord, b public.text_ord_query)
+function eql_v3.eq(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.eq(a public.text_ord_ope, b jsonb)
 function eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.eq(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.eq(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.eq(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.eq(a public.text_ord_ore, b jsonb)
 function eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.eq(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.eq(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.eq(a public.text_ord_query, b public.text_ord)
+function eql_v3.eq(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.eq(a public.text_search, b jsonb)
 function eql_v3.eq(a public.text_search, b public.text_search)
-function eql_v3.eq(a public.text_search, b public.text_search_query)
-function eql_v3.eq(a public.text_search_query, b public.text_search)
+function eql_v3.eq(a public.timestamp_eq, b eql_v3.query_timestamp_eq)
 function eql_v3.eq(a public.timestamp_eq, b jsonb)
 function eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq)
-function eql_v3.eq(a public.timestamp_eq, b public.timestamp_eq_query)
-function eql_v3.eq(a public.timestamp_eq_query, b public.timestamp_eq)
+function eql_v3.eq(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.eq(a public.timestamp_ord, b jsonb)
 function eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.eq(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.eq(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.eq(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.eq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.eq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.eq(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.eq(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.eq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.eq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.eq(a public.timestamp_ord_query, b public.timestamp_ord)
+function eql_v3.eq_term(a eql_v3.query_bigint_eq)
+function eql_v3.eq_term(a eql_v3.query_date_eq)
+function eql_v3.eq_term(a eql_v3.query_double_eq)
+function eql_v3.eq_term(a eql_v3.query_integer_eq)
+function eql_v3.eq_term(a eql_v3.query_numeric_eq)
+function eql_v3.eq_term(a eql_v3.query_real_eq)
+function eql_v3.eq_term(a eql_v3.query_smallint_eq)
+function eql_v3.eq_term(a eql_v3.query_text_eq)
+function eql_v3.eq_term(a eql_v3.query_text_ord)
+function eql_v3.eq_term(a eql_v3.query_text_ord_ope)
+function eql_v3.eq_term(a eql_v3.query_text_ord_ore)
+function eql_v3.eq_term(a eql_v3.query_text_search)
+function eql_v3.eq_term(a eql_v3.query_timestamp_eq)
 function eql_v3.eq_term(a public.bigint_eq)
-function eql_v3.eq_term(a public.bigint_eq_query)
 function eql_v3.eq_term(a public.date_eq)
-function eql_v3.eq_term(a public.date_eq_query)
 function eql_v3.eq_term(a public.double_eq)
-function eql_v3.eq_term(a public.double_eq_query)
 function eql_v3.eq_term(a public.integer_eq)
-function eql_v3.eq_term(a public.integer_eq_query)
 function eql_v3.eq_term(a public.numeric_eq)
-function eql_v3.eq_term(a public.numeric_eq_query)
 function eql_v3.eq_term(a public.real_eq)
-function eql_v3.eq_term(a public.real_eq_query)
 function eql_v3.eq_term(a public.smallint_eq)
-function eql_v3.eq_term(a public.smallint_eq_query)
 function eql_v3.eq_term(a public.text_eq)
-function eql_v3.eq_term(a public.text_eq_query)
 function eql_v3.eq_term(a public.text_ord)
 function eql_v3.eq_term(a public.text_ord_ope)
-function eql_v3.eq_term(a public.text_ord_ope_query)
 function eql_v3.eq_term(a public.text_ord_ore)
-function eql_v3.eq_term(a public.text_ord_ore_query)
-function eql_v3.eq_term(a public.text_ord_query)
 function eql_v3.eq_term(a public.text_search)
-function eql_v3.eq_term(a public.text_search_query)
 function eql_v3.eq_term(a public.timestamp_eq)
-function eql_v3.eq_term(a public.timestamp_eq_query)
 function eql_v3.eq_term(entry public.jsonb_entry)
+function eql_v3.gt(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.gt(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.gt(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.gt(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.gt(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.gt(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.gt(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.gt(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.gt(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.gt(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.gt(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.gt(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.gt(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.gt(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.gt(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.gt(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.gt(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.gt(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.gt(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.gt(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.gt(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.gt(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.gt(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.gt(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.gt(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.gt(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.gt(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.gt(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.gt(a jsonb, b public.bigint_ord)
 function eql_v3.gt(a jsonb, b public.bigint_ord_ope)
 function eql_v3.gt(a jsonb, b public.bigint_ord_ore)
@@ -329,119 +357,119 @@ function eql_v3.gt(a jsonb, b public.text_search)
 function eql_v3.gt(a jsonb, b public.timestamp_ord)
 function eql_v3.gt(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.gt(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.gt(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.gt(a public.bigint_ord, b jsonb)
 function eql_v3.gt(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.gt(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.gt(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.gt(a public.bigint_ord_ope, b jsonb)
 function eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.gt(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.gt(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.gt(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.gt(a public.bigint_ord_ore, b jsonb)
 function eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.gt(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.gt(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.gt(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.gt(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.gt(a public.date_ord, b jsonb)
 function eql_v3.gt(a public.date_ord, b public.date_ord)
-function eql_v3.gt(a public.date_ord, b public.date_ord_query)
+function eql_v3.gt(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.gt(a public.date_ord_ope, b jsonb)
 function eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.gt(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.gt(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.gt(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.gt(a public.date_ord_ore, b jsonb)
 function eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.gt(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.gt(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.gt(a public.date_ord_query, b public.date_ord)
+function eql_v3.gt(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.gt(a public.double_ord, b jsonb)
 function eql_v3.gt(a public.double_ord, b public.double_ord)
-function eql_v3.gt(a public.double_ord, b public.double_ord_query)
+function eql_v3.gt(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.gt(a public.double_ord_ope, b jsonb)
 function eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.gt(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.gt(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.gt(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.gt(a public.double_ord_ore, b jsonb)
 function eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.gt(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.gt(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.gt(a public.double_ord_query, b public.double_ord)
+function eql_v3.gt(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.gt(a public.integer_ord, b jsonb)
 function eql_v3.gt(a public.integer_ord, b public.integer_ord)
-function eql_v3.gt(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.gt(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.gt(a public.integer_ord_ope, b jsonb)
 function eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.gt(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.gt(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.gt(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.gt(a public.integer_ord_ore, b jsonb)
 function eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.gt(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.gt(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.gt(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.gt(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.gt(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.gt(a public.numeric_ord, b jsonb)
 function eql_v3.gt(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.gt(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.gt(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.gt(a public.numeric_ord_ope, b jsonb)
 function eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.gt(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.gt(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.gt(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.gt(a public.numeric_ord_ore, b jsonb)
 function eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.gt(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.gt(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.gt(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.gt(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.gt(a public.real_ord, b jsonb)
 function eql_v3.gt(a public.real_ord, b public.real_ord)
-function eql_v3.gt(a public.real_ord, b public.real_ord_query)
+function eql_v3.gt(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.gt(a public.real_ord_ope, b jsonb)
 function eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.gt(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.gt(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.gt(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.gt(a public.real_ord_ore, b jsonb)
 function eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.gt(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.gt(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.gt(a public.real_ord_query, b public.real_ord)
+function eql_v3.gt(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.gt(a public.smallint_ord, b jsonb)
 function eql_v3.gt(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.gt(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.gt(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.gt(a public.smallint_ord_ope, b jsonb)
 function eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.gt(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.gt(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.gt(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.gt(a public.smallint_ord_ore, b jsonb)
 function eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.gt(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.gt(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.gt(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.gt(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.gt(a public.text_ord, b jsonb)
 function eql_v3.gt(a public.text_ord, b public.text_ord)
-function eql_v3.gt(a public.text_ord, b public.text_ord_query)
+function eql_v3.gt(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.gt(a public.text_ord_ope, b jsonb)
 function eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.gt(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.gt(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.gt(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.gt(a public.text_ord_ore, b jsonb)
 function eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.gt(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.gt(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.gt(a public.text_ord_query, b public.text_ord)
+function eql_v3.gt(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.gt(a public.text_search, b jsonb)
 function eql_v3.gt(a public.text_search, b public.text_search)
-function eql_v3.gt(a public.text_search, b public.text_search_query)
-function eql_v3.gt(a public.text_search_query, b public.text_search)
+function eql_v3.gt(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.gt(a public.timestamp_ord, b jsonb)
 function eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.gt(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.gt(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.gt(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.gt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.gt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.gt(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.gt(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.gt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.gt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.gt(a public.timestamp_ord_query, b public.timestamp_ord)
+function eql_v3.gte(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.gte(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.gte(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.gte(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.gte(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.gte(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.gte(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.gte(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.gte(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.gte(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.gte(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.gte(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.gte(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.gte(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.gte(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.gte(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.gte(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.gte(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.gte(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.gte(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.gte(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.gte(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.gte(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.gte(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.gte(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.gte(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.gte(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.gte(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.gte(a jsonb, b public.bigint_ord)
 function eql_v3.gte(a jsonb, b public.bigint_ord_ope)
 function eql_v3.gte(a jsonb, b public.bigint_ord_ore)
@@ -470,119 +498,91 @@ function eql_v3.gte(a jsonb, b public.text_search)
 function eql_v3.gte(a jsonb, b public.timestamp_ord)
 function eql_v3.gte(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.gte(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.gte(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.gte(a public.bigint_ord, b jsonb)
 function eql_v3.gte(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.gte(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.gte(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.gte(a public.bigint_ord_ope, b jsonb)
 function eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.gte(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.gte(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.gte(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.gte(a public.bigint_ord_ore, b jsonb)
 function eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.gte(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.gte(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.gte(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.gte(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.gte(a public.date_ord, b jsonb)
 function eql_v3.gte(a public.date_ord, b public.date_ord)
-function eql_v3.gte(a public.date_ord, b public.date_ord_query)
+function eql_v3.gte(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.gte(a public.date_ord_ope, b jsonb)
 function eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.gte(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.gte(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.gte(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.gte(a public.date_ord_ore, b jsonb)
 function eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.gte(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.gte(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.gte(a public.date_ord_query, b public.date_ord)
+function eql_v3.gte(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.gte(a public.double_ord, b jsonb)
 function eql_v3.gte(a public.double_ord, b public.double_ord)
-function eql_v3.gte(a public.double_ord, b public.double_ord_query)
+function eql_v3.gte(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.gte(a public.double_ord_ope, b jsonb)
 function eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.gte(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.gte(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.gte(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.gte(a public.double_ord_ore, b jsonb)
 function eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.gte(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.gte(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.gte(a public.double_ord_query, b public.double_ord)
+function eql_v3.gte(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.gte(a public.integer_ord, b jsonb)
 function eql_v3.gte(a public.integer_ord, b public.integer_ord)
-function eql_v3.gte(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.gte(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.gte(a public.integer_ord_ope, b jsonb)
 function eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.gte(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.gte(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.gte(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.gte(a public.integer_ord_ore, b jsonb)
 function eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.gte(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.gte(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.gte(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.gte(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.gte(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.gte(a public.numeric_ord, b jsonb)
 function eql_v3.gte(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.gte(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.gte(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.gte(a public.numeric_ord_ope, b jsonb)
 function eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.gte(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.gte(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.gte(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.gte(a public.numeric_ord_ore, b jsonb)
 function eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.gte(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.gte(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.gte(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.gte(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.gte(a public.real_ord, b jsonb)
 function eql_v3.gte(a public.real_ord, b public.real_ord)
-function eql_v3.gte(a public.real_ord, b public.real_ord_query)
+function eql_v3.gte(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.gte(a public.real_ord_ope, b jsonb)
 function eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.gte(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.gte(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.gte(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.gte(a public.real_ord_ore, b jsonb)
 function eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.gte(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.gte(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.gte(a public.real_ord_query, b public.real_ord)
+function eql_v3.gte(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.gte(a public.smallint_ord, b jsonb)
 function eql_v3.gte(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.gte(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.gte(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.gte(a public.smallint_ord_ope, b jsonb)
 function eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.gte(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.gte(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.gte(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.gte(a public.smallint_ord_ore, b jsonb)
 function eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.gte(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.gte(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.gte(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.gte(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.gte(a public.text_ord, b jsonb)
 function eql_v3.gte(a public.text_ord, b public.text_ord)
-function eql_v3.gte(a public.text_ord, b public.text_ord_query)
+function eql_v3.gte(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.gte(a public.text_ord_ope, b jsonb)
 function eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.gte(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.gte(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.gte(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.gte(a public.text_ord_ore, b jsonb)
 function eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.gte(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.gte(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.gte(a public.text_ord_query, b public.text_ord)
+function eql_v3.gte(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.gte(a public.text_search, b jsonb)
 function eql_v3.gte(a public.text_search, b public.text_search)
-function eql_v3.gte(a public.text_search, b public.text_search_query)
-function eql_v3.gte(a public.text_search_query, b public.text_search)
+function eql_v3.gte(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.gte(a public.timestamp_ord, b jsonb)
 function eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.gte(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.gte(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.gte(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.gte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.gte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.gte(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.gte(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.gte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.gte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.gte(a public.timestamp_ord_query, b public.timestamp_ord)
 function eql_v3.has_ore_cllw(entry public.jsonb_entry)
 function eql_v3.jsonb_array(val jsonb)
 function eql_v3.jsonb_array_elements(val jsonb)
@@ -594,6 +594,34 @@ function eql_v3.jsonb_path_exists(val jsonb, selector text)
 function eql_v3.jsonb_path_query(val jsonb, selector text)
 function eql_v3.jsonb_path_query_first(val jsonb, selector text)
 function eql_v3.lints()
+function eql_v3.lt(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.lt(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.lt(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.lt(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.lt(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.lt(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.lt(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.lt(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.lt(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.lt(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.lt(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.lt(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.lt(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.lt(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.lt(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.lt(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.lt(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.lt(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.lt(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.lt(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.lt(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.lt(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.lt(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.lt(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.lt(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.lt(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.lt(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.lt(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.lt(a jsonb, b public.bigint_ord)
 function eql_v3.lt(a jsonb, b public.bigint_ord_ope)
 function eql_v3.lt(a jsonb, b public.bigint_ord_ore)
@@ -622,119 +650,119 @@ function eql_v3.lt(a jsonb, b public.text_search)
 function eql_v3.lt(a jsonb, b public.timestamp_ord)
 function eql_v3.lt(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.lt(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.lt(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.lt(a public.bigint_ord, b jsonb)
 function eql_v3.lt(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.lt(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.lt(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.lt(a public.bigint_ord_ope, b jsonb)
 function eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.lt(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.lt(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.lt(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.lt(a public.bigint_ord_ore, b jsonb)
 function eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.lt(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.lt(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.lt(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.lt(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.lt(a public.date_ord, b jsonb)
 function eql_v3.lt(a public.date_ord, b public.date_ord)
-function eql_v3.lt(a public.date_ord, b public.date_ord_query)
+function eql_v3.lt(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.lt(a public.date_ord_ope, b jsonb)
 function eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.lt(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.lt(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.lt(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.lt(a public.date_ord_ore, b jsonb)
 function eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.lt(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.lt(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.lt(a public.date_ord_query, b public.date_ord)
+function eql_v3.lt(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.lt(a public.double_ord, b jsonb)
 function eql_v3.lt(a public.double_ord, b public.double_ord)
-function eql_v3.lt(a public.double_ord, b public.double_ord_query)
+function eql_v3.lt(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.lt(a public.double_ord_ope, b jsonb)
 function eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.lt(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.lt(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.lt(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.lt(a public.double_ord_ore, b jsonb)
 function eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.lt(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.lt(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.lt(a public.double_ord_query, b public.double_ord)
+function eql_v3.lt(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.lt(a public.integer_ord, b jsonb)
 function eql_v3.lt(a public.integer_ord, b public.integer_ord)
-function eql_v3.lt(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.lt(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.lt(a public.integer_ord_ope, b jsonb)
 function eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.lt(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.lt(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.lt(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.lt(a public.integer_ord_ore, b jsonb)
 function eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.lt(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.lt(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.lt(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.lt(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.lt(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.lt(a public.numeric_ord, b jsonb)
 function eql_v3.lt(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.lt(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.lt(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.lt(a public.numeric_ord_ope, b jsonb)
 function eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.lt(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.lt(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.lt(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.lt(a public.numeric_ord_ore, b jsonb)
 function eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.lt(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.lt(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.lt(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.lt(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.lt(a public.real_ord, b jsonb)
 function eql_v3.lt(a public.real_ord, b public.real_ord)
-function eql_v3.lt(a public.real_ord, b public.real_ord_query)
+function eql_v3.lt(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.lt(a public.real_ord_ope, b jsonb)
 function eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.lt(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.lt(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.lt(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.lt(a public.real_ord_ore, b jsonb)
 function eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.lt(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.lt(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.lt(a public.real_ord_query, b public.real_ord)
+function eql_v3.lt(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.lt(a public.smallint_ord, b jsonb)
 function eql_v3.lt(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.lt(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.lt(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.lt(a public.smallint_ord_ope, b jsonb)
 function eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.lt(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.lt(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.lt(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.lt(a public.smallint_ord_ore, b jsonb)
 function eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.lt(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.lt(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.lt(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.lt(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.lt(a public.text_ord, b jsonb)
 function eql_v3.lt(a public.text_ord, b public.text_ord)
-function eql_v3.lt(a public.text_ord, b public.text_ord_query)
+function eql_v3.lt(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.lt(a public.text_ord_ope, b jsonb)
 function eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.lt(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.lt(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.lt(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.lt(a public.text_ord_ore, b jsonb)
 function eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.lt(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.lt(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.lt(a public.text_ord_query, b public.text_ord)
+function eql_v3.lt(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.lt(a public.text_search, b jsonb)
 function eql_v3.lt(a public.text_search, b public.text_search)
-function eql_v3.lt(a public.text_search, b public.text_search_query)
-function eql_v3.lt(a public.text_search_query, b public.text_search)
+function eql_v3.lt(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.lt(a public.timestamp_ord, b jsonb)
 function eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.lt(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.lt(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.lt(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.lt(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.lt(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.lt(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.lt(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.lt(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.lt(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.lt(a public.timestamp_ord_query, b public.timestamp_ord)
+function eql_v3.lte(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.lte(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.lte(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.lte(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.lte(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.lte(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.lte(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.lte(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.lte(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.lte(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.lte(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.lte(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.lte(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.lte(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.lte(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.lte(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.lte(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.lte(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.lte(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.lte(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.lte(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.lte(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.lte(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.lte(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.lte(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.lte(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.lte(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.lte(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.lte(a jsonb, b public.bigint_ord)
 function eql_v3.lte(a jsonb, b public.bigint_ord_ope)
 function eql_v3.lte(a jsonb, b public.bigint_ord_ore)
@@ -763,124 +791,133 @@ function eql_v3.lte(a jsonb, b public.text_search)
 function eql_v3.lte(a jsonb, b public.timestamp_ord)
 function eql_v3.lte(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.lte(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.lte(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.lte(a public.bigint_ord, b jsonb)
 function eql_v3.lte(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.lte(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.lte(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.lte(a public.bigint_ord_ope, b jsonb)
 function eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.lte(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.lte(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.lte(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.lte(a public.bigint_ord_ore, b jsonb)
 function eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.lte(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.lte(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.lte(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.lte(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.lte(a public.date_ord, b jsonb)
 function eql_v3.lte(a public.date_ord, b public.date_ord)
-function eql_v3.lte(a public.date_ord, b public.date_ord_query)
+function eql_v3.lte(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.lte(a public.date_ord_ope, b jsonb)
 function eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.lte(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.lte(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.lte(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.lte(a public.date_ord_ore, b jsonb)
 function eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.lte(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.lte(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.lte(a public.date_ord_query, b public.date_ord)
+function eql_v3.lte(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.lte(a public.double_ord, b jsonb)
 function eql_v3.lte(a public.double_ord, b public.double_ord)
-function eql_v3.lte(a public.double_ord, b public.double_ord_query)
+function eql_v3.lte(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.lte(a public.double_ord_ope, b jsonb)
 function eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.lte(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.lte(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.lte(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.lte(a public.double_ord_ore, b jsonb)
 function eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.lte(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.lte(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.lte(a public.double_ord_query, b public.double_ord)
+function eql_v3.lte(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.lte(a public.integer_ord, b jsonb)
 function eql_v3.lte(a public.integer_ord, b public.integer_ord)
-function eql_v3.lte(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.lte(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.lte(a public.integer_ord_ope, b jsonb)
 function eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.lte(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.lte(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.lte(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.lte(a public.integer_ord_ore, b jsonb)
 function eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.lte(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.lte(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.lte(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.lte(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.lte(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.lte(a public.numeric_ord, b jsonb)
 function eql_v3.lte(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.lte(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.lte(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.lte(a public.numeric_ord_ope, b jsonb)
 function eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.lte(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.lte(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.lte(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.lte(a public.numeric_ord_ore, b jsonb)
 function eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.lte(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.lte(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.lte(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.lte(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.lte(a public.real_ord, b jsonb)
 function eql_v3.lte(a public.real_ord, b public.real_ord)
-function eql_v3.lte(a public.real_ord, b public.real_ord_query)
+function eql_v3.lte(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.lte(a public.real_ord_ope, b jsonb)
 function eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.lte(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.lte(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.lte(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.lte(a public.real_ord_ore, b jsonb)
 function eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.lte(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.lte(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.lte(a public.real_ord_query, b public.real_ord)
+function eql_v3.lte(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.lte(a public.smallint_ord, b jsonb)
 function eql_v3.lte(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.lte(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.lte(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.lte(a public.smallint_ord_ope, b jsonb)
 function eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.lte(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.lte(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.lte(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.lte(a public.smallint_ord_ore, b jsonb)
 function eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.lte(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.lte(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.lte(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.lte(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.lte(a public.text_ord, b jsonb)
 function eql_v3.lte(a public.text_ord, b public.text_ord)
-function eql_v3.lte(a public.text_ord, b public.text_ord_query)
+function eql_v3.lte(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.lte(a public.text_ord_ope, b jsonb)
 function eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.lte(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.lte(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.lte(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.lte(a public.text_ord_ore, b jsonb)
 function eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.lte(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.lte(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.lte(a public.text_ord_query, b public.text_ord)
+function eql_v3.lte(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.lte(a public.text_search, b jsonb)
 function eql_v3.lte(a public.text_search, b public.text_search)
-function eql_v3.lte(a public.text_search, b public.text_search_query)
-function eql_v3.lte(a public.text_search_query, b public.text_search)
+function eql_v3.lte(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.lte(a public.timestamp_ord, b jsonb)
 function eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.lte(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.lte(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.lte(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.lte(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.lte(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.lte(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.lte(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.lte(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.lte(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.lte(a public.timestamp_ord_query, b public.timestamp_ord)
+function eql_v3.match_term(a eql_v3.query_text_match)
+function eql_v3.match_term(a eql_v3.query_text_search)
 function eql_v3.match_term(a public.text_match)
-function eql_v3.match_term(a public.text_match_query)
 function eql_v3.match_term(a public.text_search)
-function eql_v3.match_term(a public.text_search_query)
 function eql_v3.meta_data(val jsonb)
+function eql_v3.neq(a eql_v3.query_bigint_eq, b public.bigint_eq)
+function eql_v3.neq(a eql_v3.query_bigint_ord, b public.bigint_ord)
+function eql_v3.neq(a eql_v3.query_bigint_ord_ope, b public.bigint_ord_ope)
+function eql_v3.neq(a eql_v3.query_bigint_ord_ore, b public.bigint_ord_ore)
+function eql_v3.neq(a eql_v3.query_date_eq, b public.date_eq)
+function eql_v3.neq(a eql_v3.query_date_ord, b public.date_ord)
+function eql_v3.neq(a eql_v3.query_date_ord_ope, b public.date_ord_ope)
+function eql_v3.neq(a eql_v3.query_date_ord_ore, b public.date_ord_ore)
+function eql_v3.neq(a eql_v3.query_double_eq, b public.double_eq)
+function eql_v3.neq(a eql_v3.query_double_ord, b public.double_ord)
+function eql_v3.neq(a eql_v3.query_double_ord_ope, b public.double_ord_ope)
+function eql_v3.neq(a eql_v3.query_double_ord_ore, b public.double_ord_ore)
+function eql_v3.neq(a eql_v3.query_integer_eq, b public.integer_eq)
+function eql_v3.neq(a eql_v3.query_integer_ord, b public.integer_ord)
+function eql_v3.neq(a eql_v3.query_integer_ord_ope, b public.integer_ord_ope)
+function eql_v3.neq(a eql_v3.query_integer_ord_ore, b public.integer_ord_ore)
+function eql_v3.neq(a eql_v3.query_numeric_eq, b public.numeric_eq)
+function eql_v3.neq(a eql_v3.query_numeric_ord, b public.numeric_ord)
+function eql_v3.neq(a eql_v3.query_numeric_ord_ope, b public.numeric_ord_ope)
+function eql_v3.neq(a eql_v3.query_numeric_ord_ore, b public.numeric_ord_ore)
+function eql_v3.neq(a eql_v3.query_real_eq, b public.real_eq)
+function eql_v3.neq(a eql_v3.query_real_ord, b public.real_ord)
+function eql_v3.neq(a eql_v3.query_real_ord_ope, b public.real_ord_ope)
+function eql_v3.neq(a eql_v3.query_real_ord_ore, b public.real_ord_ore)
+function eql_v3.neq(a eql_v3.query_smallint_eq, b public.smallint_eq)
+function eql_v3.neq(a eql_v3.query_smallint_ord, b public.smallint_ord)
+function eql_v3.neq(a eql_v3.query_smallint_ord_ope, b public.smallint_ord_ope)
+function eql_v3.neq(a eql_v3.query_smallint_ord_ore, b public.smallint_ord_ore)
+function eql_v3.neq(a eql_v3.query_text_eq, b public.text_eq)
+function eql_v3.neq(a eql_v3.query_text_ord, b public.text_ord)
+function eql_v3.neq(a eql_v3.query_text_ord_ope, b public.text_ord_ope)
+function eql_v3.neq(a eql_v3.query_text_ord_ore, b public.text_ord_ore)
+function eql_v3.neq(a eql_v3.query_text_search, b public.text_search)
+function eql_v3.neq(a eql_v3.query_timestamp_eq, b public.timestamp_eq)
+function eql_v3.neq(a eql_v3.query_timestamp_ord, b public.timestamp_ord)
+function eql_v3.neq(a eql_v3.query_timestamp_ord_ope, b public.timestamp_ord_ope)
+function eql_v3.neq(a eql_v3.query_timestamp_ord_ore, b public.timestamp_ord_ore)
 function eql_v3.neq(a jsonb, b public.bigint_eq)
 function eql_v3.neq(a jsonb, b public.bigint_ord)
 function eql_v3.neq(a jsonb, b public.bigint_ord_ope)
@@ -918,211 +955,174 @@ function eql_v3.neq(a jsonb, b public.timestamp_eq)
 function eql_v3.neq(a jsonb, b public.timestamp_ord)
 function eql_v3.neq(a jsonb, b public.timestamp_ord_ope)
 function eql_v3.neq(a jsonb, b public.timestamp_ord_ore)
+function eql_v3.neq(a public.bigint_eq, b eql_v3.query_bigint_eq)
 function eql_v3.neq(a public.bigint_eq, b jsonb)
 function eql_v3.neq(a public.bigint_eq, b public.bigint_eq)
-function eql_v3.neq(a public.bigint_eq, b public.bigint_eq_query)
-function eql_v3.neq(a public.bigint_eq_query, b public.bigint_eq)
+function eql_v3.neq(a public.bigint_ord, b eql_v3.query_bigint_ord)
 function eql_v3.neq(a public.bigint_ord, b jsonb)
 function eql_v3.neq(a public.bigint_ord, b public.bigint_ord)
-function eql_v3.neq(a public.bigint_ord, b public.bigint_ord_query)
+function eql_v3.neq(a public.bigint_ord_ope, b eql_v3.query_bigint_ord_ope)
 function eql_v3.neq(a public.bigint_ord_ope, b jsonb)
 function eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope)
-function eql_v3.neq(a public.bigint_ord_ope, b public.bigint_ord_ope_query)
-function eql_v3.neq(a public.bigint_ord_ope_query, b public.bigint_ord_ope)
+function eql_v3.neq(a public.bigint_ord_ore, b eql_v3.query_bigint_ord_ore)
 function eql_v3.neq(a public.bigint_ord_ore, b jsonb)
 function eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore)
-function eql_v3.neq(a public.bigint_ord_ore, b public.bigint_ord_ore_query)
-function eql_v3.neq(a public.bigint_ord_ore_query, b public.bigint_ord_ore)
-function eql_v3.neq(a public.bigint_ord_query, b public.bigint_ord)
+function eql_v3.neq(a public.date_eq, b eql_v3.query_date_eq)
 function eql_v3.neq(a public.date_eq, b jsonb)
 function eql_v3.neq(a public.date_eq, b public.date_eq)
-function eql_v3.neq(a public.date_eq, b public.date_eq_query)
-function eql_v3.neq(a public.date_eq_query, b public.date_eq)
+function eql_v3.neq(a public.date_ord, b eql_v3.query_date_ord)
 function eql_v3.neq(a public.date_ord, b jsonb)
 function eql_v3.neq(a public.date_ord, b public.date_ord)
-function eql_v3.neq(a public.date_ord, b public.date_ord_query)
+function eql_v3.neq(a public.date_ord_ope, b eql_v3.query_date_ord_ope)
 function eql_v3.neq(a public.date_ord_ope, b jsonb)
 function eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope)
-function eql_v3.neq(a public.date_ord_ope, b public.date_ord_ope_query)
-function eql_v3.neq(a public.date_ord_ope_query, b public.date_ord_ope)
+function eql_v3.neq(a public.date_ord_ore, b eql_v3.query_date_ord_ore)
 function eql_v3.neq(a public.date_ord_ore, b jsonb)
 function eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore)
-function eql_v3.neq(a public.date_ord_ore, b public.date_ord_ore_query)
-function eql_v3.neq(a public.date_ord_ore_query, b public.date_ord_ore)
-function eql_v3.neq(a public.date_ord_query, b public.date_ord)
+function eql_v3.neq(a public.double_eq, b eql_v3.query_double_eq)
 function eql_v3.neq(a public.double_eq, b jsonb)
 function eql_v3.neq(a public.double_eq, b public.double_eq)
-function eql_v3.neq(a public.double_eq, b public.double_eq_query)
-function eql_v3.neq(a public.double_eq_query, b public.double_eq)
+function eql_v3.neq(a public.double_ord, b eql_v3.query_double_ord)
 function eql_v3.neq(a public.double_ord, b jsonb)
 function eql_v3.neq(a public.double_ord, b public.double_ord)
-function eql_v3.neq(a public.double_ord, b public.double_ord_query)
+function eql_v3.neq(a public.double_ord_ope, b eql_v3.query_double_ord_ope)
 function eql_v3.neq(a public.double_ord_ope, b jsonb)
 function eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope)
-function eql_v3.neq(a public.double_ord_ope, b public.double_ord_ope_query)
-function eql_v3.neq(a public.double_ord_ope_query, b public.double_ord_ope)
+function eql_v3.neq(a public.double_ord_ore, b eql_v3.query_double_ord_ore)
 function eql_v3.neq(a public.double_ord_ore, b jsonb)
 function eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore)
-function eql_v3.neq(a public.double_ord_ore, b public.double_ord_ore_query)
-function eql_v3.neq(a public.double_ord_ore_query, b public.double_ord_ore)
-function eql_v3.neq(a public.double_ord_query, b public.double_ord)
+function eql_v3.neq(a public.integer_eq, b eql_v3.query_integer_eq)
 function eql_v3.neq(a public.integer_eq, b jsonb)
 function eql_v3.neq(a public.integer_eq, b public.integer_eq)
-function eql_v3.neq(a public.integer_eq, b public.integer_eq_query)
-function eql_v3.neq(a public.integer_eq_query, b public.integer_eq)
+function eql_v3.neq(a public.integer_ord, b eql_v3.query_integer_ord)
 function eql_v3.neq(a public.integer_ord, b jsonb)
 function eql_v3.neq(a public.integer_ord, b public.integer_ord)
-function eql_v3.neq(a public.integer_ord, b public.integer_ord_query)
+function eql_v3.neq(a public.integer_ord_ope, b eql_v3.query_integer_ord_ope)
 function eql_v3.neq(a public.integer_ord_ope, b jsonb)
 function eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope)
-function eql_v3.neq(a public.integer_ord_ope, b public.integer_ord_ope_query)
-function eql_v3.neq(a public.integer_ord_ope_query, b public.integer_ord_ope)
+function eql_v3.neq(a public.integer_ord_ore, b eql_v3.query_integer_ord_ore)
 function eql_v3.neq(a public.integer_ord_ore, b jsonb)
 function eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore)
-function eql_v3.neq(a public.integer_ord_ore, b public.integer_ord_ore_query)
-function eql_v3.neq(a public.integer_ord_ore_query, b public.integer_ord_ore)
-function eql_v3.neq(a public.integer_ord_query, b public.integer_ord)
 function eql_v3.neq(a public.jsonb_entry, b public.jsonb_entry)
+function eql_v3.neq(a public.numeric_eq, b eql_v3.query_numeric_eq)
 function eql_v3.neq(a public.numeric_eq, b jsonb)
 function eql_v3.neq(a public.numeric_eq, b public.numeric_eq)
-function eql_v3.neq(a public.numeric_eq, b public.numeric_eq_query)
-function eql_v3.neq(a public.numeric_eq_query, b public.numeric_eq)
+function eql_v3.neq(a public.numeric_ord, b eql_v3.query_numeric_ord)
 function eql_v3.neq(a public.numeric_ord, b jsonb)
 function eql_v3.neq(a public.numeric_ord, b public.numeric_ord)
-function eql_v3.neq(a public.numeric_ord, b public.numeric_ord_query)
+function eql_v3.neq(a public.numeric_ord_ope, b eql_v3.query_numeric_ord_ope)
 function eql_v3.neq(a public.numeric_ord_ope, b jsonb)
 function eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope)
-function eql_v3.neq(a public.numeric_ord_ope, b public.numeric_ord_ope_query)
-function eql_v3.neq(a public.numeric_ord_ope_query, b public.numeric_ord_ope)
+function eql_v3.neq(a public.numeric_ord_ore, b eql_v3.query_numeric_ord_ore)
 function eql_v3.neq(a public.numeric_ord_ore, b jsonb)
 function eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore)
-function eql_v3.neq(a public.numeric_ord_ore, b public.numeric_ord_ore_query)
-function eql_v3.neq(a public.numeric_ord_ore_query, b public.numeric_ord_ore)
-function eql_v3.neq(a public.numeric_ord_query, b public.numeric_ord)
+function eql_v3.neq(a public.real_eq, b eql_v3.query_real_eq)
 function eql_v3.neq(a public.real_eq, b jsonb)
 function eql_v3.neq(a public.real_eq, b public.real_eq)
-function eql_v3.neq(a public.real_eq, b public.real_eq_query)
-function eql_v3.neq(a public.real_eq_query, b public.real_eq)
+function eql_v3.neq(a public.real_ord, b eql_v3.query_real_ord)
 function eql_v3.neq(a public.real_ord, b jsonb)
 function eql_v3.neq(a public.real_ord, b public.real_ord)
-function eql_v3.neq(a public.real_ord, b public.real_ord_query)
+function eql_v3.neq(a public.real_ord_ope, b eql_v3.query_real_ord_ope)
 function eql_v3.neq(a public.real_ord_ope, b jsonb)
 function eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope)
-function eql_v3.neq(a public.real_ord_ope, b public.real_ord_ope_query)
-function eql_v3.neq(a public.real_ord_ope_query, b public.real_ord_ope)
+function eql_v3.neq(a public.real_ord_ore, b eql_v3.query_real_ord_ore)
 function eql_v3.neq(a public.real_ord_ore, b jsonb)
 function eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore)
-function eql_v3.neq(a public.real_ord_ore, b public.real_ord_ore_query)
-function eql_v3.neq(a public.real_ord_ore_query, b public.real_ord_ore)
-function eql_v3.neq(a public.real_ord_query, b public.real_ord)
+function eql_v3.neq(a public.smallint_eq, b eql_v3.query_smallint_eq)
 function eql_v3.neq(a public.smallint_eq, b jsonb)
 function eql_v3.neq(a public.smallint_eq, b public.smallint_eq)
-function eql_v3.neq(a public.smallint_eq, b public.smallint_eq_query)
-function eql_v3.neq(a public.smallint_eq_query, b public.smallint_eq)
+function eql_v3.neq(a public.smallint_ord, b eql_v3.query_smallint_ord)
 function eql_v3.neq(a public.smallint_ord, b jsonb)
 function eql_v3.neq(a public.smallint_ord, b public.smallint_ord)
-function eql_v3.neq(a public.smallint_ord, b public.smallint_ord_query)
+function eql_v3.neq(a public.smallint_ord_ope, b eql_v3.query_smallint_ord_ope)
 function eql_v3.neq(a public.smallint_ord_ope, b jsonb)
 function eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope)
-function eql_v3.neq(a public.smallint_ord_ope, b public.smallint_ord_ope_query)
-function eql_v3.neq(a public.smallint_ord_ope_query, b public.smallint_ord_ope)
+function eql_v3.neq(a public.smallint_ord_ore, b eql_v3.query_smallint_ord_ore)
 function eql_v3.neq(a public.smallint_ord_ore, b jsonb)
 function eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore)
-function eql_v3.neq(a public.smallint_ord_ore, b public.smallint_ord_ore_query)
-function eql_v3.neq(a public.smallint_ord_ore_query, b public.smallint_ord_ore)
-function eql_v3.neq(a public.smallint_ord_query, b public.smallint_ord)
+function eql_v3.neq(a public.text_eq, b eql_v3.query_text_eq)
 function eql_v3.neq(a public.text_eq, b jsonb)
 function eql_v3.neq(a public.text_eq, b public.text_eq)
-function eql_v3.neq(a public.text_eq, b public.text_eq_query)
-function eql_v3.neq(a public.text_eq_query, b public.text_eq)
+function eql_v3.neq(a public.text_ord, b eql_v3.query_text_ord)
 function eql_v3.neq(a public.text_ord, b jsonb)
 function eql_v3.neq(a public.text_ord, b public.text_ord)
-function eql_v3.neq(a public.text_ord, b public.text_ord_query)
+function eql_v3.neq(a public.text_ord_ope, b eql_v3.query_text_ord_ope)
 function eql_v3.neq(a public.text_ord_ope, b jsonb)
 function eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope)
-function eql_v3.neq(a public.text_ord_ope, b public.text_ord_ope_query)
-function eql_v3.neq(a public.text_ord_ope_query, b public.text_ord_ope)
+function eql_v3.neq(a public.text_ord_ore, b eql_v3.query_text_ord_ore)
 function eql_v3.neq(a public.text_ord_ore, b jsonb)
 function eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore)
-function eql_v3.neq(a public.text_ord_ore, b public.text_ord_ore_query)
-function eql_v3.neq(a public.text_ord_ore_query, b public.text_ord_ore)
-function eql_v3.neq(a public.text_ord_query, b public.text_ord)
+function eql_v3.neq(a public.text_search, b eql_v3.query_text_search)
 function eql_v3.neq(a public.text_search, b jsonb)
 function eql_v3.neq(a public.text_search, b public.text_search)
-function eql_v3.neq(a public.text_search, b public.text_search_query)
-function eql_v3.neq(a public.text_search_query, b public.text_search)
+function eql_v3.neq(a public.timestamp_eq, b eql_v3.query_timestamp_eq)
 function eql_v3.neq(a public.timestamp_eq, b jsonb)
 function eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq)
-function eql_v3.neq(a public.timestamp_eq, b public.timestamp_eq_query)
-function eql_v3.neq(a public.timestamp_eq_query, b public.timestamp_eq)
+function eql_v3.neq(a public.timestamp_ord, b eql_v3.query_timestamp_ord)
 function eql_v3.neq(a public.timestamp_ord, b jsonb)
 function eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord)
-function eql_v3.neq(a public.timestamp_ord, b public.timestamp_ord_query)
+function eql_v3.neq(a public.timestamp_ord_ope, b eql_v3.query_timestamp_ord_ope)
 function eql_v3.neq(a public.timestamp_ord_ope, b jsonb)
 function eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope)
-function eql_v3.neq(a public.timestamp_ord_ope, b public.timestamp_ord_ope_query)
-function eql_v3.neq(a public.timestamp_ord_ope_query, b public.timestamp_ord_ope)
+function eql_v3.neq(a public.timestamp_ord_ore, b eql_v3.query_timestamp_ord_ore)
 function eql_v3.neq(a public.timestamp_ord_ore, b jsonb)
 function eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore)
-function eql_v3.neq(a public.timestamp_ord_ore, b public.timestamp_ord_ore_query)
-function eql_v3.neq(a public.timestamp_ord_ore_query, b public.timestamp_ord_ore)
-function eql_v3.neq(a public.timestamp_ord_query, b public.timestamp_ord)
+function eql_v3.ord_ope_term(a eql_v3.query_bigint_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_date_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_double_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_integer_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_numeric_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_real_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_smallint_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_text_ord_ope)
+function eql_v3.ord_ope_term(a eql_v3.query_timestamp_ord_ope)
 function eql_v3.ord_ope_term(a public.bigint_ord_ope)
-function eql_v3.ord_ope_term(a public.bigint_ord_ope_query)
 function eql_v3.ord_ope_term(a public.date_ord_ope)
-function eql_v3.ord_ope_term(a public.date_ord_ope_query)
 function eql_v3.ord_ope_term(a public.double_ord_ope)
-function eql_v3.ord_ope_term(a public.double_ord_ope_query)
 function eql_v3.ord_ope_term(a public.integer_ord_ope)
-function eql_v3.ord_ope_term(a public.integer_ord_ope_query)
 function eql_v3.ord_ope_term(a public.numeric_ord_ope)
-function eql_v3.ord_ope_term(a public.numeric_ord_ope_query)
 function eql_v3.ord_ope_term(a public.real_ord_ope)
-function eql_v3.ord_ope_term(a public.real_ord_ope_query)
 function eql_v3.ord_ope_term(a public.smallint_ord_ope)
-function eql_v3.ord_ope_term(a public.smallint_ord_ope_query)
 function eql_v3.ord_ope_term(a public.text_ord_ope)
-function eql_v3.ord_ope_term(a public.text_ord_ope_query)
 function eql_v3.ord_ope_term(a public.timestamp_ord_ope)
-function eql_v3.ord_ope_term(a public.timestamp_ord_ope_query)
+function eql_v3.ord_term(a eql_v3.query_bigint_ord)
+function eql_v3.ord_term(a eql_v3.query_bigint_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_date_ord)
+function eql_v3.ord_term(a eql_v3.query_date_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_double_ord)
+function eql_v3.ord_term(a eql_v3.query_double_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_integer_ord)
+function eql_v3.ord_term(a eql_v3.query_integer_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_numeric_ord)
+function eql_v3.ord_term(a eql_v3.query_numeric_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_real_ord)
+function eql_v3.ord_term(a eql_v3.query_real_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_smallint_ord)
+function eql_v3.ord_term(a eql_v3.query_smallint_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_text_ord)
+function eql_v3.ord_term(a eql_v3.query_text_ord_ore)
+function eql_v3.ord_term(a eql_v3.query_text_search)
+function eql_v3.ord_term(a eql_v3.query_timestamp_ord)
+function eql_v3.ord_term(a eql_v3.query_timestamp_ord_ore)
 function eql_v3.ord_term(a public.bigint_ord)
 function eql_v3.ord_term(a public.bigint_ord_ore)
-function eql_v3.ord_term(a public.bigint_ord_ore_query)
-function eql_v3.ord_term(a public.bigint_ord_query)
 function eql_v3.ord_term(a public.date_ord)
 function eql_v3.ord_term(a public.date_ord_ore)
-function eql_v3.ord_term(a public.date_ord_ore_query)
-function eql_v3.ord_term(a public.date_ord_query)
 function eql_v3.ord_term(a public.double_ord)
 function eql_v3.ord_term(a public.double_ord_ore)
-function eql_v3.ord_term(a public.double_ord_ore_query)
-function eql_v3.ord_term(a public.double_ord_query)
 function eql_v3.ord_term(a public.integer_ord)
 function eql_v3.ord_term(a public.integer_ord_ore)
-function eql_v3.ord_term(a public.integer_ord_ore_query)
-function eql_v3.ord_term(a public.integer_ord_query)
 function eql_v3.ord_term(a public.numeric_ord)
 function eql_v3.ord_term(a public.numeric_ord_ore)
-function eql_v3.ord_term(a public.numeric_ord_ore_query)
-function eql_v3.ord_term(a public.numeric_ord_query)
 function eql_v3.ord_term(a public.real_ord)
 function eql_v3.ord_term(a public.real_ord_ore)
-function eql_v3.ord_term(a public.real_ord_ore_query)
-function eql_v3.ord_term(a public.real_ord_query)
 function eql_v3.ord_term(a public.smallint_ord)
 function eql_v3.ord_term(a public.smallint_ord_ore)
-function eql_v3.ord_term(a public.smallint_ord_ore_query)
-function eql_v3.ord_term(a public.smallint_ord_query)
 function eql_v3.ord_term(a public.text_ord)
 function eql_v3.ord_term(a public.text_ord_ore)
-function eql_v3.ord_term(a public.text_ord_ore_query)
-function eql_v3.ord_term(a public.text_ord_query)
 function eql_v3.ord_term(a public.text_search)
-function eql_v3.ord_term(a public.text_search_query)
 function eql_v3.ord_term(a public.timestamp_ord)
 function eql_v3.ord_term(a public.timestamp_ord_ore)
-function eql_v3.ord_term(a public.timestamp_ord_ore_query)
-function eql_v3.ord_term(a public.timestamp_ord_query)
 function eql_v3.ore_cllw(entry public.jsonb_entry)
 function eql_v3.selector(entry public.jsonb_entry)
 function eql_v3.selector(val jsonb)
diff --git a/tests/sqlx/src/matrix.rs b/tests/sqlx/src/matrix.rs
index f2b23b3bc..aa6b5814e 100644
--- a/tests/sqlx/src/matrix.rs
+++ b/tests/sqlx/src/matrix.rs
@@ -1507,8 +1507,8 @@ macro_rules! __scalar_matrix_planner_metadata_case {
 
                 // 5 arg shapes per operator: the 3 storage shapes — (d,d),
                 // (d,jsonb), (jsonb,d) — plus the 2 CIP-3432 query-operand shapes
-                // — (d, d_query), (d_query, d). Every term-bearing domain the
-                // planner-metadata suite runs on has a `<name>_query` twin, so
+                // — (d, query_d), (query_d, d). Every term-bearing domain the
+                // planner-metadata suite runs on has a `query_<name>` twin, so
                 // the count is uniformly ops x 5.
                 let expected = ops.len() * 5;
                 anyhow::ensure!(
diff --git a/tests/sqlx/src/property.rs b/tests/sqlx/src/property.rs
index cf4b04848..d4228c1c1 100644
--- a/tests/sqlx/src/property.rs
+++ b/tests/sqlx/src/property.rs
@@ -85,19 +85,29 @@ fn jsonb(payload_json: &str) -> String {
 }
 
 /// Cast a JSON text literal into a QUERY-operand value: strip the ciphertext
-/// `c` (a query operand carries index terms only) and cast to `<domain>_query`.
-/// This is exactly what a client sends — the stored envelope minus `c` — and
-/// the RHS the `(storage, <name>_query)` query operators consume (CIP-3432).
+/// `c` (a query operand carries index terms only) and cast to the domain's
+/// `query_<name>` twin (prefix naming — CIP-3442). This is exactly what a
+/// client sends — the stored envelope minus `c` — and the RHS the
+/// `(storage, query_<name>)` query operators consume (CIP-3432).
 fn query_cast(payload_json: &str, domain: &str) -> String {
     let mut v: serde_json::Value =
         serde_json::from_str(payload_json).expect("payload_json is valid JSON");
     if let Some(obj) = v.as_object_mut() {
         obj.remove("c");
     }
+    // `domain` is schema-qualified (`public.integer_eq`); the twin prefixes
+    // the unqualified name and lives in the eql_v3 schema, not `public`
+    // (query operands are never column types — CIP-3442):
+    // `eql_v3.query_integer_eq`.
+    let bare = match domain.rsplit_once('.') {
+        Some((_, name)) => name,
+        None => domain,
+    };
+    let query_domain = format!("eql_v3.query_{bare}");
     format!(
-        "'{}'::jsonb::{}_query",
+        "'{}'::jsonb::{}",
         v.to_string().replace('\'', "''"),
-        domain
+        query_domain
     )
 }
 
@@ -113,7 +123,7 @@ pub async fn assert_eq_oracle<T: ScalarType>(pool: &PgPool, rows: &[Row<T>]) ->
             let b_dom = cast(&b.payload_json, &domain);
             // CIP-3432: the SAME pair also exercises the term-only query operand
             // (the stored payload minus its ciphertext `c`) through the
-            // `(storage, <name>_query)` operators, in both directions — folded
+            // `(storage, query_<name>)` operators, in both directions — folded
             // into this one round trip so query coverage adds no DB load.
             let a_qry = query_cast(&a.payload_json, &domain);
             let b_qry = query_cast(&b.payload_json, &domain);
@@ -146,19 +156,19 @@ pub async fn assert_eq_oracle<T: ScalarType>(pool: &PgPool, rows: &[Row<T>]) ->
             );
             anyhow::ensure!(
                 eq_q == Some(want),
-                "query `=` mismatch on {domain}_query: {:?} vs {:?} want {want}, got {eq_q:?}",
+                "query `=` mismatch on the query twin of {domain}: {:?} vs {:?} want {want}, got {eq_q:?}",
                 a.plaintext,
                 b.plaintext
             );
             anyhow::ensure!(
                 neq_q == Some(!want),
-                "query `<>` mismatch on {domain}_query: {:?} vs {:?}",
+                "query `<>` mismatch on the query twin of {domain}: {:?} vs {:?}",
                 a.plaintext,
                 b.plaintext
             );
             anyhow::ensure!(
                 eq_qc == Some(want),
-                "commutator query `=` mismatch on {domain}_query: {:?} vs {:?}",
+                "commutator query `=` mismatch on the query twin of {domain}: {:?} vs {:?}",
                 a.plaintext,
                 b.plaintext
             );
@@ -186,7 +196,7 @@ pub async fn assert_ord_oracle<T: ScalarType>(
             let a_cast = cast(&a.payload_json, &domain);
             let b_cast = cast(&b.payload_json, &domain);
             // CIP-3432: the term-only query operand for `b` (payload minus `c`),
-            // exercised through `(storage, <name>_query)` ordering in the SAME
+            // exercised through `(storage, query_<name>)` ordering in the SAME
             // round trip (no added DB load).
             let b_qry = query_cast(&b.payload_json, &domain);
             let sql = format!(
@@ -221,19 +231,19 @@ pub async fn assert_ord_oracle<T: ScalarType>(
             );
             anyhow::ensure!(
                 lt_q == Some(pa < pb),
-                "query `<` mismatch on {domain}_query: {pa:?}<{pb:?}"
+                "query `<` mismatch on the query twin of {domain}: {pa:?}<{pb:?}"
             );
             anyhow::ensure!(
                 lte_q == Some(pa <= pb),
-                "query `<=` mismatch on {domain}_query: {pa:?}<={pb:?}"
+                "query `<=` mismatch on the query twin of {domain}: {pa:?}<={pb:?}"
             );
             anyhow::ensure!(
                 gt_q == Some(pa > pb),
-                "query `>` mismatch on {domain}_query: {pa:?}>{pb:?}"
+                "query `>` mismatch on the query twin of {domain}: {pa:?}>{pb:?}"
             );
             anyhow::ensure!(
                 gte_q == Some(pa >= pb),
-                "query `>=` mismatch on {domain}_query: {pa:?}>={pb:?}"
+                "query `>=` mismatch on the query twin of {domain}: {pa:?}>={pb:?}"
             );
         }
     }
@@ -250,9 +260,9 @@ pub enum Overload {
     DomainDomain,
     DomainJsonb,
     JsonbDomain,
-    /// CIP-3432: the RHS is the term-only query operand (`<domain>_query`, the
-    /// payload minus `c`) — the `(storage, <name>_query)` function overload. The
-    /// facet that reaches `text_search_query`, which the operator oracle (which
+    /// CIP-3432: the RHS is the term-only query operand (`query_<domain>`, the
+    /// payload minus `c`) — the `(storage, query_<name>)` function overload. The
+    /// facet that reaches `query_text_search`, which the operator oracle (which
     /// runs text via `_eq`/`_ord`/`_ord_ore`, not `_search`) never touches.
     DomainQuery,
 }
@@ -502,7 +512,7 @@ pub async fn assert_match_smoke(
     let needle = cast(needle_json, domain);
     let disjoint = cast(disjoint_json, domain);
     // CIP-3432: the term-only query operands (bloom `bf`, no ciphertext `c`),
-    // consumed by the `(text_match, text_match_query)` containment operators.
+    // consumed by the `(text_match, query_text_match)` containment operators.
     let needle_q = query_cast(needle_json, domain);
     let disjoint_q = query_cast(disjoint_json, domain);
 
diff --git a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs
index 85767afbf..3fe4f31fc 100644
--- a/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs
+++ b/tests/sqlx/tests/encrypted_domain/family/jsonb_check.rs
@@ -12,11 +12,11 @@
 //! divergence is SQL NULL, which both forms accept (the validator via
 //! STRICT, the inline expression via a leading `VALUE IS NULL OR`).
 //!
-//! `public.jsonb_query`'s CHECK CANNOT be inlined — validating sv elements
+//! `eql_v3.query_jsonb`'s CHECK CANNOT be inlined — validating sv elements
 //! needs a subquery, which CHECK constraints forbid — so its validator is
 //! plpgsql instead (cached plan vs the per-call SQL-function executor; the
-//! issue #353 finding). `jsonb_query_check_behaviour` characterises the
-//! accept/reject matrix, and `jsonb_query_validator_is_plpgsql` guards the
+//! issue #353 finding). `query_jsonb_check_behaviour` characterises the
+//! accept/reject matrix, and `query_jsonb_validator_is_plpgsql` guards the
 //! language so a revert to LANGUAGE sql fails here.
 
 use anyhow::Result;
@@ -102,7 +102,7 @@ async fn jsonb_entry_check_matches_validator(pool: PgPool) -> Result<()> {
 }
 
 #[sqlx::test]
-async fn jsonb_query_check_behaviour(pool: PgPool) -> Result<()> {
+async fn query_jsonb_check_behaviour(pool: PgPool) -> Result<()> {
     // (payload, expected accept) — hardcoded verdicts: the CHECK calls the
     // validator, so a validator-equivalence assertion would be tautological.
     let candidates: &[(Option<&str>, bool)] = &[
@@ -128,22 +128,22 @@ async fn jsonb_query_check_behaviour(pool: PgPool) -> Result<()> {
         (Some("[]"), false),
     ];
     for (payload, expected) in candidates {
-        let cast = cast_accepts(&pool, "public.jsonb_query", *payload).await?;
+        let cast = cast_accepts(&pool, "eql_v3.query_jsonb", *payload).await?;
         anyhow::ensure!(
             cast == *expected,
-            "public.jsonb_query cast verdict changed for {payload:?}: \
+            "eql_v3.query_jsonb cast verdict changed for {payload:?}: \
              accepted = {cast}, expected = {expected}"
         );
     }
     Ok(())
 }
 
-/// The jsonb_query validator must stay plpgsql: its only caller is the domain
+/// The query_jsonb validator must stay plpgsql: its only caller is the domain
 /// CHECK (a context that can never inline a SQL function), so LANGUAGE sql
 /// pays the per-call SQL-function executor on every containment-needle cast
 /// (issues #353/#354). A revert fails here.
 #[sqlx::test]
-async fn jsonb_query_validator_is_plpgsql(pool: PgPool) -> Result<()> {
+async fn query_jsonb_validator_is_plpgsql(pool: PgPool) -> Result<()> {
     let lang: String = sqlx::query_scalar(
         "SELECT l.lanname FROM pg_proc p \
          JOIN pg_language l ON l.oid = p.prolang \
diff --git a/tests/sqlx/tests/encrypted_domain/family/support.rs b/tests/sqlx/tests/encrypted_domain/family/support.rs
index d16f25b0d..bc6576d17 100644
--- a/tests/sqlx/tests/encrypted_domain/family/support.rs
+++ b/tests/sqlx/tests/encrypted_domain/family/support.rs
@@ -146,17 +146,17 @@ async fn no_cross_variant_operator_is_declared(pool: PgPool) -> Result<()> {
     // `=`. If someone accidentally adds such an operator, this test fails.
     //
     // The jsonb DOCUMENT surface is excluded: it intentionally defines
-    // cross-type containment operators (`json @> jsonb_query`,
+    // cross-type containment operators (`json @> query_jsonb`,
     // `json @> jsonb_entry` and their `<@` commutators) — the documented
     // document-containment API, not scalar capability variants that must
-    // resolve to a blocker. So `json` / `jsonb_entry` / `jsonb_query` are
+    // resolve to a blocker. So `json` / `jsonb_entry` / `query_jsonb` are
     // out of scope for this scalar-variant guard.
     //
     // The check is structural (`pg_operator`) rather than dynamic
     // ("invoke and see it raise") so a future PG version with stricter
     // operator resolution doesn't mask the regression.
     // Derive the excluded (non-scalar) domain names from the catalog rather than
-    // hardcoding `'json', 'jsonb_entry', 'jsonb_query'` — a future rename or a
+    // hardcoding `'json', 'jsonb_entry', 'query_jsonb'` — a future rename or a
     // second non-scalar family stays covered automatically (the names come from
     // the same `DomainFamily::domain_name` the SQL surface is generated through).
     let excluded: Vec<String> = eql_domains::CATALOG
diff --git a/tests/sqlx/tests/encrypted_domain/ope/support.rs b/tests/sqlx/tests/encrypted_domain/ope/support.rs
index a42ca510e..d52aa062e 100644
--- a/tests/sqlx/tests/encrypted_domain/ope/support.rs
+++ b/tests/sqlx/tests/encrypted_domain/ope/support.rs
@@ -257,9 +257,10 @@ macro_rules! ope_ord_fixture_smoke {
             );
 
             // CIP-3432: the term-only query operand — the pivot payload minus
-            // its ciphertext `c`, cast to `<domain>_query`. Every predicate must
-            // match the SAME oracle through the `(storage, <domain>_query)`
-            // operators as through the full-envelope operand.
+            // its ciphertext `c`, cast to `query_<domain>` (prefix naming —
+            // CIP-3442). Every predicate must match the SAME oracle through the
+            // `(storage, query_<domain>)` operators as through the
+            // full-envelope operand.
             let pivot_query_cast = {
                 let mut v: serde_json::Value =
                     serde_json::from_str(&pivot_json).expect("pivot payload is valid JSON");
@@ -267,7 +268,7 @@ macro_rules! ope_ord_fixture_smoke {
                     o.remove("c");
                 }
                 format!(
-                    "'{}'::jsonb::public.{}_query",
+                    "'{}'::jsonb::eql_v3.query_{}",
                     v.to_string().replace('\'', "''"),
                     $domain
                 )
diff --git a/tests/sqlx/tests/payload_schema_tests.rs b/tests/sqlx/tests/payload_schema_tests.rs
index ce46ef8b9..6919ebf7c 100644
--- a/tests/sqlx/tests/payload_schema_tests.rs
+++ b/tests/sqlx/tests/payload_schema_tests.rs
@@ -598,9 +598,9 @@ fn from_v2_query_output_validates_against_published_v3_schema() {
     });
     let out = from_v2_query(&v2, TargetDomain::Json).expect("query conversion must succeed");
     assert_valid(
-        &load_v3_schema("jsonb_query"),
+        &load_v3_schema("query_jsonb"),
         &out,
-        "from_v2_query output for jsonb_query",
+        "from_v2_query output for query_jsonb",
     );
 }
 
diff --git a/tests/sqlx/tests/v3_jsonb_bindings_tests.rs b/tests/sqlx/tests/v3_jsonb_bindings_tests.rs
index 8aa96c951..000922915 100644
--- a/tests/sqlx/tests/v3_jsonb_bindings_tests.rs
+++ b/tests/sqlx/tests/v3_jsonb_bindings_tests.rs
@@ -65,7 +65,7 @@ async fn real_ste_vec_row_parses_into_document_and_entries(pool: PgPool) -> anyh
 #[sqlx::test(fixtures(path = "../fixtures", scripts("v3_ste_vec")))]
 async fn real_ste_vec_query_parses_into_bindings(pool: PgPool) -> anyhow::Result<()> {
     // `eql_v3.to_ste_vec_query` turns an encrypted document into a containment
-    // needle (`public.jsonb_query`), the shape a caller builds a `@>` / `<@`
+    // needle (`eql_v3.query_jsonb`), the shape a caller builds a `@>` / `<@`
     // query from. Parse a REAL one into `SteVecQuery` (and, transitively, its
     // `SteVecQueryEntry` elements), tying those two bindings to real crypto and
     // the hand-written `is_valid_ste_vec_query_payload` CHECK — the document/entry
diff --git a/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs b/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs
index c6535f74f..9e4c6b8a1 100644
--- a/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs
+++ b/tests/sqlx/tests/v3_jsonb_operator_surface_tests.rs
@@ -38,7 +38,7 @@ async fn v3_jsonb_operators(pool: &PgPool) -> anyhow::Result<Vec<(String, String
         WITH d AS (
           SELECT 'public.json'::regtype          AS j,
                  'public.jsonb_entry'::regtype  AS e,
-                 'public.jsonb_query'::regtype  AS q
+                 'eql_v3.query_jsonb'::regtype  AS q
         )
         SELECT o.oprname,
                pg_catalog.format_type(o.oprleft, NULL)  AS lhs,
@@ -59,7 +59,7 @@ fn norm(ty: &str) -> String {
     match ty {
         "\"json\"" => "public.json".to_string(),
         "jsonb_entry" => "public.jsonb_entry".to_string(),
-        "jsonb_query" => "public.jsonb_query".to_string(),
+        "query_jsonb" => "eql_v3.query_jsonb".to_string(),
         _ => ty.replace("public.\"json\"", "public.json"),
     }
 }
@@ -144,10 +144,10 @@ async fn v3_jsonb_surface_supported_signatures(pool: PgPool) -> anyhow::Result<(
     let expected_supported: &[(&str, &str, &str)] = &[
         // containment
         ("@>", "public.json", "public.json"),
-        ("@>", "public.json", "public.jsonb_query"),
+        ("@>", "public.json", "eql_v3.query_jsonb"),
         ("@>", "public.json", "public.jsonb_entry"),
         ("<@", "public.json", "public.json"),
-        ("<@", "public.jsonb_query", "public.json"),
+        ("<@", "eql_v3.query_jsonb", "public.json"),
         ("<@", "public.jsonb_entry", "public.json"),
         // path access
         ("->", "public.json", "text"),
@@ -316,7 +316,7 @@ async fn v3_jsonb_surface_blocker_signatures(pool: PgPool) -> anyhow::Result<()>
         (">=", "public.json", "jsonb"),
         (">=", "jsonb", "public.json"),
         // mixed jsonb containment shapes are blocked; safe forms use json,
-        // jsonb_query, or jsonb_entry.
+        // query_jsonb, or jsonb_entry.
         ("@>", "public.json", "jsonb"),
         ("@>", "jsonb", "public.json"),
         ("<@", "public.json", "jsonb"),
diff --git a/tests/sqlx/tests/v3_jsonb_tests.rs b/tests/sqlx/tests/v3_jsonb_tests.rs
index d13a7ba68..fbbe163e2 100644
--- a/tests/sqlx/tests/v3_jsonb_tests.rs
+++ b/tests/sqlx/tests/v3_jsonb_tests.rs
@@ -1,5 +1,5 @@
 //! Parameterized test harness for the `eql_v3` encrypted-JSONB (SteVec) surface
-//! (`public.json` / `public.jsonb_entry` / `public.jsonb_query`).
+//! (`public.json` / `public.jsonb_entry` / `eql_v3.query_jsonb`).
 //!
 //! Design source of truth:
 //! `docs/superpowers/plans/2026-06-09-eql-v3-jsonb-test-harness-design.md`.
@@ -102,7 +102,7 @@ fn doc(elems: &[String]) -> String {
     )
 }
 
-/// Build a `jsonb_query` needle literal from `(selector, term_field, hex)`
+/// Build a `query_jsonb` needle literal from `(selector, term_field, hex)`
 /// triples (each element carries `s` + exactly one term, never `c`).
 fn needle(elems: &[(&str, &str, &str)]) -> String {
     let parts: Vec<String> = elems
@@ -306,7 +306,7 @@ async fn v3_jsonb_containment_hm_only(pool: PgPool) -> anyhow::Result<()> {
     let root_hm = root_hm_term(&pool).await?;
     let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]);
     let hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -315,9 +315,9 @@ async fn v3_jsonb_containment_hm_only(pool: PgPool) -> anyhow::Result<()> {
         "every fixture row carries the constant root hm"
     );
 
-    // Commutator: jsonb_query <@ json must agree row-for-row.
+    // Commutator: query_jsonb <@ json must agree row-for-row.
     let hits_rev: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::public.jsonb_query <@ payload"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_jsonb <@ payload"
     ))
     .fetch_one(&pool)
     .await?;
@@ -337,7 +337,7 @@ async fn v3_jsonb_containment_oc_only(pool: PgPool) -> anyhow::Result<()> {
 
     // Row 1 must be among the matches (oc terms can repeat across rows).
     let row1: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -345,12 +345,12 @@ async fn v3_jsonb_containment_oc_only(pool: PgPool) -> anyhow::Result<()> {
 
     // Commutator agreement over the whole table.
     let fwd: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
     let rev: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::public.jsonb_query <@ payload"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE '{n}'::eql_v3.query_jsonb <@ payload"
     ))
     .fetch_one(&pool)
     .await?;
@@ -403,7 +403,7 @@ async fn v3_jsonb_containment_mixed(pool: PgPool) -> anyhow::Result<()> {
     let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm), (SEL_HELLO_OC, "oc", &oc)]);
 
     let row1: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE id = 1 AND payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -625,7 +625,7 @@ async fn v3_jsonb_containment_rejects_wrong_bytes(pool: PgPool) -> anyhow::Resul
     let root_hm = root_hm_term(&pool).await?;
     let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]);
     let good_hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -637,7 +637,7 @@ async fn v3_jsonb_containment_rejects_wrong_bytes(pool: PgPool) -> anyhow::Resul
     // Real selector, WRONG hm bytes — must match nothing.
     let n = needle(&[(SEL_ROOT_HM, "hm", "deadbeefdeadbeefdeadbeefdeadbeef")]);
     let hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -664,12 +664,12 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R
     let oc_needle = needle(&[(COLLIDE_SEL, "oc", COLLIDE_TERM)]);
     let hm_needle = needle(&[(COLLIDE_SEL, "hm", COLLIDE_TERM)]);
     let collide_accept: bool = sqlx::query_scalar(&format!(
-        "SELECT '{hm_doc}'::public.json @> '{hm_needle}'::public.jsonb_query"
+        "SELECT '{hm_doc}'::public.json @> '{hm_needle}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
     let collide_reject: bool = sqlx::query_scalar(&format!(
-        "SELECT '{hm_doc}'::public.json @> '{oc_needle}'::public.jsonb_query"
+        "SELECT '{hm_doc}'::public.json @> '{oc_needle}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -685,7 +685,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R
     let root_hm = root_hm_term(&pool).await?;
     let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]);
     let good_hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -697,7 +697,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R
     // An `oc`-field needle carrying the real hm term at the hm selector: rejects.
     let n = needle(&[(SEL_ROOT_HM, "oc", &root_hm)]);
     let hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -715,7 +715,7 @@ async fn v3_jsonb_containment_rejects_wrong_term_type(pool: PgPool) -> anyhow::R
     .await?;
     let n2 = needle(&[(SEL_HELLO_OC, "hm", &oc)]);
     let hits2: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n2}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n2}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -733,7 +733,7 @@ async fn v3_jsonb_containment_rejects_wrong_selector(pool: PgPool) -> anyhow::Re
     let root_hm = root_hm_term(&pool).await?;
     let good = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]);
     let good_hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{good}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -745,7 +745,7 @@ async fn v3_jsonb_containment_rejects_wrong_selector(pool: PgPool) -> anyhow::Re
     // Right term bytes, but a selector that exists in no fixture row.
     let n = needle(&[("ffffffffffffffffffffffffffffffff", "hm", &root_hm)]);
     let hits: i64 = sqlx::query_scalar(&format!(
-        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query"
+        "SELECT count(*) FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb"
     ))
     .fetch_one(&pool)
     .await?;
@@ -803,12 +803,12 @@ v3_jsonb_supported_null!(
     // document containment: json @> json
     (doc_contains_doc_lhs, "SELECT NULL::public.json @> '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json"),
     (doc_contains_doc_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json @> NULL::public.json"),
-    // json @> jsonb_query / json @> jsonb_entry
-    (doc_contains_query_lhs, "SELECT NULL::public.json @> '{\"sv\":[]}'::public.jsonb_query"),
-    (doc_contains_query_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json @> NULL::public.jsonb_query"),
+    // json @> query_jsonb / json @> jsonb_entry
+    (doc_contains_query_lhs, "SELECT NULL::public.json @> '{\"sv\":[]}'::eql_v3.query_jsonb"),
+    (doc_contains_query_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json @> NULL::eql_v3.query_jsonb"),
     (doc_contains_entry_rhs, "SELECT '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json @> NULL::public.jsonb_entry"),
     // <@ reverses
-    (query_contained_lhs, "SELECT NULL::public.jsonb_query <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json"),
+    (query_contained_lhs, "SELECT NULL::eql_v3.query_jsonb <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json"),
     (entry_contained_lhs, "SELECT NULL::public.jsonb_entry <@ '{\"i\":{},\"v\":3,\"sv\":[]}'::public.json"),
 );
 
@@ -1164,7 +1164,7 @@ v3_jsonb_payload_reject!(
 
 v3_jsonb_payload_reject!(
     v3_jsonb_ste_vec_query_payload_check,
-    "public.jsonb_query",
+    "eql_v3.query_jsonb",
     [
         "[]",                                                   // non-object
         "{\"sv\":{}}",                                          // sv not an array
@@ -1194,7 +1194,7 @@ async fn v3_jsonb_payload_check_accepts_valid(pool: PgPool) -> anyhow::Result<()
     .await?;
     assert!(ok_entry);
     let ok_query: bool = sqlx::query_scalar(
-        "SELECT '{\"sv\":[{\"s\":\"x\",\"hm\":\"00\"}]}'::public.jsonb_query IS NOT NULL",
+        "SELECT '{\"sv\":[{\"s\":\"x\",\"hm\":\"00\"}]}'::eql_v3.query_jsonb IS NOT NULL",
     )
     .fetch_one(&pool)
     .await?;
@@ -1371,7 +1371,7 @@ async fn v3_jsonb_index_to_ste_vec_query_gin_engages(pool: PgPool) -> anyhow::Re
     let root_hm = root_hm_term(&pool).await?;
     let n = needle(&[(SEL_ROOT_HM, "hm", &root_hm)]);
     let query =
-        format!("SELECT id FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::public.jsonb_query");
+        format!("SELECT id FROM fixtures.v3_ste_vec WHERE payload @> '{n}'::eql_v3.query_jsonb");
     assert_index_scan_uses(
         &mut *tx,
         &query,
@@ -1483,7 +1483,7 @@ async fn v3_jsonb_to_ste_vec_query_gin_is_cost_chosen(pool: PgPool) -> anyhow::R
     // oc, exactly the single pivot row contains it.
     let n = needle(&[(SEL_HELLO_OC, "oc", &pivot_oc)]);
     let query =
-        format!("SELECT count(*) FROM v3_jsonb_scale WHERE payload @> '{n}'::public.jsonb_query");
+        format!("SELECT count(*) FROM v3_jsonb_scale WHERE payload @> '{n}'::eql_v3.query_jsonb");
     assert_index_scan_uses(
         &mut *tx,
         &query,
diff --git a/tests/sqlx/tests/v3_operator_equivalents_tests.rs b/tests/sqlx/tests/v3_operator_equivalents_tests.rs
index 74aa9d0ca..f41bb5a8c 100644
--- a/tests/sqlx/tests/v3_operator_equivalents_tests.rs
+++ b/tests/sqlx/tests/v3_operator_equivalents_tests.rs
@@ -23,17 +23,63 @@
 use anyhow::Result;
 use sqlx::PgPool;
 
-/// #1 — Every operator that operates on an `eql_v3` domain and is backed by a
+/// Every EQL COLUMN-domain name in the `public` schema, from the catalog: the
+/// storage and capability domains of every family. The jsonb needle
+/// (`query_jsonb`) is a query operand and lives in `eql_v3`, so `full_name`s
+/// starting with `query_` are excluded here (see [`eql_query_domain_names`]).
+/// The structural scan below identifies "an EQL operator" by these names —
+/// the column domains deliberately live in `public` (dropping EQL-owned
+/// schemas must not drop application columns), so a namespace filter alone
+/// cannot find them.
+fn eql_public_domain_names() -> Vec<String> {
+    eql_domains::CATALOG
+        .iter()
+        .flat_map(|f| f.domains.iter().map(move |d| d.full_name(f.name)))
+        .filter(|n| !n.starts_with("query_"))
+        .collect()
+}
+
+/// Every EQL QUERY-OPERAND domain name, from the catalog: the `query_<name>`
+/// twin of every term-bearing scalar domain plus the jsonb containment needle
+/// (`query_jsonb`). These live in the `eql_v3` schema (CIP-3442) — never
+/// valid column types, so they don't share the column domains' `public` home.
+fn eql_query_domain_names() -> Vec<String> {
+    let mut names: Vec<String> = eql_domains::scalar_families()
+        .flat_map(|f| {
+            f.domains
+                .iter()
+                .filter(|d| !d.terms.is_empty())
+                .map(move |d| d.query_name(f.name))
+        })
+        .collect();
+    names.push("query_jsonb".to_string());
+    names
+}
+
+/// #1 — Every operator that operates on an EQL domain and is backed by a
 /// real comparison WRAPPER (a `LANGUAGE sql` function — blockers are
 /// `LANGUAGE plpgsql`) must have that wrapper in the PUBLIC `eql_v3` schema.
 ///
 /// An offender is a supported operator whose function equivalent is hidden in
 /// `eql_v3_internal`, where an operator-free caller cannot reach it.
+///
+/// EQL operands are identified by catalog name in their home namespace —
+/// column domains in `public`, query-operand twins in `eql_v3` (an earlier
+/// bare `nspname = 'eql_v3'` filter matched zero operators, before the query
+/// domains moved there, and the scan passed vacuously). The test first
+/// asserts the scan MATCHES a healthy number of operators, so it can never
+/// silently rot back into vacuous-pass.
 #[sqlx::test]
 async fn every_supported_eql_v3_operator_has_a_public_function_equivalent(
     pool: PgPool,
 ) -> Result<()> {
-    let offenders: Vec<(String, String, String)> = sqlx::query_as(
+    let column_domains = eql_public_domain_names();
+    let query_domains = eql_query_domain_names();
+
+    // All operators touching an EQL domain, wrapper-backed (LANGUAGE sql) or
+    // not, with the backing function's schema. One scan, partitioned in Rust:
+    // non-vacuousness first, then the offender assertion.
+    let scanned: Vec<(String, String, String, String)> = sqlx::query_as(
         r#"
         SELECT
           o.oprname::text,
@@ -41,7 +87,8 @@ async fn every_supported_eql_v3_operator_has_a_public_function_equivalent(
           format('%s %s %s',
                  lt.typname,
                  o.oprname,
-                 COALESCE(rt.typname, '')) AS operator_shape
+                 COALESCE(rt.typname, '')) AS operator_shape,
+          l.lanname::text
         FROM pg_catalog.pg_operator o
         JOIN pg_catalog.pg_proc       p  ON p.oid = o.oprcode
         JOIN pg_catalog.pg_namespace  pn ON pn.oid = p.pronamespace
@@ -50,15 +97,39 @@ async fn every_supported_eql_v3_operator_has_a_public_function_equivalent(
         JOIN pg_catalog.pg_namespace  ln ON ln.oid = lt.typnamespace
         LEFT JOIN pg_catalog.pg_type      rt ON rt.oid = o.oprright
         LEFT JOIN pg_catalog.pg_namespace rn ON rn.oid = rt.typnamespace
-        WHERE (ln.nspname = 'eql_v3' OR rn.nspname = 'eql_v3')  -- touches an eql_v3 domain
-          AND l.lanname = 'sql'          -- a supported wrapper, not a plpgsql blocker
-          AND pn.nspname <> 'eql_v3'     -- OFFENDER: backing wrapper is not public
+        WHERE (ln.nspname = 'public' AND lt.typname = ANY($1))
+           OR (rn.nspname = 'public' AND rt.typname = ANY($1))
+           OR (ln.nspname = 'eql_v3' AND lt.typname = ANY($2))
+           OR (rn.nspname = 'eql_v3' AND rt.typname = ANY($2))
         ORDER BY 3, 1
         "#,
     )
+    .bind(&column_domains)
+    .bind(&query_domains)
     .fetch_all(&pool)
     .await?;
 
+    // Anti-vacuousness guard: the generated surface binds hundreds of
+    // operators to EQL domains (10 scalar families x supported ops x operand
+    // shapes, plus the jsonb surface). If the scan stops matching, the filter
+    // is broken — fail loudly instead of passing on an empty set.
+    assert!(
+        scanned.len() >= 100,
+        "the structural scan matched only {} operators on EQL domains — the \
+         domain-name filter is broken (vacuous pass), fix the query instead of \
+         trusting an empty offender list",
+        scanned.len()
+    );
+
+    // A supported wrapper is LANGUAGE sql (blockers are plpgsql and stay
+    // internal by design). Its backing function must be public.
+    let offenders: Vec<&(String, String, String, String)> = scanned
+        .iter()
+        .filter(|(_, backing_fn, _, lanname)| {
+            lanname == "sql" && !backing_fn.starts_with("eql_v3.")
+        })
+        .collect();
+
     assert!(
         offenders.is_empty(),
         "Supported eql_v3 operators must be backed by a PUBLIC eql_v3 function so \
diff --git a/tests/sqlx/tests/v3_public_surface_tests.rs b/tests/sqlx/tests/v3_public_surface_tests.rs
index 2c439c8e2..df2030a2d 100644
--- a/tests/sqlx/tests/v3_public_surface_tests.rs
+++ b/tests/sqlx/tests/v3_public_surface_tests.rs
@@ -91,9 +91,11 @@ async fn public_surface(pool: &PgPool) -> Result<Vec<String>> {
 }
 
 /// User-column domain names, as they appear in SQL: scalar-family domains plus
-/// the hand-written JSON/JSONB domains. These MUST live in `public` (never
-/// `eql_v3` or `eql_v3_internal`) so application tables using them survive EQL
-/// schema uninstall.
+/// the hand-written JSON/JSONB column domains. These MUST live in `public`
+/// (never `eql_v3` or `eql_v3_internal`) so application tables using them
+/// survive EQL schema uninstall. The query-operand domains are deliberately
+/// NOT here — they are never column types and live in `eql_v3` (CIP-3442);
+/// see [`query_domain_names`].
 fn user_domain_names() -> Vec<String> {
     let mut names = Vec::new();
     for family in eql_domains::scalar_families() {
@@ -105,11 +107,26 @@ fn user_domain_names() -> Vec<String> {
             }
         }
     }
-    names.extend(
-        ["json", "jsonb_entry", "jsonb_query"]
-            .into_iter()
-            .map(String::from),
-    );
+    names.extend(["json", "jsonb_entry"].into_iter().map(String::from));
+    names.sort();
+    names
+}
+
+/// Query-operand domain names: the `query_<name>` twin of every term-bearing
+/// scalar domain plus the jsonb containment needle. These MUST live in
+/// `eql_v3` (never `public`) — a query operand is not a column type, so it
+/// stays out of the column-type namespace and is uninstalled with the EQL
+/// surface (CIP-3442).
+fn query_domain_names() -> Vec<String> {
+    let mut names: Vec<String> = eql_domains::scalar_families()
+        .flat_map(|f| {
+            f.domains
+                .iter()
+                .filter(|d| !d.terms.is_empty())
+                .map(move |d| d.query_name(f.name))
+        })
+        .collect();
+    names.push("query_jsonb".to_string());
     names.sort();
     names
 }
@@ -251,6 +268,65 @@ async fn user_column_domains_absent_from_eql_owned_schemas(pool: PgPool) -> Resu
     Ok(())
 }
 
+/// #2 — Placement invariant (mirror): every query-operand domain lives in
+/// `eql_v3` as a jsonb-backed domain, and none leaks into `public`. A query
+/// operand is never a column type, so it is versioned and uninstalled with
+/// the EQL surface instead of sharing the column domains' `public` home
+/// (CIP-3442).
+#[sqlx::test]
+async fn query_operand_domains_are_eql_v3_jsonb_domains(pool: PgPool) -> Result<()> {
+    let installed: Vec<(String, String, String)> = sqlx::query_as(
+        r#"
+        SELECT n.nspname::text, t.typname::text, bt.typname::text
+        FROM pg_catalog.pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        JOIN pg_catalog.pg_type bt ON bt.oid = t.typbasetype
+        WHERE n.nspname IN ('public', 'eql_v3', 'eql_v3_internal')
+          AND t.typtype = 'd'
+          AND t.typname = ANY($1)
+        ORDER BY t.typname
+        "#,
+    )
+    .bind(query_domain_names())
+    .fetch_all(&pool)
+    .await?;
+
+    let misplaced: Vec<String> = installed
+        .iter()
+        .filter(|(schema, _, _)| schema != "eql_v3")
+        .map(|(schema, name, _)| format!("{schema}.{name}"))
+        .collect();
+    assert!(
+        misplaced.is_empty(),
+        "query-operand domains must live in eql_v3 only: {misplaced:?}"
+    );
+
+    let in_eql_v3: Vec<&String> = installed
+        .iter()
+        .filter(|(schema, _, _)| schema == "eql_v3")
+        .map(|(_, name, _)| name)
+        .collect();
+    let missing: Vec<String> = query_domain_names()
+        .into_iter()
+        .filter(|name| !in_eql_v3.contains(&name))
+        .collect();
+    assert!(
+        missing.is_empty(),
+        "query-operand domain(s) missing from eql_v3: {missing:?}"
+    );
+
+    let non_jsonb: Vec<String> = installed
+        .iter()
+        .filter(|(_, _, base)| base != "jsonb")
+        .map(|(_, name, base)| format!("{name} (base {base})"))
+        .collect();
+    assert!(
+        non_jsonb.is_empty(),
+        "eql_v3 query-operand domains must be jsonb-backed domains: {non_jsonb:?}"
+    );
+    Ok(())
+}
+
 /// #2 — Dependency invariant: public user-column domain CHECK constraints do not
 /// depend on objects in droppable EQL-owned schemas. Otherwise an EQL uninstall
 /// can still cascade into application table columns even when the domain type
diff --git a/tests/sqlx/tests/v3_scalar_query_operand_tests.rs b/tests/sqlx/tests/v3_scalar_query_operand_tests.rs
index 0f4a72f47..755d9a41d 100644
--- a/tests/sqlx/tests/v3_scalar_query_operand_tests.rs
+++ b/tests/sqlx/tests/v3_scalar_query_operand_tests.rs
@@ -1,11 +1,11 @@
-//! CIP-3432 conformance: a term-only query operand (`public.<name>_query` — the
+//! CIP-3432 conformance: a term-only query operand (`eql_v3.query_<name>` — the
 //! index terms only, NO ciphertext `c`) matches stored rows through the
 //! generated query operators, using FRESH ZeroKMS encryption for both the
 //! stored values AND the query value.
 //!
 //! This is the end-to-end proof the operator surface exists for: two
 //! INDEPENDENT encryptions of the same plaintext produce equal index terms that
-//! the `(storage_domain, <name>_query)` operator equates — with the query
+//! the `(storage_domain, query_<name>)` operator equates — with the query
 //! operand carrying no decryptable ciphertext. Gated behind `proptest-e2e`
 //! (needs `CS_*` creds at test time), like the rest of the fresh-encryption
 //! suite.
@@ -61,7 +61,7 @@ async fn eq_term_only_operand_matches_exactly_the_equal_rows(pool: PgPool) -> Re
     );
 
     let matches: i64 =
-        sqlx::query_scalar("SELECT count(*) FROM q WHERE val = $1::jsonb::public.integer_eq_query")
+        sqlx::query_scalar("SELECT count(*) FROM q WHERE val = $1::jsonb::eql_v3.query_integer_eq")
             .bind(operand.to_string())
             .fetch_one(&pool)
             .await?;
@@ -73,7 +73,7 @@ async fn eq_term_only_operand_matches_exactly_the_equal_rows(pool: PgPool) -> Re
     // A value never stored matches nothing (the eq-false branch).
     let absent = to_query_operand(encrypt_one(99, &[IndexKind::Unique]).await?);
     let none: i64 =
-        sqlx::query_scalar("SELECT count(*) FROM q WHERE val = $1::jsonb::public.integer_eq_query")
+        sqlx::query_scalar("SELECT count(*) FROM q WHERE val = $1::jsonb::eql_v3.query_integer_eq")
             .bind(absent.to_string())
             .fetch_one(&pool)
             .await?;
@@ -98,7 +98,7 @@ async fn ord_term_only_operand_orders_via_the_ore_operator(pool: PgPool) -> Resu
     // A term-only ordering operand for 25 (never stored): `< 25` → {10, 20}.
     let operand = to_query_operand(encrypt_one(25, &[IndexKind::Ore]).await?);
     let below: i64 = sqlx::query_scalar(
-        "SELECT count(*) FROM q WHERE val < $1::jsonb::public.integer_ord_query",
+        "SELECT count(*) FROM q WHERE val < $1::jsonb::eql_v3.query_integer_ord",
     )
     .bind(operand.to_string())
     .fetch_one(&pool)
@@ -107,7 +107,7 @@ async fn ord_term_only_operand_orders_via_the_ore_operator(pool: PgPool) -> Resu
 
     // The commutator direction resolves too: `operand > val`.
     let above: i64 = sqlx::query_scalar(
-        "SELECT count(*) FROM q WHERE $1::jsonb::public.integer_ord_query > val",
+        "SELECT count(*) FROM q WHERE $1::jsonb::eql_v3.query_integer_ord > val",
     )
     .bind(operand.to_string())
     .fetch_one(&pool)
@@ -125,7 +125,7 @@ async fn query_domain_rejects_a_ciphertext_bearing_operand(pool: PgPool) -> Resu
     // `c`) must not be accepted as a query operand.
     let stored = encrypt_one(7, &[IndexKind::Unique]).await?;
     assert!(stored.as_object().unwrap().contains_key("c"));
-    let err = sqlx::query("SELECT $1::jsonb::public.integer_eq_query")
+    let err = sqlx::query("SELECT $1::jsonb::eql_v3.query_integer_eq")
         .bind(stored.to_string())
         .execute(&pool)
         .await
diff --git a/tests/sqlx/tests/v3_uninstall_tests.rs b/tests/sqlx/tests/v3_uninstall_tests.rs
index 8f4322f18..7833be142 100644
--- a/tests/sqlx/tests/v3_uninstall_tests.rs
+++ b/tests/sqlx/tests/v3_uninstall_tests.rs
@@ -142,7 +142,7 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) ->
         FROM pg_catalog.pg_type t
         JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
         WHERE n.nspname = 'public'
-          AND t.typname IN ('integer_eq', 'json', 'jsonb_entry', 'jsonb_query')
+          AND t.typname IN ('integer_eq', 'json', 'jsonb_entry')
         ORDER BY 1
         "#,
     )
@@ -154,15 +154,34 @@ async fn shipped_installer_can_run_over_existing_public_domains(pool: PgPool) ->
     public_domains.sort();
     assert_eq!(
         public_domains,
-        vec![
-            "public.integer_eq",
-            "public.json",
-            "public.jsonb_entry",
-            "public.jsonb_query",
-        ],
+        vec!["public.integer_eq", "public.json", "public.jsonb_entry"],
         "repeat install must keep public user-column domains available"
     );
 
+    // The query-operand domains are NOT column types and live in the EQL-owned
+    // eql_v3 schema (CIP-3442); a repeat install recreates them there.
+    let mut query_domains: Vec<String> = sqlx::query_scalar(
+        r#"
+        SELECT format('%I.%I', n.nspname, t.typname)
+        FROM pg_catalog.pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE n.nspname = 'eql_v3'
+          AND t.typname IN ('query_integer_eq', 'query_jsonb')
+        ORDER BY 1
+        "#,
+    )
+    .fetch_all(&pool)
+    .await?
+    .into_iter()
+    .map(normalize_regtype_name)
+    .collect();
+    query_domains.sort();
+    assert_eq!(
+        query_domains,
+        vec!["eql_v3.query_integer_eq", "eql_v3.query_jsonb"],
+        "repeat install must recreate the eql_v3 query-operand domains"
+    );
+
     Ok(())
 }
 
@@ -178,7 +197,6 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns(
 
     let scalar_payload = r#"{"v":3,"i":{},"c":"scalar-42","hm":"hm-42"}"#;
     let json_payload = r#"{"i":{},"v":3,"sv":[{"s":"age","c":"cipher-age","hm":"hm-age"}]}"#;
-    let query_payload = r#"{"sv":[{"s":"age","hm":"hm-age"}]}"#;
     let entry_payload = r#"{"s":"age","c":"cipher-age","hm":"hm-age"}"#;
 
     sqlx::query(
@@ -187,7 +205,6 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns(
           id integer PRIMARY KEY,
           scalar_value public.integer_eq NOT NULL,
           doc_value public.json NOT NULL,
-          query_value public.jsonb_query NOT NULL,
           entry_value public.jsonb_entry
         )
         "#,
@@ -198,24 +215,37 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns(
     sqlx::query(
         r#"
         INSERT INTO public.eql_v3_uninstall_preserve
-          (id, scalar_value, doc_value, query_value, entry_value)
+          (id, scalar_value, doc_value, entry_value)
         VALUES
           (
             1,
             $1::jsonb::public.integer_eq,
             $2::jsonb::public.json,
-            $3::jsonb::public.jsonb_query,
-            $4::jsonb::public.jsonb_entry
+            $3::jsonb::public.jsonb_entry
           )
         "#,
     )
     .bind(scalar_payload)
     .bind(json_payload)
-    .bind(query_payload)
     .bind(entry_payload)
     .execute(&pool)
     .await?;
 
+    // The inverse contract (CIP-3442): a query-operand domain is NOT a column
+    // type and lives in the EQL-owned eql_v3 schema, so a column misusing it
+    // is dropped with the schema. Pin that a table holding one loses exactly
+    // that column on uninstall (CASCADE), while the table itself survives.
+    sqlx::query(
+        r#"
+        CREATE TABLE public.eql_v3_uninstall_query_misuse (
+          id integer PRIMARY KEY,
+          misused_query_value eql_v3.query_jsonb
+        )
+        "#,
+    )
+    .execute(&pool)
+    .await?;
+
     run_shipped_uninstaller(&pool).await?;
 
     assert_eq!(
@@ -260,22 +290,15 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns(
             "pg_catalog.int4",
             "public.integer_eq",
             "public.json",
-            "public.jsonb_query",
             "public.jsonb_entry",
         ]
     );
 
-    let values: (
-        serde_json::Value,
-        serde_json::Value,
-        serde_json::Value,
-        serde_json::Value,
-    ) = sqlx::query_as(
+    let values: (serde_json::Value, serde_json::Value, serde_json::Value) = sqlx::query_as(
         r#"
         SELECT
           scalar_value::jsonb,
           doc_value::jsonb,
-          query_value::jsonb,
           entry_value::jsonb
         FROM public.eql_v3_uninstall_preserve
         WHERE id = 1
@@ -293,11 +316,35 @@ async fn uninstaller_preserves_application_tables_with_public_domain_columns(
     );
     assert_eq!(
         values.2,
-        serde_json::from_str::<serde_json::Value>(query_payload)?
+        serde_json::from_str::<serde_json::Value>(entry_payload)?
     );
+
+    // The misuse table survives, but its query-operand column went down with
+    // the eql_v3 schema (DROP SCHEMA ... CASCADE drops the domain, which
+    // cascades to columns of that type).
+    assert!(
+        table_exists(&pool, "eql_v3_uninstall_query_misuse").await?,
+        "the misuse table itself must survive uninstall"
+    );
+    let misuse_columns: Vec<String> = sqlx::query_scalar(
+        r#"
+        SELECT a.attname
+        FROM pg_catalog.pg_attribute a
+        JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+        JOIN pg_catalog.pg_namespace cn ON cn.oid = c.relnamespace
+        WHERE cn.nspname = 'public'
+          AND c.relname = 'eql_v3_uninstall_query_misuse'
+          AND a.attnum > 0
+          AND NOT a.attisdropped
+        ORDER BY a.attnum
+        "#,
+    )
+    .fetch_all(&pool)
+    .await?;
     assert_eq!(
-        values.3,
-        serde_json::from_str::<serde_json::Value>(entry_payload)?
+        misuse_columns,
+        vec!["id"],
+        "a column typed as an eql_v3 query-operand domain is dropped with the schema"
     );
 
     Ok(())